Snap for 6337755 from c0d7f16b78 to sc-release

Change-Id: I8992f4a53204c098b8170b8ffdd499055ab141b1

libwvdrmengine/cdm/core/include/crypto_session.h

@@ -254,11 +254,17 @@ class CryptoSession {
   virtual UsageTableHeader* GetUsageTableHeader() {
     return usage_table_header_;
   }
-
+  // The following crypto methods do not require an open session to
+  // complete the operations.
   virtual CdmResponseType CreateUsageTableHeader(
+      SecurityLevel requested_security_level,
       CdmUsageTableHeader* usage_table_header);
   virtual CdmResponseType LoadUsageTableHeader(
+      SecurityLevel requested_security_level,
       const CdmUsageTableHeader& usage_table_header);
+  virtual CdmResponseType ShrinkUsageTableHeader(
+      SecurityLevel requested_security_level, uint32_t new_entry_count,
+      CdmUsageTableHeader* usage_table_header);
 
   // Usage entry.
   virtual CdmResponseType CreateUsageEntry(uint32_t* entry_number);
@@ -268,8 +274,6 @@ class CryptoSession {
       CdmUsageTableHeader* usage_table_header, CdmUsageEntry* usage_entry);
 
   // Adjust usage entries in usage table header.
-  virtual CdmResponseType ShrinkUsageTableHeader(
-      uint32_t new_entry_count, CdmUsageTableHeader* usage_table_header);
   virtual CdmResponseType MoveUsageEntry(uint32_t new_entry_number);
 
   virtual bool GetAnalogOutputCapabilities(bool* can_support_output,

libwvdrmengine/cdm/core/include/wv_cdm_types.h

@@ -281,7 +281,7 @@ enum CdmResponseType {
   /* previsouly INVALID_PARAMETERS_ENG_20 = 227, */
   UPDATE_USAGE_ENTRY_UNKNOWN_ERROR = 228,
   /* previously INVALID_PARAMETERS_ENG_21 = 229, */
-  SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR = 230,
+  SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR = 230,
   MOVE_USAGE_ENTRY_UNKNOWN_ERROR = 231,
   COPY_OLD_USAGE_ENTRY_UNKNOWN_ERROR = 232,
   INVALID_PARAMETERS_ENG_22 = 233,
@@ -408,6 +408,9 @@ enum CdmResponseType {
   CANNOT_DECRYPT_ZERO_SUBSAMPLES = 354,
   SAMPLE_AND_SUBSAMPLE_SIZE_MISMATCH = 355,
   INVALID_IV_SIZE = 356,
+  LOAD_USAGE_ENTRY_INVALID_SESSION = 357,
+  MOVE_USAGE_ENTRY_DESTINATION_IN_USE = 358,
+  SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE = 359,
   // Don't forget to add new values to
   //  * core/test/test_printers.cpp.
   //  * android/include/mapErrors-inl.h

libwvdrmengine/cdm/core/src/crypto_session.cpp

@@ -708,12 +708,10 @@ uint8_t CryptoSession::GetSecurityPatchLevel() {
 }
 
 CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
-  LOGD(
+  LOGD("Opening crypto session: requested_security_level = %s",
-      "Opening crypto session: requested_security_level: "
+       requested_security_level == kLevel3
-      "requested_security_level = %s",
+           ? QUERY_VALUE_SECURITY_LEVEL_L3.c_str()
-      requested_security_level == kLevel3
+           : QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str());
-          ? QUERY_VALUE_SECURITY_LEVEL_L3.c_str()
-          : QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str());
   RETURN_IF_UNINITIALIZED(UNKNOWN_ERROR);
   if (open_) return NO_ERROR;
 
@@ -802,35 +800,33 @@ CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
       CdmSecurityLevel security_level = GetSecurityLevel();
       if (security_level == kSecurityLevelL1 ||
           security_level == kSecurityLevelL3) {
-        {
+        // This block cannot use |WithStaticFieldWriteLock| because it needs
-          // This block cannot use |WithStaticFieldWriteLock| because it needs
+        // to unlock the lock partway through.
-          // to unlock the lock partway through.
+        LOGV("Static field write lock: Open() initializing usage table");
-          LOGV("Static field write lock: Open() initializing usage table");
+        std::unique_lock<shared_mutex> auto_lock(static_field_mutex_);
-          std::unique_lock<shared_mutex> auto_lock(static_field_mutex_);
 
-          UsageTableHeader** header = security_level == kSecurityLevelL1
+        UsageTableHeader** header = security_level == kSecurityLevelL1
-                                          ? &usage_table_header_l1_
+                                        ? &usage_table_header_l1_
-                                          : &usage_table_header_l3_;
+                                        : &usage_table_header_l3_;
-          if (*header == nullptr) {
+        if (*header == nullptr) {
-            *header = new UsageTableHeader();
+          *header = new UsageTableHeader();
-            // Ignore errors since we do not know when a session is opened,
+          // Ignore errors since we do not know when a session is opened,
-            // if it is intended to be used for offline/usage session related
+          // if it is intended to be used for offline/usage session related
-            // or otherwise.
+          // or otherwise.
-            auto_lock.unlock();
+          auto_lock.unlock();
-            bool is_usage_table_header_inited =
+          bool is_usage_table_header_inited =
-                (*header)->Init(security_level, this);
+              (*header)->Init(security_level, this);
-            auto_lock.lock();
+          auto_lock.lock();
-            if (!is_usage_table_header_inited) {
+          if (!is_usage_table_header_inited) {
-              delete *header;
+            delete *header;
-              *header = nullptr;
+            *header = nullptr;
-              usage_table_header_ = nullptr;
+            usage_table_header_ = nullptr;
-              return NO_ERROR;
+            return NO_ERROR;
-            }
           }
-          usage_table_header_ = *header;
-          metrics_->usage_table_header_initial_size_.Record((*header)->size());
         }
-      }
+        usage_table_header_ = *header;
+        metrics_->usage_table_header_initial_size_.Record((*header)->size());
+      }  // End |static_field_mutex_| block.
     }
   } else {
     metrics_->oemcrypto_usage_table_support_.SetError(result);
@@ -2342,18 +2338,20 @@ CdmResponseType CryptoSession::GetUsageSupportType(
 }
 
 CdmResponseType CryptoSession::CreateUsageTableHeader(
+    SecurityLevel requested_security_level,
     CdmUsageTableHeader* usage_table_header) {
-  LOGV("Creating usage table header: id = %u", oec_session_id_);
+  LOGV("Creating usage table header: requested_security_level = %s",
-
+       requested_security_level == kLevel3
+           ? QUERY_VALUE_SECURITY_LEVEL_L3.c_str()
+           : QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str());
   RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
 
   usage_table_header->resize(kEstimatedInitialUsageTableHeader);
-
   size_t usage_table_header_size = usage_table_header->size();
   OEMCryptoResult result;
   WithOecWriteLock("CreateUsageTableHeader Attempt 1", [&] {
     result = OEMCrypto_CreateUsageTableHeader(
-        requested_security_level_,
+        requested_security_level,
         reinterpret_cast<uint8_t*>(
             const_cast<char*>(usage_table_header->data())),
         &usage_table_header_size);
@@ -2364,7 +2362,7 @@ CdmResponseType CryptoSession::CreateUsageTableHeader(
     usage_table_header->resize(usage_table_header_size);
     WithOecWriteLock("CreateUsageTableHeader Attempt 2", [&] {
       result = OEMCrypto_CreateUsageTableHeader(
-          requested_security_level_,
+          requested_security_level,
           reinterpret_cast<uint8_t*>(
               const_cast<char*>(usage_table_header->data())),
           &usage_table_header_size);
@@ -2372,22 +2370,28 @@ CdmResponseType CryptoSession::CreateUsageTableHeader(
     });
   }
 
-  if (result == OEMCrypto_SUCCESS) {
+  switch (result) {
-    usage_table_header->resize(usage_table_header_size);
+    case OEMCrypto_SUCCESS:
+      usage_table_header->resize(usage_table_header_size);
+      return NO_ERROR;
+    default:
+      return MapOEMCryptoResult(result, CREATE_USAGE_TABLE_ERROR,
+                                "CreateUsageTableHeader");
   }
-
-  return MapOEMCryptoResult(result, CREATE_USAGE_TABLE_ERROR,
-                            "CreateUsageTableHeader");
 }
 
 CdmResponseType CryptoSession::LoadUsageTableHeader(
+    SecurityLevel requested_security_level,
     const CdmUsageTableHeader& usage_table_header) {
-  LOGV("Loading usage table header: id = %u", oec_session_id_);
+  LOGV("Loading usage table header: requested_security_level = %s",
+       requested_security_level == kLevel3
+           ? QUERY_VALUE_SECURITY_LEVEL_L3.c_str()
+           : QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str());
 
   OEMCryptoResult result;
   WithOecWriteLock("LoadUsageTableHeader", [&] {
     result = OEMCrypto_LoadUsageTableHeader(
-        requested_security_level_,
+        requested_security_level,
         reinterpret_cast<const uint8_t*>(usage_table_header.data()),
         usage_table_header.size());
     metrics_->oemcrypto_load_usage_table_header_.Increment(result);
@@ -2420,6 +2424,48 @@ CdmResponseType CryptoSession::LoadUsageTableHeader(
   }
 }
 
+CdmResponseType CryptoSession::ShrinkUsageTableHeader(
+    SecurityLevel requested_security_level, uint32_t new_entry_count,
+    CdmUsageTableHeader* usage_table_header) {
+  LOGV("Shrinking usage table header: requested_security_level = %s",
+       requested_security_level == kLevel3
+           ? QUERY_VALUE_SECURITY_LEVEL_L3.c_str()
+           : QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str());
+  RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
+
+  size_t usage_table_header_len = 0;
+  OEMCryptoResult result;
+  WithOecWriteLock("ShrinkUsageTableHeader Attempt 1", [&] {
+    result = OEMCrypto_ShrinkUsageTableHeader(requested_security_level,
+                                              new_entry_count, nullptr,
+                                              &usage_table_header_len);
+    metrics_->oemcrypto_shrink_usage_table_header_.Increment(result);
+  });
+
+  if (result == OEMCrypto_ERROR_SHORT_BUFFER) {
+    usage_table_header->resize(usage_table_header_len);
+    WithOecWriteLock("ShrinkUsageTableHeader Attempt 2", [&] {
+      result = OEMCrypto_ShrinkUsageTableHeader(
+          requested_security_level, new_entry_count,
+          reinterpret_cast<uint8_t*>(
+              const_cast<char*>(usage_table_header->data())),
+          &usage_table_header_len);
+      metrics_->oemcrypto_shrink_usage_table_header_.Increment(result);
+    });
+  }
+
+  switch (result) {
+    case OEMCrypto_SUCCESS:
+      usage_table_header->resize(usage_table_header_len);
+      return NO_ERROR;
+    case OEMCrypto_ERROR_ENTRY_IN_USE:
+      return SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE;
+    default:
+      return MapOEMCryptoResult(result, SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR,
+                                "ShrinkUsageTableHeader");
+  }
+}
+
 CdmResponseType CryptoSession::CreateUsageEntry(uint32_t* entry_number) {
   LOGV("Creating usage entry: id = %u", oec_session_id_);
 
@@ -2476,18 +2522,19 @@ CdmResponseType CryptoSession::LoadUsageEntry(
     case OEMCrypto_SUCCESS:
     case OEMCrypto_WARNING_GENERATION_SKEW:
       return NO_ERROR;
+    case OEMCrypto_ERROR_INVALID_SESSION:
+      // This case is special, as it could imply that the provided
+      // session ID is invalid (CDM internal bug), or that the entry
+      // being loaded is already in use in a different session.
+      // It is up to the caller to handle this.
+      return LOAD_USAGE_ENTRY_INVALID_SESSION;
     case OEMCrypto_ERROR_GENERATION_SKEW:
       return LOAD_USAGE_ENTRY_GENERATION_SKEW;
     case OEMCrypto_ERROR_SIGNATURE_FAILURE:
       return LOAD_USAGE_ENTRY_SIGNATURE_FAILURE;
-    case OEMCrypto_ERROR_INSUFFICIENT_RESOURCES:
-      return INSUFFICIENT_CRYPTO_RESOURCES_3;
-    case OEMCrypto_ERROR_SESSION_LOST_STATE:
-      return SESSION_LOST_STATE_ERROR;
-    case OEMCrypto_ERROR_SYSTEM_INVALIDATED:
-      return SYSTEM_INVALIDATED_ERROR;
     default:
-      return LOAD_USAGE_ENTRY_UNKNOWN_ERROR;
+      return MapOEMCryptoResult(result, LOAD_USAGE_ENTRY_UNKNOWN_ERROR,
+                                "LoadUsageEntry");
   }
 }
 
@@ -2533,42 +2580,6 @@ CdmResponseType CryptoSession::UpdateUsageEntry(
                             "UpdateUsageEntry");
 }
 
-CdmResponseType CryptoSession::ShrinkUsageTableHeader(
-    uint32_t new_entry_count, CdmUsageTableHeader* usage_table_header) {
-  LOGV("Shrinking usage table header: id = %u", oec_session_id_);
-
-  RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
-
-  size_t usage_table_header_len = 0;
-  OEMCryptoResult result;
-  WithOecWriteLock("ShrinkUsageTableHeader Attempt 1", [&] {
-    result = OEMCrypto_ShrinkUsageTableHeader(requested_security_level_,
-                                              new_entry_count, nullptr,
-                                              &usage_table_header_len);
-    metrics_->oemcrypto_shrink_usage_table_header_.Increment(result);
-  });
-
-  if (result == OEMCrypto_ERROR_SHORT_BUFFER) {
-    usage_table_header->resize(usage_table_header_len);
-
-    WithOecWriteLock("ShrinkUsageTableHeader Attempt 2", [&] {
-      result = OEMCrypto_ShrinkUsageTableHeader(
-          requested_security_level_, new_entry_count,
-          reinterpret_cast<uint8_t*>(
-              const_cast<char*>(usage_table_header->data())),
-          &usage_table_header_len);
-      metrics_->oemcrypto_shrink_usage_table_header_.Increment(result);
-    });
-  }
-
-  if (result == OEMCrypto_SUCCESS) {
-    usage_table_header->resize(usage_table_header_len);
-  }
-
-  return MapOEMCryptoResult(result, SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR,
-                            "ShrinkUsageTableHeader");
-}
-
 CdmResponseType CryptoSession::MoveUsageEntry(uint32_t new_entry_number) {
   LOGV("Moving usage entry: id = %u", oec_session_id_);
 
@@ -2578,8 +2589,15 @@ CdmResponseType CryptoSession::MoveUsageEntry(uint32_t new_entry_number) {
     metrics_->oemcrypto_move_entry_.Increment(result);
   });
 
-  return MapOEMCryptoResult(result, MOVE_USAGE_ENTRY_UNKNOWN_ERROR,
+  switch (result) {
-                            "MoveUsageEntry");
+    case OEMCrypto_ERROR_ENTRY_IN_USE:
+      LOGW("OEMCrypto_MoveEntry failed: Destination index in use: index = %u",
+           new_entry_number);
+      return MOVE_USAGE_ENTRY_DESTINATION_IN_USE;
+    default:
+      return MapOEMCryptoResult(result, MOVE_USAGE_ENTRY_UNKNOWN_ERROR,
+                                "MoveUsageEntry");
+  }
 }
 
 bool CryptoSession::GetAnalogOutputCapabilities(bool* can_support_output,

libwvdrmengine/cdm/core/src/usage_table_header.cpp

@@ -186,7 +186,8 @@ bool UsageTableHeader::Init(CdmSecurityLevel security_level,
   if (file_handle_->RetrieveUsageTableInfo(
           &usage_table_header_, &usage_entry_info_, &run_lru_upgrade)) {
     LOGI("Number of usage entries: %zu", usage_entry_info_.size());
-    status = crypto_session->LoadUsageTableHeader(usage_table_header_);
+    status = crypto_session->LoadUsageTableHeader(requested_security_level_,
+                                                  usage_table_header_);
 
     bool lru_success = true;
     if (status == NO_ERROR && run_lru_upgrade) {
@@ -250,12 +251,14 @@ bool UsageTableHeader::Init(CdmSecurityLevel security_level,
       file_handle_->DeleteUsageTableInfo();
       usage_entry_info_.clear();
       usage_table_header_.clear();
-      status = crypto_session->CreateUsageTableHeader(&usage_table_header_);
+      status = crypto_session->CreateUsageTableHeader(requested_security_level_,
+                                                      &usage_table_header_);
       if (status != NO_ERROR) return false;
       file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_);
     }
   } else {
-    status = crypto_session->CreateUsageTableHeader(&usage_table_header_);
+    status = crypto_session->CreateUsageTableHeader(requested_security_level_,
+                                                    &usage_table_header_);
     if (status != NO_ERROR) return false;
     file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_);
   }
@@ -537,7 +540,7 @@ CdmResponseType UsageTableHeader::MoveEntry(
   std::unique_ptr<CryptoSession> scoped_crypto_session;
   CryptoSession* crypto_session = test_crypto_session_.get();
   if (crypto_session == nullptr) {
-    scoped_crypto_session.reset((CryptoSession::MakeCryptoSession(metrics)));
+    scoped_crypto_session.reset(CryptoSession::MakeCryptoSession(metrics));
     crypto_session = scoped_crypto_session.get();
   }
 
@@ -731,6 +734,7 @@ CdmResponseType UsageTableHeader::Shrink(
 
   if (number_of_usage_entries_to_delete == 0) return NO_ERROR;
 
+  // TODO(b/150887808):  Only resize if the shrink operation is successful.
   usage_entry_info_.resize(usage_entry_info_.size() -
                            number_of_usage_entries_to_delete);
 
@@ -743,15 +747,14 @@ CdmResponseType UsageTableHeader::Shrink(
     crypto_session = scoped_crypto_session.get();
   }
 
-  CdmResponseType status = crypto_session->Open(requested_security_level_);
+  const CdmResponseType status = crypto_session->ShrinkUsageTableHeader(
-  if (status != NO_ERROR) return status;
+      requested_security_level_, usage_entry_info_.size(),
+      &usage_table_header_);
 
-  status = crypto_session->ShrinkUsageTableHeader(usage_entry_info_.size(),
+  if (status == NO_ERROR) {
-                                                  &usage_table_header_);
+    file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_);
-  if (status != NO_ERROR) return status;
+  }
-
+  return status;
-  file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_);
-  return NO_ERROR;
 }
 
 // Test only method.

libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp

@@ -40,16 +40,19 @@ class MockCryptoSession : public TestCryptoSession {
   MockCryptoSession(metrics::CryptoMetrics* metrics)
       : TestCryptoSession(metrics) {}
   MOCK_METHOD1(Open, CdmResponseType(SecurityLevel));
-  MOCK_METHOD1(LoadUsageTableHeader,
+  // Usage Table Header.
-               CdmResponseType(const CdmUsageTableHeader&));
+  MOCK_METHOD2(CreateUsageTableHeader,
-  MOCK_METHOD1(CreateUsageTableHeader, CdmResponseType(CdmUsageTableHeader*));
+               CdmResponseType(SecurityLevel, CdmUsageTableHeader*));
+  MOCK_METHOD2(LoadUsageTableHeader,
+               CdmResponseType(SecurityLevel, const CdmUsageTableHeader&));
+  MOCK_METHOD3(ShrinkUsageTableHeader,
+               CdmResponseType(SecurityLevel, uint32_t, CdmUsageTableHeader*));
+  // Usage Entry.
   MOCK_METHOD1(CreateUsageEntry, CdmResponseType(uint32_t*));
   MOCK_METHOD2(LoadUsageEntry, CdmResponseType(uint32_t, const CdmUsageEntry&));
   MOCK_METHOD2(UpdateUsageEntry,
                CdmResponseType(CdmUsageTableHeader*, CdmUsageEntry*));
   MOCK_METHOD1(MoveUsageEntry, CdmResponseType(uint32_t));
-  MOCK_METHOD2(ShrinkUsageTableHeader,
-               CdmResponseType(uint32_t, CdmUsageTableHeader*));
 };
 
 class TestStubCryptoSessionFactory : public CryptoSessionFactory {

libwvdrmengine/cdm/core/test/test_printers.cpp

@@ -560,6 +560,9 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
     case LOAD_USAGE_ENTRY_GENERATION_SKEW:
       *os << "LOAD_USAGE_ENTRY_GENERATION_SKEW";
       break;
+    case LOAD_USAGE_ENTRY_INVALID_SESSION:
+      *os << "LOAD_USAGE_ENTRY_INVALID_SESSION";
+      break;
     case LOAD_USAGE_ENTRY_SIGNATURE_FAILURE:
       *os << "LOAD_USAGE_ENTRY_SIGNATURE_FAILURE";
       break;
@@ -578,6 +581,9 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
     case LOAD_USAGE_HEADER_UNKNOWN_ERROR:
       *os << "LOAD_USAGE_HEADER_UNKNOWN_ERROR";
       break;
+    case MOVE_USAGE_ENTRY_DESTINATION_IN_USE:
+      *os << "MOVE_USAGE_ENTRY_DESTINATION_IN_USE";
+      break;
     case MOVE_USAGE_ENTRY_UNKNOWN_ERROR:
       *os << "MOVE_USAGE_ENTRY_UNKNOWN_ERROR";
       break;
@@ -818,8 +824,11 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
     case SET_DECRYPT_HASH_ERROR:
       *os << "SET_DECRYPT_HASH_ERROR";
       break;
-    case SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR:
+    case SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE:
-      *os << "SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR";
+      *os << "SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE";
+      break;
+    case SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR:
+      *os << "SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR";
       break;
     case SIGNATURE_NOT_FOUND:
       *os << "SIGNATURE_NOT_FOUND";

libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp

@@ -424,16 +424,19 @@ class MockCryptoSession : public TestCryptoSession {
   MockCryptoSession(metrics::CryptoMetrics* metrics)
       : TestCryptoSession(metrics) {}
   MOCK_METHOD1(Open, CdmResponseType(SecurityLevel));
-  MOCK_METHOD1(LoadUsageTableHeader,
+  // Usage Table Header.
-               CdmResponseType(const CdmUsageTableHeader&));
+  MOCK_METHOD2(CreateUsageTableHeader,
-  MOCK_METHOD1(CreateUsageTableHeader, CdmResponseType(CdmUsageTableHeader*));
+               CdmResponseType(SecurityLevel, CdmUsageTableHeader*));
+  MOCK_METHOD2(LoadUsageTableHeader,
+               CdmResponseType(SecurityLevel, const CdmUsageTableHeader&));
+  MOCK_METHOD3(ShrinkUsageTableHeader,
+               CdmResponseType(SecurityLevel, uint32_t, CdmUsageTableHeader*));
+  // Usage Entry.
   MOCK_METHOD1(CreateUsageEntry, CdmResponseType(uint32_t*));
   MOCK_METHOD2(LoadUsageEntry, CdmResponseType(uint32_t, const CdmUsageEntry&));
   MOCK_METHOD2(UpdateUsageEntry,
                CdmResponseType(CdmUsageTableHeader*, CdmUsageEntry*));
   MOCK_METHOD1(MoveUsageEntry, CdmResponseType(uint32_t));
-  MOCK_METHOD2(ShrinkUsageTableHeader,
-               CdmResponseType(uint32_t, CdmUsageTableHeader*));
 
   // Fake method for testing.  Having an EXPECT_CALL causes complexities
   // for getting table capacity during initialization.
@@ -561,7 +564,7 @@ class UsageTableHeaderTest : public WvCdmTestBase {
         .WillOnce(DoAll(SetArgPointee<0>(usage_table_header),
                         SetArgPointee<1>(usage_entry_info_vector),
                         SetArgPointee<2>(false), Return(true)));
-    EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(usage_table_header))
+    EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(_, usage_table_header))
         .WillOnce(Return(NO_ERROR));
     EXPECT_TRUE(usage_table_header_->Init(security_level, crypto_session_));
   }
@@ -594,14 +597,17 @@ class UsageTableHeaderInitializationTest
 };
 
 TEST_P(UsageTableHeaderInitializationTest, CreateUsageTableHeader) {
+  const SecurityLevel security_level =
+      (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
   EXPECT_CALL(*device_files_,
               RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kEmptyUsageTableHeader),
                       SetArgPointee<1>(kEmptyUsageEntryInfoVector),
                       SetArgPointee<2>(false), Return(false)));
-  EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
+  EXPECT_CALL(*crypto_session_,
+              CreateUsageTableHeader(security_level, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR)));
   EXPECT_CALL(*device_files_, StoreUsageTableInfo(kEmptyUsageTableHeader,
                                                   kEmptyUsageEntryInfoVector))
       .WillOnce(Return(true));
@@ -610,14 +616,17 @@ TEST_P(UsageTableHeaderInitializationTest, CreateUsageTableHeader) {
 }
 
 TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveLicenses) {
+  const SecurityLevel security_level =
+      (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
   EXPECT_CALL(*device_files_,
               RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kEmptyUsageTableHeader),
                       SetArgPointee<1>(kEmptyUsageEntryInfoVector),
                       SetArgPointee<2>(false), Return(false)));
-  EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
+  EXPECT_CALL(*crypto_session_,
+              CreateUsageTableHeader(security_level, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR)));
   // TODO: Why not being called?
   //EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true));
   EXPECT_CALL(*device_files_, StoreUsageTableInfo(kEmptyUsageTableHeader,
@@ -628,14 +637,17 @@ TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveLicenses) {
 }
 
 TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveUsageInfo) {
+  const SecurityLevel security_level =
+      (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
   EXPECT_CALL(*device_files_,
               RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kEmptyUsageTableHeader),
                       SetArgPointee<1>(kEmptyUsageEntryInfoVector),
                       SetArgPointee<2>(false), Return(false)));
-  EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
+  EXPECT_CALL(*crypto_session_,
+              CreateUsageTableHeader(security_level, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR)));
   EXPECT_CALL(*device_files_, StoreUsageTableInfo(kEmptyUsageTableHeader,
                                                   kEmptyUsageEntryInfoVector))
       .WillOnce(Return(true));
@@ -644,12 +656,15 @@ TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveUsageInfo) {
 }
 
 TEST_P(UsageTableHeaderInitializationTest, UsageTableHeaderExists) {
+  const SecurityLevel security_level =
+      (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
   EXPECT_CALL(*device_files_,
               RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
                       SetArgPointee<1>(kUsageEntryInfoVector),
                       SetArgPointee<2>(false), Return(true)));
-  EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
+  EXPECT_CALL(*crypto_session_,
+              LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
 
   EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
@@ -658,12 +673,15 @@ TEST_P(UsageTableHeaderInitializationTest, UsageTableHeaderExists) {
 TEST_P(UsageTableHeaderInitializationTest, 200UsageEntries) {
   std::vector<CdmUsageEntryInfo> usage_entries_200 = k201UsageEntryInfoVector;
   usage_entries_200.resize(200);
+  const SecurityLevel security_level =
+      (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
   EXPECT_CALL(*device_files_,
               RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
                       SetArgPointee<1>(usage_entries_200),
                       SetArgPointee<2>(false), Return(true)));
-  EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
+  EXPECT_CALL(*crypto_session_,
+              LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
 
   EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
@@ -681,11 +699,13 @@ TEST_P(UsageTableHeaderInitializationTest,
       (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
   EXPECT_CALL(*crypto_session_,
               Open(security_level)).WillOnce(Return(NO_ERROR));
-  EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
+  EXPECT_CALL(*crypto_session_,
+              LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
-  EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
+  EXPECT_CALL(*crypto_session_,
+              CreateUsageTableHeader(security_level, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR)));
   EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true));
   EXPECT_CALL(*device_files_, DeleteAllUsageInfo()).WillOnce(Return(true));
   EXPECT_CALL(*device_files_, DeleteUsageTableInfo()).WillOnce(Return(true));
@@ -706,17 +726,21 @@ TEST_P(UsageTableHeaderInitializationTest,
        201UsageEntries_DeleteEntryFails_UsageTableHeaderRecreated) {
   std::vector<CdmUsageEntryInfo> usage_entries_202 = k201UsageEntryInfoVector;
   usage_entries_202.push_back(kDummyUsageEntryInfo);
+  const SecurityLevel security_level =
+      (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
 
   EXPECT_CALL(*device_files_,
               RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
                       SetArgPointee<1>(k201UsageEntryInfoVector),
                       SetArgPointee<2>(false), Return(true)));
-  EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
+  EXPECT_CALL(*crypto_session_,
+              LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
-  EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
+  EXPECT_CALL(*crypto_session_,
+              CreateUsageTableHeader(security_level, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR)));
   EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true));
   EXPECT_CALL(*device_files_, DeleteAllUsageInfo()).WillOnce(Return(true));
   EXPECT_CALL(*device_files_, DeleteUsageTableInfo()).WillOnce(Return(true));
@@ -734,16 +758,12 @@ TEST_P(UsageTableHeaderInitializationTest,
       .WillOnce(Return(true));
 
   // Expectations for DeleteEntry
-  const SecurityLevel security_level =
+  EXPECT_CALL(*crypto_session_, Open(security_level))
-      (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
+      .WillOnce(Return(NO_ERROR));
   EXPECT_CALL(*crypto_session_,
-              Open(security_level))
+              ShrinkUsageTableHeader(security_level,
-      .Times(2)
+                                     usage_entries_202.size() - 1, NotNull()))
-      .WillRepeatedly(Return(NO_ERROR));
+      .WillOnce(Return(SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR));
-  EXPECT_CALL(
-      *crypto_session_,
-      ShrinkUsageTableHeader(usage_entries_202.size() - 1, NotNull()))
-      .WillOnce(Return(SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR));
 
   EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
 }
@@ -753,12 +773,16 @@ TEST_P(UsageTableHeaderInitializationTest,
   std::vector<CdmUsageEntryInfo> usage_entries_202 = k201UsageEntryInfoVector;
   usage_entries_202.push_back(kDummyUsageEntryInfo);
 
+  const SecurityLevel security_level =
+      (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
+
   EXPECT_CALL(*device_files_,
               RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
                       SetArgPointee<1>(k201UsageEntryInfoVector),
                       SetArgPointee<2>(false), Return(true)));
-  EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
+  EXPECT_CALL(*crypto_session_,
+              LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
 
   // Expectations for AddEntry
@@ -771,18 +795,13 @@ TEST_P(UsageTableHeaderInitializationTest,
       .WillOnce(Return(true));
 
   // Expectations for DeleteEntry
-  const SecurityLevel security_level =
+  EXPECT_CALL(*crypto_session_, Open(security_level))
-      (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
+      .WillOnce(Return(NO_ERROR));
-
   EXPECT_CALL(*crypto_session_,
-              Open(security_level))
+              ShrinkUsageTableHeader(security_level,
-      .Times(2)
+                                     usage_entries_202.size() - 1, NotNull()))
-      .WillRepeatedly(Return(NO_ERROR));
-  EXPECT_CALL(
-      *crypto_session_,
-      ShrinkUsageTableHeader(usage_entries_202.size() - 1, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
   EXPECT_CALL(*device_files_,
               StoreUsageTableInfo(
                   kAnotherUsageTableHeader,
@@ -1302,11 +1321,10 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_CryptoSessionError) {
       usage_entry_info_vector.size() - 1;  // kUsageEntryInfoOfflineLicense2
   metrics::CryptoMetrics metrics;
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
+  EXPECT_CALL(*crypto_session_,
-  EXPECT_CALL(
+              ShrinkUsageTableHeader(
-      *crypto_session_,
+                  kLevelDefault, usage_entry_info_vector.size() - 1, NotNull()))
-      ShrinkUsageTableHeader(usage_entry_info_vector.size() - 1, NotNull()))
+      .WillOnce(Return(SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR));
-      .WillOnce(Return(SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR));
 
   EXPECT_NE(NO_ERROR,
             usage_table_header_->DeleteEntry(usage_entry_number_to_be_deleted,
@@ -1341,12 +1359,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastOfflineEntry) {
       usage_entry_info_vector.size() - 1;  // kUsageEntryInfoOfflineLicense2
   metrics::CryptoMetrics metrics;
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
+  EXPECT_CALL(*crypto_session_,
-  EXPECT_CALL(
+              ShrinkUsageTableHeader(
-      *crypto_session_,
+                  kLevelDefault, usage_entry_info_vector.size() - 1, NotNull()))
-      ShrinkUsageTableHeader(usage_entry_info_vector.size() - 1, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
 
   EXPECT_CALL(*device_files_,
               StoreUsageTableInfo(
@@ -1389,12 +1406,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastSecureStopEntry) {
       usage_entry_info_vector.size() - 1;  // kUsageEntryInfoSecureStop2
   metrics::CryptoMetrics metrics;
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
+  EXPECT_CALL(*crypto_session_,
-  EXPECT_CALL(
+              ShrinkUsageTableHeader(
-      *crypto_session_,
+                  kLevelDefault, usage_entry_info_vector.size() - 1, NotNull()))
-      ShrinkUsageTableHeader(usage_entry_info_vector.size() - 1, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
 
   EXPECT_CALL(*device_files_,
               StoreUsageTableInfo(
@@ -1440,12 +1456,11 @@ TEST_F(UsageTableHeaderTest,
       usage_entry_info_vector.size() - 3;  // kUsageEntryInfoOfflineLicense1
   metrics::CryptoMetrics metrics;
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
+  EXPECT_CALL(*crypto_session_,
-  EXPECT_CALL(
+              ShrinkUsageTableHeader(
-      *crypto_session_,
+                  kLevelDefault, usage_entry_number_to_be_deleted, NotNull()))
-      ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
 
   EXPECT_CALL(*device_files_,
               StoreUsageTableInfo(
@@ -1498,12 +1513,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastSecureStopEntriesAreMissing) {
       usage_entry_info_vector.size() - 3;  // kUsageEntryInfoSecureStop1
   metrics::CryptoMetrics metrics;
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
+  EXPECT_CALL(*crypto_session_,
-  EXPECT_CALL(
+              ShrinkUsageTableHeader(
-      *crypto_session_,
+                  kLevelDefault, usage_entry_number_to_be_deleted, NotNull()))
-      ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
 
   EXPECT_CALL(*device_files_,
               RetrieveUsageInfoByKeySetId(
@@ -1599,12 +1613,11 @@ TEST_F(UsageTableHeaderTest,
       device_files_->StoreLicense(offline_license_2_data, &sub_error_code));
   EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
+  EXPECT_CALL(*crypto_session_,
-  EXPECT_CALL(
+              ShrinkUsageTableHeader(
-      *crypto_session_,
+                  kLevelDefault, usage_entry_number_to_be_deleted, NotNull()))
-      ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
   EXPECT_CALL(*device_files_,
               StoreUsageTableInfo(
                   kAnotherUsageTableHeader,
@@ -1657,12 +1670,11 @@ TEST_F(UsageTableHeaderTest,
       usage_entry_number_to_be_deleted + 1;
   metrics::CryptoMetrics metrics;
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
+  EXPECT_CALL(*crypto_session_,
-  EXPECT_CALL(
+              ShrinkUsageTableHeader(
-      *crypto_session_,
+                  kLevelDefault, usage_entry_number_to_be_deleted, NotNull()))
-      ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
 
   EXPECT_CALL(*device_files_,
               RetrieveUsageInfoByKeySetId(
@@ -1733,12 +1745,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreStorageTypeUnknown) {
       usage_entry_info_vector.size() - 3;  // kUsageEntryInfoOfflineLicense3
   metrics::CryptoMetrics metrics;
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
+  EXPECT_CALL(*crypto_session_,
-  EXPECT_CALL(
+              ShrinkUsageTableHeader(
-      *crypto_session_,
+                  kLevelDefault, usage_entry_number_to_be_deleted, NotNull()))
-      ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
 
   EXPECT_CALL(
       *device_files_,
@@ -1969,20 +1980,18 @@ TEST_F(UsageTableHeaderTest,
   EXPECT_TRUE(device_files_->StoreLicense(license_data, &sub_error_code));
   EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
+  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
-      .Times(2)
-      .WillRepeatedly(Return(NO_ERROR));
   EXPECT_CALL(*crypto_session_,
               LoadUsageEntry(last_valid_usage_entry_number, kUsageEntry))
       .WillOnce(Return(NO_ERROR));
   EXPECT_CALL(*crypto_session_,
               MoveUsageEntry(usage_entry_number_to_be_deleted))
       .WillOnce(Return(MOVE_USAGE_ENTRY_UNKNOWN_ERROR));
-  EXPECT_CALL(
+  EXPECT_CALL(*crypto_session_,
-      *crypto_session_,
+              ShrinkUsageTableHeader(
-      ShrinkUsageTableHeader(last_valid_usage_entry_number + 1, NotNull()))
+                  kLevelDefault, last_valid_usage_entry_number + 1, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
 
   EXPECT_CALL(
       *device_files_,
@@ -2044,9 +2053,7 @@ TEST_F(UsageTableHeaderTest,
       usage_entry_info_vector.size() - 3;  // kUsageEntryInfoOfflineLicense3
   metrics::CryptoMetrics metrics;
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
+  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
-      .Times(2)
-      .WillRepeatedly(Return(NO_ERROR));
   EXPECT_CALL(*crypto_session_,
               LoadUsageEntry(last_valid_usage_entry_number, kUsageEntry))
       .WillOnce(Return(NO_ERROR));
@@ -2064,11 +2071,11 @@ TEST_F(UsageTableHeaderTest,
                 SetArgPointee<3>(kKeyRequest), SetArgPointee<4>(kKeyResponse),
                 SetArgPointee<5>(kUsageEntry),
                 SetArgPointee<6>(last_valid_usage_entry_number), Return(true)));
-  EXPECT_CALL(
+  EXPECT_CALL(*crypto_session_,
-      *crypto_session_,
+              ShrinkUsageTableHeader(
-      ShrinkUsageTableHeader(last_valid_usage_entry_number + 1, NotNull()))
+                  kLevelDefault, last_valid_usage_entry_number + 1, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
 
   EXPECT_CALL(
       *device_files_,
@@ -2139,9 +2146,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsOffline) {
       device_files_->StoreLicense(stored_license_data, &sub_error_code));
   EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
+  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
-      .Times(2)
-      .WillRepeatedly(Return(NO_ERROR));
   EXPECT_CALL(*crypto_session_,
               LoadUsageEntry(last_usage_entry_number, kUsageEntry))
       .WillOnce(Return(NO_ERROR));
@@ -2151,10 +2156,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsOffline) {
   EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader),
                       SetArgPointee<1>(kAnotherUsageEntry), Return(NO_ERROR)));
-  EXPECT_CALL(*crypto_session_,
+  EXPECT_CALL(
-              ShrinkUsageTableHeader(last_usage_entry_number, NotNull()))
+      *crypto_session_,
+      ShrinkUsageTableHeader(kLevelDefault, last_usage_entry_number, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
 
   EXPECT_CALL(
       *device_files_,
@@ -2244,9 +2250,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsSecureStop) {
       usage_entry_info_vector.size() - 1;  // kUsageEntryInfoSecureStop3
   metrics::CryptoMetrics metrics;
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
+  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
-      .Times(2)
-      .WillRepeatedly(Return(NO_ERROR));
   EXPECT_CALL(*crypto_session_,
               LoadUsageEntry(last_usage_entry_number, kUsageEntry))
       .WillOnce(Return(NO_ERROR));
@@ -2256,10 +2260,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsSecureStop) {
   EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader),
                       SetArgPointee<1>(kAnotherUsageEntry), Return(NO_ERROR)));
-  EXPECT_CALL(*crypto_session_,
+  EXPECT_CALL(
-              ShrinkUsageTableHeader(last_usage_entry_number, NotNull()))
+      *crypto_session_,
+      ShrinkUsageTableHeader(kLevelDefault, last_usage_entry_number, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
 
   EXPECT_CALL(*device_files_,
               RetrieveUsageInfoByKeySetId(
@@ -2367,9 +2372,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreOfflineAndUnknknown) {
       device_files_->StoreLicense(stored_license_data, &sub_error_code));
   EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
+  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
-      .Times(2)
-      .WillRepeatedly(Return(NO_ERROR));
   EXPECT_CALL(*crypto_session_,
               LoadUsageEntry(last_valid_usage_entry_number, kUsageEntry))
       .WillOnce(Return(NO_ERROR));
@@ -2380,9 +2383,10 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreOfflineAndUnknknown) {
       .WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader),
                       SetArgPointee<1>(kAnotherUsageEntry), Return(NO_ERROR)));
   EXPECT_CALL(*crypto_session_,
-              ShrinkUsageTableHeader(last_valid_usage_entry_number, NotNull()))
+              ShrinkUsageTableHeader(kLevelDefault,
+                                     last_valid_usage_entry_number, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
 
   EXPECT_CALL(
       *device_files_,
@@ -2477,9 +2481,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreSecureStopAndUnknknown) {
       usage_entry_info_vector.size() - 3;  // kUsageEntryInfoSecureStop3
   metrics::CryptoMetrics metrics;
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
+  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
-      .Times(2)
-      .WillRepeatedly(Return(NO_ERROR));
   EXPECT_CALL(*crypto_session_,
               LoadUsageEntry(last_valid_usage_entry_number, kUsageEntry))
       .WillOnce(Return(NO_ERROR));
@@ -2490,9 +2492,10 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreSecureStopAndUnknknown) {
       .WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader),
                       SetArgPointee<1>(kAnotherUsageEntry), Return(NO_ERROR)));
   EXPECT_CALL(*crypto_session_,
-              ShrinkUsageTableHeader(last_valid_usage_entry_number, NotNull()))
+              ShrinkUsageTableHeader(kLevelDefault,
+                                     last_valid_usage_entry_number, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
 
   EXPECT_CALL(*device_files_,
               RetrieveUsageInfoByKeySetId(
@@ -2557,11 +2560,13 @@ TEST_F(UsageTableHeaderTest, StaleHeader) {
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
                       SetArgPointee<1>(usage_entry_info_vector),
                       SetArgPointee<2>(false), Return(true)));
-  EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
+  EXPECT_CALL(*crypto_session_,
+              LoadUsageTableHeader(kLevelDefault, kUsageTableHeader))
       .WillOnce(Return(LOAD_USAGE_HEADER_GENERATION_SKEW));
-  EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
+  EXPECT_CALL(*crypto_session_,
+              CreateUsageTableHeader(kLevelDefault, NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
+          DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR)));
   EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true));
   EXPECT_CALL(*device_files_, DeleteAllUsageInfo()).WillOnce(Return(true));
   EXPECT_CALL(*device_files_, DeleteUsageTableInfo()).WillOnce(Return(true));
@@ -2580,7 +2585,9 @@ TEST_F(UsageTableHeaderTest, Shrink_NoneOfTable) {
 
   // These calls are "expensive" and should be avoided if possible.
   EXPECT_CALL(*crypto_session_, Open(_)).Times(0);
-  EXPECT_CALL(*crypto_session_, ShrinkUsageTableHeader(_, NotNull())).Times(0);
+  EXPECT_CALL(*crypto_session_,
+              ShrinkUsageTableHeader(kLevelDefault, _, NotNull()))
+      .Times(0);
   EXPECT_CALL(*device_files_, StoreUsageTableInfo(_, _)).Times(0);
 
   EXPECT_EQ(usage_table_header_->Shrink(&metrics, 0), NO_ERROR);
@@ -2595,9 +2602,9 @@ TEST_F(UsageTableHeaderTest, Shrink_PartOfTable) {
       k10UsageEntryInfoVector.cend() - to_shink);
   metrics::CryptoMetrics metrics;
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
+  EXPECT_CALL(
-  EXPECT_CALL(*crypto_session_,
+      *crypto_session_,
-              ShrinkUsageTableHeader(shunken_entries.size(), NotNull()))
+      ShrinkUsageTableHeader(kLevelDefault, shunken_entries.size(), NotNull()))
       .WillOnce(Return(NO_ERROR));
   EXPECT_CALL(*device_files_,
               StoreUsageTableInfo(kUsageTableHeader, shunken_entries))
@@ -2611,8 +2618,8 @@ TEST_F(UsageTableHeaderTest, Shrink_AllOfTable) {
   Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector);
   metrics::CryptoMetrics metrics;
 
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
+  EXPECT_CALL(*crypto_session_,
-  EXPECT_CALL(*crypto_session_, ShrinkUsageTableHeader(0, NotNull()))
+              ShrinkUsageTableHeader(kLevelDefault, 0, NotNull()))
       .WillOnce(Return(NO_ERROR));
   EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader,
                                                   kEmptyUsageEntryInfoVector))
@@ -2628,8 +2635,8 @@ TEST_F(UsageTableHeaderTest, Shrink_AllOfTable) {
 TEST_F(UsageTableHeaderTest, Shrink_MoreThanTable) {
   Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector);
   metrics::CryptoMetrics metrics;
-  EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
+  EXPECT_CALL(*crypto_session_,
-  EXPECT_CALL(*crypto_session_, ShrinkUsageTableHeader(0, NotNull()))
+              ShrinkUsageTableHeader(kLevelDefault, 0, NotNull()))
       .WillOnce(Return(NO_ERROR));
   EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader,
                                                   kEmptyUsageEntryInfoVector))
@@ -2654,7 +2661,7 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_NoAction) {
                       SetArgPointee<2>(/* lru_upgrade = */ false),
                       Return(true)));
   EXPECT_CALL(*crypto_session_,
-              LoadUsageTableHeader(kUpgradableUsageTableHeader))
+              LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
 
   // These function are called specifically by the LRU upgrading system.
@@ -2680,7 +2687,7 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_Succeed) {
                       SetArgPointee<2>(/* lru_upgrade = */ true),
                       Return(true)));
   EXPECT_CALL(*crypto_session_,
-              LoadUsageTableHeader(kUpgradableUsageTableHeader))
+              LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
 
   for (size_t i = 0; i < kUpgradableUsageEntryInfoList.size(); ++i) {
@@ -2744,7 +2751,7 @@ TEST_F(UsageTableHeaderTest,
                       SetArgPointee<2>(/* lru_upgrade = */ true),
                       Return(true)));
   EXPECT_CALL(*crypto_session_,
-              LoadUsageTableHeader(kUpgradableUsageTableHeader))
+              LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
 
   // Expectations of the one successful license.
@@ -2804,7 +2811,7 @@ TEST_F(UsageTableHeaderTest,
                       SetArgPointee<2>(/* lru_upgrade = */ true),
                       Return(true)));
   EXPECT_CALL(*crypto_session_,
-              LoadUsageTableHeader(kUpgradableUsageTableHeader))
+              LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
 
   for (size_t i = 0; i < kUpgradableUsageEntryInfoList.size(); ++i) {
@@ -2857,7 +2864,7 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_AllFailure) {
                       SetArgPointee<2>(/* lru_upgrade = */ true),
                       Return(true)));
   EXPECT_CALL(*crypto_session_,
-              LoadUsageTableHeader(kUpgradableUsageTableHeader))
+              LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
 
   for (size_t i = 0; i < kUpgradableUsageEntryInfoList.size(); ++i) {
@@ -2881,7 +2888,8 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_AllFailure) {
   EXPECT_CALL(*device_files_, DeleteAllLicenses());
   EXPECT_CALL(*device_files_, DeleteAllUsageInfo());
   EXPECT_CALL(*device_files_, DeleteUsageTableInfo());
-  EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
+  EXPECT_CALL(*crypto_session_,
+              CreateUsageTableHeader(kLevelDefault, NotNull()))
       .WillOnce(Return(NO_ERROR));
   EXPECT_CALL(*device_files_, StoreUsageTableInfo(_, _));
 
@@ -2896,7 +2904,8 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateLicenseEntry) {
                       SetArgPointee<1>(kUpgradedUsageEntryInfoList),
                       SetArgPointee<2>(/* lru_upgrade = */ false),
                       Return(true)));
-  EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUpgradedUsageTableHeader))
+  EXPECT_CALL(*crypto_session_,
+              LoadUsageTableHeader(kLevelDefault, kUpgradedUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
   EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_));
 
@@ -2940,7 +2949,8 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateUsageInfoEntry) {
                       SetArgPointee<1>(kUpgradedUsageEntryInfoList),
                       SetArgPointee<2>(/* lru_upgrade = */ false),
                       Return(true)));
-  EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUpgradedUsageTableHeader))
+  EXPECT_CALL(*crypto_session_,
+              LoadUsageTableHeader(kLevelDefault, kUpgradedUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
   EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_));
 
@@ -2985,7 +2995,8 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_UpdateEntry) {
                       SetArgPointee<1>(kUpgradedUsageEntryInfoList),
                       SetArgPointee<2>(/* lru_upgrade = */ false),
                       Return(true)));
-  EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUpgradedUsageTableHeader))
+  EXPECT_CALL(*crypto_session_,
+              LoadUsageTableHeader(kLevelDefault, kUpgradedUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
   EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_));
 
@@ -3027,7 +3038,8 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_LoadEntry) {
                       SetArgPointee<1>(kUpgradedUsageEntryInfoList),
                       SetArgPointee<2>(/* lru_upgrade = */ false),
                       Return(true)));
-  EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUpgradedUsageTableHeader))
+  EXPECT_CALL(*crypto_session_,
+              LoadUsageTableHeader(kLevelDefault, kUpgradedUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
   EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_));
 

libwvdrmengine/include/WVErrors.h

@@ -206,7 +206,7 @@ enum {
   kLoadUsageEntrySignatureFailure = ERROR_DRM_VENDOR_MIN + 218,
   kLoadUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 219,
   kUpdateUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 222,
-  kShrinkUsageTablerHeaderUnknownError = ERROR_DRM_VENDOR_MIN + 224,
+  kShrinkUsageTableHeaderUnknownError = ERROR_DRM_VENDOR_MIN + 224,
   kMoveUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 225,
   kCopyOldUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 226,
   kInvalidParametersEng22 = ERROR_DRM_VENDOR_MIN + 227,
@@ -289,10 +289,13 @@ enum {
   kCannotDecryptZeroSubsamples = ERROR_DRM_VENDOR_MIN + 306,
   kSampleAndSubsampleSizeMismatch = ERROR_DRM_VENDOR_MIN + 307,
   kInvalidIvSize = ERROR_DRM_VENDOR_MIN + 308,
+  kLoadUsageEntryInvalidSession = ERROR_DRM_VENDOR_MIN + 309,
+  kMoveUsageEntryDestinationInUse = ERROR_DRM_VENDOR_MIN + 310,
+  kShrinkUsageTableHeaderEntryInUse = ERROR_DRM_VENDOR_MIN + 311,
 
   // This should always follow the last error code.
   // The offset value should be updated each time a new error code is added.
-  kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 308,
+  kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 311,
 
   // Used by crypto test mode
   kErrorTestMode = ERROR_DRM_VENDOR_MAX,

libwvdrmengine/include/mapErrors-inl.h

@@ -378,6 +378,8 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
       return kLoadSystemIdError;
     case wvcdm::LOAD_USAGE_ENTRY_GENERATION_SKEW:
       return kLoadUsageEntryGenerationSkew;
+    case wvcdm::LOAD_USAGE_ENTRY_INVALID_SESSION:
+      return kLoadUsageEntryInvalidSession;
     case wvcdm::LOAD_USAGE_ENTRY_SIGNATURE_FAILURE:
       return kLoadUsageEntrySignatureFailure;
     case wvcdm::LOAD_USAGE_ENTRY_UNKNOWN_ERROR:
@@ -394,6 +396,8 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
       return kLoadUsageInfoFileError;
     case wvcdm::LOAD_USAGE_INFO_MISSING:
       return kLoadUsageInfoMissing;
+    case wvcdm::MOVE_USAGE_ENTRY_DESTINATION_IN_USE:
+      return kMoveUsageEntryDestinationInUse;
     case wvcdm::MOVE_USAGE_ENTRY_UNKNOWN_ERROR:
       return kMoveUsageEntryUnknownError;
     case wvcdm::NOT_AN_ENTITLEMENT_SESSION:
@@ -492,8 +496,10 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
       return kSessionNotFound16;
     case wvcdm::SET_DECRYPT_HASH_ERROR:
       return kSetDecryptHashError;
-    case wvcdm::SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR:
+    case wvcdm::SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE:
-      return kShrinkUsageTablerHeaderUnknownError;
+      return kShrinkUsageTableHeaderEntryInUse;
+    case wvcdm::SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR:
+      return kShrinkUsageTableHeaderUnknownError;
     case wvcdm::SIGNATURE_NOT_FOUND:
       return kSignatureNotFound;
     case wvcdm::SIGNATURE_NOT_FOUND_2:

libwvdrmengine/include_hidl/mapErrors-inl.h

@@ -246,7 +246,7 @@ static Status mapCdmResponseType(wvcdm::CdmResponseType res) {
     case wvcdm::LOAD_USAGE_ENTRY_SIGNATURE_FAILURE:
     case wvcdm::LOAD_USAGE_ENTRY_UNKNOWN_ERROR:
     case wvcdm::UPDATE_USAGE_ENTRY_UNKNOWN_ERROR:
-    case wvcdm::SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR:
+    case wvcdm::SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR:
     case wvcdm::MOVE_USAGE_ENTRY_UNKNOWN_ERROR:
     case wvcdm::COPY_OLD_USAGE_ENTRY_UNKNOWN_ERROR:
     case wvcdm::INVALID_PARAMETERS_ENG_22:
@@ -355,6 +355,9 @@ static Status mapCdmResponseType(wvcdm::CdmResponseType res) {
     case wvcdm::CANNOT_DECRYPT_ZERO_SUBSAMPLES:
     case wvcdm::SAMPLE_AND_SUBSAMPLE_SIZE_MISMATCH:
     case wvcdm::INVALID_IV_SIZE:
+    case wvcdm::LOAD_USAGE_ENTRY_INVALID_SESSION:
+    case wvcdm::MOVE_USAGE_ENTRY_DESTINATION_IN_USE:
+    case wvcdm::SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE:
       ALOGW("Returns UNKNOWN error for legacy status: %d", res);
       return Status::ERROR_DRM_UNKNOWN;
 

libwvdrmengine/oemcrypto/ref/src/oemcrypto_session.cpp

@@ -210,14 +210,6 @@ SessionContext::SessionContext(CryptoEngine* ce, SessionId sid,
 }
 
 SessionContext::~SessionContext() {
-  if (usage_entry_) {
-    delete usage_entry_;
-    usage_entry_ = nullptr;
-  }
-  if (session_keys_) {
-    delete session_keys_;
-    session_keys_ = nullptr;
-  }
 }
 
 // Internal utility function to derive key using CMAC-128
@@ -777,11 +769,11 @@ OEMCryptoResult SessionContext::LoadKeysNoSignature(
   if (session_keys_ == nullptr) {
     switch (license_type) {
       case OEMCrypto_ContentLicense:
-        session_keys_ = new ContentKeysContext();
+        session_keys_.reset(new ContentKeysContext());
         break;
 
       case OEMCrypto_EntitlementLicense:
-        session_keys_ = new EntitlementKeysContext();
+        session_keys_.reset(new EntitlementKeysContext());
         break;
 
       default:
@@ -915,7 +907,8 @@ OEMCryptoResult SessionContext::LoadEntitledContentKeys(
   if (!key_array) {
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
-  if (!session_keys_ || session_keys_->type() != OEMCrypto_EntitlementLicense) {
+  if (session_keys_ == nullptr ||
+      session_keys_->type() != OEMCrypto_EntitlementLicense) {
     return OEMCrypto_ERROR_INVALID_CONTEXT;
   }
   for (size_t i = 0; i < key_array_length; ++i) {
@@ -1494,8 +1487,8 @@ OEMCryptoResult SessionContext::UpdateUsageEntry(uint8_t* header_buffer,
     return OEMCrypto_ERROR_INVALID_CONTEXT;
   }
   return ce_->usage_table().UpdateUsageEntry(
-      this, usage_entry_, header_buffer, header_buffer_length, entry_buffer,
+      this, usage_entry_.get(), header_buffer, header_buffer_length,
-      entry_buffer_length, &clock_values_);
+      entry_buffer, entry_buffer_length, &clock_values_);
 }
 
 OEMCryptoResult SessionContext::DeactivateUsageEntry(
@@ -1514,7 +1507,7 @@ OEMCryptoResult SessionContext::ReportUsage(const std::vector<uint8_t>& pst,
 
 OEMCryptoResult SessionContext::MoveEntry(uint32_t new_index) {
   if (!usage_entry_) return OEMCrypto_ERROR_INVALID_CONTEXT;
-  return ce_->usage_table().MoveEntry(usage_entry_, new_index);
+  return ce_->usage_table().MoveEntry(usage_entry_.get(), new_index);
 }
 
 // Internal utility function to decrypt the message

libwvdrmengine/oemcrypto/ref/src/oemcrypto_session.h

@@ -267,7 +267,7 @@ class SessionContext {
   std::vector<uint8_t> encryption_key_;
   std::vector<uint8_t> session_key_;
   const Key* current_content_key_;
-  SessionContextKeys* session_keys_;
+  std::unique_ptr<SessionContextKeys> session_keys_;
   ODK_NonceValues nonce_values_;
   uint8_t license_request_hash_[ODK_SHA256_HASH_SIZE];
   RSA_shared_ptr rsa_key_;
@@ -275,7 +275,7 @@ class SessionContext {
   bool decrypt_started_;      // If the license has been used in this session.
   ODK_TimerLimits timer_limits_;
   ODK_ClockValues clock_values_;
-  UsageTableEntry* usage_entry_;
+  std::unique_ptr<UsageTableEntry> usage_entry_;
   SRMVersionStatus srm_requirements_status_;
   enum UsageEntryStatus {
     kNoUsageEntry,      // No entry loaded for this session.

libwvdrmengine/oemcrypto/ref/src/oemcrypto_usage_table_ref.cpp

@@ -348,9 +348,9 @@ UsageTableEntry* UsageTable::MakeEntry(uint32_t index) {
   return new UsageTableEntry(this, index, master_generation_number_);
 }
 
-OEMCryptoResult UsageTable::CreateNewUsageEntry(SessionContext* session,
+OEMCryptoResult UsageTable::CreateNewUsageEntry(
-                                                UsageTableEntry** entry,
+    SessionContext* session, std::unique_ptr<UsageTableEntry>* entry,
-                                                uint32_t* usage_entry_number) {
+    uint32_t* usage_entry_number) {
   if (!header_loaded_) {
     LOGE("CreateNewUsageEntry: Header not loaded.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
@@ -367,16 +367,15 @@ OEMCryptoResult UsageTable::CreateNewUsageEntry(SessionContext* session,
   generation_numbers_.push_back(master_generation_number_);
   sessions_.push_back(session);
   master_generation_number_++;
-  *entry = new_entry;
+  entry->reset(new_entry);
   *usage_entry_number = index;
   return OEMCrypto_SUCCESS;
 }
 
-OEMCryptoResult UsageTable::LoadUsageEntry(SessionContext* session,
+OEMCryptoResult UsageTable::LoadUsageEntry(
-                                           UsageTableEntry** entry,
+    SessionContext* session, std::unique_ptr<UsageTableEntry>* entry,
-                                           uint32_t index,
+    uint32_t index, const std::vector<uint8_t>& buffer,
-                                           const std::vector<uint8_t>& buffer,
+    ODK_ClockValues* clock_values) {
-                                           ODK_ClockValues* clock_values) {
   if (!header_loaded_) {
     LOGE("CreateNewUsageEntry: Header not loaded.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
@@ -393,12 +392,11 @@ OEMCryptoResult UsageTable::LoadUsageEntry(SessionContext* session,
     LOGE("Too many usage entries: %d/%d", index, max);
     return OEMCrypto_ERROR_INSUFFICIENT_RESOURCES;
   }
-  UsageTableEntry* new_entry = MakeEntry(index);
+  std::unique_ptr<UsageTableEntry> new_entry(MakeEntry(index));
 
   OEMCryptoResult status =
       new_entry->LoadData(ce_, index, buffer, clock_values);
   if (status != OEMCrypto_SUCCESS) {
-    delete new_entry;
     return status;
   }
   if (new_entry->generation_number() != generation_numbers_[index]) {
@@ -406,13 +404,12 @@ OEMCryptoResult UsageTable::LoadUsageEntry(SessionContext* session,
          generation_numbers_[index]);
     if ((new_entry->generation_number() + 1 < generation_numbers_[index]) ||
         (new_entry->generation_number() - 1 > generation_numbers_[index])) {
-      delete new_entry;
       return OEMCrypto_ERROR_GENERATION_SKEW;
     }
     status = OEMCrypto_WARNING_GENERATION_SKEW;
   }
   sessions_[index] = session;
-  *entry = new_entry;
+  *entry = std::move(new_entry);
   return status;
 }
 

libwvdrmengine/oemcrypto/ref/src/oemcrypto_usage_table_ref.h

@@ -88,10 +88,11 @@ class UsageTable {
   virtual ~UsageTable();
 
   OEMCryptoResult CreateNewUsageEntry(SessionContext* session,
-                                      UsageTableEntry** entry,
+                                      std::unique_ptr<UsageTableEntry>* entry,
                                       uint32_t* usage_entry_number);
   OEMCryptoResult LoadUsageEntry(SessionContext* session,
-                                 UsageTableEntry** entry, uint32_t index,
+                                 std::unique_ptr<UsageTableEntry>* entry,
+                                 uint32_t index,
                                  const std::vector<uint8_t>& buffer,
                                  ODK_ClockValues* clock_values);
   OEMCryptoResult UpdateUsageEntry(