Core CDM: Remove usage info as a run-time type.

[ Merge of http://go/wvgerrit/159221 ]

This CL modifies how usage entry info is tracked internally by the
CDM at run time.  It removes the different "storage types" that
entries represent (license or usage info), and instead it contains
only the information associated with license types.  The presences
of a key-set-id allows the UsageTableHeader to determine if the
entry slot is currently being used, or if it can be treated as
unoccupied.

By removing this different type, it completely prevents the CDM and
its tests from using "usage-info" type entries.  This required
significant updates to the UsageTableHeader tests.

Additionally, several of the variable names within the usage table
have been simplified and shortened to reflect their new meanings.

Bug: 242289743
Test: run_x86_64_tests and usage_table_header_unittest
Change-Id: I939e479779425550a17a3c9e6c6d1bc6885e493e

libwvdrmengine/cdm/core/include/device_files.h

@@ -103,17 +103,6 @@ class DeviceFiles {
     CryptoWrappedKey wrapped_private_key;
   };
 
-  struct CdmUsageData {
-    std::string provider_session_token;
-    CdmKeyMessage license_request;
-    CdmKeyResponse license;
-    std::string key_set_id;
-    CdmUsageEntry usage_entry;
-    uint32_t usage_entry_number;
-    std::string drm_certificate;
-    CryptoWrappedKey wrapped_private_key;
-  };
-
   DeviceFiles(wvutil::FileSystem*);
   virtual ~DeviceFiles();
 
@@ -179,7 +168,7 @@ class DeviceFiles {
 
   virtual bool StoreUsageTableInfo(
       const CdmUsageTableHeader& usage_table_header,
-      const std::vector<CdmUsageEntryInfo>& usage_entry_info);
+      const std::vector<CdmUsageEntryInfo>& usage_entry_info_list);
 
   // When retrieving usage table information from the file system; any
   // table that has yet to be updated for the LRU attributes will be
@@ -190,7 +179,7 @@ class DeviceFiles {
   // 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_list, bool* lru_upgrade,
       bool* has_usage_info_entries);
 
   virtual bool DeleteUsageTableInfo();
@@ -262,10 +251,6 @@ class DeviceFiles {
   FRIEND_TEST(DeviceFilesTest, OkpInfo_FileDoesNotExist);
   FRIEND_TEST(DeviceFilesTest, OkpInfo_DeleteFile);
   FRIEND_TEST(DeviceFilesTest, OkpInfo_StoreAndRetrieve);
-  FRIEND_TEST(DeviceFilesUsageInfoTest, Delete);
-  FRIEND_TEST(DeviceFilesUsageInfoTest, DeleteAll);
-  FRIEND_TEST(DeviceFilesUsageInfoTest, Read);
-  FRIEND_TEST(DeviceFilesUsageInfoTest, Store);
   FRIEND_TEST(DeviceFilesUsageTableTest, Read);
   FRIEND_TEST(DeviceFilesUsageTableTest, Store);
   FRIEND_TEST(DeviceFilesUsageTableTest, ReadWithoutLruData);
@@ -275,11 +260,7 @@ class DeviceFiles {
   FRIEND_TEST(StoreCertificateTest, DefaultAndLegacy);
   FRIEND_TEST(WvCdmRequestLicenseTest, UnprovisionTest);
   FRIEND_TEST(WvCdmRequestLicenseTest, ForceL3Test);
-  FRIEND_TEST(WvCdmRequestLicenseTest, UsageInfoRetryTest);
   FRIEND_TEST(WvCdmRequestLicenseTest, UsageReleaseAllTest);
-  FRIEND_TEST(WvCdmUsageInfoTest, UsageInfo);
-  FRIEND_TEST(WvCdmUsageTest, WithClientId);
-  FRIEND_TEST(WvCdmExtendedDurationTest, UsageOverflowTest);
 #endif
 
   static std::set<std::string> reserved_license_ids_;

libwvdrmengine/cdm/core/include/usage_table_header.h

@@ -46,7 +46,7 @@ namespace wvcdm {
 //
 // Upgrades from a fixed size usage table (supported by previous
 // versions of the OEMCrypto API v9-12) are handled by this class.
-// |usage_entry| and |usage_entry_number|s need to be saved in the license
+// |usage_entry| and |entry_number|s need to be saved in the license
 // and usage info records by the caller.
 class UsageTableHeader {
  public:
@@ -65,30 +65,30 @@ class UsageTableHeader {
 
   // Adds a new entry to the OEMCrypto usage table header, and associates
   // the entry with the provided |crypto_session|.  The index of the new
-  // usage entry will be returned by |usage_entry_number|.
+  // usage entry will be returned by |entry_number|.
   //
-  // Threading: Method takes exclusive use of |usage_table_header_lock_|.
+  // Threading: Method takes exclusive use of |table_lock_|.
   virtual CdmResponseType AddEntry(CryptoSession* crypto_session,
                                    const CdmKeySetId& key_set_id,
                                    const CdmKeyResponse& license_message,
-                                   uint32_t* usage_entry_number);
-  // Threading: Method takes exclusive use of |usage_table_header_lock_|.
+                                   uint32_t* entry_number);
+  // Threading: Method takes exclusive use of |table_lock_|.
   virtual CdmResponseType LoadEntry(CryptoSession* crypto_session,
                                     const CdmUsageEntry& usage_entry,
-                                    uint32_t usage_entry_number);
-  // Threading: Method takes exclusive use of |usage_table_header_lock_|.
-  virtual CdmResponseType UpdateEntry(uint32_t usage_entry_number,
+                                    uint32_t entry_number);
+  // Threading: Method takes exclusive use of |table_lock_|.
+  virtual CdmResponseType UpdateEntry(uint32_t entry_number,
                                       CryptoSession* crypto_session,
                                       CdmUsageEntry* usage_entry);
 
-  // The licenses or usage info records specified by |usage_entry_number|
+  // The licenses or usage info records specified by |entry_number|
   // should not be in use by any open CryptoSession objects when calls
   // to InvalidateEntry and MoveEntry are made.
   // If |defrag_table| is true, the table will be defragmented after
   // the entry has been invalidated.
   //
-  // Threading: Method takes exclusive use of |usage_table_header_lock_|.
-  virtual CdmResponseType InvalidateEntry(uint32_t usage_entry_number,
+  // Threading: Method takes exclusive use of |table_lock_|.
+  virtual CdmResponseType InvalidateEntry(uint32_t entry_number,
                                           bool defrag_table,
                                           DeviceFiles* device_files,
                                           metrics::CryptoMetrics* metrics);
@@ -101,13 +101,13 @@ class UsageTableHeader {
   // for the objects that InvalidateEntry depends on.
   //
   // Threading: Method requires care of caller for exclusive access.
-  void InvalidateEntryForTest(uint32_t usage_entry_number);
+  void InvalidateEntryForTest(uint32_t entry_number);
 
   // == Table information methods ==
   // Threading: None of the following are thread safe.  Intended for
   // testing or internal use.
 
-  size_t size() { return usage_entry_info_.size(); }
+  size_t size() { return entry_info_list_.size(); }
 
   size_t potential_table_capacity() const { return potential_table_capacity_; }
 
@@ -116,11 +116,11 @@ class UsageTableHeader {
   }
 
   // Returns the number of entries currently tracked by the CDM that
-  // are related to offline licenses.
-  size_t OfflineEntryCount() const;
+  // are populated (non-empty).
+  size_t OccupiedEntryCount() const;
 
-  const std::vector<CdmUsageEntryInfo>& usage_entry_info() const {
-    return usage_entry_info_;
+  const std::vector<CdmUsageEntryInfo>& entry_info_list() const {
+    return entry_info_list_;
   }
 
   // Set the reference clock used for the method GetCurrentTime().
@@ -132,10 +132,10 @@ class UsageTableHeader {
   }
 
   static bool DetermineLicenseToRemoveForTesting(
-      const std::vector<CdmUsageEntryInfo>& usage_entry_info_list,
+      const std::vector<CdmUsageEntryInfo>& entry_info_list,
       int64_t current_time, size_t unexpired_threshold,
       uint32_t* entry_to_remove) {
-    return DetermineLicenseToRemove(usage_entry_info_list, current_time,
+    return DetermineLicenseToRemove(entry_info_list, current_time,
                                     unexpired_threshold, entry_to_remove);
   }
 
@@ -146,13 +146,13 @@ class UsageTableHeader {
 
   // Creates a new, empty usage table.  Any existing usage table files
   // will be deleted.
-  // Threading: Method takes exclusive use of |usage_table_header_lock_|
+  // Threading: Method takes exclusive use of |table_lock_|
   // when required.
   bool CreateNewTable(CryptoSession* const crypto_session);
   // Attempts to restore the usage table from persistent storage, and
   // loads the usage table header into OEMCrypto.
   // Note: No other OEMCrypto session should be opened before calling.
-  // Threading: Method takes exclusive use of |usage_table_header_lock_|
+  // Threading: Method takes exclusive use of |table_lock_|
   // when required.
   bool RestoreTable(CryptoSession* const crypto_session);
 
@@ -164,52 +164,52 @@ class UsageTableHeader {
   // one more entry if the table is at or near the reported capacity.
   // If this check fails, a new usage table SHOULD be created.
   // Threading: Method requires caller to take exclusive use of
-  // |usage_table_header_lock_|.
+  // |table_lock_|.
   bool CapacityCheck(CryptoSession* const crypto_session);
 
   // Attempts to determine the capacity of the OEMCrypto usage table.
   // Sets the result to |potential_table_capacity_|.
   // Threading: Method requires caller to take exclusive use of
-  // |usage_table_header_lock_|.
+  // |table_lock_|.
   bool DetermineTableCapacity(CryptoSession* crypto_session);
 
   // == Table operation methods ==
   // Threading: All of the following methods require caller to take
-  // exclusive use of |usage_table_header_lock_|.
+  // exclusive use of |table_lock_|.
 
   // Creates a new entry for the provided crypto session.  If the
   // entry is created successfully in OEMCrypto, then a new entry
   // info is added to the table's vector of entry info.
   CdmResponseType CreateEntry(CryptoSession* const crypto_session,
-                              uint32_t* usage_entry_number);
+                              uint32_t* entry_number);
 
   // Attempts to relocate a newly created usage entry associated with
   // the provided |crypto_session| to the lowest unoccupied position in
   // the table.
-  // |usage_entry_number| is treated as both an input and output.
+  // |entry_number| is treated as both an input and output.
   // Returns NO_ERROR so long as no internal operation fails,
   // regardless of whether the entry was moved or not.
   CdmResponseType RelocateNewEntry(CryptoSession* const crypto_session,
-                                   uint32_t* usage_entry_number);
+                                   uint32_t* entry_number);
 
-  // Checks if the specified |usage_entry_number| is known to be
+  // Checks if the specified |entry_number| is known to be
   // unoccupied (released).
-  bool IsEntryUnoccupied(const uint32_t usage_entry_number) const;
+  bool IsEntryUnoccupied(const uint32_t entry_number) const;
 
   // Populates the entry's meta-data with the required information based
   // entry meta-data with the required information based on the type
   // on the license content.
-  void SetOfflineEntryInfo(const uint32_t usage_entry_number,
+  void SetOfflineEntryInfo(const uint32_t entry_number,
                            const std::string& key_set_id,
                            const CdmKeyResponse& license_message);
 
   // Shrinks the table, removing all trailing unoccupied entries.
-  // |usage_entry_info_| will be resized appropriately.
+  // |entry_info_| will be resized appropriately.
   // Caller must store the table after a successful call.
   CdmResponseType RefitTable(CryptoSession* const crypto_session);
 
   virtual CdmResponseType InvalidateEntryInternal(
-      uint32_t usage_entry_number, bool defrag_table, DeviceFiles* device_files,
+      uint32_t entry_number, bool defrag_table, DeviceFiles* device_files,
       metrics::CryptoMetrics* metrics);
 
   CdmResponseType MoveEntry(uint32_t from /* usage entry number */,
@@ -218,11 +218,9 @@ class UsageTableHeader {
                             DeviceFiles* device_files,
                             metrics::CryptoMetrics* metrics);
 
-  CdmResponseType GetEntry(uint32_t usage_entry_number,
-                           DeviceFiles* device_files,
+  CdmResponseType GetEntry(uint32_t entry_number, DeviceFiles* device_files,
                            CdmUsageEntry* usage_entry);
-  CdmResponseType StoreEntry(uint32_t usage_entry_number,
-                             DeviceFiles* device_files,
+  CdmResponseType StoreEntry(uint32_t entry_number, DeviceFiles* device_files,
                              const CdmUsageEntry& usage_entry);
 
   // Stores the usage table and it's info.  This will increment
@@ -273,7 +271,7 @@ class UsageTableHeader {
   //   types.
   //
   // Parameters:
-  //    [in] usage_entry_info_list: The complete list of known usage
+  //    [in] entry_info_list: The complete list of known usage
   //            entries.
   //    [in] current_time: The current time to compare expiration times
   //            against.
@@ -288,20 +286,20 @@ class UsageTableHeader {
   //   |true| if an entry has been determined to be removed.
   //   Otherwise returns |false|.
   static bool DetermineLicenseToRemove(
-      const std::vector<CdmUsageEntryInfo>& usage_entry_info_list,
+      const std::vector<CdmUsageEntryInfo>& entry_info_list,
       int64_t current_time, size_t unexpired_threshold,
       uint32_t* entry_to_remove);
 
   // This handle and file system is only to be used when accessing
-  // usage_table_header. Usage entries should use the file system provided
+  // |table_header|. Usage entries should use the file system provided
   // by CdmSession.
   std::unique_ptr<DeviceFiles> device_files_;
   std::unique_ptr<wvutil::FileSystem> file_system_;
   CdmSecurityLevel security_level_ = kSecurityLevelUninitialized;
   RequestedSecurityLevel requested_security_level_ = kLevelDefault;
 
-  CdmUsageTableHeader usage_table_header_;
-  std::vector<CdmUsageEntryInfo> usage_entry_info_;
+  CdmUsageTableHeader table_header_;
+  std::vector<CdmUsageEntryInfo> entry_info_list_;
 
   // Table is sync with persistent storage and can be used by the CDM
   // to interact with OEMCrypto.
@@ -309,7 +307,7 @@ class UsageTableHeader {
 
   // Synchonizes access to the Usage Table Header and bookkeeping
   // data-structures
-  mutable std::mutex usage_table_header_lock_;
+  mutable std::mutex table_lock_;
 
   metrics::CryptoMetrics alternate_crypto_metrics_;
 

libwvdrmengine/cdm/core/include/wv_cdm_types.h

@@ -537,44 +537,71 @@ enum CdmUsageSupportType : int32_t {
   kUnknownUsageSupport,
 };
 
-enum CdmUsageEntryStorageType : int32_t {
-  kStorageLicense,
-  kStorageUsageInfo,
-  kStorageTypeUnknown,
-};
+class CdmUsageEntryInfo {
+ public:
+  CdmUsageEntryInfo() {}
+  CdmUsageEntryInfo(const std::string& key_set_id, int64_t last_use_time,
+                    int64_t license_expiry_time)
+      : key_set_id_(key_set_id),
+        last_use_time_(last_use_time),
+        license_expiry_time_(license_expiry_time) {
+    if (key_set_id.empty()) Clear();
+  }
+
+  CdmUsageEntryInfo(const CdmUsageEntryInfo&) = default;
+  CdmUsageEntryInfo& operator=(const CdmUsageEntryInfo&) = default;
+
+  CdmUsageEntryInfo(CdmUsageEntryInfo&&) = default;
+  CdmUsageEntryInfo& operator=(CdmUsageEntryInfo&&) = default;
+
+  bool HasKeySetId() const { return !key_set_id_.empty(); }
+  bool IsEmpty() const { return key_set_id_.empty(); }
+
+  const std::string& key_set_id() const { return key_set_id_; }
+  void SetKeySetId(const std::string& key_set_id) {
+    if (key_set_id.empty()) {
+      Clear();
+    } else {
+      key_set_id_ = key_set_id;
+    }
+  }
+
+  int64_t last_use_time() const { return last_use_time_; }
+  void SetLastUseTime(int64_t last_use_time) { last_use_time_ = last_use_time; }
+  // Used for testing.
+  void IncLastUseTime() { last_use_time_++; }
+  void DecLastUseTime() { last_use_time_--; }
+
+  int64_t license_expiry_time() const { return license_expiry_time_; }
+  void SetLicenseExpiryTime(int64_t license_expiry_time) {
+    license_expiry_time_ = license_expiry_time;
+  }
+
+  void Clear() {
+    key_set_id_.clear();
+    last_use_time_ = license_expiry_time_ = 0;
+  }
 
-struct CdmUsageEntryInfo {
-  CdmUsageEntryStorageType storage_type;
-  CdmKeySetId key_set_id;
-  std::string usage_info_file_name;
-  int64_t last_use_time;
-  int64_t offline_license_expiry_time;  // Only for offline licenses.
   bool operator==(const CdmUsageEntryInfo& other) const {
     if (this == &other) {
       return true;
     }
-    if (storage_type != other.storage_type || key_set_id != other.key_set_id ||
-        last_use_time != other.last_use_time) {
+    if (IsEmpty() && other.IsEmpty()) {
+      // All other fields are ignored if there is no key set ID set.
+      return true;
+    }
+    if (key_set_id_ != other.key_set_id_) {
       return false;
     }
-    // Certain fields only have meaning based on the storage type.
-    if (storage_type == kStorageUsageInfo) {
-      return usage_info_file_name == other.usage_info_file_name;
-    }
-    if (storage_type == kStorageLicense) {
-      return offline_license_expiry_time == other.offline_license_expiry_time;
-    }
-    // else storage_type == kStorageTypeUnknown
-    return true;
+    return last_use_time_ == other.last_use_time_ &&
+           license_expiry_time_ == other.license_expiry_time_;
   }
 
-  void Clear() {
-    storage_type = kStorageTypeUnknown;
-    key_set_id.clear();
-    usage_info_file_name.clear();
-    last_use_time = 0;
-    offline_license_expiry_time = 0;
-  }
+ private:
+  // If |key_set_id_| is empty, the other fields are ignored.
+  CdmKeySetId key_set_id_ = "";
+  int64_t last_use_time_ = 0;
+  int64_t license_expiry_time_ = 0;
 };
 
 enum CdmKeySecurityLevel : int32_t {
@@ -846,7 +873,6 @@ const char* CdmOfflineLicenseStateToString(
     CdmOfflineLicenseState license_state);
 const std::string CdmResponseTypeToString(int cdm_response_type);
 const char* CdmSecurityLevelToString(CdmSecurityLevel security_level);
-const char* CdmUsageEntryStorageTypeToString(CdmUsageEntryStorageType type);
 const char* RequestedSecurityLevelToString(
     RequestedSecurityLevel security_level);
 const char* CdmWatermarkingSupportToString(CdmWatermarkingSupport support);

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -1049,9 +1049,9 @@ bool CdmSession::VerifyOfflineUsageEntry() {
     return false;
   }
   const CdmUsageEntryInfo& usage_entry_info =
-      usage_table_header_->usage_entry_info().at(usage_entry_number_);
-  if (usage_entry_info.storage_type != kStorageLicense ||
-      usage_entry_info.key_set_id != key_set_id_) {
+      usage_table_header_->entry_info_list().at(usage_entry_number_);
+  if (usage_entry_info.IsEmpty() ||
+      usage_entry_info.key_set_id() != key_set_id_) {
     LOGD("License usage entry does not match");
     return false;
   }

libwvdrmengine/cdm/core/src/device_files.cpp

@@ -1014,7 +1014,7 @@ bool DeviceFiles::DeleteHlsAttributes(const std::string& key_set_id) {
 
 bool DeviceFiles::StoreUsageTableInfo(
     const CdmUsageTableHeader& usage_table_header,
-    const std::vector<CdmUsageEntryInfo>& usage_entry_info) {
+    const std::vector<CdmUsageEntryInfo>& usage_entry_info_list) {
   RETURN_FALSE_IF_UNINITIALIZED();
   using video_widevine_client::sdk::UsageTableInfo;
   using UsageEntryInfo = UsageTableInfo::UsageEntryInfo;
@@ -1028,14 +1028,14 @@ bool DeviceFiles::StoreUsageTableInfo(
   UsageTableInfo* stored_table_info = file.mutable_usage_table_info();
   stored_table_info->set_usage_table_header(usage_table_header);
 
-  for (const auto& entry_info : usage_entry_info) {
+  for (const auto& entry_info : usage_entry_info_list) {
     UsageEntryInfo* stored_info = stored_table_info->add_usage_entry_info();
-    if (entry_info.storage_type == kStorageLicense) {
+    if (entry_info.HasKeySetId()) {
       stored_info->set_storage(UsageEntryInfo::LICENSE);
-      stored_info->set_key_set_id(entry_info.key_set_id);
-      stored_info->set_last_use_time(entry_info.last_use_time);
+      stored_info->set_key_set_id(entry_info.key_set_id());
+      stored_info->set_last_use_time(entry_info.last_use_time());
       stored_info->set_offline_license_expiry_time(
-          entry_info.offline_license_expiry_time);
+          entry_info.license_expiry_time());
     } else {
       stored_info->set_storage(UsageEntryInfo::UNKNOWN);
     }
@@ -1051,11 +1051,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_list, 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(usage_entry_info_list);
   RETURN_FALSE_IF_NULL(lru_upgrade);
   RETURN_FALSE_IF_NULL(has_usage_info_entries);
   using video_widevine_client::sdk::UsageTableInfo;
@@ -1091,22 +1091,22 @@ bool DeviceFiles::RetrieveUsageTableInfo(
   *lru_upgrade = !stored_table_info.use_lru();
   *has_usage_info_entries = false;
   *usage_table_header = stored_table_info.usage_table_header();
-  usage_entry_info->reserve(stored_table_info.usage_entry_info_size());
+  usage_entry_info_list->clear();
+  usage_entry_info_list->reserve(stored_table_info.usage_entry_info_size());
 
   for (const auto& stored_entry_info : stored_table_info.usage_entry_info()) {
     CdmUsageEntryInfo entry_info;
     entry_info.Clear();
     if (stored_entry_info.storage() == UsageEntryInfo::LICENSE) {
-      entry_info.storage_type = kStorageLicense;
-      entry_info.key_set_id = stored_entry_info.key_set_id();
-      entry_info.last_use_time = stored_entry_info.last_use_time();
-      entry_info.offline_license_expiry_time =
-          stored_entry_info.offline_license_expiry_time();
+      entry_info.SetKeySetId(stored_entry_info.key_set_id());
+      entry_info.SetLastUseTime(stored_entry_info.last_use_time());
+      entry_info.SetLicenseExpiryTime(
+          stored_entry_info.offline_license_expiry_time());
     } else if (stored_entry_info.storage() == UsageEntryInfo::USAGE_INFO) {
       // USAGE_INFO are deprecated, do not retrieve this entries.
       *has_usage_info_entries = true;
     }
-    usage_entry_info->emplace_back(std::move(entry_info));
+    usage_entry_info_list->emplace_back(std::move(entry_info));
   }
   return true;
 }

libwvdrmengine/cdm/core/src/wv_cdm_types.cpp

@@ -95,19 +95,6 @@ const char* CdmOfflineLicenseStateToString(
   return UnknownValueRep(license_state);
 }
 
-const char* CdmUsageEntryStorageTypeToString(CdmUsageEntryStorageType type) {
-  switch (type) {
-    case kStorageLicense:
-      return "License";
-    case kStorageUsageInfo:
-      return "UsageInfo";
-    case kStorageTypeUnknown:
-      // Special value used to indicate an empty entry.
-      return "None";
-  }
-  return UnknownValueRep(type);
-}
-
 const char* RequestedSecurityLevelToString(
     RequestedSecurityLevel security_level) {
   switch (security_level) {

libwvdrmengine/cdm/core/test/device_files_unittest.cpp

@@ -2920,17 +2920,17 @@ constexpr size_t kNumberOfHlsAttributes = ArraySize(kHlsAttributesTestData);
 //       kUsageTableInfoTestData are equal.
 const std::vector<CdmUsageEntryInfo> kUsageEntriesTestData = {
     // usage entry 0
-    {kStorageLicense, "ksid0", "", 1318402800, 1321254000},
+    {"ksid0", 1318402800, 1321254000},
     // usage entry 1
-    {kStorageLicense, "ksid1", "", 1050649200, 1053500400},
+    {"ksid1", 1050649200, 1053500400},
     // usage entry 2
-    {kStorageTypeUnknown, "", "", 0, 0},
+    {"", 0, 0},
     // usage entry 3
-    {kStorageTypeUnknown, "", "", 0, 0},
+    {"", 0, 0},
     // usage entry 4
-    {kStorageLicense, "ksid4", "", 316166400, 319017600},
+    {"ksid4", 316166400, 319017600},
     // usage entry 5
-    {kStorageLicense, "ksid5", "", 316166400, 319017600},
+    {"ksid5", 316166400, 319017600},
 };
 
 struct UsageTableTestInfo {
@@ -3008,8 +3008,8 @@ const UsageTableTestInfo kUsageTableInfoTestData[] = {
               "ce072f3d2ef52febcaddff3040246a638deee994a0862142")},
 };
 
-const CdmUsageEntryInfo kUsageEntriesWithoutLruData[] = {
-    {kStorageLicense, "ksid0", "", 0, 0}, {kStorageTypeUnknown, "", "", 0, 0}};
+const CdmUsageEntryInfo kUsageEntriesWithoutLruData[] = {{"ksid0", 0, 0},
+                                                         {"", 0, 0}};
 
 const std::string kUsageTableWithoutLruData = a2bs_hex(
     "0A1F080510013A191209080112056B73696430120C08021A086170705F69645F"
@@ -3030,9 +3030,7 @@ const UsageTableTestInfo kUsageTableInfoWithUsageInfoType = {
 
 // Expected entries after removal of USAGE_INFO.
 const std::vector<CdmUsageEntryInfo> kUsageEntriesWithoutUsageInfoType = {
-    {kStorageLicense, "ksid0", "", 1318402800, 1321254000},
-    {kStorageTypeUnknown, "", "", 0, 0},
-    {kStorageTypeUnknown, "", "", 0, 0}};
+    {"ksid0", 1318402800, 1321254000}, {"", 0, 0}, {"", 0, 0}};
 
 // Contains kOemCertificate and kCryptoWrappedKey
 const std::string kFakeOemCertificateFile = a2bs_hex(
@@ -4389,11 +4387,11 @@ TEST_P(DeviceFilesUsageTableTest, Store) {
   const int entry_count = GetParam();
 
   std::vector<std::string> entry_data;
-  const std::vector<CdmUsageEntryInfo> usage_entry_info(
+  const std::vector<CdmUsageEntryInfo> usage_entry_info_list(
       kUsageEntriesTestData.begin(),
       kUsageEntriesTestData.begin() + entry_count);
   for (int i = 0; i < entry_count; ++i) {
-    entry_data.push_back(kUsageEntriesTestData[i].key_set_id);
+    entry_data.push_back(kUsageEntriesTestData[i].key_set_id());
   }
   entry_data.push_back(kUsageTableInfoTestData[entry_count].usage_table_header);
 
@@ -4411,7 +4409,7 @@ TEST_P(DeviceFilesUsageTableTest, Store) {
   EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
   ASSERT_TRUE(device_files.StoreUsageTableInfo(
       kUsageTableInfoTestData[entry_count].usage_table_header,
-      usage_entry_info));
+      usage_entry_info_list));
 }
 
 TEST_P(DeviceFilesUsageTableTest, Read) {
@@ -4437,20 +4435,20 @@ TEST_P(DeviceFilesUsageTableTest, Read) {
   DeviceFiles device_files(&file_system);
   EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
 
-  std::vector<CdmUsageEntryInfo> usage_entry_info;
+  std::vector<CdmUsageEntryInfo> usage_entry_info_list;
   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_list, &lru_upgrade,
       &has_usage_info_entries));
   EXPECT_EQ(kUsageTableInfoTestData[entry_count].usage_table_header,
             usage_table_header);
-  EXPECT_EQ(entry_count, usage_entry_info.size());
+  EXPECT_EQ(entry_count, usage_entry_info_list.size());
 
   for (size_t i = 0; i < entry_count; ++i) {
     // TODO(b/242289743): Update test data to exclude usage info files.
-    EXPECT_EQ(usage_entry_info[i], kUsageEntriesTestData[i]);
+    EXPECT_EQ(usage_entry_info_list[i], kUsageEntriesTestData[i]);
   }
   EXPECT_FALSE(lru_upgrade);
 }
@@ -4478,19 +4476,20 @@ TEST_F(DeviceFilesUsageTableTest, ReadWithoutLruData) {
   DeviceFiles device_files(&file_system);
   EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
 
-  std::vector<CdmUsageEntryInfo> usage_entry_info;
+  std::vector<CdmUsageEntryInfo> usage_entry_info_list;
   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_list, &lru_upgrade,
       &has_usage_info_entries));
 
-  EXPECT_EQ(ArraySize(kUsageEntriesWithoutLruData), usage_entry_info.size());
+  EXPECT_EQ(ArraySize(kUsageEntriesWithoutLruData),
+            usage_entry_info_list.size());
 
   for (size_t i = 0; i < ArraySize(kUsageEntriesWithoutLruData); ++i) {
     const CdmUsageEntryInfo& expected_entry = kUsageEntriesWithoutLruData[i];
-    const CdmUsageEntryInfo& retrieved_entry = usage_entry_info[i];
+    const CdmUsageEntryInfo& retrieved_entry = usage_entry_info_list[i];
     EXPECT_EQ(expected_entry, retrieved_entry);
   }
 
@@ -4520,20 +4519,21 @@ TEST_F(DeviceFilesUsageTableTest, ReadWithUsageInfoType) {
   DeviceFiles device_files(&file_system);
   EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
 
-  std::vector<CdmUsageEntryInfo> usage_entry_info;
+  std::vector<CdmUsageEntryInfo> usage_entry_info_list;
   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_list, &lru_upgrade,
       &has_usage_info_entries));
 
-  EXPECT_EQ(kUsageEntriesWithoutUsageInfoType.size(), usage_entry_info.size());
+  EXPECT_EQ(kUsageEntriesWithoutUsageInfoType.size(),
+            usage_entry_info_list.size());
 
   for (size_t i = 0; i < kUsageEntriesWithoutUsageInfoType.size(); ++i) {
     const CdmUsageEntryInfo& expected_entry =
         kUsageEntriesWithoutUsageInfoType[i];
-    const CdmUsageEntryInfo& retrieved_entry = usage_entry_info[i];
+    const CdmUsageEntryInfo& retrieved_entry = usage_entry_info_list[i];
     EXPECT_EQ(expected_entry, retrieved_entry);
   }
 

libwvdrmengine/cdm/metrics/test/metrics_collections_unittest.cpp

@@ -358,8 +358,7 @@ TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
   crypto_metrics.usage_table_header_lru_usage_info_count_.Record(150);
   crypto_metrics.usage_table_header_lru_offline_license_count_.Record(50);
   crypto_metrics.usage_table_header_lru_evicted_entry_staleness_.Record(259200);
-  crypto_metrics.usage_table_header_lru_evicted_entry_type_.Record(
-      kStorageUsageInfo);
+  crypto_metrics.usage_table_header_lru_evicted_entry_type_.Record(1);
 
   // Oem crypto metrics.
   crypto_metrics.oemcrypto_api_version_.Record(123);
@@ -482,8 +481,7 @@ TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
   EXPECT_EQ(
       259200,
       actual.usage_table_header_lru_evicted_entry_staleness_s().int_value());
-  EXPECT_EQ(kStorageUsageInfo,
-            actual.usage_table_header_lru_evicted_entry_type().int_value());
+  EXPECT_EQ(1, actual.usage_table_header_lru_evicted_entry_type().int_value());
 
   // Oem crypto metrics.
   EXPECT_EQ(123, actual.oemcrypto_api_version().int_value());