VTS tests for fixed MediaDrm security level APIs

Vendors implementing the newly added MediaDrm.setSecurityLevel
HAL found that it was difficult to implement properly. Also the
semantics are somewhat ambiguous from the Java platform API
level. The APIs have changed to bind the security level
assignment to openSession which clarifies the API for apps as
well as making it more natural to implement in HAL modules. This
CL updates the VTS tests to account for those changes.

bug:72831697
bug:64001680

test: VtsHalDrmV1_1TargetTest, GTS media tests
Change-Id: I2adf13f9da7726b206df6fcc82b1e2e11fc94674

1 files changed, 82 insertions, 49 deletions

diff --git a/drm/1.1/vts/functional/drm_hal_clearkey_test.cpp b/drm/1.1/vts/functional/drm_hal_clearkey_test.cpp
index 62cc8b67e..a8ed0e500 100644
--- a/drm/1.1/vts/functional/drm_hal_clearkey_test.cpp
+++ b/drm/1.1/vts/functional/drm_hal_clearkey_test.cpp
@@ -158,6 +158,7 @@ public:
     virtual void TearDown() override {}
 
     SessionId openSession();
+    SessionId openSession(SecurityLevel level);
     void closeSession(const SessionId& sessionId);
     hidl_vec<uint8_t> loadKeys(const SessionId& sessionId, const KeyType& type);
     sp<IMemory> getDecryptMemory(size_t size, size_t index);
