Revert "VTS tests for fixed MediaDrm security level APIs"

This reverts commit 45c3855f4fc04fc80f354139b7f084ca817f3db1.

Reason for revert: Build cop here. The CL topic that I'm reverting broke several builds: Drm.h's openSession(Vector<uint8_t> &sessionId) hides overloaded virtual function openSession(DrmPlugin::SecurityLevel securityLevel, ..) from IDrm.h.

https://android-build.googleplex.com/builds/submitted/4598692/full-eng/latest/view/logs/build_error.log

Change-Id: Ie61888464a2ac17b1ee6f47b23f5bb84fdbfa095

1 files changed, 49 insertions, 82 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 a8ed0e500..62cc8b67e 100644
--- a/drm/1.1/vts/functional/drm_hal_clearkey_test.cpp
+++ b/drm/1.1/vts/functional/drm_hal_clearkey_test.cpp
@@ -158,7 +158,6 @@ 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);
@@ -278,23 +277,6 @@ 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) {
@@ -316,14 +298,14 @@ TEST_F(DrmHalClearkeyTest, GetHdcpLevels) {
 }
 
 /**
- * Test that the plugin returns default open and max session counts
+ * Test that the plugin returns valid open and max session counts
  */
-TEST_F(DrmHalClearkeyTest, GetDefaultSessionCounts) {
+TEST_F(DrmHalClearkeyTest, GetSessionCounts) {
     auto res = drmPlugin->getNumberOfSessions(
             [&](Status status, uint32_t currentSessions,
                     uint32_t maxSessions) {
                 EXPECT_EQ(Status::OK, status);
-                EXPECT_GE(maxSessions, (uint32_t)8);
+                EXPECT_GT(maxSessions, (uint32_t)0);
                 EXPECT_GE(currentSessions, (uint32_t)0);
                 EXPECT_LE(currentSessions, maxSessions);
             });
@@ -331,92 +313,77 @@ TEST_F(DrmHalClearkeyTest, GetDefaultSessionCounts) {
 }
 
 /**
- * Test that the plugin returns valid open and max session counts
- * after a session is opened.
+ * Test that the plugin returns a valid security level for
+ * a valid session
  */
-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);
-
+TEST_F(DrmHalClearkeyTest, GetSecurityLevel) {
     SessionId session = openSession();
-    res = drmPlugin->getNumberOfSessions(
-            [&](Status status, uint32_t currentSessions,
-                    uint32_t /*maxSessions*/) {
+    auto res = drmPlugin->getSecurityLevel(session,
+            [&](Status status, SecurityLevel level) {
                 EXPECT_EQ(Status::OK, status);
-                EXPECT_EQ(currentSessions, initialSessions + 1);
+                EXPECT_GE(level, SecurityLevel::SW_SECURE_CRYPTO);
+                EXPECT_LE(level, SecurityLevel::HW_SECURE_ALL);
             });
     EXPECT_OK(res);
-
     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 the plugin returns the same security level
- * by default as when it is requested explicitly
+ * Test that the plugin returns the documented error
+ * when requesting the security level for an invalid sessionId
  */
-TEST_F(DrmHalClearkeyTest, GetDefaultSecurityLevel) {
-    SessionId session = openSession();
-    SecurityLevel defaultLevel;
+TEST_F(DrmHalClearkeyTest, GetSecurityLevelInvalidSessionId) {
+    SessionId session;
     auto res = drmPlugin->getSecurityLevel(session,
-            [&](Status status, SecurityLevel level) {
-                EXPECT_EQ(Status::OK, status);
-                defaultLevel = level;
+            [&](Status status, SecurityLevel /*level*/) {
+                EXPECT_EQ(Status::BAD_VALUE, status);
             });
     EXPECT_OK(res);
-    closeSession(session);
+}
 
-    session = openSession(defaultLevel);
-    res = drmPlugin->getSecurityLevel(session,
-            [&](Status status, SecurityLevel level) {
-                EXPECT_EQ(Status::OK, status);
-                EXPECT_EQ(level, defaultLevel);
-            });
-    EXPECT_OK(res);
+/**
+ * Test that setting all valid security levels on a valid sessionId
+ * is supported
+ */
+TEST_F(DrmHalClearkeyTest, SetSecurityLevel) {
+    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)));
+
+        // 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);
+    }
     closeSession(session);
 }
 
 /**
- * Test that the plugin returns the lowest security level
- * when it is requested
+ * Test that setting an invalid security level on a valid
+ * sessionId is prohibited with the documented error code.
  */
-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);
+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);
     closeSession(session);
 }
 
 /**
- * Test that the plugin returns the documented error
- * when requesting the security level for an invalid sessionId
+ * Test that attempting to set security level on an invalid
+ * (empty) sessionId is prohibited with the documented error
+ * code.
  */
-TEST_F(DrmHalClearkeyTest, GetSecurityLevelInvalidSessionId) {
+TEST_F(DrmHalClearkeyTest, SetSecurityLevelInvalidSessionId) {
     SessionId session;
-    auto res = drmPlugin->getSecurityLevel(session,
-            [&](Status status, SecurityLevel /*level*/) {
-                EXPECT_EQ(Status::BAD_VALUE, status);
-            });
-    EXPECT_OK(res);
+    SecurityLevel level = SecurityLevel::SW_SECURE_CRYPTO;
+    EXPECT_EQ(Status::BAD_VALUE, drmPlugin->setSecurityLevel(session, level));
 }
 
 /**