Revert "Core CDM: Retrieving USAGE_INFO triggers clean-up."

This reverts commit da9ba6c3ba.

Reason for revert: Feature rejected by Android

Bug: 242289743
Change-Id: Ia9ee53b4a897b4b52551c665e8551233abee6b6b

libwvdrmengine/cdm/core/include/device_files.h

@@ -277,14 +277,9 @@ class DeviceFiles {
   // When retrieving usage table information from the file system; any
   // table that has yet to be updated for the LRU attributes will be
   // indicated by |lru_upgrade|.
-  // Tables from earlier CDM releases might contain USAGE_INFO type
-  // entries.  This entries are no long required, by their presence
-  // requires the usage table to be cleaned up.  |has_usage_info_entries|
-  // is set to true if any are detected.
   virtual bool RetrieveUsageTableInfo(
       CdmUsageTableHeader* usage_table_header,
-      std::vector<CdmUsageEntryInfo>* usage_entry_info, bool* lru_upgrade,
+      std::vector<CdmUsageEntryInfo>* usage_entry_info, bool* lru_upgrade);
-      bool* has_usage_info_entries);
 
   virtual bool DeleteUsageTableInfo();
 

libwvdrmengine/cdm/core/src/device_files.cpp

@@ -1678,13 +1678,11 @@ bool DeviceFiles::StoreUsageTableInfo(
 
 bool DeviceFiles::RetrieveUsageTableInfo(
     CdmUsageTableHeader* usage_table_header,
-    std::vector<CdmUsageEntryInfo>* usage_entry_info, bool* lru_upgrade,
+    std::vector<CdmUsageEntryInfo>* usage_entry_info, bool* lru_upgrade) {
-    bool* has_usage_info_entries) {
   RETURN_FALSE_IF_UNINITIALIZED();
   RETURN_FALSE_IF_NULL(usage_table_header);
   RETURN_FALSE_IF_NULL(usage_entry_info);
   RETURN_FALSE_IF_NULL(lru_upgrade);
-  RETURN_FALSE_IF_NULL(has_usage_info_entries);
 
   video_widevine_client::sdk::File file;
   if (RetrieveHashedFile(GetUsageTableFileName(), &file) != kNoError) {
@@ -1714,7 +1712,6 @@ bool DeviceFiles::RetrieveUsageTableInfo(
   const UsageTableInfo& usage_table_info = file.usage_table_info();
 
   *lru_upgrade = !usage_table_info.use_lru();
-  *has_usage_info_entries = false;
 
   *usage_table_header = usage_table_info.usage_table_header();
   usage_entry_info->resize(usage_table_info.usage_entry_info_size());
@@ -1730,8 +1727,10 @@ bool DeviceFiles::RetrieveUsageTableInfo(
             info.offline_license_expiry_time();
         break;
       case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_USAGE_INFO:
-        (*usage_entry_info)[i].storage_type = kStorageTypeUnknown;
+        (*usage_entry_info)[i].storage_type = kStorageUsageInfo;
-        *has_usage_info_entries = true;
+        (*usage_entry_info)[i].usage_info_file_name =
+            info.usage_info_file_name();
+        (*usage_entry_info)[i].last_use_time = info.last_use_time();
         break;
       case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_UNKNOWN:
       default:

libwvdrmengine/cdm/core/src/usage_table_header.cpp

@@ -194,10 +194,8 @@ bool UsageTableHeader::Init(CdmSecurityLevel security_level,
 
 bool UsageTableHeader::RestoreTable(CryptoSession* const crypto_session) {
   bool run_lru_upgrade = false;
-  bool has_usage_info_entries = false;
   if (!device_files_->RetrieveUsageTableInfo(
-          &usage_table_header_, &usage_entry_info_, &run_lru_upgrade,
+          &usage_table_header_, &usage_entry_info_, &run_lru_upgrade)) {
-          &has_usage_info_entries)) {
     LOGW("Could not retrieve usage table");
     return false;
   }
@@ -212,15 +210,6 @@ bool UsageTableHeader::RestoreTable(CryptoSession* const crypto_session) {
     return false;
   }
 
-  // Remove all usage info entries from storage and clear their
-  // table meta data.
-  if (has_usage_info_entries) {
-    LOGI("Removing all usage info entries");
-    device_files_->DeleteAllUsageInfo();
-    // Store table to remove usage info entries from storage.
-    StoreTable();
-  }
-
   // If the saved usage entries/meta data is missing LRU information,
   // then the entries and their meta data must be updated.
   if (run_lru_upgrade && !LruUpgradeAllUsageEntries()) {

libwvdrmengine/cdm/core/test/device_files_unittest.cpp

@@ -3713,7 +3713,8 @@ const UsageTableTestInfo kUsageTableInfoTestData[] = {
 };
 
 const CdmUsageEntryInfo kUsageEntriesWithoutLruData[] = {
-    {kStorageLicense, "ksid0", "", 0, 0}, {kStorageTypeUnknown, "", "", 0, 0}};
+    {kStorageLicense, "ksid0", "", 0, 0},
+    {kStorageUsageInfo, "", "app_id_1", 0, 0}};
 
 const std::string kUsageTableWithoutLruData = a2bs_hex(
     "0A1F080510013A191209080112056B73696430120C08021A086170705F69645F"
@@ -5814,21 +5815,13 @@ TEST_P(DeviceFilesUsageTableTest, Read) {
   std::vector<CdmUsageEntryInfo> usage_entry_info;
   CdmUsageTableHeader usage_table_header;
   bool lru_upgrade;
-  bool has_usage_info_entries;
   ASSERT_TRUE(device_files.RetrieveUsageTableInfo(
-      &usage_table_header, &usage_entry_info, &lru_upgrade,
+      &usage_table_header, &usage_entry_info, &lru_upgrade));
-      &has_usage_info_entries));
   EXPECT_EQ(kUsageTableInfoTestData[index].usage_table_header,
             usage_table_header);
   EXPECT_EQ(index + 1u, usage_entry_info.size());
 
   for (size_t i = 0; i <= index; ++i) {
-    // TODO(b/242289743): Update test data to exclude usage info files.
-    if (kUsageEntriesTestData[i].storage_type == kStorageUsageInfo) {
-      // Usage info entry types are no longer loaded.
-      EXPECT_EQ(usage_entry_info[i].storage_type, kStorageTypeUnknown);
-      continue;
-    }
     EXPECT_EQ(kUsageEntriesTestData[i].storage_type,
               usage_entry_info[i].storage_type);
     EXPECT_EQ(kUsageEntriesTestData[i].key_set_id,
@@ -5870,10 +5863,8 @@ TEST_F(DeviceFilesUsageTableTest, ReadWithoutLruData) {
   std::vector<CdmUsageEntryInfo> usage_entry_info;
   CdmUsageTableHeader usage_table_header;
   bool lru_upgrade;
-  bool has_usage_info_entries;
   ASSERT_TRUE(device_files.RetrieveUsageTableInfo(
-      &usage_table_header, &usage_entry_info, &lru_upgrade,
+      &usage_table_header, &usage_entry_info, &lru_upgrade));
-      &has_usage_info_entries));
 
   EXPECT_EQ(ArraySize(kUsageEntriesWithoutLruData), usage_entry_info.size());
 

libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp

@@ -212,12 +212,6 @@ const std::vector<CdmUsageEntryInfo> k10UsageEntryInfoVector = {
     kUsageEntryInfoOfflineLicense4, kUsageEntryInfoSecureStop4,
     kUsageEntryInfoOfflineLicense5, kUsageEntryInfoSecureStop5,
 };
-const std::vector<CdmUsageEntryInfo> k5UsageEntryInfoVector = {
-    kUsageEntryInfoOfflineLicense1, kUsageEntryInfoOfflineLicense2,
-    kUsageEntryInfoOfflineLicense3, kUsageEntryInfoOfflineLicense4,
-    kUsageEntryInfoOfflineLicense5,
-};
-
 std::vector<CdmUsageEntryInfo> kOverFullUsageEntryInfoVector;
 
 const CdmOfflineLicenseState kActiveLicenseState = kLicenseStateActive;
@@ -300,6 +294,8 @@ const int64_t kUpgradedUsageEntryInfo3ExpireTime =
 const CdmUsageTableHeader kUpgradedUsageTableHeader = "Upgraded Table Header";
 std::vector<CdmUsageEntryInfo> kUpgradedUsageEntryInfoList;
 
+namespace {
+
 void InitVectorConstants() {
   kOverFullUsageEntryInfoVector.clear();
   for (size_t i = 0; i < (kDefaultTableCapacity + 1); ++i) {
@@ -377,6 +373,8 @@ void ToVector(std::vector<CdmUsageEntryInfo>& vec, const CdmUsageEntryInfo* arr,
   }
 }
 
+};  // namespace
+
 class MockDeviceFiles : public DeviceFiles {
  public:
   MockDeviceFiles() : DeviceFiles(&file_system_) { Init(kSecurityLevelL1); }
@@ -394,7 +392,7 @@ class MockDeviceFiles : public DeviceFiles {
 
   MOCK_METHOD(bool, RetrieveUsageTableInfo,
               (CdmUsageTableHeader*, std::vector<CdmUsageEntryInfo>*,
-               bool* lru_upgrade, bool* has_usage_info_entries),
+               bool* lru_upgrade),
               (override));
   MOCK_METHOD(bool, StoreUsageTableInfo,
               (const CdmUsageTableHeader&,
@@ -576,12 +574,11 @@ class UsageTableHeaderTest : public WvCdmTestBase {
             const std::vector<CdmUsageEntryInfo>& usage_entry_info_vector) {
     EXPECT_CALL(*crypto_session_, GetNumberOfOpenSessions(_, NotNull()))
         .WillOnce(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-    EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+    EXPECT_CALL(*device_files_,
-                                                       NotNull(), NotNull()))
+                RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
         .WillOnce(DoAll(SetArgPointee<0>(usage_table_header),
                         SetArgPointee<1>(usage_entry_info_vector),
-                        SetArgPointee<2>(false), SetArgPointee<3>(false),
+                        SetArgPointee<2>(false), Return(true)));
-                        Return(true)));
     EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(_, usage_table_header))
         .WillOnce(Return(NO_ERROR));
     EXPECT_TRUE(usage_table_header_->Init(security_level, crypto_session_));
@@ -626,12 +623,11 @@ TEST_P(UsageTableHeaderInitializationTest, RestoreUsageTable_Success) {
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(security_level, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
                       SetArgPointee<1>(kUsageEntryInfoVector),
-                      SetArgPointee<2>(false), SetArgPointee<3>(false),
+                      SetArgPointee<2>(false), Return(true)));
-                      Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
@@ -648,12 +644,11 @@ TEST_P(UsageTableHeaderInitializationTest,
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(security_level, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
                       SetArgPointee<1>(kUsageEntryInfoVector),
-                      SetArgPointee<2>(false), SetArgPointee<3>(false),
+                      SetArgPointee<2>(false), Return(true)));
-                      Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
@@ -683,8 +678,8 @@ TEST_P(UsageTableHeaderInitializationTest,
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(security_level, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(Return(false));
 
   // Expectations for create:
@@ -715,12 +710,11 @@ TEST_P(UsageTableHeaderInitializationTest,
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(security_level, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
                       SetArgPointee<1>(kUsageEntryInfoVector),
-                      SetArgPointee<2>(false), SetArgPointee<3>(false),
+                      SetArgPointee<2>(false), Return(true)));
-                      Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(LOAD_USAGE_HEADER_GENERATION_SKEW));
@@ -751,8 +745,8 @@ TEST_P(UsageTableHeaderInitializationTest,
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(security_level, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(Return(false));
   // Expectations for create:
   //  1) Create new header within OEMCrypto fails
@@ -775,8 +769,8 @@ TEST_P(UsageTableHeaderInitializationTest,
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(security_level, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(Return(false));
   // Expectations for create:
   //  1) Create new header within OEMCrypto succeeds
@@ -803,11 +797,11 @@ TEST_P(UsageTableHeaderInitializationTest, RestoreUsageTable_AtCapacity) {
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(security_level, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
                       SetArgPointee<1>(usage_entries), SetArgPointee<2>(false),
-                      SetArgPointee<3>(false), Return(true)));
+                      Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
@@ -830,11 +824,11 @@ TEST_P(UsageTableHeaderInitializationTest,
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(security_level, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
                       SetArgPointee<1>(usage_entries), SetArgPointee<2>(false),
-                      SetArgPointee<3>(false), Return(true)));
+                      Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
@@ -860,12 +854,11 @@ TEST_P(UsageTableHeaderInitializationTest,
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(security_level, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
                       SetArgPointee<1>(kOverFullUsageEntryInfoVector),
-                      SetArgPointee<2>(false), SetArgPointee<3>(false),
+                      SetArgPointee<2>(false), Return(true)));
-                      Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
@@ -918,12 +911,11 @@ TEST_P(UsageTableHeaderInitializationTest,
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(security_level, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
                       SetArgPointee<1>(kOverFullUsageEntryInfoVector),
-                      SetArgPointee<2>(false), SetArgPointee<3>(false),
+                      SetArgPointee<2>(false), Return(true)));
-                      Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
@@ -971,12 +963,11 @@ TEST_P(UsageTableHeaderInitializationTest,
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(security_level, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
                       SetArgPointee<1>(kOverFullUsageEntryInfoVector),
-                      SetArgPointee<2>(false), SetArgPointee<3>(false),
+                      SetArgPointee<2>(false), Return(true)));
-                      Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
@@ -1023,31 +1014,6 @@ TEST_P(UsageTableHeaderInitializationTest,
   EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
 }
 
-// If the stored usage table info contains entries of type USAGE_INFO,
-// these entries will not be included in the store, however, the
-// UsageTableHeader must delete the existing usage info files and
-// store the table.
-TEST_P(UsageTableHeaderInitializationTest, RestoreTableWithUsageInfo) {
-  EXPECT_CALL(*crypto_session_, GetNumberOfOpenSessions(_, NotNull()))
-      .WillOnce(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
-                                                     NotNull(), NotNull()))
-      .WillOnce(DoAll(
-          SetArgPointee<0>(kUsageTableHeader),
-          SetArgPointee<1>(k5UsageEntryInfoVector), SetArgPointee<2>(false),
-          SetArgPointee<3>(/* has_usage_info_entries = */ true), Return(true)));
-
-  EXPECT_CALL(*device_files_, DeleteAllUsageInfo()).WillOnce(Return(true));
-  EXPECT_CALL(*device_files_,
-              StoreUsageTableInfo(kUsageTableHeader, k5UsageEntryInfoVector))
-      .WillOnce(Return(true));
-
-  EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(_, kUsageTableHeader))
-      .WillOnce(Return(NO_ERROR));
-
-  EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
-}
-
 INSTANTIATE_TEST_SUITE_P(Cdm, UsageTableHeaderInitializationTest,
                          ::testing::Values(kSecurityLevelL1, kSecurityLevelL3));
 
@@ -3612,12 +3578,11 @@ TEST_F(UsageTableHeaderTest, StaleHeader) {
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(kLevelDefault, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
                       SetArgPointee<1>(usage_entry_info_vector),
-                      SetArgPointee<2>(false), SetArgPointee<3>(false),
+                      SetArgPointee<2>(false), Return(true)));
-                      Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(kLevelDefault, kUsageTableHeader))
       .WillOnce(Return(LOAD_USAGE_HEADER_GENERATION_SKEW));
@@ -3716,12 +3681,12 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_NoAction) {
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(kLevelDefault, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUpgradableUsageTableHeader),
                       SetArgPointee<1>(kUpgradableUsageEntryInfoList),
                       SetArgPointee<2>(/* lru_upgrade = */ false),
-                      SetArgPointee<3>(false), Return(true)));
+                      Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
@@ -3746,12 +3711,12 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_Succeed) {
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(kLevelDefault, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUpgradableUsageTableHeader),
                       SetArgPointee<1>(kUpgradableUsageEntryInfoList),
                       SetArgPointee<2>(/* lru_upgrade = */ true),
-                      SetArgPointee<3>(false), Return(true)));
+                      Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
@@ -3815,12 +3780,12 @@ TEST_F(UsageTableHeaderTest,
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(kLevelDefault, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUpgradableUsageTableHeader),
                       SetArgPointee<1>(upgradable_usage_entry_info_list),
                       SetArgPointee<2>(/* lru_upgrade = */ true),
-                      SetArgPointee<3>(false), Return(true)));
+                      Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
@@ -3878,12 +3843,12 @@ TEST_F(UsageTableHeaderTest,
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(kLevelDefault, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUpgradableUsageTableHeader),
                       SetArgPointee<1>(kUpgradableUsageEntryInfoList),
                       SetArgPointee<2>(/* lru_upgrade = */ true),
-                      SetArgPointee<3>(false), Return(true)));
+                      Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
@@ -3936,12 +3901,12 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_AllFailure) {
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(kLevelDefault, NotNull()))
       .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(),
+  EXPECT_CALL(*device_files_,
-                                                     NotNull(), NotNull()))
+              RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUpgradableUsageTableHeader),
                       SetArgPointee<1>(kUpgradableUsageEntryInfoList),
                       SetArgPointee<2>(/* lru_upgrade = */ true),
-                      SetArgPointee<3>(false), Return(true)));
+                      Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
       .WillOnce(Return(NO_ERROR));