@@ -277,6 +278,23 @@ SessionId DrmHalClearkeyTest::openSession() {
 }
 
 /**
+ * Helper method to open as session using V1.1 API
+ */
+SessionId DrmHalClearkeyTest::openSession(SecurityLevel level) {
+    SessionId sessionId;
+
+    auto res = drmPlugin->openSession_1_1(level,
+            [&sessionId](Status status, const SessionId& id) {
+                EXPECT_EQ(Status::OK, status);
+                EXPECT_NE(0u, id.size());
+                sessionId = id;
+            });
+    EXPECT_OK(res);
+    return sessionId;
+}
+
+
+/**
  * Helper method to close a session
  */
 void DrmHalClearkeyTest::closeSession(const SessionId& sessionId) {
@@ -298,14 +316,14 @@ TEST_F(DrmHalClearkeyTest, GetHdcpLevels) {
 }
 
 /**
- * Test that the plugin returns valid open and max session counts
+ * Test that the plugin returns default open and max session counts
  */
-TEST_F(DrmHalClearkeyTest, GetSessionCounts) {
+TEST_F(DrmHalClearkeyTest, GetDefaultSessionCounts) {
     auto res = drmPlugin->getNumberOfSessions(
             [&](Status status, uint32_t currentSessions,
                     uint32_t maxSessions) {
                 EXPECT_EQ(Status::OK, status);
-                EXPECT_GT(maxSessions, (uint32_t)0);
+                EXPECT_GE(maxSessions, (uint32_t)8);
                 EXPECT_GE(currentSessions, (uint32_t)0);
                 EXPECT_LE(currentSessions, maxSessions);
             });
@@ -313,77 +331,92 @@ TEST_F(DrmHalClearkeyTest, GetSessionCounts) {
 }
 
 /**
- * Test that the plugin returns a valid security level for
- * a valid session
+ * Test that the plugin returns valid open and max session counts
+ * after a session is opened.
  */
-TEST_F(DrmHalClearkeyTest, GetSecurityLevel) {
+TEST_F(DrmHalClearkeyTest, GetOpenSessionCounts) {
+    uint32_t initialSessions = 0;
+    auto res = drmPlugin->getNumberOfSessions(
+            [&](Status status, uint32_t currentSessions,
+                    uint32_t maxSessions) {
+                EXPECT_EQ(Status::OK, status);
+                EXPECT_GE(maxSessions, (uint32_t)8);
+                EXPECT_GE(currentSessions, (uint32_t)0);
+                EXPECT_LE(currentSessions, maxSessions);
+                initialSessions = currentSessions;
+            });
+    EXPECT_OK(res);
+
     SessionId session = openSession();
-    auto res = drmPlugin->getSecurityLevel(session,
-            [&](Status status, SecurityLevel level) {
+    res = drmPlugin->getNumberOfSessions(
+            [&](Status status, uint32_t currentSessions,
+                    uint32_t /*maxSessions*/) {
                 EXPECT_EQ(Status::OK, status);
-                EXPECT_GE(level, SecurityLevel::SW_SECURE_CRYPTO);
-                EXPECT_LE(level, SecurityLevel::HW_SECURE_ALL);
+                EXPECT_EQ(currentSessions, initialSessions + 1);
             });
     EXPECT_OK(res);
-    closeSession(session);
-}
 
-/**
- * Test that the plugin returns the documented error
- * when requesting the security level for an invalid sessionId
- */
-TEST_F(DrmHalClearkeyTest, GetSecurityLevelInvalidSessionId) {
-    SessionId session;
-    auto res = drmPlugin->getSecurityLevel(session,
-            [&](Status status, SecurityLevel /*level*/) {
-                EXPECT_EQ(Status::BAD_VALUE, status);
+    closeSession(session);
+    res = drmPlugin->getNumberOfSessions(
+            [&](Status status, uint32_t currentSessions,
+                    uint32_t /*maxSessions*/) {
+                EXPECT_EQ(Status::OK, status);
+                EXPECT_EQ(currentSessions, initialSessions);
             });
     EXPECT_OK(res);
 }
 
 /**
- * Test that setting all valid security levels on a valid sessionId
- * is supported
+ * Test that the plugin returns the same security level
+ * by default as when it is requested explicitly
  */
-TEST_F(DrmHalClearkeyTest, SetSecurityLevel) {
+TEST_F(DrmHalClearkeyTest, GetDefaultSecurityLevel) {
     SessionId session = openSession();
-    for (uint32_t level = static_cast<uint32_t>(SecurityLevel::SW_SECURE_CRYPTO);
-         level <= static_cast<uint32_t>(SecurityLevel::HW_SECURE_ALL); level++) {
-        EXPECT_EQ(Status::OK, drmPlugin->setSecurityLevel(session, static_cast<SecurityLevel>(level)));
+    SecurityLevel defaultLevel;
+    auto res = drmPlugin->getSecurityLevel(session,
+            [&](Status status, SecurityLevel level) {
+                EXPECT_EQ(Status::OK, status);
+                defaultLevel = level;
+            });
+    EXPECT_OK(res);
+    closeSession(session);
 
-        // check that the level got set
-        auto res = drmPlugin->getSecurityLevel(session,
-                [&](Status status, SecurityLevel readLevel) {
-                    EXPECT_EQ(Status::OK, status);
-                    EXPECT_EQ(level, static_cast<uint32_t>(readLevel));
-                });
-        EXPECT_OK(res);
-    }
+    session = openSession(defaultLevel);
+    res = drmPlugin->getSecurityLevel(session,
+            [&](Status status, SecurityLevel level) {
+                EXPECT_EQ(Status::OK, status);
+                EXPECT_EQ(level, defaultLevel);
+            });
+    EXPECT_OK(res);
     closeSession(session);
 }
 
 /**
- * Test that setting an invalid security level on a valid
- * sessionId is prohibited with the documented error code.
+ * Test that the plugin returns the lowest security level
+ * when it is requested
  */
-TEST_F(DrmHalClearkeyTest, SetInvalidSecurityLevel) {
-    SessionId session = openSession();
-    SecurityLevel level = static_cast<SecurityLevel>(
-            static_cast<uint32_t>(SecurityLevel::HW_SECURE_ALL) + 1);
-    Status status = drmPlugin->setSecurityLevel(session, level);
-    EXPECT_EQ(Status::BAD_VALUE, status);
+TEST_F(DrmHalClearkeyTest, GetSecurityLevel) {
+    SessionId session = openSession(SecurityLevel::SW_SECURE_CRYPTO);
+    auto res = drmPlugin->getSecurityLevel(session,
+            [&](Status status, SecurityLevel level) {
+                EXPECT_EQ(Status::OK, status);
+                EXPECT_EQ(level, SecurityLevel::SW_SECURE_CRYPTO);
+            });
+    EXPECT_OK(res);
     closeSession(session);
 }
 
 /**
- * Test that attempting to set security level on an invalid
- * (empty) sessionId is prohibited with the documented error
- * code.
+ * Test that the plugin returns the documented error
+ * when requesting the security level for an invalid sessionId
  */
-TEST_F(DrmHalClearkeyTest, SetSecurityLevelInvalidSessionId) {
+TEST_F(DrmHalClearkeyTest, GetSecurityLevelInvalidSessionId) {
     SessionId session;
-    SecurityLevel level = SecurityLevel::SW_SECURE_CRYPTO;
-    EXPECT_EQ(Status::BAD_VALUE, drmPlugin->setSecurityLevel(session, level));
+    auto res = drmPlugin->getSecurityLevel(session,
+            [&](Status status, SecurityLevel /*level*/) {
+                EXPECT_EQ(Status::BAD_VALUE, status);
+            });
+    EXPECT_OK(res);
 }
 
 /**