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

This reverts commit 5dd2b07286.

Reason for revert: Feature rejected by Android

Bug: 242289743
Change-Id: I8dc95139d113ad1d44acd2e8dd6cbda604b6c073

libwvdrmengine/cdm/core/include/device_files.h

@@ -103,6 +103,17 @@ 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();
 
@@ -168,7 +179,7 @@ class DeviceFiles {
 
   virtual bool StoreUsageTableInfo(
       const CdmUsageTableHeader& usage_table_header,
-      const std::vector<CdmUsageEntryInfo>& usage_entry_info_list);
+      const std::vector<CdmUsageEntryInfo>& usage_entry_info);
 
   // When retrieving usage table information from the file system; any
   // table that has yet to be updated for the LRU attributes will be
@@ -179,7 +190,7 @@ class DeviceFiles {
   // is set to true if any are detected.
   virtual bool RetrieveUsageTableInfo(
       CdmUsageTableHeader* usage_table_header,
-      std::vector<CdmUsageEntryInfo>* usage_entry_info_list, bool* lru_upgrade,
+      std::vector<CdmUsageEntryInfo>* usage_entry_info, bool* lru_upgrade,
       bool* has_usage_info_entries);
 
   virtual bool DeleteUsageTableInfo();
@@ -251,6 +262,10 @@ 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);
@@ -260,7 +275,11 @@ 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 |entry_number|s need to be saved in the license
+// |usage_entry| and |usage_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 |entry_number|.
+  // usage entry will be returned by |usage_entry_number|.
   //
-  // Threading: Method takes exclusive use of |table_lock_|.
+  // Threading: Method takes exclusive use of |usage_table_header_lock_|.
   virtual CdmResponseType AddEntry(CryptoSession* crypto_session,
                                    const CdmKeySetId& key_set_id,
                                    const CdmKeyResponse& license_message,
-                                   uint32_t* entry_number);
-  // Threading: Method takes exclusive use of |table_lock_|.
+                                   uint32_t* usage_entry_number);
+  // Threading: Method takes exclusive use of |usage_table_header_lock_|.
   virtual CdmResponseType LoadEntry(CryptoSession* crypto_session,
                                     const CdmUsageEntry& usage_entry,
-                                    uint32_t entry_number);
-  // Threading: Method takes exclusive use of |table_lock_|.
-  virtual CdmResponseType UpdateEntry(uint32_t entry_number,
+                                    uint32_t usage_entry_number);
+  // Threading: Method takes exclusive use of |usage_table_header_lock_|.
+  virtual CdmResponseType UpdateEntry(uint32_t usage_entry_number,
                                       CryptoSession* crypto_session,
                                       CdmUsageEntry* usage_entry);
 
-  // The licenses or usage info records specified by |entry_number|
+  // The licenses or usage info records specified by |usage_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 |table_lock_|.
-  virtual CdmResponseType InvalidateEntry(uint32_t entry_number,
+  // Threading: Method takes exclusive use of |usage_table_header_lock_|.
+  virtual CdmResponseType InvalidateEntry(uint32_t usage_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 entry_number);
+  void InvalidateEntryForTest(uint32_t usage_entry_number);
 
   // == Table information methods ==
   // Threading: None of the following are thread safe.  Intended for
   // testing or internal use.
 
-  size_t size() { return entry_info_list_.size(); }
+  size_t size() { return usage_entry_info_.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 populated (non-empty).
-  size_t OccupiedEntryCount() const;
+  // are related to offline licenses.
+  size_t OfflineEntryCount() const;
 
-  const std::vector<CdmUsageEntryInfo>& entry_info_list() const {
-    return entry_info_list_;
+  const std::vector<CdmUsageEntryInfo>& usage_entry_info() const {
+    return usage_entry_info_;
   }
 
   // Set the reference clock used for the method GetCurrentTime().
@@ -132,10 +132,10 @@ class UsageTableHeader {
   }
 
   static bool DetermineLicenseToRemoveForTesting(
-      const std::vector<CdmUsageEntryInfo>& entry_info_list,
+      const std::vector<CdmUsageEntryInfo>& usage_entry_info_list,
       int64_t current_time, size_t unexpired_threshold,
       uint32_t* entry_to_remove) {
-    return DetermineLicenseToRemove(entry_info_list, current_time,
+    return DetermineLicenseToRemove(usage_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 |table_lock_|
+  // Threading: Method takes exclusive use of |usage_table_header_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 |table_lock_|
+  // Threading: Method takes exclusive use of |usage_table_header_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
-  // |table_lock_|.
+  // |usage_table_header_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
-  // |table_lock_|.
+  // |usage_table_header_lock_|.
   bool DetermineTableCapacity(CryptoSession* crypto_session);
 
   // == Table operation methods ==
   // Threading: All of the following methods require caller to take
-  // exclusive use of |table_lock_|.
+  // exclusive use of |usage_table_header_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* entry_number);
+                              uint32_t* usage_entry_number);
 
   // Attempts to relocate a newly created usage entry associated with
   // the provided |crypto_session| to the lowest unoccupied position in
   // the table.
-  // |entry_number| is treated as both an input and output.
+  // |usage_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* entry_number);
+                                   uint32_t* usage_entry_number);
 
-  // Checks if the specified |entry_number| is known to be
+  // Checks if the specified |usage_entry_number| is known to be
   // unoccupied (released).
-  bool IsEntryUnoccupied(const uint32_t entry_number) const;
+  bool IsEntryUnoccupied(const uint32_t usage_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 entry_number,
+  void SetOfflineEntryInfo(const uint32_t usage_entry_number,
                            const std::string& key_set_id,
                            const CdmKeyResponse& license_message);
 
   // Shrinks the table, removing all trailing unoccupied entries.
-  // |entry_info_| will be resized appropriately.
+  // |usage_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 entry_number, bool defrag_table, DeviceFiles* device_files,
+      uint32_t usage_entry_number, bool defrag_table, DeviceFiles* device_files,
       metrics::CryptoMetrics* metrics);
 
   CdmResponseType MoveEntry(uint32_t from /* usage entry number */,
@@ -218,9 +218,11 @@ class UsageTableHeader {
                             DeviceFiles* device_files,
                             metrics::CryptoMetrics* metrics);
 
-  CdmResponseType GetEntry(uint32_t entry_number, DeviceFiles* device_files,
+  CdmResponseType GetEntry(uint32_t usage_entry_number,
+                           DeviceFiles* device_files,
                            CdmUsageEntry* usage_entry);
-  CdmResponseType StoreEntry(uint32_t entry_number, DeviceFiles* device_files,
+  CdmResponseType StoreEntry(uint32_t usage_entry_number,
+                             DeviceFiles* device_files,
                              const CdmUsageEntry& usage_entry);
 
   // Stores the usage table and it's info.  This will increment
@@ -271,7 +273,7 @@ class UsageTableHeader {
   //   types.
   //
   // Parameters:
-  //    [in] entry_info_list: The complete list of known usage
+  //    [in] usage_entry_info_list: The complete list of known usage
   //            entries.
   //    [in] current_time: The current time to compare expiration times
   //            against.
@@ -286,20 +288,20 @@ class UsageTableHeader {
   //   |true| if an entry has been determined to be removed.
   //   Otherwise returns |false|.
   static bool DetermineLicenseToRemove(
-      const std::vector<CdmUsageEntryInfo>& entry_info_list,
+      const std::vector<CdmUsageEntryInfo>& usage_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
-  // |table_header|. Usage entries should use the file system provided
+  // usage_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 table_header_;
-  std::vector<CdmUsageEntryInfo> entry_info_list_;
+  CdmUsageTableHeader usage_table_header_;
+  std::vector<CdmUsageEntryInfo> usage_entry_info_;
 
   // Table is sync with persistent storage and can be used by the CDM
   // to interact with OEMCrypto.
@@ -307,7 +309,7 @@ class UsageTableHeader {
 
   // Synchonizes access to the Usage Table Header and bookkeeping
   // data-structures
-  mutable std::mutex table_lock_;
+  mutable std::mutex usage_table_header_lock_;
 
   metrics::CryptoMetrics alternate_crypto_metrics_;
 

libwvdrmengine/cdm/core/include/wv_cdm_types.h

@@ -537,71 +537,44 @@ enum CdmUsageSupportType : int32_t {
   kUnknownUsageSupport,
 };
 
-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;
-  }
+enum CdmUsageEntryStorageType : int32_t {
+  kStorageLicense,
+  kStorageUsageInfo,
+  kStorageTypeUnknown,
+};
 
+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 (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_) {
+    if (storage_type != other.storage_type || key_set_id != other.key_set_id ||
+        last_use_time != other.last_use_time) {
       return false;
     }
-    return last_use_time_ == other.last_use_time_ &&
-           license_expiry_time_ == other.license_expiry_time_;
+    // 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;
   }
 
- 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;
+  void Clear() {
+    storage_type = kStorageTypeUnknown;
+    key_set_id.clear();
+    usage_info_file_name.clear();
+    last_use_time = 0;
+    offline_license_expiry_time = 0;
+  }
 };
 
 enum CdmKeySecurityLevel : int32_t {
@@ -873,6 +846,7 @@ 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_->entry_info_list().at(usage_entry_number_);
-  if (usage_entry_info.IsEmpty() ||
-      usage_entry_info.key_set_id() != key_set_id_) {
+      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_) {
     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_list) {
+    const std::vector<CdmUsageEntryInfo>& usage_entry_info) {
   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_list) {
+  for (const auto& entry_info : usage_entry_info) {
     UsageEntryInfo* stored_info = stored_table_info->add_usage_entry_info();
-    if (entry_info.HasKeySetId()) {
+    if (entry_info.storage_type == kStorageLicense) {
       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.license_expiry_time());
+          entry_info.offline_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_list, 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_list);
+  RETURN_FALSE_IF_NULL(usage_entry_info);
   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_list->clear();
-  usage_entry_info_list->reserve(stored_table_info.usage_entry_info_size());
+  usage_entry_info->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.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());
+      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();
     } 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_list->emplace_back(std::move(entry_info));
+    usage_entry_info->emplace_back(std::move(entry_info));
   }
   return true;
 }

libwvdrmengine/cdm/core/src/wv_cdm_types.cpp

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

libwvdrmengine/cdm/metrics/test/metrics_collections_unittest.cpp

@@ -358,7 +358,8 @@ 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(1);
+  crypto_metrics.usage_table_header_lru_evicted_entry_type_.Record(
+      kStorageUsageInfo);
 
   // Oem crypto metrics.
   crypto_metrics.oemcrypto_api_version_.Record(123);
@@ -481,7 +482,8 @@ TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
   EXPECT_EQ(
       259200,
       actual.usage_table_header_lru_evicted_entry_staleness_s().int_value());
-  EXPECT_EQ(1, actual.usage_table_header_lru_evicted_entry_type().int_value());
+  EXPECT_EQ(kStorageUsageInfo,
+            actual.usage_table_header_lru_evicted_entry_type().int_value());
 
   // Oem crypto metrics.
   EXPECT_EQ(123, actual.oemcrypto_api_version().int_value());