diff --git a/libwvdrmengine/build_all_unit_tests.sh b/libwvdrmengine/build_all_unit_tests.sh
index c95b0b4f..8bd360e8 100755
--- a/libwvdrmengine/build_all_unit_tests.sh
+++ b/libwvdrmengine/build_all_unit_tests.sh
@@ -36,6 +36,7 @@ WV_UNITTESTS="base64_test \
      cdm_feature_test \
      cdm_extended_duration_test \
      cdm_session_unittest \
+     cdm_usage_table_unittest \
      certificate_provisioning_unittest \
      counter_metric_unittest \
      crypto_session_unittest \
@@ -69,7 +70,6 @@ WV_UNITTESTS="base64_test \
      service_certificate_unittest \
      system_id_extractor_unittest \
      timer_unittest \
-     usage_table_header_unittest \
      value_metric_unittest \
      wv_cdm_metrics_test"
 
diff --git a/libwvdrmengine/cdm/Android.bp b/libwvdrmengine/cdm/Android.bp
index 1de41a91..9b0cfacb 100644
--- a/libwvdrmengine/cdm/Android.bp
+++ b/libwvdrmengine/cdm/Android.bp
@@ -45,6 +45,7 @@ cc_library_static {
         CORE_SRC_DIR + "/cdm_engine_factory.cpp",
         CORE_SRC_DIR + "/cdm_session.cpp",
         CORE_SRC_DIR + "/cdm_session_map.cpp",
+        CORE_SRC_DIR + "/cdm_usage_table.cpp",
         CORE_SRC_DIR + "/certificate_provisioning.cpp",
         CORE_SRC_DIR + "/client_identification.cpp",
         CORE_SRC_DIR + "/content_key_session.cpp",
@@ -66,7 +67,6 @@ cc_library_static {
         CORE_SRC_DIR + "/privacy_crypto_boringssl.cpp",
         CORE_SRC_DIR + "/service_certificate.cpp",
         CORE_SRC_DIR + "/system_id_extractor.cpp",
-        CORE_SRC_DIR + "/usage_table_header.cpp",
         CORE_SRC_DIR + "/wv_cdm_types.cpp",
         SRC_DIR + "/wv_content_decryption_module.cpp",
         METRICS_SRC_DIR + "/attribute_handler.cpp",
diff --git a/libwvdrmengine/cdm/core/include/cdm_session.h b/libwvdrmengine/cdm/core/include/cdm_session.h
index c98c8030..553f69a6 100644
--- a/libwvdrmengine/cdm/core/include/cdm_session.h
+++ b/libwvdrmengine/cdm/core/include/cdm_session.h
@@ -27,7 +27,7 @@ namespace wvcdm {
 class CdmClientPropertySet;
 class ServiceCertificate;
 class WvCdmEventListener;
-class UsageTableHeader;
+class CdmUsageTable;
 
 class CdmSession {
  public:
@@ -129,7 +129,7 @@ class CdmSession {
   // ReleaseKey() - Accept response and release key.
   virtual CdmResponseType ReleaseKey(const CdmKeyResponse& key_response);
 
-  virtual CdmResponseType DeleteUsageEntry(uint32_t usage_entry_number);
+  virtual CdmResponseType DeleteUsageEntry(UsageEntryIndex entry_index);
 
   virtual bool IsKeyLoaded(const KeyId& key_id);
   virtual int64_t GetDurationRemaining();
@@ -164,9 +164,7 @@ class CdmSession {
             license_parser_->provider_session_token().size() > 0);
   }
 
-  virtual bool supports_usage_info() const {
-    return usage_table_header_ != nullptr;
-  }
+  virtual bool SupportsUsageTable() const { return usage_table_ != nullptr; }
 
   // This method will remove keys by resetting crypto resources and
   // policy information. This renders the session mostly useless and it is
@@ -307,11 +305,11 @@ class CdmSession {
   // Usage related flags and data
   bool is_initial_usage_update_;
   bool is_usage_update_needed_;
-  // Only assign |usage_table_header_| if capable of supporting usage
+  // Only assign |usage_table_| if capable of supporting usage
   // information.
-  UsageTableHeader* usage_table_header_ = nullptr;
-  uint32_t usage_entry_number_;
-  CdmUsageEntry usage_entry_;
+  CdmUsageTable* usage_table_ = nullptr;
+  UsageEntryIndex usage_entry_index_;
+  UsageEntry usage_entry_;
   std::string usage_provider_session_token_;
 
   // information useful for offline and usage scenarios
diff --git a/libwvdrmengine/cdm/core/include/usage_table_header.h b/libwvdrmengine/cdm/core/include/cdm_usage_table.h
similarity index 77%
rename from libwvdrmengine/cdm/core/include/usage_table_header.h
rename to libwvdrmengine/cdm/core/include/cdm_usage_table.h
index 66aef9b3..5c9c874c 100644
--- a/libwvdrmengine/cdm/core/include/usage_table_header.h
+++ b/libwvdrmengine/cdm/core/include/cdm_usage_table.h
@@ -2,8 +2,8 @@
 // source code may only be used and distributed under the Widevine License
 // Agreement.
 
-#ifndef WVCDM_CORE_USAGE_TABLE_HEADER_H_
-#define WVCDM_CORE_USAGE_TABLE_HEADER_H_
+#ifndef WVCDM_CORE_CDM_USAGE_TABLE_H_
+#define WVCDM_CORE_CDM_USAGE_TABLE_H_
 
 #include <memory>
 #include <mutex>
@@ -46,12 +46,12 @@ 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
+// |entry| and |entry_index|s need to be saved in the license
 // and usage info records by the caller.
-class UsageTableHeader {
+class CdmUsageTable {
  public:
-  UsageTableHeader();
-  virtual ~UsageTableHeader() {}
+  CdmUsageTable();
+  virtual ~CdmUsageTable() {}
 
   // |crypto_session| is used to create or load a usage master table
   // and not cached beyound this call.
@@ -65,36 +65,36 @@ 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_index|.
   //
   // Type of entry depends on the value of |persistent_license|:
   //    false - usage info / secure stop record
   //    true  - offline license
   //
-  // Threading: Method takes exclusive use of |usage_table_header_lock_|.
+  // Threading: Method takes exclusive use of |lock_|.
   virtual CdmResponseType AddEntry(CryptoSession* crypto_session,
                                    bool persistent_license,
                                    const CdmKeySetId& key_set_id,
                                    const std::string& usage_info_filename,
                                    const CdmKeyResponse& license_message,
-                                   uint32_t* usage_entry_number);
-  // Threading: Method takes exclusive use of |usage_table_header_lock_|.
+                                   UsageEntryIndex* entry_index);
+  // Threading: Method takes exclusive use of |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,
+                                    const UsageEntry& entry,
+                                    UsageEntryIndex entry_index);
+  // Threading: Method takes exclusive use of |lock_|.
+  virtual CdmResponseType UpdateEntry(UsageEntryIndex entry_index,
                                       CryptoSession* crypto_session,
-                                      CdmUsageEntry* usage_entry);
+                                      UsageEntry* entry);
 
-  // The licenses or usage info records specified by |usage_entry_number|
+  // The licenses or usage info records specified by |entry_index|
   // 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 |lock_|.
+  virtual CdmResponseType InvalidateEntry(UsageEntryIndex entry_index,
                                           bool defrag_table,
                                           DeviceFiles* device_files,
                                           metrics::CryptoMetrics* metrics);
@@ -107,13 +107,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(UsageEntryIndex entry_index);
 
   // == 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_; }
 
@@ -128,8 +128,8 @@ class UsageTableHeader {
   // are related to offline licenses.
   size_t OfflineEntryCount() 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().
@@ -141,10 +141,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,
+      UsageEntryIndex* entry_to_remove) {
+    return DetermineLicenseToRemove(entry_info_list, current_time,
                                     unexpired_threshold, entry_to_remove);
   }
 
@@ -155,13 +155,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 |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 |lock_|
   // when required.
   bool RestoreTable(CryptoSession* const crypto_session);
 
@@ -173,76 +173,73 @@ 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_|.
+  // |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_|.
+  // |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 |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);
+                              UsageEntryIndex* entry_index);
 
   // 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_index| 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);
+                                   UsageEntryIndex* entry_index);
 
-  // Checks if the specified |usage_entry_number| is known to be
+  // Checks if the specified |entry_index| is known to be
   // unoccupied (released).
-  bool IsEntryUnoccupied(const uint32_t usage_entry_number) const;
+  bool IsEntryUnoccupied(const UsageEntryIndex entry_index) const;
 
   // SetOfflineEntryInfo() and SetUsageInfoEntryInfo() populate the
   // entry meta-data with the required information based on the type
   // of entry.
-  void SetOfflineEntryInfo(const uint32_t usage_entry_number,
+  void SetOfflineEntryInfo(const UsageEntryIndex entry_index,
                            const std::string& key_set_id,
                            const CdmKeyResponse& license_message);
-  void SetUsageInfoEntryInfo(const uint32_t usage_entry_number,
+  void SetUsageInfoEntryInfo(const UsageEntryIndex entry_index,
                              const std::string& key_set_id,
                              const std::string& usage_info_file_name);
 
   // Shrinks the table, removing all trailing unoccupied entries.
-  // |usage_entry_info_| will be resized appropriately.
+  // |entry_info_list_| 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,
+      UsageEntryIndex entry_index, bool defrag_table, DeviceFiles* device_files,
       metrics::CryptoMetrics* metrics);
 
-  CdmResponseType MoveEntry(uint32_t from /* usage entry number */,
-                            const CdmUsageEntry& from_usage_entry,
-                            uint32_t to /* usage entry number */,
-                            DeviceFiles* device_files,
+  CdmResponseType MoveEntry(UsageEntryIndex from, const UsageEntry& from_entry,
+                            UsageEntryIndex to, DeviceFiles* device_files,
                             metrics::CryptoMetrics* metrics);
 
-  CdmResponseType GetEntry(uint32_t usage_entry_number,
-                           DeviceFiles* device_files,
-                           CdmUsageEntry* usage_entry);
-  CdmResponseType StoreEntry(uint32_t usage_entry_number,
+  CdmResponseType GetEntry(UsageEntryIndex entry_index,
+                           DeviceFiles* device_files, UsageEntry* entry);
+  CdmResponseType StoreEntry(UsageEntryIndex entry_index,
                              DeviceFiles* device_files,
-                             const CdmUsageEntry& usage_entry);
+                             const UsageEntry& entry);
 
   // Stores the usage table and it's info.  This will increment
   // |store_table_counter_| if successful.
   bool StoreTable();
 
   CdmResponseType Shrink(metrics::CryptoMetrics* metrics,
-                         uint32_t number_of_usage_entries_to_delete);
+                         uint32_t number_of_entries_to_delete);
 
   // Must lock table before calling.
   CdmResponseType DefragTable(DeviceFiles* device_files,
@@ -286,7 +283,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.
@@ -301,20 +298,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);
+      UsageEntryIndex* 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
+  // 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_;
+  UsageTableHeader header_;
+  std::vector<CdmUsageEntryInfo> entry_info_list_;
 
   // Table is sync with persistent storage and can be used by the CDM
   // to interact with OEMCrypto.
@@ -322,7 +319,7 @@ class UsageTableHeader {
 
   // Synchonizes access to the Usage Table Header and bookkeeping
   // data-structures
-  mutable std::mutex usage_table_header_lock_;
+  mutable std::mutex lock_;
 
   metrics::CryptoMetrics alternate_crypto_metrics_;
 
@@ -347,12 +344,12 @@ class UsageTableHeader {
 
 #if defined(UNIT_TEST)
   // Test related declarations
-  friend class UsageTableHeaderTest;
+  friend class CdmUsageTableTest;
 
-  FRIEND_TEST(UsageTableHeaderTest, Shrink_NoneOfTable);
-  FRIEND_TEST(UsageTableHeaderTest, Shrink_PartOfTable);
-  FRIEND_TEST(UsageTableHeaderTest, Shrink_AllOfTable);
-  FRIEND_TEST(UsageTableHeaderTest, Shrink_MoreThanTable);
+  FRIEND_TEST(CdmUsageTableTest, Shrink_NoneOfTable);
+  FRIEND_TEST(CdmUsageTableTest, Shrink_PartOfTable);
+  FRIEND_TEST(CdmUsageTableTest, Shrink_AllOfTable);
+  FRIEND_TEST(CdmUsageTableTest, Shrink_MoreThanTable);
 #endif
 
   // These setters are for testing only. Takes ownership of the pointers.
@@ -366,9 +363,9 @@ class UsageTableHeader {
   // Test related data members
   std::unique_ptr<CryptoSession> test_crypto_session_;
 
-  CORE_DISALLOW_COPY_AND_ASSIGN(UsageTableHeader);
+  CORE_DISALLOW_COPY_AND_ASSIGN(CdmUsageTable);
 };
 
 }  // namespace wvcdm
 
-#endif  // WVCDM_CORE_USAGE_TABLE_HEADER_H_
+#endif  // WVCDM_CORE_CDM_USAGE_TABLE_H_
diff --git a/libwvdrmengine/cdm/core/include/crypto_session.h b/libwvdrmengine/cdm/core/include/crypto_session.h
index fdf4986c..77799658 100644
--- a/libwvdrmengine/cdm/core/include/crypto_session.h
+++ b/libwvdrmengine/cdm/core/include/crypto_session.h
@@ -26,7 +26,7 @@ namespace wvcdm {
 class CryptoKey;
 class CryptoSessionFactory;
 class OtaKeyboxProvisioner;
-class UsageTableHeader;
+class CdmUsageTable;
 
 namespace okp {
 class SystemFallbackPolicy;
@@ -273,13 +273,13 @@ class CryptoSession {
   //   Used to manipulate the CDM managed usage table header & entries,
   //   delegating calls to OEMCrypto.
 
-  // Determines whether the OEMCrypto library supports usage info.
+  // Determines whether the OEMCrypto library supports usage table.
   // As of V16, the only valid type of support is usage table header +
   // usage entries.
   // The first method will use a cached value if present.
-  virtual bool HasUsageInfoSupport(bool* has_support);
-  virtual bool HasUsageInfoSupport(RequestedSecurityLevel security_level,
-                                   bool* has_support);
+  virtual bool HasUsageTableSupport(bool* has_support);
+  virtual bool HasUsageTableSupport(RequestedSecurityLevel security_level,
+                                    bool* has_support);
 
   // Usage report.
   virtual CdmResponseType DeactivateUsageInformation(
@@ -290,30 +290,28 @@ class CryptoSession {
       int64_t* seconds_since_started, int64_t* seconds_since_last_played);
 
   // Usage table header.
-  virtual UsageTableHeader* GetUsageTableHeader() {
-    return usage_table_header_;
-  }
+  virtual CdmUsageTable* GetUsageTable() { return usage_table_; }
   // The following crypto methods do not require an open session to
   // complete the operations.
   virtual CdmResponseType CreateUsageTableHeader(
       RequestedSecurityLevel requested_security_level,
-      CdmUsageTableHeader* usage_table_header);
+      UsageTableHeader* usage_table_header);
   virtual CdmResponseType LoadUsageTableHeader(
       RequestedSecurityLevel requested_security_level,
-      const CdmUsageTableHeader& usage_table_header);
+      const UsageTableHeader& usage_table_header);
   virtual CdmResponseType ShrinkUsageTableHeader(
       RequestedSecurityLevel requested_security_level, uint32_t new_entry_count,
-      CdmUsageTableHeader* usage_table_header);
+      UsageTableHeader* usage_table_header);
 
   // Usage entry.
-  virtual CdmResponseType CreateUsageEntry(uint32_t* entry_number);
-  virtual CdmResponseType LoadUsageEntry(uint32_t entry_number,
-                                         const CdmUsageEntry& usage_entry);
-  virtual CdmResponseType UpdateUsageEntry(
-      CdmUsageTableHeader* usage_table_header, CdmUsageEntry* usage_entry);
+  virtual CdmResponseType CreateUsageEntry(UsageEntryIndex* entry_index);
+  virtual CdmResponseType LoadUsageEntry(UsageEntryIndex entry_index,
+                                         const UsageEntry& usage_entry);
+  virtual CdmResponseType UpdateUsageEntry(UsageTableHeader* usage_table_header,
+                                           UsageEntry* usage_entry);
 
   // Adjust usage entries in usage table header.
-  virtual CdmResponseType MoveUsageEntry(uint32_t new_entry_number);
+  virtual CdmResponseType MoveUsageEntry(UsageEntryIndex new_entry_index);
 
   virtual bool GetAnalogOutputCapabilities(bool* can_support_output,
                                            bool* can_disable_output,
@@ -384,11 +382,11 @@ class CryptoSession {
 
   void Init();
 
-  // Will set up the UsageTableHeader for this session.  This may require
-  // creating a new UsageTableHeader if the global instance has not
+  // Will set up the CdmUsageTable for this session.  This may require
+  // creating a new CdmUsageTable if the global instance has not
   // been initialized.
   // Note:  This function will lock the global static field lock in write mode.
-  bool SetUpUsageTableHeader(RequestedSecurityLevel requested_security_level);
+  bool SetUpUsageTable(RequestedSecurityLevel requested_security_level);
 
   CdmResponseType GenerateRsaSignature(const std::string& message,
                                        std::string* signature);
@@ -399,10 +397,10 @@ class CryptoSession {
   CdmResponseType SelectKey(const std::string& key_id,
                             CdmCipherMode cipher_mode);
 
-  // Retrieves the OEMCrypto usage info support for the specified
+  // Retrieves the OEMCrypto usage table support for the specified
   // |requested_security_level|.
   // Caller should acquire the OEMCrypto read lock before calling.
-  bool HasUsageInfoSupportInternal(
+  bool HasUsageTableSupportInternal(
       RequestedSecurityLevel requested_security_level, bool* has_support);
 
   // These methods fall back into each other in the order given, depending on
@@ -526,12 +524,12 @@ class CryptoSession {
   RequestedSecurityLevel requested_security_level_;
 
   // Open session-cached result of OEMCrypto_SupportsUsageTable().
-  CachedBooleanProperty has_usage_info_support_ = kBooleanUnset;
-  UsageTableHeader* usage_table_header_ = nullptr;
+  CachedBooleanProperty has_usage_table_support_ = kBooleanUnset;
+  CdmUsageTable* usage_table_ = nullptr;
   // These fields are protected by |usage_table_mutex_| and not
   // |static_field_mutex_|.
-  static std::unique_ptr<UsageTableHeader> usage_table_header_l1_;
-  static std::unique_ptr<UsageTableHeader> usage_table_header_l3_;
+  static std::unique_ptr<CdmUsageTable> usage_table_l1_;
+  static std::unique_ptr<CdmUsageTable> usage_table_l3_;
 
   std::string request_id_;
   static std::atomic<uint64_t> request_id_index_source_;
diff --git a/libwvdrmengine/cdm/core/include/device_files.h b/libwvdrmengine/cdm/core/include/device_files.h
index 99854b2d..91ea13b2 100644
--- a/libwvdrmengine/cdm/core/include/device_files.h
+++ b/libwvdrmengine/cdm/core/include/device_files.h
@@ -97,8 +97,8 @@ class DeviceFiles {
     // App parameters.
     CdmAppParameterMap app_parameters;
     // Usage entry and index.
-    CdmUsageEntry usage_entry;
-    uint32_t usage_entry_number;
+    UsageEntry usage_entry;
+    UsageEntryIndex usage_entry_index;
     std::string drm_certificate;
     CryptoWrappedKey wrapped_private_key;
   };
@@ -108,8 +108,8 @@ class DeviceFiles {
     CdmKeyMessage license_request;
     CdmKeyResponse license;
     std::string key_set_id;
-    CdmUsageEntry usage_entry;
-    uint32_t usage_entry_number;
+    UsageEntry usage_entry;
+    UsageEntryIndex usage_entry_index;
     std::string drm_certificate;
     CryptoWrappedKey wrapped_private_key;
   };
@@ -183,7 +183,7 @@ class DeviceFiles {
       const std::string& provider_session_token,
       const CdmKeyMessage& key_request, const CdmKeyResponse& key_response,
       const std::string& usage_info_file_name, const std::string& key_set_id,
-      const CdmUsageEntry& usage_entry, uint32_t usage_entry_number,
+      const UsageEntry& usage_entry, UsageEntryIndex usage_entry_index,
       const std::string& drm_certificate, const CryptoWrappedKey& wrapped_key);
 
   // Retrieve usage identifying information stored on the file system.
@@ -236,8 +236,8 @@ class DeviceFiles {
                                  const std::string& provider_session_token,
                                  CdmKeyMessage* license_request,
                                  CdmKeyResponse* license_response,
-                                 CdmUsageEntry* usage_entry,
-                                 uint32_t* usage_entry_number,
+                                 UsageEntry* usage_entry,
+                                 UsageEntryIndex* usage_entry_index,
                                  std::string* drm_certificate,
                                  CryptoWrappedKey* wrapped_key);
   // Retrieve the usage info entry specified by |key_set_id|.
@@ -245,8 +245,8 @@ class DeviceFiles {
   virtual bool RetrieveUsageInfoByKeySetId(
       const std::string& usage_info_file_name, const std::string& key_set_id,
       std::string* provider_session_token, CdmKeyMessage* license_request,
-      CdmKeyResponse* license_response, CdmUsageEntry* usage_entry,
-      uint32_t* usage_entry_number, std::string* drm_certificate,
+      CdmKeyResponse* license_response, UsageEntry* usage_entry,
+      UsageEntryIndex* usage_entry_index, std::string* drm_certificate,
       CryptoWrappedKey* wrapped_key);
 
   // These APIs support upgrading from usage tables to usage tabler header +
@@ -274,15 +274,15 @@ class DeviceFiles {
   virtual bool DeleteHlsAttributes(const std::string& key_set_id);
 
   virtual bool StoreUsageTableInfo(
-      const CdmUsageTableHeader& usage_table_header,
-      const std::vector<CdmUsageEntryInfo>& usage_entry_info);
+      const UsageTableHeader& usage_table_header,
+      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
   // indicated by |lru_upgrade|.
   virtual bool RetrieveUsageTableInfo(
-      CdmUsageTableHeader* usage_table_header,
-      std::vector<CdmUsageEntryInfo>* usage_entry_info, bool* lru_upgrade);
+      UsageTableHeader* usage_table_header,
+      std::vector<CdmUsageEntryInfo>* usage_entry_info_list, bool* lru_upgrade);
 
   virtual bool DeleteUsageTableInfo();
 
diff --git a/libwvdrmengine/cdm/core/include/wv_cdm_types.h b/libwvdrmengine/cdm/core/include/wv_cdm_types.h
index 43c5ce28..01e08450 100644
--- a/libwvdrmengine/cdm/core/include/wv_cdm_types.h
+++ b/libwvdrmengine/cdm/core/include/wv_cdm_types.h
@@ -25,7 +25,6 @@ using CdmSecureStopId = std::string;
 using CdmSessionId = std::string;
 using CdmKeySetId = std::string;
 using RequestId = std::string;
-using CryptoResult = uint32_t;
 using CryptoSessionId = uint32_t;
 using EntitledKeySessionId = uint32_t;
 using CdmAppParameterMap = std::map<std::string, std::string>;
@@ -34,8 +33,11 @@ using CdmUsageInfo = std::vector<std::string>;
 using CdmUsageInfoReleaseMessage = std::string;
 using CdmProvisioningRequest = std::string;
 using CdmProvisioningResponse = std::string;
-using CdmUsageTableHeader = std::string;
-using CdmUsageEntry = std::string;
+
+// OEMCrypto's usage table information.
+using UsageTableHeader = std::string;
+using UsageEntry = std::string;
+using UsageEntryIndex = uint32_t;
 
 enum CdmKeyRequestType : uint32_t {
   kKeyRequestTypeUnknown,
diff --git a/libwvdrmengine/cdm/core/src/cdm_engine.cpp b/libwvdrmengine/cdm/core/src/cdm_engine.cpp
index 4c033637..60a8c0d9 100644
--- a/libwvdrmengine/cdm/core/src/cdm_engine.cpp
+++ b/libwvdrmengine/cdm/core/src/cdm_engine.cpp
@@ -607,11 +607,11 @@ CdmResponseType CdmEngine::QueryStatus(RequestedSecurityLevel security_level,
   }
   if (query_token == QUERY_KEY_USAGE_SUPPORT) {
     bool supports_usage_reporting;
-    const bool got_info = crypto_session->HasUsageInfoSupport(
+    const bool got_info = crypto_session->HasUsageTableSupport(
         security_level, &supports_usage_reporting);
 
     if (!got_info) {
-      LOGW("HasUsageInfoSupport failed");
+      LOGW("HasUsageTableSupport failed");
       metrics_->GetCryptoMetrics()
           ->crypto_session_usage_information_support_.SetError(got_info);
       return CdmResponseType(UNKNOWN_ERROR);
@@ -1661,7 +1661,7 @@ CdmResponseType CdmEngine::RemoveAllUsageInfo(
     usage_session_.reset(new CdmSession(file_system_, metrics_->AddSession()));
     usage_session_->Init(usage_property_set_.get());
 
-    if (usage_session_->supports_usage_info()) {
+    if (usage_session_->SupportsUsageTable()) {
       std::vector<DeviceFiles::CdmUsageData> usage_data;
       // Retrieve all usage information but delete only one before
       // refetching. This is because deleting the usage entry
@@ -1676,7 +1676,7 @@ CdmResponseType CdmEngine::RemoveAllUsageInfo(
         if (usage_data.empty()) break;
 
         CdmResponseType res =
-            usage_session_->DeleteUsageEntry(usage_data[0].usage_entry_number);
+            usage_session_->DeleteUsageEntry(usage_data[0].usage_entry_index);
 
         if (res != NO_ERROR) {
           LOGW("Failed to delete usage entry: status = %d",
@@ -1739,21 +1739,21 @@ CdmResponseType CdmEngine::RemoveUsageInfo(
 
       CdmKeyMessage license_request;
       CdmKeyResponse license_response;
-      CdmUsageEntry usage_entry;
-      uint32_t usage_entry_number;
+      UsageEntry usage_entry;
+      UsageEntryIndex usage_entry_index;
       std::string drm_certificate;
       CryptoWrappedKey wrapped_private_key;
 
       if (!handle.RetrieveUsageInfo(
               DeviceFiles::GetUsageInfoFileName(app_id), provider_session_token,
               &license_request, &license_response, &usage_entry,
-              &usage_entry_number, &drm_certificate, &wrapped_private_key)) {
+              &usage_entry_index, &drm_certificate, &wrapped_private_key)) {
         // Try other security level
         continue;
       }
 
-      if (usage_session_->supports_usage_info()) {
-        status = usage_session_->DeleteUsageEntry(usage_entry_number);
+      if (usage_session_->SupportsUsageTable()) {
+        status = usage_session_->DeleteUsageEntry(usage_entry_index);
         if (!handle.DeleteUsageInfo(DeviceFiles::GetUsageInfoFileName(app_id),
                                     provider_session_token)) {
           status = CdmResponseType(REMOVE_USAGE_INFO_ERROR_1);
@@ -1820,7 +1820,7 @@ CdmResponseType CdmEngine::LoadUsageSession(const CdmKeySetId& key_set_id,
           DeviceFiles::GetUsageInfoFileName(app_id), key_set_id,
           &(usage_data.provider_session_token), &(usage_data.license_request),
           &(usage_data.license), &(usage_data.usage_entry),
-          &(usage_data.usage_entry_number), &(usage_data.drm_certificate),
+          &(usage_data.usage_entry_index), &(usage_data.drm_certificate),
           &(usage_data.wrapped_private_key))) {
     LOGE("Unable to find usage information");
     return CdmResponseType(LOAD_USAGE_INFO_MISSING);
@@ -2149,7 +2149,7 @@ void CdmEngine::OnTimerEvent() {
       for (CdmSessionList::iterator iter = sessions.begin();
            iter != sessions.end(); ++iter) {
         (*iter)->reset_usage_flags();
-        if ((*iter)->supports_usage_info() &&
+        if ((*iter)->SupportsUsageTable() &&
             (*iter)->has_provider_session_token()) {
           (*iter)->UpdateUsageEntryInformation();
         }
diff --git a/libwvdrmengine/cdm/core/src/cdm_session.cpp b/libwvdrmengine/cdm/core/src/cdm_session.cpp
index d1752370..ff096cbd 100644
--- a/libwvdrmengine/cdm/core/src/cdm_session.cpp
+++ b/libwvdrmengine/cdm/core/src/cdm_session.cpp
@@ -13,13 +13,13 @@
 
 #include "cdm_engine.h"
 #include "cdm_random.h"
+#include "cdm_usage_table.h"
 #include "clock.h"
 #include "crypto_wrapped_key.h"
 #include "file_store.h"
 #include "log.h"
 #include "properties.h"
 #include "string_conversions.h"
-#include "usage_table_header.h"
 #include "wv_cdm_constants.h"
 #include "wv_cdm_event_listener.h"
 
@@ -81,8 +81,6 @@ CdmSession::CdmSession(wvutil::FileSystem* file_system,
       requested_security_level_(kLevelDefault),
       is_initial_usage_update_(true),
       is_usage_update_needed_(false),
-      usage_table_header_(nullptr),
-      usage_entry_number_(0),
       mock_license_parser_in_use_(false),
       mock_policy_engine_in_use_(false) {
   assert(metrics_);  // metrics_ must not be null.
@@ -92,7 +90,7 @@ CdmSession::CdmSession(wvutil::FileSystem* file_system,
 }
 
 CdmSession::~CdmSession() {
-  if (has_provider_session_token() && supports_usage_info() && !is_release_) {
+  if (has_provider_session_token() && SupportsUsageTable() && !is_release_) {
     UpdateUsageEntryInformation();
   }
 
@@ -149,8 +147,8 @@ CdmResponseType CdmSession::Init(CdmClientPropertySet* cdm_client_property_set,
   }
 
   bool has_support = false;
-  if (crypto_session_->HasUsageInfoSupport(&has_support) && has_support) {
-    usage_table_header_ = crypto_session_->GetUsageTableHeader();
+  if (crypto_session_->HasUsageTableSupport(&has_support) && has_support) {
+    usage_table_ = crypto_session_->GetUsageTable();
   }
 
   if (cdm_client_property_set != nullptr)
@@ -247,7 +245,7 @@ CdmResponseType CdmSession::RestoreOfflineSession(const CdmKeySetId& key_set_id,
   offline_release_server_url_ = std::move(license_data.release_server_url);
   app_parameters_ = std::move(license_data.app_parameters);
   usage_entry_ = std::move(license_data.usage_entry);
-  usage_entry_number_ = license_data.usage_entry_number;
+  usage_entry_index_ = license_data.usage_entry_index;
 
   CdmResponseType result = LoadPrivateOrLegacyKey(
       license_data.drm_certificate, license_data.wrapped_private_key);
@@ -273,7 +271,7 @@ CdmResponseType CdmSession::RestoreOfflineSession(const CdmKeySetId& key_set_id,
 
   std::string provider_session_token;
   bool sign_fake_request = false;  // TODO(b/169483174): remove this variable.
-  if (supports_usage_info()) {
+  if (SupportsUsageTable()) {
     if (!license_parser_->ExtractProviderSessionToken(
             key_response_, &provider_session_token)) {
       provider_session_token.clear();
@@ -282,8 +280,8 @@ CdmResponseType CdmSession::RestoreOfflineSession(const CdmKeySetId& key_set_id,
       LOGE("License usage entry is invalid, cannot restore");
       return CdmResponseType(LICENSE_USAGE_ENTRY_MISSING);
     } else {
-      CdmResponseType sts = usage_table_header_->LoadEntry(
-          crypto_session_.get(), usage_entry_, usage_entry_number_);
+      CdmResponseType sts = usage_table_->LoadEntry(
+          crypto_session_.get(), usage_entry_, usage_entry_index_);
       crypto_metrics_->usage_table_header_load_entry_.Increment(sts);
       if (sts == LOAD_USAGE_ENTRY_INVALID_SESSION) {
         LOGE("License loaded in different session: key_set_id = %s",
@@ -340,9 +338,9 @@ CdmResponseType CdmSession::RestoreOfflineSession(const CdmKeySetId& key_set_id,
     }
   }
 
-  if (!provider_session_token.empty() && supports_usage_info()) {
-    CdmResponseType sts = usage_table_header_->UpdateEntry(
-        usage_entry_number_, crypto_session_.get(), &usage_entry_);
+  if (!provider_session_token.empty() && SupportsUsageTable()) {
+    CdmResponseType sts = usage_table_->UpdateEntry(
+        usage_entry_index_, crypto_session_.get(), &usage_entry_);
     if (sts != NO_ERROR) {
       LOGE("Failed to update usage entry: status = %d", static_cast<int>(sts));
       return sts;
@@ -372,7 +370,7 @@ CdmResponseType CdmSession::RestoreUsageSession(
   key_request_ = usage_data.license_request;
   key_response_ = usage_data.license;
   usage_entry_ = usage_data.usage_entry;
-  usage_entry_number_ = usage_data.usage_entry_number;
+  usage_entry_index_ = usage_data.usage_entry_index;
   usage_provider_session_token_ = usage_data.provider_session_token;
 
   CdmResponseType status = LoadPrivateOrLegacyKey(
@@ -380,9 +378,9 @@ CdmResponseType CdmSession::RestoreUsageSession(
   if (status != NO_ERROR) return status;
 
   CdmResponseType sts(NO_ERROR);
-  if (supports_usage_info()) {
-    sts = usage_table_header_->LoadEntry(crypto_session_.get(), usage_entry_,
-                                         usage_entry_number_);
+  if (SupportsUsageTable()) {
+    sts = usage_table_->LoadEntry(crypto_session_.get(), usage_entry_,
+                                  usage_entry_index_);
     crypto_metrics_->usage_table_header_load_entry_.Increment(sts);
     if (sts != NO_ERROR) {
       LOGE("Failed to load usage entry: status = %d", static_cast<int>(sts));
@@ -398,9 +396,9 @@ CdmResponseType CdmSession::RestoreUsageSession(
     return CdmResponseType(RELEASE_LICENSE_ERROR_2);
   }
 
-  if (supports_usage_info()) {
-    sts = usage_table_header_->UpdateEntry(
-        usage_entry_number_, crypto_session_.get(), &usage_entry_);
+  if (SupportsUsageTable()) {
+    sts = usage_table_->UpdateEntry(usage_entry_index_, crypto_session_.get(),
+                                    &usage_entry_);
     if (sts != NO_ERROR) {
       LOGE("Failed to update usage entry: status = %d", static_cast<int>(sts));
       return sts;
@@ -541,16 +539,16 @@ CdmResponseType CdmSession::AddKeyInternal(const CdmKeyResponse& key_response) {
   // to be created.
   CdmResponseType sts;
   std::string provider_session_token;
-  if (supports_usage_info()) {
+  if (SupportsUsageTable()) {
     if (license_parser_->ExtractProviderSessionToken(key_response,
                                                      &provider_session_token) &&
         !provider_session_token.empty()) {
       std::string app_id;
       GetApplicationId(&app_id);
-      sts = usage_table_header_->AddEntry(
-          crypto_session_.get(), is_offline_, key_set_id_,
-          DeviceFiles::GetUsageInfoFileName(app_id), key_response,
-          &usage_entry_number_);
+      sts = usage_table_->AddEntry(crypto_session_.get(), is_offline_,
+                                   key_set_id_,
+                                   DeviceFiles::GetUsageInfoFileName(app_id),
+                                   key_response, &usage_entry_index_);
       crypto_metrics_->usage_table_header_add_entry_.Increment(sts);
       if (sts != NO_ERROR) return sts;
     }
@@ -565,11 +563,10 @@ CdmResponseType CdmSession::AddKeyInternal(const CdmKeyResponse& key_response) {
       version_info.license_service_version());
 
   // Update or invalidate entry if usage table header+entries are supported
-  if (!provider_session_token.empty() && supports_usage_info()) {
+  if (!provider_session_token.empty() && SupportsUsageTable()) {
     if (sts != KEY_ADDED) {
-      const CdmResponseType invalidate_sts =
-          usage_table_header_->InvalidateEntry(
-              usage_entry_number_, true, file_handle_.get(), crypto_metrics_);
+      const CdmResponseType invalidate_sts = usage_table_->InvalidateEntry(
+          usage_entry_index_, true, file_handle_.get(), crypto_metrics_);
       crypto_metrics_->usage_table_header_delete_entry_.Increment(
           invalidate_sts);
       if (invalidate_sts != NO_ERROR) {
@@ -590,9 +587,9 @@ CdmResponseType CdmSession::AddKeyInternal(const CdmKeyResponse& key_response) {
        license_parser_->provider_session_token().size());
 
   if ((is_offline_ || has_provider_session_token()) && !is_temporary_) {
-    if (has_provider_session_token() && supports_usage_info()) {
-      usage_table_header_->UpdateEntry(usage_entry_number_,
-                                       crypto_session_.get(), &usage_entry_);
+    if (has_provider_session_token() && SupportsUsageTable()) {
+      usage_table_->UpdateEntry(usage_entry_index_, crypto_session_.get(),
+                                &usage_entry_);
     }
 
     if (!is_offline_)
@@ -790,16 +787,16 @@ CdmResponseType CdmSession::GenerateReleaseRequest(CdmKeyRequest* key_request) {
   is_release_ = true;
   license_request_latency_.Clear();
   CdmResponseType status = license_parser_->PrepareKeyUpdateRequest(
-      false, app_parameters_, usage_table_header_ == nullptr ? nullptr : this,
+      false, app_parameters_, usage_table_ == nullptr ? nullptr : this,
       &key_request->message, &key_request->url);
 
   key_request->type = kKeyRequestTypeRelease;
 
   if (KEY_MESSAGE != status) return status;
 
-  if (has_provider_session_token() && supports_usage_info()) {
-    status = usage_table_header_->UpdateEntry(
-        usage_entry_number_, crypto_session_.get(), &usage_entry_);
+  if (has_provider_session_token() && SupportsUsageTable()) {
+    status = usage_table_->UpdateEntry(usage_entry_index_,
+                                       crypto_session_.get(), &usage_entry_);
 
     if (status != NO_ERROR) {
       LOGE("Update usage entry failed: status = %d", static_cast<int>(status));
@@ -811,7 +808,7 @@ CdmResponseType CdmSession::GenerateReleaseRequest(CdmKeyRequest* key_request) {
     if (!StoreLicense(kLicenseStateReleasing, nullptr))
       return CdmResponseType(RELEASE_KEY_REQUEST_ERROR);
   } else if (!usage_provider_session_token_.empty()) {
-    if (supports_usage_info()) {
+    if (SupportsUsageTable()) {
       if (!UpdateUsageInfo()) return CdmResponseType(RELEASE_USAGE_INFO_FAILED);
     }
   }
@@ -840,12 +837,12 @@ CdmResponseType CdmSession::ReleaseKey(const CdmKeyResponse& key_response) {
   return RemoveLicense();
 }
 
-CdmResponseType CdmSession::DeleteUsageEntry(uint32_t usage_entry_number) {
+CdmResponseType CdmSession::DeleteUsageEntry(uint32_t usage_entry_index) {
   if (!initialized_) {
     LOGE("CDM session not initialized");
     return CdmResponseType(NOT_INITIALIZED_ERROR);
   }
-  if (!supports_usage_info()) {
+  if (!SupportsUsageTable()) {
     LOGE("Cannot delete entry, usage table not supported");
     return CdmResponseType(INCORRECT_USAGE_SUPPORT_TYPE_1);
   }
@@ -860,19 +857,19 @@ CdmResponseType CdmSession::DeleteUsageEntry(uint32_t usage_entry_number) {
          crypto_metrics_, crypto_session_open_, sts, requested_security_level_);
   if (sts != NO_ERROR) return sts;
 
-  usage_table_header_ = nullptr;
+  usage_table_ = nullptr;
   bool has_support = false;
-  if (crypto_session_->HasUsageInfoSupport(&has_support) && has_support) {
-    usage_table_header_ = crypto_session_->GetUsageTableHeader();
+  if (crypto_session_->HasUsageTableSupport(&has_support) && has_support) {
+    usage_table_ = crypto_session_->GetUsageTable();
   }
 
-  if (usage_table_header_ == nullptr) {
+  if (usage_table_ == nullptr) {
     LOGE("Usage table header unavailable");
     return CdmResponseType(INCORRECT_USAGE_SUPPORT_TYPE_1);
   }
 
-  sts = usage_table_header_->InvalidateEntry(
-      usage_entry_number, true, file_handle_.get(), crypto_metrics_);
+  sts = usage_table_->InvalidateEntry(usage_entry_index, true,
+                                      file_handle_.get(), crypto_metrics_);
   crypto_metrics_->usage_table_header_delete_entry_.Increment(sts);
   return sts;
 }
@@ -954,11 +951,11 @@ CdmResponseType CdmSession::StoreLicense() {
   if (!file_handle_->StoreUsageInfo(
           provider_session_token, key_request_, key_response_,
           DeviceFiles::GetUsageInfoFileName(app_id), key_set_id_, usage_entry_,
-          usage_entry_number_, drm_certificate_, wrapped_private_key_)) {
+          usage_entry_index_, drm_certificate_, wrapped_private_key_)) {
     LOGE("Unable to store usage info");
     // Usage info file is corrupt. Delete current usage entry and file.
-    if (supports_usage_info()) {
-      DeleteUsageEntry(usage_entry_number_);
+    if (SupportsUsageTable()) {
+      DeleteUsageEntry(usage_entry_index_);
     } else {
       LOGW("Cannot store, usage table not supported");
     }
@@ -987,7 +984,7 @@ bool CdmSession::StoreLicense(CdmOfflineLicenseState state, int* error_detail) {
       policy_engine_->GetGracePeriodEndTime(),
       app_parameters_,
       usage_entry_,
-      usage_entry_number_,
+      usage_entry_index_,
       drm_certificate_,
       wrapped_private_key_};
 
@@ -1011,8 +1008,8 @@ CdmResponseType CdmSession::RemoveKeys() {
 
 CdmResponseType CdmSession::RemoveLicense() {
   if (is_offline_ || has_provider_session_token()) {
-    if (has_provider_session_token() && supports_usage_info()) {
-      DeleteUsageEntry(usage_entry_number_);
+    if (has_provider_session_token() && SupportsUsageTable()) {
+      DeleteUsageEntry(usage_entry_index_);
     }
     DeleteLicenseFile();
   }
@@ -1061,9 +1058,9 @@ void CdmSession::GetApplicationId(std::string* app_id) {
 }
 
 CdmResponseType CdmSession::UpdateUsageEntryInformation() {
-  if (!has_provider_session_token() || !supports_usage_info()) {
+  if (!has_provider_session_token() || !SupportsUsageTable()) {
     LOGE("Unexpected state: usage_support = %s, PST present = %s, ",
-         supports_usage_info() ? "true" : "false",
+         SupportsUsageTable() ? "true" : "false",
          has_provider_session_token() ? "yes" : "no");
     return CdmResponseType(INCORRECT_USAGE_SUPPORT_TYPE_2);
   }
@@ -1072,8 +1069,8 @@ CdmResponseType CdmSession::UpdateUsageEntryInformation() {
   // TODO(blueeyes): Add measurements to all UpdateEntry calls in a way that
   // allos us to isolate this particular use case within
   // UpdateUsageEntryInformation.
-  M_TIME(sts = usage_table_header_->UpdateEntry(
-             usage_entry_number_, crypto_session_.get(), &usage_entry_),
+  M_TIME(sts = usage_table_->UpdateEntry(usage_entry_index_,
+                                         crypto_session_.get(), &usage_entry_),
          crypto_metrics_, usage_table_header_update_entry_, sts);
 
   if (sts != NO_ERROR) return sts;
@@ -1159,7 +1156,7 @@ bool CdmSession::UpdateUsageInfo() {
   usage_data.license = key_response_;
   usage_data.key_set_id = key_set_id_;
   usage_data.usage_entry = usage_entry_;
-  usage_data.usage_entry_number = usage_entry_number_;
+  usage_data.usage_entry_index = usage_entry_index_;
 
   return file_handle_->UpdateUsageInfo(
       DeviceFiles::GetUsageInfoFileName(app_id), usage_provider_session_token_,
@@ -1178,15 +1175,15 @@ bool CdmSession::VerifyOfflineUsageEntry() {
   // Check that the current license is the same as the expected
   // entry in the usage table.  It is possible that the license has
   // been removed from the usage table but the license file remains.
-  if (usage_entry_number_ >= usage_table_header_->size()) {
-    LOGD("License usage entry does not exist: entry_number = %u, size = %zu",
-         usage_entry_number_, usage_table_header_->size());
+  if (usage_entry_index_ >= usage_table_->size()) {
+    LOGD("License usage entry does not exist: entry_index = %u, size = %zu",
+         usage_entry_index_, usage_table_->size());
     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_) {
+  const CdmUsageEntryInfo& entry_info =
+      usage_table_->entry_info_list().at(usage_entry_index_);
+  if (entry_info.storage_type != kStorageLicense ||
+      entry_info.key_set_id != key_set_id_) {
     LOGD("License usage entry does not match");
     return false;
   }
diff --git a/libwvdrmengine/cdm/core/src/usage_table_header.cpp b/libwvdrmengine/cdm/core/src/cdm_usage_table.cpp
similarity index 62%
rename from libwvdrmengine/cdm/core/src/usage_table_header.cpp
rename to libwvdrmengine/cdm/core/src/cdm_usage_table.cpp
index 0e8cffd6..c31f3abd 100644
--- a/libwvdrmengine/cdm/core/src/usage_table_header.cpp
+++ b/libwvdrmengine/cdm/core/src/cdm_usage_table.cpp
@@ -2,7 +2,7 @@
 // source code may only be used and distributed under the Widevine License
 // Agreement.
 
-#include "usage_table_header.h"
+#include "cdm_usage_table.h"
 
 #include <algorithm>
 #include <limits>
@@ -71,7 +71,7 @@ bool ParseLicenseFromLicenseMessage(const CdmKeyResponse& license_message,
 bool RetrieveOfflineLicense(DeviceFiles* device_files,
                             const std::string& key_set_id,
                             CdmKeyResponse* license_message,
-                            uint32_t* usage_entry_number) {
+                            UsageEntryIndex* entry_index) {
   if (device_files == nullptr) {
     LOGE("DeviceFiles handle is null");
     return false;
@@ -80,8 +80,8 @@ bool RetrieveOfflineLicense(DeviceFiles* device_files,
     LOGE("Output parameter |license_message| is null");
     return false;
   }
-  if (usage_entry_number == nullptr) {
-    LOGE("Output parameter |usage_entry_number| is null");
+  if (entry_index == nullptr) {
+    LOGE("Output parameter |entry_index| is null");
     return false;
   }
   DeviceFiles::CdmLicenseData license_data;
@@ -92,7 +92,7 @@ bool RetrieveOfflineLicense(DeviceFiles* device_files,
     return false;
   }
   *license_message = std::move(license_data.license);
-  *usage_entry_number = license_data.usage_entry_number;
+  *entry_index = license_data.usage_entry_index;
   return true;
 }
 
@@ -100,7 +100,7 @@ bool RetrieveUsageInfoLicense(DeviceFiles* device_files,
                               const std::string& usage_info_file_name,
                               const std::string& key_set_id,
                               CdmKeyResponse* license_message,
-                              uint32_t* usage_entry_number) {
+                              UsageEntryIndex* entry_index) {
   if (device_files == nullptr) {
     LOGE("DeviceFiles handle is null");
     return false;
@@ -109,18 +109,18 @@ bool RetrieveUsageInfoLicense(DeviceFiles* device_files,
     LOGE("Output parameter |license_message| is null");
     return false;
   }
-  if (usage_entry_number == nullptr) {
-    LOGE("Output parameter |usage_entry_number| is null");
+  if (entry_index == nullptr) {
+    LOGE("Output parameter |entry_index| is null");
     return false;
   }
-  CdmUsageEntry usage_entry;
+  UsageEntry entry;
   std::string provider_session_token;
   CdmKeyMessage license_request;
   std::string drm_certificate;
   CryptoWrappedKey wrapped_private_key;
   if (!device_files->RetrieveUsageInfoByKeySetId(
           usage_info_file_name, key_set_id, &provider_session_token,
-          &license_request, license_message, &usage_entry, usage_entry_number,
+          &license_request, license_message, &entry, entry_index,
           &drm_certificate, &wrapped_private_key)) {
     LOGW(
         "Failed to retrieve usage information: "
@@ -152,13 +152,13 @@ RequestedSecurityLevel CdmSecurityLevelToRequestedLevel(
 }
 }  // namespace
 
-UsageTableHeader::UsageTableHeader() : clock_ref_(&clock_) {
+CdmUsageTable::CdmUsageTable() : clock_ref_(&clock_) {
   file_system_.reset(new wvutil::FileSystem());
   device_files_.reset(new DeviceFiles(file_system_.get()));
 }
 
-bool UsageTableHeader::Init(CdmSecurityLevel security_level,
-                            CryptoSession* crypto_session) {
+bool CdmUsageTable::Init(CdmSecurityLevel security_level,
+                         CryptoSession* crypto_session) {
   LOGD("security_level = %s", CdmSecurityLevelToString(security_level));
   if (crypto_session == nullptr) {
     LOGE("No crypto session provided");
@@ -192,18 +192,18 @@ bool UsageTableHeader::Init(CdmSecurityLevel security_level,
   return RestoreTable(crypto_session) || CreateNewTable(crypto_session);
 }
 
-bool UsageTableHeader::RestoreTable(CryptoSession* const crypto_session) {
+bool CdmUsageTable::RestoreTable(CryptoSession* const crypto_session) {
   bool run_lru_upgrade = false;
-  if (!device_files_->RetrieveUsageTableInfo(
-          &usage_table_header_, &usage_entry_info_, &run_lru_upgrade)) {
+  if (!device_files_->RetrieveUsageTableInfo(&header_, &entry_info_list_,
+                                             &run_lru_upgrade)) {
     LOGW("Could not retrieve usage table");
     return false;
   }
   LOGI("Found usage table to restore: entry_count = %zu",
-       usage_entry_info_.size());
+       entry_info_list_.size());
 
-  const CdmResponseType status = crypto_session->LoadUsageTableHeader(
-      requested_security_level_, usage_table_header_);
+  const CdmResponseType status =
+      crypto_session->LoadUsageTableHeader(requested_security_level_, header_);
   if (status != NO_ERROR) {
     LOGE("Failed to load usage table header: sts = %d", status.Enum());
     return false;
@@ -224,18 +224,18 @@ bool UsageTableHeader::RestoreTable(CryptoSession* const crypto_session) {
   return true;
 }
 
-bool UsageTableHeader::CreateNewTable(CryptoSession* const crypto_session) {
+bool CdmUsageTable::CreateNewTable(CryptoSession* const crypto_session) {
   LOGD("Removing all usage table files");
   // Existing files need to be deleted to avoid attempts to restore
   // licenses which no longer have a usage entry.
   device_files_->DeleteAllLicenses();
   device_files_->DeleteAllUsageInfo();
   device_files_->DeleteUsageTableInfo();
-  usage_entry_info_.clear();
-  usage_table_header_.clear();
+  entry_info_list_.clear();
+  header_.clear();
 
   const CdmResponseType status = crypto_session->CreateUsageTableHeader(
-      requested_security_level_, &usage_table_header_);
+      requested_security_level_, &header_);
   if (status != NO_ERROR) {
     LOGE("Failed to create new usage table header");
     return false;
@@ -248,72 +248,72 @@ bool UsageTableHeader::CreateNewTable(CryptoSession* const crypto_session) {
   return true;
 }
 
-CdmResponseType UsageTableHeader::AddEntry(
-    CryptoSession* crypto_session, bool persistent_license,
-    const CdmKeySetId& key_set_id, const std::string& usage_info_file_name,
-    const CdmKeyResponse& license_message, uint32_t* usage_entry_number) {
+CdmResponseType CdmUsageTable::AddEntry(CryptoSession* crypto_session,
+                                        bool persistent_license,
+                                        const CdmKeySetId& key_set_id,
+                                        const std::string& usage_info_file_name,
+                                        const CdmKeyResponse& license_message,
+                                        UsageEntryIndex* entry_index) {
   LOGD("key_set_id = %s, type = %s, current_size = %zu", IdToString(key_set_id),
        persistent_license ? "OfflineLicense" : "Streaming",
-       usage_entry_info_.size());
+       entry_info_list_.size());
 
   metrics::CryptoMetrics* metrics = crypto_session->GetCryptoMetrics();
   if (metrics == nullptr) metrics = &alternate_crypto_metrics_;
-  TableLock auto_lock(usage_table_header_lock_);
+  TableLock auto_lock(lock_);
 
-  CdmResponseType status = CreateEntry(crypto_session, usage_entry_number);
+  CdmResponseType status = CreateEntry(crypto_session, entry_index);
   if (status == INSUFFICIENT_CRYPTO_RESOURCES) {
     LOGW("Usage table may be full, releasing oldest entry: size = %zu",
-         usage_entry_info_.size());
+         entry_info_list_.size());
     status = ReleaseOldestEntry(metrics);
     if (status == NO_ERROR) {
-      status = CreateEntry(crypto_session, usage_entry_number);
+      status = CreateEntry(crypto_session, entry_index);
     }
   }
   if (status != NO_ERROR) return status;
 
-  status = RelocateNewEntry(crypto_session, usage_entry_number);
+  status = RelocateNewEntry(crypto_session, entry_index);
   if (status != NO_ERROR) return status;
 
   if (persistent_license) {
-    SetOfflineEntryInfo(*usage_entry_number, key_set_id, license_message);
+    SetOfflineEntryInfo(*entry_index, key_set_id, license_message);
   } else {
-    SetUsageInfoEntryInfo(*usage_entry_number, key_set_id,
-                          usage_info_file_name);
+    SetUsageInfoEntryInfo(*entry_index, key_set_id, usage_info_file_name);
   }
 
   status = RefitTable(crypto_session);
   if (status != NO_ERROR) {
-    usage_entry_info_[*usage_entry_number].Clear();
+    entry_info_list_[*entry_index].Clear();
     return status;
   }
 
   // Call to update the usage table header, but don't store the usage
   // entry.  If the entry is used by the CDM, the CDM session will make
   // subsequent calls to update the usage entry and store that entry.
-  std::string usage_entry;
-  status = crypto_session->UpdateUsageEntry(&usage_table_header_, &usage_entry);
+  UsageEntry entry;
+  status = crypto_session->UpdateUsageEntry(&header_, &entry);
   if (status != NO_ERROR) {
-    LOGE("Failed to update new usage entry: usage_entry_number = %u",
-         *usage_entry_number);
-    usage_entry_info_[*usage_entry_number].Clear();
+    LOGE("Failed to update new usage entry: entry_index = %u", *entry_index);
+    entry_info_list_[*entry_index].Clear();
     return status;
   }
   StoreTable();
   return CdmResponseType(NO_ERROR);
 }
 
-CdmResponseType UsageTableHeader::LoadEntry(CryptoSession* crypto_session,
-                                            const CdmUsageEntry& usage_entry,
-                                            uint32_t usage_entry_number) {
+CdmResponseType CdmUsageTable::LoadEntry(CryptoSession* crypto_session,
+                                         const UsageEntry& entry,
+                                         UsageEntryIndex entry_index) {
   {
-    LOGD("usage_entry_number = %u", usage_entry_number);
-    std::unique_lock<std::mutex> auto_lock(usage_table_header_lock_);
+    LOGD("entry_index = %u", entry_index);
+    std::unique_lock<std::mutex> auto_lock(lock_);
 
-    if (usage_entry_number >= usage_entry_info_.size()) {
+    if (entry_index >= entry_info_list_.size()) {
       LOGE(
-          "Requested usage entry number is larger than table size: "
-          "usage_entry_number = %u, table_size = %zu",
-          usage_entry_number, usage_entry_info_.size());
+          "Requested usage entry index is larger than table size: "
+          "entry_index = %u, table_size = %zu",
+          entry_index, entry_info_list_.size());
       return CdmResponseType(USAGE_INVALID_LOAD_ENTRY);
     }
   }
@@ -321,60 +321,59 @@ CdmResponseType UsageTableHeader::LoadEntry(CryptoSession* crypto_session,
   if (metrics == nullptr) metrics = &alternate_crypto_metrics_;
 
   const CdmResponseType status =
-      crypto_session->LoadUsageEntry(usage_entry_number, usage_entry);
+      crypto_session->LoadUsageEntry(entry_index, entry);
 
   if (status == NO_ERROR) {
-    usage_entry_info_[usage_entry_number].last_use_time = GetCurrentTime();
+    entry_info_list_[entry_index].last_use_time = GetCurrentTime();
   }
 
   return status;
 }
 
-CdmResponseType UsageTableHeader::UpdateEntry(uint32_t usage_entry_number,
-                                              CryptoSession* crypto_session,
-                                              CdmUsageEntry* usage_entry) {
-  LOGD("usage_entry_number = %u", usage_entry_number);
-  std::unique_lock<std::mutex> auto_lock(usage_table_header_lock_);
-  if (usage_entry_number >= usage_entry_info_.size()) {
-    LOGE("Usage entry number %u is larger than usage entry size %zu",
-         usage_entry_number, usage_entry_info_.size());
+CdmResponseType CdmUsageTable::UpdateEntry(UsageEntryIndex entry_index,
+                                           CryptoSession* crypto_session,
+                                           UsageEntry* entry) {
+  LOGD("entry_index = %u", entry_index);
+  std::unique_lock<std::mutex> auto_lock(lock_);
+  if (entry_index >= entry_info_list_.size()) {
+    LOGE("Usage entry index %u is larger than usage entry size %zu",
+         entry_index, entry_info_list_.size());
     return CdmResponseType(USAGE_INVALID_PARAMETERS_2);
   }
 
-  CdmResponseType status =
-      crypto_session->UpdateUsageEntry(&usage_table_header_, usage_entry);
+  CdmResponseType status = crypto_session->UpdateUsageEntry(&header_, entry);
 
   if (status != NO_ERROR) return status;
-  usage_entry_info_[usage_entry_number].last_use_time = GetCurrentTime();
+  entry_info_list_[entry_index].last_use_time = GetCurrentTime();
 
   StoreTable();
   return CdmResponseType(NO_ERROR);
 }
 
-CdmResponseType UsageTableHeader::InvalidateEntry(
-    uint32_t usage_entry_number, bool defrag_table, DeviceFiles* device_files,
+CdmResponseType CdmUsageTable::InvalidateEntry(
+    UsageEntryIndex entry_index, bool defrag_table, DeviceFiles* device_files,
     metrics::CryptoMetrics* metrics) {
-  LOGD("usage_entry_number = %u", usage_entry_number);
-  TableLock auto_lock(usage_table_header_lock_);
-  return InvalidateEntryInternal(usage_entry_number, defrag_table, device_files,
+  LOGD("entry_index = %u", entry_index);
+  TableLock auto_lock(lock_);
+  return InvalidateEntryInternal(entry_index, defrag_table, device_files,
                                  metrics);
 }
 
-CdmResponseType UsageTableHeader::InvalidateEntryInternal(
-    uint32_t usage_entry_number, bool defrag_table, DeviceFiles* device_files,
+CdmResponseType CdmUsageTable::InvalidateEntryInternal(
+    UsageEntryIndex entry_index, bool defrag_table, DeviceFiles* device_files,
     metrics::CryptoMetrics* metrics) {
   // OEMCrypto does not have any concept of "deleting" an entry.
   // Instead, the CDM marks the entry's meta data as invalid (storage
   // type unknown) and then performs a "defrag" of the OEMCrypto table.
-  if (usage_entry_number >= usage_entry_info_.size()) {
+  if (entry_index >= entry_info_list_.size()) {
     LOGE(
-        "Usage entry number is larger than table size: "
-        "usage_entry_number = %u, table_size = %zu",
-        usage_entry_number, usage_entry_info_.size());
+        "Usage entry index is larger than table size: "
+        "entry_index = %u, table_size = %zu",
+        entry_index, entry_info_list_.size());
     return CdmResponseType(USAGE_INVALID_PARAMETERS_1);
   }
 
-  usage_entry_info_[usage_entry_number].Clear();
+  entry_info_list_[entry_index].Clear();
 
   if (defrag_table) {
     // The defrag operation calls many OEMCrypto functions that are
@@ -403,20 +402,20 @@ CdmResponseType UsageTableHeader::InvalidateEntryInternal(
   return CdmResponseType(NO_ERROR);
 }
 
-size_t UsageTableHeader::UsageInfoCount() const {
+size_t CdmUsageTable::UsageInfoCount() const {
   LOGV("Locking to count usage info (streaming license) entries");
-  return std::count_if(usage_entry_info_.cbegin(), usage_entry_info_.cend(),
+  return std::count_if(entry_info_list_.cbegin(), entry_info_list_.cend(),
                        EntryIsUsageInfo);
 }
 
-size_t UsageTableHeader::OfflineEntryCount() const {
+size_t CdmUsageTable::OfflineEntryCount() const {
   LOGV("Locking to count offline license entries");
-  return std::count_if(usage_entry_info_.cbegin(), usage_entry_info_.cend(),
+  return std::count_if(entry_info_list_.cbegin(), entry_info_list_.cend(),
                        EntryIsOfflineLicense);
 }
 
-bool UsageTableHeader::OpenSessionCheck(CryptoSession* const crypto_session) {
-  // The UsageTableHeader for the specified |requested_security_level_|
+bool CdmUsageTable::OpenSessionCheck(CryptoSession* const crypto_session) {
+  // The CdmUsageTable for the specified |requested_security_level_|
   // MUST be initialized before any sessions are opened.
   size_t session_count = 0;
   const CdmResponseType status = crypto_session->GetNumberOfOpenSessions(
@@ -431,7 +430,7 @@ bool UsageTableHeader::OpenSessionCheck(CryptoSession* const crypto_session) {
   return true;
 }
 
-bool UsageTableHeader::CapacityCheck(CryptoSession* const crypto_session) {
+bool CdmUsageTable::CapacityCheck(CryptoSession* const crypto_session) {
   // If the table is around capacity or if unlimited and the table is
   // larger than the minimally required capacity, then a test must be
   // performed to ensure that the usage table is not in a state which
@@ -439,7 +438,7 @@ bool UsageTableHeader::CapacityCheck(CryptoSession* const crypto_session) {
   const size_t capacity_threshold = HasUnlimitedTableCapacity()
                                         ? kMinimumUsageTableEntriesSupported
                                         : potential_table_capacity();
-  if (usage_entry_info_.size() <= capacity_threshold) {
+  if (entry_info_list_.size() <= capacity_threshold) {
     // No need to perform test if below capacity.
     return true;
   }
@@ -463,23 +462,23 @@ bool UsageTableHeader::CapacityCheck(CryptoSession* const crypto_session) {
     return false;
   }
 
-  uint32_t temporary_usage_entry_number;
+  UsageEntryIndex temporary_entry_index;
   status = AddEntry(local_crypto_session, true, kDummyKeySetId, kEmptyString,
-                    kEmptyString, &temporary_usage_entry_number);
+                    kEmptyString, &temporary_entry_index);
   if (status != NO_ERROR) {
     LOGE("Failed to add entry for capacity test: sts = %d", status.Enum());
     return false;
   }
 
   status =
-      InvalidateEntry(temporary_usage_entry_number,
+      InvalidateEntry(temporary_entry_index,
                       /* defrag_table = */ true, device_files_.get(), metrics);
   if (status != NO_ERROR) {
     LOGE("Failed to invalidate entry for capacity test: sts = %d",
          status.Enum());
     return false;
   }
-  if (usage_entry_info_.size() > temporary_usage_entry_number) {
+  if (entry_info_list_.size() > temporary_entry_index) {
     // The entry should have been deleted from the usage table,
     // not just marked as type unknown.  Failure to call
     // Shrink() may be an indicator of other issues.
@@ -489,7 +488,7 @@ bool UsageTableHeader::CapacityCheck(CryptoSession* const crypto_session) {
   return true;
 }
 
-bool UsageTableHeader::DetermineTableCapacity(CryptoSession* crypto_session) {
+bool CdmUsageTable::DetermineTableCapacity(CryptoSession* crypto_session) {
   if (!crypto_session->GetMaximumUsageTableEntries(
           requested_security_level_, &potential_table_capacity_)) {
     LOGW(
@@ -513,78 +512,75 @@ bool UsageTableHeader::DetermineTableCapacity(CryptoSession* crypto_session) {
   return true;
 }
 
-CdmResponseType UsageTableHeader::CreateEntry(
-    CryptoSession* const crypto_session, uint32_t* usage_entry_number) {
-  const CdmResponseType status =
-      crypto_session->CreateUsageEntry(usage_entry_number);
+CdmResponseType CdmUsageTable::CreateEntry(CryptoSession* const crypto_session,
+                                           UsageEntryIndex* entry_index) {
+  const CdmResponseType status = crypto_session->CreateUsageEntry(entry_index);
   if (status != NO_ERROR) return status;
-  // If the new entry number is smaller than expected, then the usage
+  // If the new entry index is smaller than expected, then the usage
   // table may be out of sync or OEMCrypto has been rolled back.
   // Not safe to continue.
-  if (*usage_entry_number < usage_entry_info_.size()) {
+  if (*entry_index < entry_info_list_.size()) {
     LOGE(
-        "New entry number is smaller than table size: "
-        "entry_info_number = %u, table_size = %zu",
-        *usage_entry_number, usage_entry_info_.size());
+        "New entry index is smaller than table size: "
+        "entry_index = %u, table_size = %zu",
+        *entry_index, entry_info_list_.size());
     return CdmResponseType(USAGE_INVALID_NEW_ENTRY);
   }
-  LOGI("usage_entry_number = %u", *usage_entry_number);
-  const size_t previous_size = usage_entry_info_.size();
-  usage_entry_info_.resize(*usage_entry_number + 1);
-  if (*usage_entry_number > previous_size) {
+  LOGI("entry_index = %u", *entry_index);
+  const size_t previous_size = entry_info_list_.size();
+  entry_info_list_.resize(*entry_index + 1);
+  if (*entry_index > previous_size) {
     LOGW(
-        "New entry number is larger than table size, resizing: "
-        "entry_info_number = %u, table_size = %zu",
-        *usage_entry_number, previous_size);
-    for (size_t i = previous_size; i < usage_entry_info_.size() - 1; ++i) {
-      usage_entry_info_[i].Clear();
+        "New entry index is larger than table size, resizing: "
+        "entry_index = %u, table_size = %zu",
+        *entry_index, previous_size);
+    for (size_t i = previous_size; i < entry_info_list_.size() - 1; ++i) {
+      entry_info_list_[i].Clear();
     }
   }
-  usage_entry_info_[*usage_entry_number].Clear();
+  entry_info_list_[*entry_index].Clear();
   return CdmResponseType(NO_ERROR);
 }
 
-CdmResponseType UsageTableHeader::RelocateNewEntry(
-    CryptoSession* const crypto_session, uint32_t* usage_entry_number) {
-  static constexpr uint32_t kMinimumEntryNumber = 0;
-  const uint32_t initial_entry_number = *usage_entry_number;
-  if (initial_entry_number == kMinimumEntryNumber) {
+CdmResponseType CdmUsageTable::RelocateNewEntry(
+    CryptoSession* const crypto_session, UsageEntryIndex* entry_index) {
+  static constexpr UsageEntryIndex kMinimumEntryNumber = 0;
+  const UsageEntryIndex initial_entry_index = *entry_index;
+  if (initial_entry_index == kMinimumEntryNumber) {
     // First entry in the table.
     return CdmResponseType(NO_ERROR);
   }
-  uint32_t unoccupied_entry_number = initial_entry_number;
-  for (uint32_t i = kMinimumEntryNumber; i < initial_entry_number; i++) {
+  UsageEntryIndex unoccupied_entry_index = initial_entry_index;
+  for (UsageEntryIndex i = kMinimumEntryNumber; i < initial_entry_index; i++) {
     if (IsEntryUnoccupied(i)) {
-      unoccupied_entry_number = i;
+      unoccupied_entry_index = i;
       break;
     }
   }
-  if (unoccupied_entry_number == initial_entry_number) {
+  if (unoccupied_entry_index == initial_entry_index) {
     // No open position.
     return CdmResponseType(NO_ERROR);
   }
   const CdmResponseType status =
-      crypto_session->MoveUsageEntry(unoccupied_entry_number);
+      crypto_session->MoveUsageEntry(unoccupied_entry_index);
   if (status == MOVE_USAGE_ENTRY_DESTINATION_IN_USE) {
     // Not unexpected, there is a window of time between releasing the
     // entry and closing the OEMCrypto session.
-    LOGD("Released entry still in use: index = %u", unoccupied_entry_number);
+    LOGD("Released entry still in use: index = %u", unoccupied_entry_index);
     return CdmResponseType(NO_ERROR);
   }
   if (status != NO_ERROR) return status;
-  LOGI("Entry moved: from_index = %u, to_index = %u", initial_entry_number,
-       unoccupied_entry_number);
-  *usage_entry_number = unoccupied_entry_number;
-  usage_entry_info_[unoccupied_entry_number] =
-      std::move(usage_entry_info_[initial_entry_number]);
-  usage_entry_info_[initial_entry_number].Clear();
+  LOGI("Entry moved: from_index = %u, to_index = %u", initial_entry_index,
+       unoccupied_entry_index);
+  *entry_index = unoccupied_entry_index;
+  entry_info_list_[unoccupied_entry_index] =
+      std::move(entry_info_list_[initial_entry_index]);
+  entry_info_list_[initial_entry_index].Clear();
   return CdmResponseType(NO_ERROR);
 }
 
-bool UsageTableHeader::IsEntryUnoccupied(
-    const uint32_t usage_entry_number) const {
-  if (usage_entry_info_[usage_entry_number].storage_type !=
-      kStorageTypeUnknown) {
+bool CdmUsageTable::IsEntryUnoccupied(const UsageEntryIndex entry_index) const {
+  if (entry_info_list_[entry_index].storage_type != kStorageTypeUnknown) {
     return false;
   }
   // TODO(sigquit): Check that entry is not in use by another session.
@@ -594,10 +590,10 @@ bool UsageTableHeader::IsEntryUnoccupied(
   return true;
 }
 
-void UsageTableHeader::SetOfflineEntryInfo(
-    const uint32_t usage_entry_number, const std::string& key_set_id,
-    const CdmKeyResponse& license_message) {
-  CdmUsageEntryInfo& entry_info = usage_entry_info_[usage_entry_number];
+void CdmUsageTable::SetOfflineEntryInfo(const UsageEntryIndex entry_index,
+                                        const std::string& key_set_id,
+                                        const CdmKeyResponse& license_message) {
+  CdmUsageEntryInfo& entry_info = entry_info_list_[entry_index];
   entry_info.Clear();
   entry_info.storage_type = kStorageLicense;
   entry_info.key_set_id = key_set_id;
@@ -618,10 +614,10 @@ void UsageTableHeader::SetOfflineEntryInfo(
   }
 }
 
-void UsageTableHeader::SetUsageInfoEntryInfo(
-    const uint32_t usage_entry_number, const std::string& key_set_id,
+void CdmUsageTable::SetUsageInfoEntryInfo(
+    const UsageEntryIndex entry_index, const std::string& key_set_id,
     const std::string& usage_info_file_name) {
-  CdmUsageEntryInfo& entry_info = usage_entry_info_[usage_entry_number];
+  CdmUsageEntryInfo& entry_info = entry_info_list_[entry_index];
   entry_info.Clear();
   entry_info.storage_type = kStorageUsageInfo;
   entry_info.key_set_id = key_set_id;
@@ -629,42 +625,42 @@ void UsageTableHeader::SetUsageInfoEntryInfo(
   entry_info.usage_info_file_name = usage_info_file_name;
 }
 
-CdmResponseType UsageTableHeader::RefitTable(
-    CryptoSession* const crypto_session) {
+CdmResponseType CdmUsageTable::RefitTable(CryptoSession* const crypto_session) {
   // Remove all unoccupied entries at end of the table.
   uint32_t entries_to_remove = 0;
-  const uint32_t old_size = static_cast<uint32_t>(usage_entry_info_.size());
+  const uint32_t old_size = static_cast<uint32_t>(entry_info_list_.size());
   for (uint32_t i = 0; i < old_size; i++) {
-    const uint32_t usage_entry_number = old_size - i - 1;
-    if (!IsEntryUnoccupied(usage_entry_number)) break;
+    const UsageEntryIndex entry_index = old_size - i - 1;
+    if (!IsEntryUnoccupied(entry_index)) break;
     ++entries_to_remove;
   }
   if (entries_to_remove == 0) return CdmResponseType(NO_ERROR);
   const uint32_t new_size = old_size - entries_to_remove;
   const CdmResponseType status = crypto_session->ShrinkUsageTableHeader(
-      requested_security_level_, new_size, &usage_table_header_);
+      requested_security_level_, new_size, &header_);
   if (status == SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE) {
     // This error likely indicates that another session has released
     // its entry via a call to InvalidateEntry(), but has yet to close
     // its OEMCrypto session.
     // Safe to assume table state is not invalidated.
     LOGW("Unexpected entry in use: range = [%u, %zu]", new_size,
-         usage_entry_info_.size() - 1);
+         entry_info_list_.size() - 1);
     return CdmResponseType(NO_ERROR);
   }
   if (status != NO_ERROR) return status;
-  LOGD("Table shrunk: old_size = %zu, new_size = %u", usage_entry_info_.size(),
+  LOGD("Table shrunk: old_size = %zu, new_size = %u", entry_info_list_.size(),
        new_size);
-  usage_entry_info_.resize(new_size);
+  entry_info_list_.resize(new_size);
   return CdmResponseType(NO_ERROR);
 }
 
-CdmResponseType UsageTableHeader::MoveEntry(
-    uint32_t from_usage_entry_number, const CdmUsageEntry& from_usage_entry,
-    uint32_t to_usage_entry_number, DeviceFiles* device_files,
-    metrics::CryptoMetrics* metrics) {
-  LOGD("from_usage_entry_number = %u, to_usage_entry_number = %u",
-       from_usage_entry_number, to_usage_entry_number);
+CdmResponseType CdmUsageTable::MoveEntry(UsageEntryIndex from_entry_index,
+                                         const UsageEntry& from_entry,
+                                         UsageEntryIndex to_entry_index,
+                                         DeviceFiles* device_files,
+                                         metrics::CryptoMetrics* metrics) {
+  LOGD("from_entry_index = %u, to_entry_index = %u", from_entry_index,
+       to_entry_index);
 
   // crypto_session points to an object whose scope is this method or a test
   // object whose scope is the lifetime of this class
@@ -677,73 +673,68 @@ CdmResponseType UsageTableHeader::MoveEntry(
 
   CdmResponseType status = crypto_session->Open(requested_security_level_);
   if (status != NO_ERROR) {
-    LOGE("Cannot open session for move: usage_entry_number = %u",
-         from_usage_entry_number);
+    LOGE("Cannot open session for move: entry_index = %u", from_entry_index);
     return status;
   }
 
-  status =
-      crypto_session->LoadUsageEntry(from_usage_entry_number, from_usage_entry);
+  status = crypto_session->LoadUsageEntry(from_entry_index, from_entry);
 
   if (status != NO_ERROR) {
-    LOGE("Failed to load usage entry: usage_entry_number = %u",
-         from_usage_entry_number);
+    LOGE("Failed to load usage entry: entry_index = %u", from_entry_index);
     return status;
   }
 
-  status = crypto_session->MoveUsageEntry(to_usage_entry_number);
+  status = crypto_session->MoveUsageEntry(to_entry_index);
 
   if (status != NO_ERROR) {
     LOGE(
         "Failed to move usage entry: "
-        "from_usage_entry_number = %u, to_usage_entry_number = %u",
-        from_usage_entry_number, to_usage_entry_number);
+        "from_entry_index = %u, to_entry_index = %u",
+        from_entry_index, to_entry_index);
     return status;
   }
 
-  usage_entry_info_[to_usage_entry_number] =
-      usage_entry_info_[from_usage_entry_number];
-  usage_entry_info_[from_usage_entry_number].Clear();
+  entry_info_list_[to_entry_index] = entry_info_list_[from_entry_index];
+  entry_info_list_[from_entry_index].Clear();
 
-  CdmUsageEntry usage_entry;
-  status = crypto_session->UpdateUsageEntry(&usage_table_header_, &usage_entry);
+  UsageEntry entry;
+  status = crypto_session->UpdateUsageEntry(&header_, &entry);
 
   if (status != NO_ERROR) {
-    LOGE("Failed to update usage entry: usage_entry_number = %u",
-         to_usage_entry_number);
+    LOGE("Failed to update usage entry: entry_index = %u", to_entry_index);
     return status;
   }
 
   // Store the usage table and usage entry after successful move.
   StoreTable();
-  StoreEntry(to_usage_entry_number, device_files, usage_entry);
+  StoreEntry(to_entry_index, device_files, entry);
 
   return CdmResponseType(NO_ERROR);
 }
 
-CdmResponseType UsageTableHeader::GetEntry(uint32_t usage_entry_number,
-                                           DeviceFiles* device_files,
-                                           CdmUsageEntry* usage_entry) {
-  LOGD("Getting usage_entry_number = %u, storage_type = %s", usage_entry_number,
+CdmResponseType CdmUsageTable::GetEntry(UsageEntryIndex entry_index,
+                                        DeviceFiles* device_files,
+                                        UsageEntry* entry) {
+  LOGD("Getting entry_index = %u, storage_type = %s", entry_index,
        CdmUsageEntryStorageTypeToString(
-           usage_entry_number < usage_entry_info_.size()
-               ? usage_entry_info_[usage_entry_number].storage_type
+           entry_index < entry_info_list_.size()
+               ? entry_info_list_[entry_index].storage_type
                : kStorageTypeUnknown));
-  uint32_t entry_number;
-  switch (usage_entry_info_[usage_entry_number].storage_type) {
+  UsageEntryIndex retrieved_entry_index;
+  switch (entry_info_list_[entry_index].storage_type) {
     case kStorageLicense: {
       DeviceFiles::CdmLicenseData license_data;
       DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError;
       if (!device_files->RetrieveLicense(
-              usage_entry_info_[usage_entry_number].key_set_id, &license_data,
+              entry_info_list_[entry_index].key_set_id, &license_data,
               &sub_error_code)) {
         LOGE("Failed to retrieve license: status = %d",
              static_cast<int>(sub_error_code));
         return CdmResponseType(USAGE_GET_ENTRY_RETRIEVE_LICENSE_FAILED);
       }
 
-      entry_number = license_data.usage_entry_number;
-      *usage_entry = std::move(license_data.usage_entry);
+      retrieved_entry_index = license_data.usage_entry_index;
+      *entry = std::move(license_data.usage_entry);
       break;
     }
     case kStorageUsageInfo: {
@@ -754,10 +745,10 @@ CdmResponseType UsageTableHeader::GetEntry(uint32_t usage_entry_number,
       CryptoWrappedKey wrapped_private_key;
 
       if (!device_files->RetrieveUsageInfoByKeySetId(
-              usage_entry_info_[usage_entry_number].usage_info_file_name,
-              usage_entry_info_[usage_entry_number].key_set_id,
-              &provider_session_token, &license_request, &license, usage_entry,
-              &entry_number, &drm_certificate, &wrapped_private_key)) {
+              entry_info_list_[entry_index].usage_info_file_name,
+              entry_info_list_[entry_index].key_set_id, &provider_session_token,
+              &license_request, &license, entry, &retrieved_entry_index,
+              &drm_certificate, &wrapped_private_key)) {
         LOGE("Failed to retrieve usage information");
         return CdmResponseType(USAGE_GET_ENTRY_RETRIEVE_USAGE_INFO_FAILED);
       }
@@ -768,37 +759,37 @@ CdmResponseType UsageTableHeader::GetEntry(uint32_t usage_entry_number,
       LOGE(
           "Cannot retrieve usage information with unknown storage type: "
           "storage_type = %d",
-          static_cast<int>(usage_entry_info_[usage_entry_number].storage_type));
+          static_cast<int>(entry_info_list_[entry_index].storage_type));
       return CdmResponseType(USAGE_GET_ENTRY_RETRIEVE_INVALID_STORAGE_TYPE);
   }
 
-  if (usage_entry_number != entry_number) {
+  if (entry_index != retrieved_entry_index) {
     LOGE(
-        "Usage entry number mismatch: expected_usage_entry_number = %u, "
-        "retrieved_usage_entry_number = %u",
-        usage_entry_number, entry_number);
+        "Usage entry index mismatch: expected_entry_index = %u, "
+        "retrieved_entry_index = %u",
+        entry_index, retrieved_entry_index);
     return CdmResponseType(USAGE_ENTRY_NUMBER_MISMATCH);
   }
 
   return CdmResponseType(NO_ERROR);
 }
 
-CdmResponseType UsageTableHeader::StoreEntry(uint32_t usage_entry_number,
-                                             DeviceFiles* device_files,
-                                             const CdmUsageEntry& usage_entry) {
-  LOGD("usage_entry_number = %u, storage_type = %s", usage_entry_number,
+CdmResponseType CdmUsageTable::StoreEntry(UsageEntryIndex entry_index,
+                                          DeviceFiles* device_files,
+                                          const UsageEntry& entry) {
+  LOGD("entry_index = %u, storage_type = %s", entry_index,
        CdmUsageEntryStorageTypeToString(
-           usage_entry_number < usage_entry_info_.size()
-               ? usage_entry_info_[usage_entry_number].storage_type
+           entry_index < entry_info_list_.size()
+               ? entry_info_list_[entry_index].storage_type
                : kStorageTypeUnknown));
 
-  switch (usage_entry_info_[usage_entry_number].storage_type) {
+  switch (entry_info_list_[entry_index].storage_type) {
     case kStorageLicense: {
       DeviceFiles::CdmLicenseData license_data;
       DeviceFiles::ResponseType sub_error_code = DeviceFiles::kNoError;
 
       if (!device_files->RetrieveLicense(
-              usage_entry_info_[usage_entry_number].key_set_id, &license_data,
+              entry_info_list_[entry_index].key_set_id, &license_data,
               &sub_error_code)) {
         LOGE("Failed to retrieve license: status = %s",
              DeviceFiles::ResponseTypeToString(sub_error_code));
@@ -806,8 +797,8 @@ CdmResponseType UsageTableHeader::StoreEntry(uint32_t usage_entry_number,
       }
 
       // Update.
-      license_data.usage_entry = usage_entry;
-      license_data.usage_entry_number = usage_entry_number;
+      license_data.usage_entry = entry;
+      license_data.usage_entry_index = entry_index;
 
       if (!device_files->StoreLicense(license_data, &sub_error_code)) {
         LOGE("Failed to store license: status = %s",
@@ -817,28 +808,28 @@ CdmResponseType UsageTableHeader::StoreEntry(uint32_t usage_entry_number,
       break;
     }
     case kStorageUsageInfo: {
-      CdmUsageEntry entry;
-      uint32_t entry_number;
+      UsageEntry retrieved_entry;
+      UsageEntryIndex retrieved_entry_index;
       std::string provider_session_token, init_data, key_request, key_response,
           key_renewal_request;
       std::string drm_certificate;
       CryptoWrappedKey wrapped_private_key;
       if (!device_files->RetrieveUsageInfoByKeySetId(
-              usage_entry_info_[usage_entry_number].usage_info_file_name,
-              usage_entry_info_[usage_entry_number].key_set_id,
-              &provider_session_token, &key_request, &key_response, &entry,
-              &entry_number, &drm_certificate, &wrapped_private_key)) {
+              entry_info_list_[entry_index].usage_info_file_name,
+              entry_info_list_[entry_index].key_set_id, &provider_session_token,
+              &key_request, &key_response, &retrieved_entry,
+              &retrieved_entry_index, &drm_certificate, &wrapped_private_key)) {
         LOGE("Failed to retrieve usage information");
         return CdmResponseType(USAGE_STORE_ENTRY_RETRIEVE_USAGE_INFO_FAILED);
       }
       device_files->DeleteUsageInfo(
-          usage_entry_info_[usage_entry_number].usage_info_file_name,
+          entry_info_list_[entry_index].usage_info_file_name,
           provider_session_token);
       if (!device_files->StoreUsageInfo(
               provider_session_token, key_request, key_response,
-              usage_entry_info_[usage_entry_number].usage_info_file_name,
-              usage_entry_info_[usage_entry_number].key_set_id, usage_entry,
-              usage_entry_number, drm_certificate, wrapped_private_key)) {
+              entry_info_list_[entry_index].usage_info_file_name,
+              entry_info_list_[entry_index].key_set_id, entry, entry_index,
+              drm_certificate, wrapped_private_key)) {
         LOGE("Failed to store usage information");
         return CdmResponseType(USAGE_STORE_USAGE_INFO_FAILED);
       }
@@ -849,16 +840,16 @@ CdmResponseType UsageTableHeader::StoreEntry(uint32_t usage_entry_number,
       LOGE(
           "Cannot retrieve usage information with unknown storage type: "
           "storage_type = %d",
-          static_cast<int>(usage_entry_info_[usage_entry_number].storage_type));
+          static_cast<int>(entry_info_list_[entry_index].storage_type));
       return CdmResponseType(USAGE_STORE_ENTRY_RETRIEVE_INVALID_STORAGE_TYPE);
   }
   return CdmResponseType(NO_ERROR);
 }
 
-bool UsageTableHeader::StoreTable() {
+bool CdmUsageTable::StoreTable() {
   LOGV("Storing usage table information");
-  const bool result = device_files_->StoreUsageTableInfo(usage_table_header_,
-                                                         usage_entry_info_);
+  const bool result =
+      device_files_->StoreUsageTableInfo(header_, entry_info_list_);
   if (result) {
     ++store_table_counter_;
   } else {
@@ -867,23 +858,23 @@ bool UsageTableHeader::StoreTable() {
   return result;
 }
 
-CdmResponseType UsageTableHeader::Shrink(
+CdmResponseType CdmUsageTable::Shrink(
     metrics::CryptoMetrics* metrics,
     uint32_t number_of_usage_entries_to_delete) {
-  LOGD("table_size = %zu, number_to_delete = %u", usage_entry_info_.size(),
+  LOGD("table_size = %zu, number_to_delete = %u", entry_info_list_.size(),
        number_of_usage_entries_to_delete);
-  if (usage_entry_info_.empty()) {
+  if (entry_info_list_.empty()) {
     LOGE("Usage entry info table unexpectedly empty");
     return CdmResponseType(NO_USAGE_ENTRIES);
   }
 
-  if (usage_entry_info_.size() < number_of_usage_entries_to_delete) {
+  if (entry_info_list_.size() < number_of_usage_entries_to_delete) {
     LOGW(
         "Cannot delete more entries than the table size, reducing to current "
         "table size: table_size = %zu, number_to_delete = %u",
-        usage_entry_info_.size(), number_of_usage_entries_to_delete);
+        entry_info_list_.size(), number_of_usage_entries_to_delete);
     number_of_usage_entries_to_delete =
-        static_cast<uint32_t>(usage_entry_info_.size());
+        static_cast<uint32_t>(entry_info_list_.size());
   }
 
   if (number_of_usage_entries_to_delete == 0) return CdmResponseType(NO_ERROR);
@@ -897,21 +888,21 @@ CdmResponseType UsageTableHeader::Shrink(
     crypto_session = scoped_crypto_session.get();
   }
 
-  const uint32_t new_size = static_cast<uint32_t>(usage_entry_info_.size()) -
+  const uint32_t new_size = static_cast<uint32_t>(entry_info_list_.size()) -
                             number_of_usage_entries_to_delete;
   const CdmResponseType status = crypto_session->ShrinkUsageTableHeader(
-      requested_security_level_, new_size, &usage_table_header_);
+      requested_security_level_, new_size, &header_);
 
   if (status == NO_ERROR) {
-    usage_entry_info_.resize(new_size);
+    entry_info_list_.resize(new_size);
     StoreTable();
   }
   return status;
 }
 
-CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
-                                              metrics::CryptoMetrics* metrics) {
-  LOGV("current_size = %zu", usage_entry_info_.size());
+CdmResponseType CdmUsageTable::DefragTable(DeviceFiles* device_files,
+                                           metrics::CryptoMetrics* metrics) {
+  LOGV("current_size = %zu", entry_info_list_.size());
   // Defragging the usage table involves moving valid entries near the
   // end of the usage table to the position of invalid entries near the
   // front of the table.  After the entries are moved, the CDM shrinks
@@ -919,7 +910,7 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
   // the table.
 
   // Special case 0: Empty table, do nothing.
-  if (usage_entry_info_.empty()) {
+  if (entry_info_list_.empty()) {
     LOGD("Table empty, nothing to defrag");
     return CdmResponseType(NO_ERROR);
   }
@@ -928,11 +919,11 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
   // Priority is given to the entries near the beginning of the table.
   // To avoid large delays from the swapping process, we limit the
   // quantity of entries to remove to |kMaxDefragEntryMoves| or fewer.
-  std::vector<uint32_t> entries_to_remove;
-  for (uint32_t i = 0; i < usage_entry_info_.size() &&
-                       entries_to_remove.size() < kMaxDefragEntryMoves;
+  std::vector<UsageEntryIndex> entries_to_remove;
+  for (UsageEntryIndex i = 0; i < entry_info_list_.size() &&
+                              entries_to_remove.size() < kMaxDefragEntryMoves;
        ++i) {
-    if (usage_entry_info_[i].storage_type == kStorageTypeUnknown) {
+    if (entry_info_list_[i].storage_type == kStorageTypeUnknown) {
       entries_to_remove.push_back(i);
     }
   }
@@ -946,14 +937,14 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
 
   // Step 2: Create a list of entries to be moved from the end of the
   // table to the positions identified for removal.
-  std::vector<uint32_t> entries_to_move;
-  for (uint32_t i = 0; i < usage_entry_info_.size() &&
+  std::vector<UsageEntryIndex> entries_to_move;
+  for (uint32_t i = 0; i < entry_info_list_.size() &&
                        entries_to_move.size() < entries_to_remove.size();
        ++i) {
     // Search from the end of the table.
-    const uint32_t entry_index =
-        static_cast<uint32_t>(usage_entry_info_.size()) - i - 1;
-    if (usage_entry_info_[entry_index].storage_type != kStorageTypeUnknown) {
+    const UsageEntryIndex entry_index =
+        static_cast<UsageEntryIndex>(entry_info_list_.size()) - i - 1;
+    if (entry_info_list_[entry_index].storage_type != kStorageTypeUnknown) {
       entries_to_move.push_back(entry_index);
     }
   }
@@ -962,8 +953,8 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
   // the whole table can be removed.
   if (entries_to_move.empty()) {
     LOGD("No valid entries found, shrinking entire table: size = %zu",
-         usage_entry_info_.size());
-    return Shrink(metrics, static_cast<uint32_t>(usage_entry_info_.size()));
+         entry_info_list_.size());
+    return Shrink(metrics, static_cast<uint32_t>(entry_info_list_.size()));
   }
 
   // Step 3: Ignore invalid entries that are after the last valid
@@ -972,7 +963,7 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
   // the shrink operation is applied to the table.
   // Note: Special case 4 will handle any non-trivial cases related to
   // interweaving of valid and invalid entries.
-  const uint32_t last_valid_entry = entries_to_move.front();
+  const UsageEntryIndex last_valid_entry = entries_to_move.front();
   while (!entries_to_remove.empty() &&
          entries_to_remove.back() > last_valid_entry) {
     entries_to_remove.pop_back();
@@ -982,48 +973,49 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
   // entry.  In this case, no movement is required and the table can just
   // be shrunk to the last valid entry.
   if (entries_to_remove.empty()) {
-    const uint32_t to_remove =
-        static_cast<uint32_t>(usage_entry_info_.size()) - last_valid_entry - 1;
+    const UsageEntryIndex to_remove =
+        static_cast<UsageEntryIndex>(entry_info_list_.size()) -
+        last_valid_entry - 1;
     LOGD("Removing all entries after the last valid entry: count = %u",
          to_remove);
     return Shrink(metrics, to_remove);
   }
 
   // Step 4: Move the valid entries to overwrite the invalid entries.
-  // Moving the highest numbered valid entry to the lowest numbered
+  // Moving the highest indexed valid entry to the lowest indexed
   // invalid entry.
 
   // Reversing vectors to make accessing and popping easier.  This
-  // will put the lowest number invalid entry and the highest number
+  // will put the lowest index invalid entry and the highest index
   // valid entry at the back of their respective vectors.
   std::reverse(entries_to_remove.begin(), entries_to_remove.end());
   std::reverse(entries_to_move.begin(), entries_to_move.end());
   while (!entries_to_remove.empty() && !entries_to_move.empty()) {
     // Entries are popped after use only.
-    const uint32_t to_entry_number = entries_to_remove.back();
-    const uint32_t from_entry_number = entries_to_move.back();
+    const UsageEntryIndex to_entry_index = entries_to_remove.back();
+    const UsageEntryIndex from_entry_index = entries_to_move.back();
 
     // Special case 4: We don't want to move any entries to a higher
     // index than their current.  Once this occurs, we can stop the
     // loop.
-    if (to_entry_number > from_entry_number) {
+    if (to_entry_index > from_entry_index) {
       LOGD("Entries will not be moved further down the table");
       break;
     }
 
-    CdmUsageEntry from_entry;
+    UsageEntry from_entry;
     CdmResponseType status =
-        GetEntry(from_entry_number, device_files, &from_entry);
+        GetEntry(from_entry_index, device_files, &from_entry);
     if (status != NO_ERROR) {
-      LOGW("Could not get entry: entry_number = %u", from_entry_number);
+      LOGW("Could not get entry: entry_index = %u", from_entry_index);
       // It is unlikely that an unretrievable entry will suddenly
       // become retrievable later on when it is needed.
-      usage_entry_info_[from_entry_number].Clear();
+      entry_info_list_[from_entry_index].Clear();
       entries_to_move.pop_back();
       continue;
     }
 
-    status = MoveEntry(from_entry_number, from_entry, to_entry_number,
+    status = MoveEntry(from_entry_index, from_entry, to_entry_index,
                        device_files, metrics);
     switch (status.Enum()) {
       case NO_ERROR: {
@@ -1036,8 +1028,8 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
         // This is a special error code when returned from LoadEntry()
         // indicating that the entry is already in use in a different
         // session.  In this case, skip the entry and move on.
-        LOGD("From entry already in use: from_entry_number = %u",
-             from_entry_number);
+        LOGD("From entry already in use: from_entry_index = %u",
+             from_entry_index);
         entries_to_move.pop_back();
         break;
       }
@@ -1048,19 +1040,19 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
         // can no longer be used.  Safe to continue loop.
         // TODO(b/152256186): Remove local files associated with this
         // entry.
-        usage_entry_info_[from_entry_number].Clear();
-        LOGW("From entry was corrupted: from_entry_number = %u",
-             from_entry_number);
+        entry_info_list_[from_entry_index].Clear();
+        LOGW("From entry was corrupted: from_entry_index = %u",
+             from_entry_index);
         entries_to_move.pop_back();
         break;
       }
       // Handle errors associated with the invalid "to" entry.
       case MOVE_USAGE_ENTRY_DESTINATION_IN_USE: {
-        // The usage entry specified by |to_entry_number| is currently
+        // The usage entry specified by |to_entry_index| is currently
         // being used by another session.  This is unlikely, but still
         // possible.  Given that this entry is already marked as unknown
         // storage type, it will likely be removed at a later time.
-        LOGD("To entry already in use: to_entry_number = %u", to_entry_number);
+        LOGD("To entry already in use: to_entry_index = %u", to_entry_index);
         entries_to_remove.pop_back();
         break;
       }
@@ -1070,8 +1062,8 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
         // entry.  Both should be skipped on the next iteration.
         LOGW(
             "Move failed, skipping both to entry and from entry: "
-            "to_entry_number = %u, from_entry_number = %u",
-            to_entry_number, from_entry_number);
+            "to_entry_index = %u, from_entry_index = %u",
+            to_entry_index, from_entry_index);
         entries_to_remove.pop_back();
         entries_to_move.pop_back();
         break;
@@ -1096,12 +1088,12 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
   }    // End while loop.
 
   // Step 5: Find the new last valid entry.
-  uint32_t new_last_valid_entry =
-      static_cast<uint32_t>(usage_entry_info_.size());
-  for (uint32_t i = 0; i < usage_entry_info_.size(); ++i) {
-    const uint32_t entry_index =
-        static_cast<uint32_t>(usage_entry_info_.size()) - i - 1;
-    if (usage_entry_info_[entry_index].storage_type != kStorageTypeUnknown) {
+  UsageEntryIndex new_last_valid_entry =
+      static_cast<UsageEntryIndex>(entry_info_list_.size());
+  for (size_t i = 0; i < entry_info_list_.size(); ++i) {
+    const UsageEntryIndex entry_index =
+        static_cast<UsageEntryIndex>(entry_info_list_.size() - i) - 1;
+    if (entry_info_list_[entry_index].storage_type != kStorageTypeUnknown) {
       new_last_valid_entry = entry_index;
       break;
     }
@@ -1110,15 +1102,16 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
   // Special case 5: No entries in the table are valid.  This could
   // have occurred if entries during the move process were found to be
   //  invalid.  In this case, remove the whole table.
-  if (new_last_valid_entry == usage_entry_info_.size()) {
+  if (new_last_valid_entry == entry_info_list_.size()) {
     LOGD(
         "All entries have been invalidated, shrinking entire table: size = %zu",
-        usage_entry_info_.size());
-    return Shrink(metrics, static_cast<uint32_t>(usage_entry_info_.size()));
+        entry_info_list_.size());
+    return Shrink(metrics, static_cast<uint32_t>(entry_info_list_.size()));
   }
 
-  const uint32_t to_remove = static_cast<uint32_t>(usage_entry_info_.size()) -
-                             new_last_valid_entry - 1;
+  const UsageEntryIndex to_remove =
+      static_cast<UsageEntryIndex>(entry_info_list_.size()) -
+      new_last_valid_entry - 1;
 
   // Special case 6: It is possible that the last entry in the table
   // is valid and currently loaded in the table by another session.
@@ -1135,25 +1128,24 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
   return Shrink(metrics, to_remove);
 }  // End Defrag().
 
-CdmResponseType UsageTableHeader::ReleaseOldestEntry(
+CdmResponseType CdmUsageTable::ReleaseOldestEntry(
     metrics::CryptoMetrics* metrics) {
   LOGV("Releasing oldest entry");
-  uint32_t entry_number_to_delete;
-  if (!GetRemovalCandidate(&entry_number_to_delete)) {
+  UsageEntryIndex entry_index_to_delete;
+  if (!GetRemovalCandidate(&entry_index_to_delete)) {
     LOGE("Could not determine which license to remove");
     return CdmResponseType(UNKNOWN_ERROR);
   }
-  const CdmUsageEntryInfo& usage_entry_info =
-      usage_entry_info_[entry_number_to_delete];
+  const CdmUsageEntryInfo& entry_info = entry_info_list_[entry_index_to_delete];
 
   const int64_t current_time = GetCurrentTime();
-  // Capture metric values now, as the |usage_entry_info| reference will
+  // Capture metric values now, as the |entry_info| reference will
   // change after the call to invalidate.
-  const int64_t staleness = current_time - usage_entry_info.last_use_time;
-  const CdmUsageEntryStorageType storage_type = usage_entry_info.storage_type;
+  const int64_t staleness = current_time - entry_info.last_use_time;
+  const CdmUsageEntryStorageType storage_type = entry_info.storage_type;
 
   const CdmResponseType status =
-      InvalidateEntryInternal(entry_number_to_delete, /* defrag_table = */ true,
+      InvalidateEntryInternal(entry_index_to_delete, /* defrag_table = */ true,
                               device_files_.get(), metrics);
 
   if (status != NO_ERROR) {
@@ -1167,134 +1159,129 @@ CdmResponseType UsageTableHeader::ReleaseOldestEntry(
 }
 
 // Test only method.
-void UsageTableHeader::InvalidateEntryForTest(uint32_t usage_entry_number) {
-  LOGD("usage_entry_number = %u", usage_entry_number);
-  if (usage_entry_number >= usage_entry_info_.size()) {
+void CdmUsageTable::InvalidateEntryForTest(UsageEntryIndex entry_index) {
+  LOGD("entry_index = %u", entry_index);
+  if (entry_index >= entry_info_list_.size()) {
     LOGE(
-        "Requested usage entry number is larger than table size: "
-        "usage_entry_number = %u, table_size = %zu",
-        usage_entry_number, usage_entry_info_.size());
+        "Requested usage entry index is larger than table size: "
+        "entry_index = %u, table_size = %zu",
+        entry_index, entry_info_list_.size());
     return;
   }
   // Move last entry into invalidated entry location and shrink usage
   // entries.
-  usage_entry_info_[usage_entry_number] =
-      usage_entry_info_[usage_entry_info_.size() - 1];
-  usage_entry_info_.resize(usage_entry_info_.size() - 1);
+  entry_info_list_[entry_index] = entry_info_list_[entry_info_list_.size() - 1];
+  entry_info_list_.resize(entry_info_list_.size() - 1);
 }
 
-bool UsageTableHeader::LruUpgradeAllUsageEntries() {
+bool CdmUsageTable::LruUpgradeAllUsageEntries() {
   LOGV("Upgrading all usage entries with LRU information");
-  if (usage_entry_info_.size() == 0) return true;  // Nothing to upgrade.
+  if (entry_info_list_.size() == 0) return true;  // Nothing to upgrade.
 
   // For each entry, the status upgrading that entry is stored.  At the
   // end, all problematic licenses will be marked as invalid.
-  std::vector<uint32_t> bad_license_file_entries;
+  std::vector<UsageEntryIndex> bad_license_file_entries;
 
-  for (uint32_t usage_entry_number = 0;
-       usage_entry_number < usage_entry_info_.size(); ++usage_entry_number) {
-    CdmUsageEntryInfo& usage_entry_info = usage_entry_info_[usage_entry_number];
+  for (UsageEntryIndex entry_index = 0; entry_index < entry_info_list_.size();
+       ++entry_index) {
+    CdmUsageEntryInfo& entry_info = entry_info_list_[entry_index];
 
-    uint32_t retrieved_entry_number;
+    UsageEntryIndex retrieved_entry_index;
     CdmKeyResponse license_message;
     bool retrieve_response = false;
-    switch (usage_entry_info.storage_type) {
+    switch (entry_info.storage_type) {
       case kStorageLicense: {
-        retrieve_response = RetrieveOfflineLicense(
-            device_files_.get(), usage_entry_info.key_set_id, &license_message,
-            &retrieved_entry_number);
+        retrieve_response =
+            RetrieveOfflineLicense(device_files_.get(), entry_info.key_set_id,
+                                   &license_message, &retrieved_entry_index);
         break;
       }
       case kStorageUsageInfo: {
         retrieve_response = RetrieveUsageInfoLicense(
-            device_files_.get(), usage_entry_info.usage_info_file_name,
-            usage_entry_info.key_set_id, &license_message,
-            &retrieved_entry_number);
+            device_files_.get(), entry_info.usage_info_file_name,
+            entry_info.key_set_id, &license_message, &retrieved_entry_index);
         break;
       }
       case kStorageTypeUnknown:
-        bad_license_file_entries.push_back(usage_entry_number);
+        bad_license_file_entries.push_back(entry_index);
         continue;
       default: {
-        LOGW("Unknown usage entry storage type: %d, usage_entry_number = %u",
-             static_cast<int>(usage_entry_info.storage_type),
-             usage_entry_number);
-        bad_license_file_entries.push_back(usage_entry_number);
+        LOGW("Unknown usage entry storage type: %d, entry_index = %u",
+             static_cast<int>(entry_info.storage_type), entry_index);
+        bad_license_file_entries.push_back(entry_index);
         continue;
       }
     }
     if (!retrieve_response) {
-      LOGW("Could not retrieve license message: usage_entry_number = %u",
-           usage_entry_number);
-      bad_license_file_entries.push_back(usage_entry_number);
+      LOGW("Could not retrieve license message: entry_index = %u", entry_index);
+      bad_license_file_entries.push_back(entry_index);
       continue;
     }
 
-    if (retrieved_entry_number != usage_entry_number) {
+    if (retrieved_entry_index != entry_index) {
       LOGW(
-          "Usage entry number mismatched: usage_entry_number = %u, "
-          "retrieved_entry_number = %u",
-          usage_entry_number, retrieved_entry_number);
-      bad_license_file_entries.push_back(usage_entry_number);
+          "Usage entry index mismatched: entry_index = %u, "
+          "retrieved_entry_index = %u",
+          entry_index, retrieved_entry_index);
+      bad_license_file_entries.push_back(entry_index);
       continue;
     }
 
     video_widevine::License license;
     if (!ParseLicenseFromLicenseMessage(license_message, &license)) {
-      LOGW("Could not parse license: usage_entry_number = %u",
-           usage_entry_number);
-      bad_license_file_entries.push_back(usage_entry_number);
+      LOGW("Could not parse license: entry_index = %u", entry_index);
+      bad_license_file_entries.push_back(entry_index);
       continue;
     }
 
     // If |license_start_time| is 0, then this entry will be considered
     // for replacement above all others.
-    usage_entry_info.last_use_time = license.license_start_time();
+    entry_info.last_use_time = license.license_start_time();
 
-    if (usage_entry_info.storage_type == kStorageLicense) {
+    if (entry_info.storage_type == kStorageLicense) {
       // Only offline licenses need |offline_license_expiry_time| set.
       const video_widevine::License::Policy& policy = license.policy();
       // TODO(b/139372190): Change how these fields are set once feature is
       //   implemented.
       if (policy.license_duration_seconds() == 0) {
         // Zero implies unlimited license duration.
-        usage_entry_info.offline_license_expiry_time =
+        entry_info.offline_license_expiry_time =
             license.license_start_time() + policy.rental_duration_seconds() +
             policy.playback_duration_seconds();
       } else {
-        usage_entry_info.offline_license_expiry_time =
+        entry_info.offline_license_expiry_time =
             license.license_start_time() + policy.license_duration_seconds();
       }
     } else {
-      usage_entry_info.offline_license_expiry_time = 0;
+      entry_info.offline_license_expiry_time = 0;
     }
   }  // End for loop.
 
-  if (bad_license_file_entries.size() == usage_entry_info_.size()) {
+  if (bad_license_file_entries.size() == entry_info_list_.size()) {
     LOGE("Failed to perform LRU upgrade for every entry: count = %zu",
-         usage_entry_info_.size());
+         entry_info_list_.size());
     return false;
   }
 
   // Maps <usage_info_file_name> -> [<key_set_id>].
   std::map<std::string, std::vector<std::string>> usage_info_clean_up;
-  for (size_t usage_entry_number : bad_license_file_entries) {
-    CdmUsageEntryInfo& usage_entry_info = usage_entry_info_[usage_entry_number];
-    if (usage_entry_info.storage_type == kStorageLicense) {
-      device_files_->DeleteLicense(usage_entry_info.key_set_id);
-    } else if (usage_entry_info.storage_type == kStorageUsageInfo) {
+  for (UsageEntryIndex entry_index : bad_license_file_entries) {
+    CdmUsageEntryInfo& entry_info = entry_info_list_[entry_index];
+    if (entry_info.storage_type == kStorageLicense) {
+      device_files_->DeleteLicense(entry_info.key_set_id);
+    } else if (entry_info.storage_type == kStorageUsageInfo) {
       // To reduce write cycles, the deletion of usage info will be done
       // in bulk.
-      auto it = usage_info_clean_up.find(usage_entry_info.usage_info_file_name);
+      auto it = usage_info_clean_up.find(entry_info.usage_info_file_name);
       if (it == usage_info_clean_up.end()) {
         it = usage_info_clean_up
-                 .emplace(usage_entry_info.usage_info_file_name,
+                 .emplace(entry_info.usage_info_file_name,
                           std::vector<std::string>())
                  .first;
       }
-      it->second.push_back(usage_entry_info.key_set_id);
+      it->second.push_back(entry_info.key_set_id);
     }  // else kStorageUnknown { Nothing special }.
-    usage_entry_info.Clear();
+    entry_info.Clear();
   }
 
   for (const auto& p : usage_info_clean_up) {
@@ -1304,16 +1291,16 @@ bool UsageTableHeader::LruUpgradeAllUsageEntries() {
   return true;
 }
 
-bool UsageTableHeader::GetRemovalCandidate(uint32_t* entry_to_remove) {
+bool CdmUsageTable::GetRemovalCandidate(UsageEntryIndex* entry_to_remove) {
   const size_t lru_unexpired_threshold =
       HasUnlimitedTableCapacity()
           ? kLruUnexpiredThresholdFraction * size()
           : kLruUnexpiredThresholdFraction * potential_table_capacity();
-  return DetermineLicenseToRemove(usage_entry_info_, GetCurrentTime(),
+  return DetermineLicenseToRemove(entry_info_list_, GetCurrentTime(),
                                   lru_unexpired_threshold, entry_to_remove);
 }
 
-void UsageTableHeader::RecordLruEventMetrics(
+void CdmUsageTable::RecordLruEventMetrics(
     metrics::CryptoMetrics* metrics, uint64_t staleness,
     CdmUsageEntryStorageType storage_type) {
   if (metrics == nullptr) return;
@@ -1326,65 +1313,63 @@ void UsageTableHeader::RecordLruEventMetrics(
 }
 
 // Static.
-bool UsageTableHeader::DetermineLicenseToRemove(
-    const std::vector<CdmUsageEntryInfo>& usage_entry_info_list,
-    int64_t current_time, size_t unexpired_threshold,
-    uint32_t* entry_to_remove) {
+bool CdmUsageTable::DetermineLicenseToRemove(
+    const std::vector<CdmUsageEntryInfo>& entry_info_list, int64_t current_time,
+    size_t unexpired_threshold, UsageEntryIndex* entry_to_remove) {
   if (entry_to_remove == nullptr) {
     LOGE("Output parameter |entry_to_remove| is null");
     return false;
   }
-  if (usage_entry_info_list.empty()) {
+  if (entry_info_list.empty()) {
     return false;
   }
 
   // Returns true if entry of first index is more stale than the
   // entry of the second index.
-  const auto is_more_stale = [&](uint32_t i, uint32_t j) -> bool {
-    return usage_entry_info_list[i].last_use_time <
-           usage_entry_info_list[j].last_use_time;
+  const auto is_more_stale = [&](UsageEntryIndex i, UsageEntryIndex j) -> bool {
+    return entry_info_list[i].last_use_time < entry_info_list[j].last_use_time;
   };
 
   // Find the most stale expired offline / streaming license and the
   // most stale unexpired offline entry.  Count the number of unexpired
   // entries.  If any entry is of storage type unknown, then it should
   // be removed.
-  constexpr uint32_t kNoEntry = std::numeric_limits<uint32_t>::max();
-  uint32_t stalest_expired_offline_license = kNoEntry;
-  uint32_t stalest_unexpired_offline_license = kNoEntry;
-  uint32_t stalest_streaming_license = kNoEntry;
+  constexpr UsageEntryIndex kNoEntry =
+      std::numeric_limits<UsageEntryIndex>::max();
+  UsageEntryIndex stalest_expired_offline_license = kNoEntry;
+  UsageEntryIndex stalest_unexpired_offline_license = kNoEntry;
+  UsageEntryIndex stalest_streaming_license = kNoEntry;
   size_t unexpired_license_count = 0;
 
-  for (uint32_t entry_number = 0; entry_number < usage_entry_info_list.size();
-       ++entry_number) {
-    const CdmUsageEntryInfo& usage_entry_info =
-        usage_entry_info_list[entry_number];
+  for (UsageEntryIndex entry_index = 0; entry_index < entry_info_list.size();
+       ++entry_index) {
+    const CdmUsageEntryInfo& entry_info = entry_info_list[entry_index];
 
-    if (usage_entry_info.storage_type != kStorageLicense &&
-        usage_entry_info.storage_type != kStorageUsageInfo) {
+    if (entry_info.storage_type != kStorageLicense &&
+        entry_info.storage_type != kStorageUsageInfo) {
       // Unknown storage type entries.  Remove this entry.
-      *entry_to_remove = entry_number;
+      *entry_to_remove = entry_index;
       return true;
     }
-    if (usage_entry_info.storage_type == kStorageLicense &&
-        usage_entry_info.offline_license_expiry_time > current_time) {
+    if (entry_info.storage_type == kStorageLicense &&
+        entry_info.offline_license_expiry_time > current_time) {
       // Unexpired offline.
       ++unexpired_license_count;
       if (stalest_unexpired_offline_license == kNoEntry ||
-          is_more_stale(entry_number, stalest_unexpired_offline_license)) {
-        stalest_unexpired_offline_license = entry_number;
+          is_more_stale(entry_index, stalest_unexpired_offline_license)) {
+        stalest_unexpired_offline_license = entry_index;
       }
-    } else if (usage_entry_info.storage_type == kStorageLicense) {
+    } else if (entry_info.storage_type == kStorageLicense) {
       // Expired offline.
       if (stalest_expired_offline_license == kNoEntry ||
-          is_more_stale(entry_number, stalest_expired_offline_license)) {
-        stalest_expired_offline_license = entry_number;
+          is_more_stale(entry_index, stalest_expired_offline_license)) {
+        stalest_expired_offline_license = entry_index;
       }
     } else {
       // Streaming.
       if (stalest_streaming_license == kNoEntry ||
-          is_more_stale(entry_number, stalest_streaming_license)) {
-        stalest_streaming_license = entry_number;
+          is_more_stale(entry_index, stalest_streaming_license)) {
+        stalest_streaming_license = entry_index;
       }
     }
   }
@@ -1396,13 +1381,13 @@ bool UsageTableHeader::DetermineLicenseToRemove(
     LOGW(
         "Table only contains unexpired offline licenses, "
         "but threshold not met: size = %zu, count = %zu, threshold = %zu",
-        usage_entry_info_list.size(), unexpired_license_count,
-        unexpired_threshold);
+        entry_info_list.size(), unexpired_license_count, unexpired_threshold);
     *entry_to_remove = stalest_unexpired_offline_license;
     return true;
   }
 
-  const auto select_most_stale = [&](uint32_t a, uint32_t b) -> uint32_t {
+  const auto select_most_stale = [&](UsageEntryIndex a,
+                                     UsageEntryIndex b) -> UsageEntryIndex {
     if (a == kNoEntry) return b;
     if (b == kNoEntry) return a;
     return is_more_stale(a, b) ? a : b;
@@ -1410,8 +1395,8 @@ bool UsageTableHeader::DetermineLicenseToRemove(
 
   // Only consider an unexpired entry if the threshold is reached.
   if (unexpired_license_count > unexpired_threshold) {
-    const uint32_t temp = select_most_stale(stalest_unexpired_offline_license,
-                                            stalest_streaming_license);
+    const UsageEntryIndex temp = select_most_stale(
+        stalest_unexpired_offline_license, stalest_streaming_license);
     *entry_to_remove = select_most_stale(temp, stalest_expired_offline_license);
   } else {
     *entry_to_remove = select_most_stale(stalest_streaming_license,
@@ -1420,9 +1405,9 @@ bool UsageTableHeader::DetermineLicenseToRemove(
 
   if (*entry_to_remove == kNoEntry) {
     // Illegal state check.  The loop above should have found at least
-    // one entry given that |usage_entry_info_list| is not empty.
+    // one entry given that |entry_info_list| is not empty.
     LOGE("No entry could be used for removal: size = %zu",
-         usage_entry_info_list.size());
+         entry_info_list.size());
     return false;
   }
   return true;
diff --git a/libwvdrmengine/cdm/core/src/client_identification.cpp b/libwvdrmengine/cdm/core/src/client_identification.cpp
index 70a8d325..62d0a728 100644
--- a/libwvdrmengine/cdm/core/src/client_identification.cpp
+++ b/libwvdrmengine/cdm/core/src/client_identification.cpp
@@ -229,9 +229,9 @@ CdmResponseType ClientIdentification::Prepare(
   client_capabilities->set_client_token(true);
 
   if (is_license_request_) {
-    bool supports_usage_information;
-    if (crypto_session_->HasUsageInfoSupport(&supports_usage_information)) {
-      client_capabilities->set_session_token(supports_usage_information);
+    bool supports_usage_table;
+    if (crypto_session_->HasUsageTableSupport(&supports_usage_table)) {
+      client_capabilities->set_session_token(supports_usage_table);
     }
 
     client_capabilities->set_anti_rollback_usage_table(
diff --git a/libwvdrmengine/cdm/core/src/crypto_session.cpp b/libwvdrmengine/cdm/core/src/crypto_session.cpp
index c24011f6..7d14f428 100644
--- a/libwvdrmengine/cdm/core/src/crypto_session.cpp
+++ b/libwvdrmengine/cdm/core/src/crypto_session.cpp
@@ -17,6 +17,7 @@
 #include "advance_iv_ctr.h"
 #include "arraysize.h"
 #include "cdm_random.h"
+#include "cdm_usage_table.h"
 #include "content_key_session.h"
 #include "crypto_key.h"
 #include "entitlement_key_session.h"
@@ -28,7 +29,6 @@
 #include "properties.h"
 #include "pst_report.h"
 #include "string_conversions.h"
-#include "usage_table_header.h"
 #include "wv_cdm_constants.h"
 
 // Stringify turns macro arguments into static C strings.
@@ -211,8 +211,8 @@ bool CryptoSession::initialized_ = false;
 bool CryptoSession::needs_keybox_provisioning_ = false;
 int CryptoSession::session_count_ = 0;
 int CryptoSession::termination_counter_ = 0;
-std::unique_ptr<UsageTableHeader> CryptoSession::usage_table_header_l1_;
-std::unique_ptr<UsageTableHeader> CryptoSession::usage_table_header_l3_;
+std::unique_ptr<CdmUsageTable> CryptoSession::usage_table_l1_;
+std::unique_ptr<CdmUsageTable> CryptoSession::usage_table_l3_;
 std::recursive_mutex CryptoSession::usage_table_mutex_;
 std::atomic<uint64_t> CryptoSession::request_id_index_source_(0);
 std::unique_ptr<okp::SystemFallbackPolicy>
@@ -400,8 +400,8 @@ void CryptoSession::ReinitializeForTest() {
     }
     initialized_ = false;
     // Tables will be reinitialized by tests when needed.
-    usage_table_header_l1_.reset();
-    usage_table_header_l3_.reset();
+    usage_table_l1_.reset();
+    usage_table_l3_.reset();
   }
   // Give up if we cannot initialize at all.
   const OEMCryptoResult status = OEMCrypto_Initialize();
@@ -479,8 +479,8 @@ bool CryptoSession::TryTerminate() {
   });
   if (terminated) {
     UsageTableLock lock(usage_table_mutex_);
-    usage_table_header_l1_.reset();
-    usage_table_header_l3_.reset();
+    usage_table_l1_.reset();
+    usage_table_l3_.reset();
   }
   return terminated;
 }
@@ -491,9 +491,9 @@ void CryptoSession::DisableDelayedTermination() {
                            [&] { termination_counter_ = 0; });
 }
 
-bool CryptoSession::SetUpUsageTableHeader(
+bool CryptoSession::SetUpUsageTable(
     RequestedSecurityLevel requested_security_level) {
-  if (usage_table_header_ != nullptr) {
+  if (usage_table_ != nullptr) {
     LOGE("Usage table is already set up for the current crypto session");
     return false;
   }
@@ -508,7 +508,7 @@ bool CryptoSession::SetUpUsageTableHeader(
 
   // Check if usage support is available.
   bool supports_usage_table = false;
-  if (!HasUsageInfoSupport(requested_security_level, &supports_usage_table)) {
+  if (!HasUsageTableSupport(requested_security_level, &supports_usage_table)) {
     metrics_->oemcrypto_usage_table_support_.SetError(
         USAGE_INFORMATION_SUPPORT_FAILED);
     return false;
@@ -519,30 +519,28 @@ bool CryptoSession::SetUpUsageTableHeader(
     return false;
   }
 
-  LOGV("Usage table lock: SetUpUsageTableHeader()");
+  LOGV("Usage table lock: SetUpUsageTable()");
   UsageTableLock auto_lock(usage_table_mutex_);
   // TODO(b/141350978): Prevent any recursive logic.
 
   // Manipulate only the usage table for the requested security level.
-  std::unique_ptr<UsageTableHeader>& header = security_level == kSecurityLevelL1
-                                                  ? usage_table_header_l1_
-                                                  : usage_table_header_l3_;
-  if (!header) {
+  std::unique_ptr<CdmUsageTable>& table =
+      security_level == kSecurityLevelL1 ? usage_table_l1_ : usage_table_l3_;
+  if (!table) {
     // This may be called twice within the same thread when the table
     // is initialized.  On the second call |header| will not be null,
     // causing this block to be skipped.
-    header.reset(new UsageTableHeader());
-    if (!header->Init(security_level, this)) {
+    table.reset(new CdmUsageTable());
+    if (!table->Init(security_level, this)) {
       LOGE("Failed to initialize and sync usage usage table");
       // Must be cleared globally to prevent the next session to be
-      // opened from using the invalid UsageTableHeader.
-      header.reset();
+      // opened from using the invalid CdmUsageTable.
+      table.reset();
       return false;
     }
   }
-  usage_table_header_ = header.get();
-  metrics_->usage_table_header_initial_size_.Record(
-      usage_table_header_->size());
+  usage_table_ = table.get();
+  metrics_->usage_table_header_initial_size_.Record(usage_table_->size());
   return true;
 }
 
@@ -890,7 +888,7 @@ CdmResponseType CryptoSession::Open(
   RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
   if (open_) return CdmResponseType(NO_ERROR);
 
-  if (!SetUpUsageTableHeader(requested_security_level)) {
+  if (!SetUpUsageTable(requested_security_level)) {
     // Ignore errors since we do not know when a session is opened,
     // if it is intended to be used for offline/usage session related
     // or otherwise.
@@ -962,7 +960,7 @@ void CryptoSession::Close() {
   metrics_->oemcrypto_close_session_.Increment(close_sts);
 
   // Clear cached values.
-  has_usage_info_support_ = kBooleanUnset;
+  has_usage_table_support_ = kBooleanUnset;
   oem_token_.clear();
   system_id_ = NULL_SYSTEM_ID;
   pre_provision_token_type_ = kClientTokenUninitialized;
@@ -975,7 +973,7 @@ void CryptoSession::Close() {
     case OEMCrypto_SUCCESS:
     case OEMCrypto_ERROR_INVALID_SESSION:
     case OEMCrypto_ERROR_SYSTEM_INVALIDATED:
-      usage_table_header_ = nullptr;
+      usage_table_ = nullptr;
       open_ = false;
       break;
     case OEMCrypto_ERROR_CLOSE_SESSION_FAILED:
@@ -1837,38 +1835,38 @@ CdmResponseType CryptoSession::Decrypt(
   }
 }
 
-bool CryptoSession::HasUsageInfoSupport(bool* has_support) {
+bool CryptoSession::HasUsageTableSupport(bool* has_support) {
   RETURN_IF_NOT_OPEN(false);
   RETURN_IF_NULL(has_support, false);
-  return WithOecReadLock("HasUsageInfoSupport", [&] {
+  return WithOecReadLock("HasUsageTableSupport", [&] {
     // Use cached value if set.
-    if (has_usage_info_support_ != kBooleanUnset) {
-      *has_support = (has_usage_info_support_ == kBooleanTrue);
+    if (has_usage_table_support_ != kBooleanUnset) {
+      *has_support = (has_usage_table_support_ == kBooleanTrue);
       return true;
     }
-    if (!HasUsageInfoSupportInternal(requested_security_level_, has_support)) {
+    if (!HasUsageTableSupportInternal(requested_security_level_, has_support)) {
       return false;
     }
     // Cache result if successful.
-    has_usage_info_support_ = (*has_support ? kBooleanTrue : kBooleanFalse);
+    has_usage_table_support_ = (*has_support ? kBooleanTrue : kBooleanFalse);
     return true;
   });
 }
 
-bool CryptoSession::HasUsageInfoSupport(
+bool CryptoSession::HasUsageTableSupport(
     RequestedSecurityLevel requested_security_level, bool* has_support) {
   RETURN_IF_UNINITIALIZED(false);
   RETURN_IF_NULL(has_support, false);
-  return WithOecReadLock("HasUsageInfoSupport", [&] {
-    return HasUsageInfoSupportInternal(requested_security_level, has_support);
+  return WithOecReadLock("HasUsageTableSupport", [&] {
+    return HasUsageTableSupportInternal(requested_security_level, has_support);
   });
 }
 
-bool CryptoSession::HasUsageInfoSupportInternal(
+bool CryptoSession::HasUsageTableSupportInternal(
     RequestedSecurityLevel requested_security_level, bool* has_support) {
   LOGV("requested_security_level = %s",
        RequestedSecurityLevelToString(requested_security_level));
-  *has_support = WithOecReadLock("HasUsageInfoSupport", [&] {
+  *has_support = WithOecReadLock("HasUsageTableSupport", [&] {
     return OEMCrypto_SupportsUsageTable(requested_security_level);
   });
   return true;
@@ -2646,7 +2644,7 @@ CdmResponseType CryptoSession::GenericVerify(const std::string& message,
 
 CdmResponseType CryptoSession::CreateUsageTableHeader(
     RequestedSecurityLevel requested_security_level,
-    CdmUsageTableHeader* usage_table_header) {
+    UsageTableHeader* usage_table_header) {
   LOGV("Creating usage table header: requested_security_level = %s",
        RequestedSecurityLevelToString(requested_security_level));
   RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
@@ -2687,7 +2685,7 @@ CdmResponseType CryptoSession::CreateUsageTableHeader(
 
 CdmResponseType CryptoSession::LoadUsageTableHeader(
     RequestedSecurityLevel requested_security_level,
-    const CdmUsageTableHeader& usage_table_header) {
+    const UsageTableHeader& usage_table_header) {
   LOGV("Loading usage table header: requested_security_level = %s",
        RequestedSecurityLevelToString(requested_security_level));
 
@@ -2728,7 +2726,7 @@ CdmResponseType CryptoSession::LoadUsageTableHeader(
 
 CdmResponseType CryptoSession::ShrinkUsageTableHeader(
     RequestedSecurityLevel requested_security_level, uint32_t new_entry_count,
-    CdmUsageTableHeader* usage_table_header) {
+    UsageTableHeader* usage_table_header) {
   LOGV("Shrinking usage table header: requested_security_level = %s",
        RequestedSecurityLevelToString(requested_security_level));
   RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
@@ -2766,14 +2764,14 @@ CdmResponseType CryptoSession::ShrinkUsageTableHeader(
   }
 }
 
-CdmResponseType CryptoSession::CreateUsageEntry(uint32_t* entry_number) {
+CdmResponseType CryptoSession::CreateUsageEntry(UsageEntryIndex* entry_index) {
   LOGV("Creating usage entry: id = %u", oec_session_id_);
 
-  RETURN_IF_NULL(entry_number, PARAMETER_NULL);
+  RETURN_IF_NULL(entry_index, PARAMETER_NULL);
 
   OEMCryptoResult result;
   WithOecWriteLock("CreateUsageEntry", [&] {
-    result = OEMCrypto_CreateNewUsageEntry(oec_session_id_, entry_number);
+    result = OEMCrypto_CreateNewUsageEntry(oec_session_id_, entry_index);
     metrics_->oemcrypto_create_new_usage_entry_.Increment(result);
   });
 
@@ -2796,14 +2794,14 @@ CdmResponseType CryptoSession::CreateUsageEntry(uint32_t* entry_number) {
   }
 }
 
-CdmResponseType CryptoSession::LoadUsageEntry(
-    uint32_t entry_number, const CdmUsageEntry& usage_entry) {
+CdmResponseType CryptoSession::LoadUsageEntry(UsageEntryIndex entry_index,
+                                              const UsageEntry& usage_entry) {
   LOGV("Loading usage entry: id = %u", oec_session_id_);
 
   OEMCryptoResult result;
   WithOecWriteLock("LoadUsageEntry", [&] {
     result = OEMCrypto_LoadUsageEntry(
-        oec_session_id_, entry_number,
+        oec_session_id_, entry_index,
         reinterpret_cast<const uint8_t*>(usage_entry.data()),
         usage_entry.size());
     metrics_->oemcrypto_load_usage_entry_.Increment(result);
@@ -2839,7 +2837,7 @@ CdmResponseType CryptoSession::LoadUsageEntry(
 }
 
 CdmResponseType CryptoSession::UpdateUsageEntry(
-    CdmUsageTableHeader* usage_table_header, CdmUsageEntry* usage_entry) {
+    UsageTableHeader* usage_table_header, UsageEntry* usage_entry) {
   LOGV("Updating usage entry: id = %u", oec_session_id_);
 
   RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
@@ -2880,19 +2878,19 @@ CdmResponseType CryptoSession::UpdateUsageEntry(
                             "UpdateUsageEntry");
 }
 
-CdmResponseType CryptoSession::MoveUsageEntry(uint32_t new_entry_number) {
+CdmResponseType CryptoSession::MoveUsageEntry(UsageEntryIndex new_entry_index) {
   LOGV("Moving usage entry: id = %u", oec_session_id_);
 
   OEMCryptoResult result;
   WithOecWriteLock("MoveUsageEntry", [&] {
-    result = OEMCrypto_MoveEntry(oec_session_id_, new_entry_number);
+    result = OEMCrypto_MoveEntry(oec_session_id_, new_entry_index);
     metrics_->oemcrypto_move_entry_.Increment(result);
   });
 
   switch (result) {
     case OEMCrypto_ERROR_ENTRY_IN_USE:
       LOGW("OEMCrypto_MoveEntry failed: Destination index in use: index = %u",
-           new_entry_number);
+           new_entry_index);
       return CRYPTO_ERROR(MOVE_USAGE_ENTRY_DESTINATION_IN_USE, result);
     default:
       return MapOEMCryptoResult(result, MOVE_USAGE_ENTRY_UNKNOWN_ERROR,
diff --git a/libwvdrmengine/cdm/core/src/device_files.cpp b/libwvdrmengine/cdm/core/src/device_files.cpp
index 885eecf0..f38f5eca 100644
--- a/libwvdrmengine/cdm/core/src/device_files.cpp
+++ b/libwvdrmengine/cdm/core/src/device_files.cpp
@@ -838,7 +838,7 @@ bool DeviceFiles::StoreLicense(const CdmLicenseData& license_data,
     app_params->set_value(iter->second);
   }
   license->set_usage_entry(license_data.usage_entry);
-  license->set_usage_entry_number(license_data.usage_entry_number);
+  license->set_usage_entry_index(license_data.usage_entry_index);
   if (!license_data.drm_certificate.empty()) {
     DeviceCertificate* device_certificate = license->mutable_drm_certificate();
     if (!SetDeviceCertificate(license_data.drm_certificate,
@@ -929,8 +929,8 @@ bool DeviceFiles::RetrieveLicense(const std::string& key_set_id,
         license.app_parameters(i).value();
   }
   license_data->usage_entry = license.usage_entry();
-  license_data->usage_entry_number =
-      static_cast<uint32_t>(license.usage_entry_number());
+  license_data->usage_entry_index =
+      static_cast<uint32_t>(license.usage_entry_index());
 
   if (!license.has_drm_certificate()) {
     license_data->drm_certificate.clear();
@@ -1015,8 +1015,8 @@ bool DeviceFiles::UnreserveLicenseId(const std::string& key_set_id) {
 bool DeviceFiles::StoreUsageInfo(
     const std::string& provider_session_token, const CdmKeyMessage& key_request,
     const CdmKeyResponse& key_response, const std::string& usage_info_file_name,
-    const std::string& key_set_id, const std::string& usage_entry,
-    uint32_t usage_entry_number, const std::string& drm_certificate,
+    const std::string& key_set_id, const UsageEntry& usage_entry,
+    UsageEntryIndex usage_entry_index, const std::string& drm_certificate,
     const CryptoWrappedKey& wrapped_private_key) {
   RETURN_FALSE_IF_UNINITIALIZED();
   video_widevine_client::sdk::File file;
@@ -1039,7 +1039,7 @@ bool DeviceFiles::StoreUsageInfo(
   provider_session->set_license(key_response.data(), key_response.size());
   provider_session->set_key_set_id(key_set_id.data(), key_set_id.size());
   provider_session->set_usage_entry(usage_entry);
-  provider_session->set_usage_entry_number(usage_entry_number);
+  provider_session->set_usage_entry_index(usage_entry_index);
 
   if (drm_certificate.size() > 0) {
     uint32_t drm_certificate_id;
@@ -1240,15 +1240,15 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
                                     const std::string& provider_session_token,
                                     CdmKeyMessage* license_request,
                                     CdmKeyResponse* license,
-                                    std::string* usage_entry,
-                                    uint32_t* usage_entry_number,
+                                    UsageEntry* usage_entry,
+                                    UsageEntryIndex* usage_entry_index,
                                     std::string* drm_certificate,
                                     CryptoWrappedKey* wrapped_private_key) {
   RETURN_FALSE_IF_UNINITIALIZED();
   RETURN_FALSE_IF_NULL(license_request);
   RETURN_FALSE_IF_NULL(license);
   RETURN_FALSE_IF_NULL(usage_entry);
-  RETURN_FALSE_IF_NULL(usage_entry_number);
+  RETURN_FALSE_IF_NULL(usage_entry_index);
   RETURN_FALSE_IF_NULL(drm_certificate);
   RETURN_FALSE_IF_NULL(wrapped_private_key);
 
@@ -1264,8 +1264,8 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
       *license_request = file.usage_info().sessions(index).license_request();
       *license = file.usage_info().sessions(index).license();
       *usage_entry = file.usage_info().sessions(index).usage_entry();
-      *usage_entry_number = static_cast<uint32_t>(
-          file.usage_info().sessions(index).usage_entry_number());
+      *usage_entry_index = static_cast<UsageEntryIndex>(
+          file.usage_info().sessions(index).usage_entry_index());
 
       if (!file.usage_info().sessions(index).has_drm_certificate_id()) {
         drm_certificate->clear();
@@ -1290,14 +1290,14 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
 bool DeviceFiles::RetrieveUsageInfoByKeySetId(
     const std::string& usage_info_file_name, const std::string& key_set_id,
     std::string* provider_session_token, CdmKeyMessage* license_request,
-    CdmKeyResponse* license, std::string* usage_entry,
-    uint32_t* usage_entry_number, std::string* drm_certificate,
+    CdmKeyResponse* license, UsageEntry* usage_entry,
+    UsageEntryIndex* usage_entry_index, std::string* drm_certificate,
     CryptoWrappedKey* wrapped_private_key) {
   RETURN_FALSE_IF_UNINITIALIZED();
   RETURN_FALSE_IF_NULL(license_request);
   RETURN_FALSE_IF_NULL(license);
   RETURN_FALSE_IF_NULL(usage_entry);
-  RETURN_FALSE_IF_NULL(usage_entry_number);
+  RETURN_FALSE_IF_NULL(usage_entry_index);
   RETURN_FALSE_IF_NULL(drm_certificate);
   RETURN_FALSE_IF_NULL(wrapped_private_key);
 
@@ -1314,8 +1314,8 @@ bool DeviceFiles::RetrieveUsageInfoByKeySetId(
       *license_request = file.usage_info().sessions(index).license_request();
       *license = file.usage_info().sessions(index).license();
       *usage_entry = file.usage_info().sessions(index).usage_entry();
-      *usage_entry_number = static_cast<uint32_t>(
-          file.usage_info().sessions(index).usage_entry_number());
+      *usage_entry_index = static_cast<UsageEntryIndex>(
+          file.usage_info().sessions(index).usage_entry_index());
 
       if (!file.usage_info().sessions(index).has_drm_certificate_id()) {
         drm_certificate->clear();
@@ -1359,7 +1359,7 @@ bool DeviceFiles::StoreUsageInfo(const std::string& usage_info_file_name,
     provider_session->set_key_set_id(usage_data[i].key_set_id.data(),
                                      usage_data[i].key_set_id.size());
     provider_session->set_usage_entry(usage_data[i].usage_entry);
-    provider_session->set_usage_entry_number(usage_data[i].usage_entry_number);
+    provider_session->set_usage_entry_index(usage_data[i].usage_entry_index);
 
     if (usage_data[i].drm_certificate.size() > 0) {
       uint32_t drm_certificate_id;
@@ -1404,7 +1404,7 @@ bool DeviceFiles::UpdateUsageInfo(const std::string& usage_info_file_name,
       provider_session->set_license(usage_data.license);
       provider_session->set_key_set_id(usage_data.key_set_id);
       provider_session->set_usage_entry(usage_data.usage_entry);
-      provider_session->set_usage_entry_number(usage_data.usage_entry_number);
+      provider_session->set_usage_entry_index(usage_data.usage_entry_index);
 
       if (usage_data.drm_certificate.size() > 0) {
         uint32_t drm_certificate_id;
@@ -1453,8 +1453,8 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
     (*usage_data)[i].license = file.usage_info().sessions(i).license();
     (*usage_data)[i].key_set_id = file.usage_info().sessions(i).key_set_id();
     (*usage_data)[i].usage_entry = file.usage_info().sessions(i).usage_entry();
-    (*usage_data)[i].usage_entry_number = static_cast<uint32_t>(
-        file.usage_info().sessions(i).usage_entry_number());
+    (*usage_data)[i].usage_entry_index = static_cast<uint32_t>(
+        file.usage_info().sessions(i).usage_entry_index());
 
     if (!file.usage_info().sessions(i).has_drm_certificate_id()) {
       (*usage_data)[i].drm_certificate.clear();
@@ -1495,8 +1495,8 @@ bool DeviceFiles::RetrieveUsageInfo(const std::string& usage_info_file_name,
       usage_data->license = file.usage_info().sessions(index).license();
       usage_data->key_set_id = file.usage_info().sessions(index).key_set_id();
       usage_data->usage_entry = file.usage_info().sessions(index).usage_entry();
-      usage_data->usage_entry_number = static_cast<uint32_t>(
-          file.usage_info().sessions(index).usage_entry_number());
+      usage_data->usage_entry_index = static_cast<uint32_t>(
+          file.usage_info().sessions(index).usage_entry_index());
 
       if (!file.usage_info().sessions(index).has_drm_certificate_id()) {
         usage_data->drm_certificate.clear();
@@ -1634,8 +1634,8 @@ 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 UsageTableHeader& table_header,
+    const std::vector<CdmUsageEntryInfo>& entry_info_list) {
   RETURN_FALSE_IF_UNINITIALIZED();
 
   // Fill in file information
@@ -1645,25 +1645,24 @@ bool DeviceFiles::StoreUsageTableInfo(
   file.set_version(video_widevine_client::sdk::File::VERSION_1);
 
   UsageTableInfo* usage_table_info = file.mutable_usage_table_info();
-  usage_table_info->set_usage_table_header(usage_table_header);
-  for (size_t i = 0; i < usage_entry_info.size(); ++i) {
+  usage_table_info->set_table_header(table_header);
+  for (size_t i = 0; i < entry_info_list.size(); ++i) {
     UsageTableInfo_UsageEntryInfo* info =
-        usage_table_info->add_usage_entry_info();
-    info->set_key_set_id(usage_entry_info[i].key_set_id);
-    switch (usage_entry_info[i].storage_type) {
+        usage_table_info->add_entry_info_list();
+    info->set_key_set_id(entry_info_list[i].key_set_id);
+    switch (entry_info_list[i].storage_type) {
       case kStorageLicense:
         info->set_storage(
             UsageTableInfo_UsageEntryInfo_UsageEntryStorage_LICENSE);
-        info->set_last_use_time(usage_entry_info[i].last_use_time);
+        info->set_last_use_time(entry_info_list[i].last_use_time);
         info->set_offline_license_expiry_time(
-            usage_entry_info[i].offline_license_expiry_time);
+            entry_info_list[i].offline_license_expiry_time);
         break;
       case kStorageUsageInfo:
         info->set_storage(
             UsageTableInfo_UsageEntryInfo_UsageEntryStorage_USAGE_INFO);
-        info->set_usage_info_file_name(
-            usage_entry_info[i].usage_info_file_name);
-        info->set_last_use_time(usage_entry_info[i].last_use_time);
+        info->set_usage_info_file_name(entry_info_list[i].usage_info_file_name);
+        info->set_last_use_time(entry_info_list[i].last_use_time);
         break;
       case kStorageTypeUnknown:
       default:
@@ -1682,11 +1681,11 @@ bool DeviceFiles::StoreUsageTableInfo(
 }
 
 bool DeviceFiles::RetrieveUsageTableInfo(
-    CdmUsageTableHeader* usage_table_header,
-    std::vector<CdmUsageEntryInfo>* usage_entry_info, bool* lru_upgrade) {
+    UsageTableHeader* table_header,
+    std::vector<CdmUsageEntryInfo>* entry_info_list, bool* lru_upgrade) {
   RETURN_FALSE_IF_UNINITIALIZED();
-  RETURN_FALSE_IF_NULL(usage_table_header);
-  RETURN_FALSE_IF_NULL(usage_entry_info);
+  RETURN_FALSE_IF_NULL(table_header);
+  RETURN_FALSE_IF_NULL(entry_info_list);
   RETURN_FALSE_IF_NULL(lru_upgrade);
 
   video_widevine_client::sdk::File file;
@@ -1718,28 +1717,28 @@ bool DeviceFiles::RetrieveUsageTableInfo(
 
   *lru_upgrade = !usage_table_info.use_lru();
 
-  *usage_table_header = usage_table_info.usage_table_header();
-  usage_entry_info->resize(usage_table_info.usage_entry_info_size());
-  for (int i = 0; i < usage_table_info.usage_entry_info_size(); ++i) {
+  *table_header = usage_table_info.table_header();
+  entry_info_list->resize(usage_table_info.entry_info_list_size());
+  for (int i = 0; i < usage_table_info.entry_info_list_size(); ++i) {
     const UsageTableInfo_UsageEntryInfo& info =
-        usage_table_info.usage_entry_info(i);
-    (*usage_entry_info)[i].key_set_id = info.key_set_id();
+        usage_table_info.entry_info_list(i);
+    (*entry_info_list)[i].key_set_id = info.key_set_id();
     switch (info.storage()) {
       case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_LICENSE:
-        (*usage_entry_info)[i].storage_type = kStorageLicense;
-        (*usage_entry_info)[i].last_use_time = info.last_use_time();
-        (*usage_entry_info)[i].offline_license_expiry_time =
+        (*entry_info_list)[i].storage_type = kStorageLicense;
+        (*entry_info_list)[i].last_use_time = info.last_use_time();
+        (*entry_info_list)[i].offline_license_expiry_time =
             info.offline_license_expiry_time();
         break;
       case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_USAGE_INFO:
-        (*usage_entry_info)[i].storage_type = kStorageUsageInfo;
-        (*usage_entry_info)[i].usage_info_file_name =
+        (*entry_info_list)[i].storage_type = kStorageUsageInfo;
+        (*entry_info_list)[i].usage_info_file_name =
             info.usage_info_file_name();
-        (*usage_entry_info)[i].last_use_time = info.last_use_time();
+        (*entry_info_list)[i].last_use_time = info.last_use_time();
         break;
       case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_UNKNOWN:
       default:
-        (*usage_entry_info)[i].storage_type = kStorageTypeUnknown;
+        (*entry_info_list)[i].storage_type = kStorageTypeUnknown;
         break;
     }
   }
diff --git a/libwvdrmengine/cdm/core/src/device_files.proto b/libwvdrmengine/cdm/core/src/device_files.proto
index b2e13f65..7b4a02ef 100644
--- a/libwvdrmengine/cdm/core/src/device_files.proto
+++ b/libwvdrmengine/cdm/core/src/device_files.proto
@@ -75,7 +75,7 @@ message License {
   // ignored if there is no grace period.
   optional int64 grace_period_end_time = 11 [default = 0];
   optional bytes usage_entry = 12;
-  optional int64 usage_entry_number = 13;
+  optional int64 usage_entry_index = 13;
   optional DeviceCertificate drm_certificate = 14;
 }
 
@@ -88,7 +88,7 @@ message UsageInfo {
     optional bytes license = 3;
     optional bytes key_set_id = 4;
     optional bytes usage_entry = 5;
-    optional int64 usage_entry_number = 6;
+    optional int64 usage_entry_index = 6;
     // If not present, use the legacy DRM certificate rather than
     // one in DrmDeviceCertificate
     optional uint32 drm_certificate_id = 7;
@@ -131,8 +131,8 @@ message UsageTableInfo {
     optional int64 offline_license_expiry_time = 5 [default = 0];
   }
 
-  optional bytes usage_table_header = 1;
-  repeated UsageEntryInfo usage_entry_info = 2;
+  optional bytes table_header = 1;
+  repeated UsageEntryInfo entry_info_list = 2;
   optional bool use_lru = 3 [default = false];
 }
 
diff --git a/libwvdrmengine/cdm/core/src/license.cpp b/libwvdrmengine/cdm/core/src/license.cpp
index 81af1c4d..44c63126 100644
--- a/libwvdrmengine/cdm/core/src/license.cpp
+++ b/libwvdrmengine/cdm/core/src/license.cpp
@@ -466,7 +466,7 @@ CdmResponseType CdmLicense::PrepareKeyUpdateRequest(
     }
 
     // TODO(rfrias): Refactor to avoid needing to call CdmSession
-    if (cdm_session && cdm_session->supports_usage_info()) {
+    if (cdm_session && cdm_session->SupportsUsageTable()) {
       const CdmResponseType status = cdm_session->UpdateUsageEntryInformation();
       if (NO_ERROR != status) return status;
     }
@@ -822,7 +822,7 @@ CdmResponseType CdmLicense::RestoreOfflineLicense(
   }
 
   if (!provider_session_token_.empty()) {
-    if (cdm_session && cdm_session->supports_usage_info()) {
+    if (cdm_session && cdm_session->SupportsUsageTable()) {
       const CdmResponseType status = cdm_session->UpdateUsageEntryInformation();
       if (NO_ERROR != status) return sts;
     }
diff --git a/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp b/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp
index 270961d9..8a048870 100644
--- a/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp
@@ -9,6 +9,7 @@
 
 #include <memory>
 
+#include "cdm_usage_table.h"
 #include "crypto_key.h"
 #include "crypto_wrapped_key.h"
 #include "properties.h"
@@ -16,7 +17,6 @@
 #include "string_conversions.h"
 #include "test_base.h"
 #include "test_printers.h"
-#include "usage_table_header.h"
 #include "wv_cdm_constants.h"
 #include "wv_metrics.pb.h"
 
@@ -123,13 +123,13 @@ class MockDeviceFiles : public DeviceFiles {
   MOCK_METHOD(bool, HasCertificate, (bool), (override));
 };
 
-class MockUsageTableHeader : public UsageTableHeader {
+class MockCdmUsageTable : public CdmUsageTable {
  public:
-  MockUsageTableHeader() : UsageTableHeader() {}
+  MockCdmUsageTable() : CdmUsageTable() {}
 
   MOCK_METHOD(CdmResponseType, UpdateEntry,
-              (uint32_t usage_entry_number, CryptoSession* crypto_session,
-               CdmUsageEntry* usage_entry),
+              (UsageEntryIndex usage_entry_index, CryptoSession* crypto_session,
+               UsageEntry* usage_entry),
               (override));
 };
 
@@ -137,10 +137,10 @@ class MockCryptoSession : public TestCryptoSession {
  public:
   MockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
       : TestCryptoSession(crypto_metrics) {
-    // By default, call the concrete implementation of HasUsageInfoSupport.
-    ON_CALL(*this, HasUsageInfoSupport(_))
+    // By default, call the concrete implementation of HasUsageTableSupport.
+    ON_CALL(*this, HasUsageTableSupport(_))
         .WillByDefault(
-            Invoke(this, &MockCryptoSession::BaseHasUsageInfoSupport));
+            Invoke(this, &MockCryptoSession::BaseHasUsageTableSupport));
   }
   MOCK_METHOD(CdmResponseType, GetProvisioningToken,
               (std::string*, std::string*), (override));
@@ -151,11 +151,11 @@ class MockCryptoSession : public TestCryptoSession {
               (override));
   MOCK_METHOD(CdmResponseType, LoadCertificatePrivateKey,
               (const CryptoWrappedKey&), (override));
-  MOCK_METHOD(bool, HasUsageInfoSupport, (bool*), (override));
-  MOCK_METHOD(UsageTableHeader*, GetUsageTableHeader, (), (override));
+  MOCK_METHOD(bool, HasUsageTableSupport, (bool*), (override));
+  MOCK_METHOD(CdmUsageTable*, GetUsageTable, (), (override));
 
-  bool BaseHasUsageInfoSupport(bool* has_support) {
-    return CryptoSession::HasUsageInfoSupport(has_support);
+  bool BaseHasUsageTableSupport(bool* has_support) {
+    return CryptoSession::HasUsageTableSupport(has_support);
   }
 };
 
@@ -209,7 +209,7 @@ class CdmSessionTest : public WvCdmTestBase {
   NiceMock<MockCryptoSession>* crypto_session_;
   MockPolicyEngine* policy_engine_;
   MockDeviceFiles* file_handle_;
-  MockUsageTableHeader usage_table_header_;
+  MockCdmUsageTable usage_table_;
 };
 
 TEST_F(CdmSessionTest, InitWithBuiltInCertificate) {
@@ -294,22 +294,22 @@ TEST_F(CdmSessionTest, UpdateUsageEntry) {
       .WillOnce(Return(level));
   EXPECT_CALL(*file_handle_, Init(Eq(level))).WillOnce(Return(true));
   EXPECT_CALL(*file_handle_, HasCertificate(false)).WillOnce(Return(true));
-  EXPECT_CALL(*crypto_session_, GetUsageTableHeader())
-      .WillOnce(Return(&usage_table_header_));
+  EXPECT_CALL(*crypto_session_, GetUsageTable())
+      .WillOnce(Return(&usage_table_));
   EXPECT_CALL(*license_parser_, Init(false, Eq(kEmptyString),
                                      Eq(crypto_session_), Eq(policy_engine_)))
       .WillOnce(Return(true));
 
   // Set up mocks and expectations for the UpdateUsageEntryInformation call.
-  EXPECT_CALL(*crypto_session_, HasUsageInfoSupport(_))
+  EXPECT_CALL(*crypto_session_, HasUsageTableSupport(_))
       .WillRepeatedly(DoAll(SetArgPointee<0>(true), Return(true)));
   EXPECT_CALL(*license_parser_, provider_session_token())
       .WillRepeatedly(Return("Mock provider session token"));
-  EXPECT_CALL(usage_table_header_, UpdateEntry(_, NotNull(), NotNull()))
+  EXPECT_CALL(usage_table_, UpdateEntry(_, NotNull(), NotNull()))
       .WillRepeatedly(Return(CdmResponseType(NO_ERROR)));
 
   EXPECT_EQ(NO_ERROR, cdm_session_->Init(nullptr));
-  EXPECT_TRUE(cdm_session_->supports_usage_info());
+  EXPECT_TRUE(cdm_session_->SupportsUsageTable());
   EXPECT_EQ(NO_ERROR, cdm_session_->UpdateUsageEntryInformation());
 
   // Verify the UsageEntry metric is set.
diff --git a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp b/libwvdrmengine/cdm/core/test/cdm_usage_table_unittest.cpp
similarity index 81%
rename from libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp
rename to libwvdrmengine/cdm/core/test/cdm_usage_table_unittest.cpp
index 205117d8..15658d05 100644
--- a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/cdm_usage_table_unittest.cpp
@@ -2,7 +2,7 @@
 // source code may only be used and distributed under the Widevine License
 // Agreement.
 
-#include "usage_table_header.h"
+#include "cdm_usage_table.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -51,21 +51,19 @@ constexpr size_t kDefaultTableCapacity = 300;
 
 constexpr int64_t kDefaultExpireDuration = 33 * 24 * 60 * 60;  // 33 Days
 
-const CdmUsageTableHeader kEmptyUsageTableHeader;
-const CdmUsageTableHeader kUsageTableHeader = "some usage table header";
-const CdmUsageTableHeader kAnotherUsageTableHeader =
-    "another usage table header";
-const CdmUsageTableHeader kYetAnotherUsageTableHeader =
+const UsageTableHeader kEmptyUsageTableHeader;
+const UsageTableHeader kUsageTableHeader = "some usage table header";
+const UsageTableHeader kAnotherUsageTableHeader = "another usage table header";
+const UsageTableHeader kYetAnotherUsageTableHeader =
     "yet another usage table header";
-const CdmUsageTableHeader kAndAnotherUsageTableHeader =
+const UsageTableHeader kAndAnotherUsageTableHeader =
     "and another usage table header";
-const CdmUsageTableHeader kOneMoreUsageTableHeader =
-    "one more usage table header";
-const CdmUsageEntry kUsageEntry = "usage entry";
-const CdmUsageEntry kAnotherUsageEntry = "another usage entry";
-const CdmUsageEntry kYetAnotherUsageEntry = "yet another usage entry";
-const CdmUsageEntry kAndAnotherUsageEntry = "and another usage entry";
-const CdmUsageEntry kOneMoreUsageEntry = "one more usage entry";
+const UsageTableHeader kOneMoreUsageTableHeader = "one more usage table header";
+const UsageEntry kUsageEntry = "usage entry";
+const UsageEntry kAnotherUsageEntry = "another usage entry";
+const UsageEntry kYetAnotherUsageEntry = "yet another usage entry";
+const UsageEntry kAndAnotherUsageEntry = "and another usage entry";
+const UsageEntry kOneMoreUsageEntry = "one more usage entry";
 const std::string kDrmCertificate = "a drm certificate";
 const std::string kWrappedPrivateKey = "a wrapped private key";
 const CryptoWrappedKey kCryptoWrappedKey(CryptoWrappedKey::kRsa,
@@ -175,7 +173,7 @@ const DeviceFiles::CdmUsageData kCdmUsageData1 = {
     /* license = */ "license_1",
     /* key_set_id = */ "key_set_id_1",
     /* usage_entry = */ "usage_entry_1",
-    /* usage_entry_number = */ 0,
+    /* usage_entry_index = */ 0,
     /* drm_certificate = */ kDrmCertificate,
     /* wrapped_private_key = */ kCryptoWrappedKey,
 };
@@ -185,7 +183,7 @@ const DeviceFiles::CdmUsageData kCdmUsageData2 = {
     /* license = */ "license_2",
     /* key_set_id = */ "key_set_id_2",
     /* usage_entry = */ "usage_entry_2",
-    /* usage_entry_number = */ 0,
+    /* usage_entry_index = */ 0,
     /* drm_certificate = */ kDrmCertificate,
     /* wrapped_private_key = */ kCryptoWrappedKey,
 };
@@ -195,7 +193,7 @@ const DeviceFiles::CdmUsageData kCdmUsageData3 = {
     /* license = */ "license_3",
     /* key_set_id = */ "key_set_id_3",
     /* usage_entry = */ "usage_entry_3",
-    /* usage_entry_number = */ 0,
+    /* usage_entry_index = */ 0,
     /* drm_certificate = */ kDrmCertificate,
     /* wrapped_private_key = */ kCryptoWrappedKey,
 };
@@ -228,8 +226,7 @@ int64_t kPlaybackDuration = 300;
 int64_t kGracePeriodEndTime = 60;
 
 // ==== LRU Upgrade Data ====
-const CdmUsageTableHeader kUpgradableUsageTableHeader =
-    "Upgradable Table Header";
+const UsageTableHeader kUpgradableUsageTableHeader = "Upgradable Table Header";
 
 // Usage entries.
 const CdmUsageEntryInfo kUpgradableUsageEntryInfo1 = {
@@ -291,7 +288,7 @@ const int64_t kUpgradedUsageEntryInfo2ExpireTime = 0;  // Unset
 const int64_t kUpgradedUsageEntryInfo3LastUsedTime = kLruBaseTime;
 const int64_t kUpgradedUsageEntryInfo3ExpireTime =
     kLruBaseTime + 604800 + 86400;
-const CdmUsageTableHeader kUpgradedUsageTableHeader = "Upgraded Table Header";
+const UsageTableHeader kUpgradedUsageTableHeader = "Upgraded Table Header";
 std::vector<CdmUsageEntryInfo> kUpgradedUsageEntryInfoList;
 
 namespace {
@@ -359,7 +356,7 @@ void InitVectorConstants() {
     license_data.key_set_id = kUpgradableUsageEntryInfoList[i].key_set_id;
     license_data.state = kActiveLicenseState;
     license_data.license = kUpgradableLicenseInfoList[i];
-    license_data.usage_entry_number = static_cast<uint32_t>(i);
+    license_data.usage_entry_index = static_cast<UsageEntryIndex>(i);
     kUpgradableLicenseDataList.push_back(license_data);
   }
 }
@@ -391,12 +388,11 @@ class MockDeviceFiles : public DeviceFiles {
   }
 
   MOCK_METHOD(bool, RetrieveUsageTableInfo,
-              (CdmUsageTableHeader*, std::vector<CdmUsageEntryInfo>*,
+              (UsageTableHeader*, std::vector<CdmUsageEntryInfo>*,
                bool* lru_upgrade),
               (override));
   MOCK_METHOD(bool, StoreUsageTableInfo,
-              (const CdmUsageTableHeader&,
-               const std::vector<CdmUsageEntryInfo>&),
+              (const UsageTableHeader&, const std::vector<CdmUsageEntryInfo>&),
               (override));
   MOCK_METHOD(bool, DeleteUsageInfo, (const std::string&, const std::string&),
               (override));
@@ -405,7 +401,7 @@ class MockDeviceFiles : public DeviceFiles {
               (override));
   MOCK_METHOD(bool, RetrieveUsageInfoByKeySetId,
               (const std::string&, const std::string&, std::string*,
-               CdmKeyMessage*, CdmKeyResponse*, CdmUsageEntry*, uint32_t*,
+               CdmKeyMessage*, CdmKeyResponse*, UsageEntry*, UsageEntryIndex*,
                std::string*, CryptoWrappedKey*),
               (override));
   MOCK_METHOD(bool, StoreLicense, (const CdmLicenseData&, ResponseType*),
@@ -416,8 +412,8 @@ class MockDeviceFiles : public DeviceFiles {
   MOCK_METHOD(bool, DeleteUsageTableInfo, (), (override));
   MOCK_METHOD(bool, StoreUsageInfo,
               (const std::string&, const CdmKeyMessage&, const CdmKeyResponse&,
-               const std::string&, const std::string&, const CdmUsageEntry&,
-               uint32_t, const std::string&, const CryptoWrappedKey&),
+               const std::string&, const std::string&, const UsageEntry&,
+               UsageEntryIndex, const std::string&, const CryptoWrappedKey&),
               (override));
   MOCK_METHOD(bool, RetrieveUsageInfo,
               (const std::string&, std::vector<CdmUsageData>*), (override));
@@ -438,21 +434,21 @@ class MockCryptoSession : public TestCryptoSession {
               (override));
   // Usage Table Header.
   MOCK_METHOD(CdmResponseType, CreateUsageTableHeader,
-              (wvcdm::RequestedSecurityLevel, CdmUsageTableHeader*),
-              (override));
+              (wvcdm::RequestedSecurityLevel, UsageTableHeader*), (override));
   MOCK_METHOD(CdmResponseType, LoadUsageTableHeader,
-              (wvcdm::RequestedSecurityLevel, const CdmUsageTableHeader&),
+              (wvcdm::RequestedSecurityLevel, const UsageTableHeader&),
               (override));
   MOCK_METHOD(CdmResponseType, ShrinkUsageTableHeader,
-              (wvcdm::RequestedSecurityLevel, uint32_t, CdmUsageTableHeader*),
+              (wvcdm::RequestedSecurityLevel, uint32_t, UsageTableHeader*),
               (override));
   // Usage Entry.
-  MOCK_METHOD(CdmResponseType, CreateUsageEntry, (uint32_t*), (override));
-  MOCK_METHOD(CdmResponseType, LoadUsageEntry, (uint32_t, const CdmUsageEntry&),
+  MOCK_METHOD(CdmResponseType, CreateUsageEntry, (UsageEntryIndex*),
               (override));
+  MOCK_METHOD(CdmResponseType, LoadUsageEntry,
+              (UsageEntryIndex, const UsageEntry&), (override));
   MOCK_METHOD(CdmResponseType, UpdateUsageEntry,
-              (CdmUsageTableHeader*, CdmUsageEntry*), (override));
-  MOCK_METHOD(CdmResponseType, MoveUsageEntry, (uint32_t), (override));
+              (UsageTableHeader*, UsageEntry*), (override));
+  MOCK_METHOD(CdmResponseType, MoveUsageEntry, (UsageEntryIndex), (override));
   MOCK_METHOD(CdmResponseType, GetNumberOfOpenSessions,
               (wvcdm::RequestedSecurityLevel, size_t*), (override));
 
@@ -478,17 +474,17 @@ class MockCryptoSession : public TestCryptoSession {
   bool maximum_usage_table_entries_set_ = true;
 };
 
-// Partial mock of the UsageTableHeader. This is to test when dependency
+// Partial mock of the CdmUsageTable. This is to test when dependency
 // exist on internal methods which would require complex expectations
-class MockUsageTableHeader : public UsageTableHeader {
+class MockCdmUsageTable : public CdmUsageTable {
  public:
-  MockUsageTableHeader() : UsageTableHeader() {}
+  MockCdmUsageTable() : CdmUsageTable() {}
   MOCK_METHOD(CdmResponseType, InvalidateEntryInternal,
-              (uint32_t, bool, DeviceFiles*, metrics::CryptoMetrics*),
+              (UsageEntryIndex, bool, DeviceFiles*, metrics::CryptoMetrics*),
               (override));
   MOCK_METHOD(CdmResponseType, AddEntry,
               (CryptoSession*, bool, const CdmKeySetId&, const std::string&,
-               const CdmKeyResponse&, uint32_t*),
+               const CdmKeyResponse&, UsageEntryIndex*),
               (override));
 
   CdmResponseType SuperAddEntry(CryptoSession* crypto_session,
@@ -496,29 +492,29 @@ class MockUsageTableHeader : public UsageTableHeader {
                                 const CdmKeySetId& key_set_id,
                                 const std::string& usage_info_filename,
                                 const CdmKeyResponse& license_message,
-                                uint32_t* usage_entry_number) {
-    return UsageTableHeader::AddEntry(crypto_session, persistent_license,
-                                      key_set_id, usage_info_filename,
-                                      license_message, usage_entry_number);
+                                UsageEntryIndex* entry_index) {
+    return CdmUsageTable::AddEntry(crypto_session, persistent_license,
+                                   key_set_id, usage_info_filename,
+                                   license_message, entry_index);
   }
 };
 
 }  // namespace
 
-class UsageTableHeaderTest : public WvCdmTestBase {
+class CdmUsageTableTest : public WvCdmTestBase {
  public:
   static void SetUpTestCase() { InitVectorConstants(); }
 
-  // Useful when UsageTableHeader is mocked
-  void InvalidateEntry(uint32_t usage_entry_number, bool, DeviceFiles*,
+  // Useful when CdmUsageTable is mocked
+  void InvalidateEntry(UsageEntryIndex entry_index, bool, DeviceFiles*,
                        metrics::CryptoMetrics*) {
-    usage_table_header_->InvalidateEntryForTest(usage_entry_number);
+    usage_table_->InvalidateEntryForTest(entry_index);
   }
 
  protected:
   void SetUp() override {
     WvCdmTestBase::SetUp();
-    // UsageTableHeader will take ownership of the pointer
+    // CdmUsageTable will take ownership of the pointer
     device_files_ = new MockDeviceFiles();
     ON_CALL(*device_files_, RetrieveLicense(_, _, _))
         .WillByDefault(
@@ -528,61 +524,61 @@ class UsageTableHeaderTest : public WvCdmTestBase {
 
     crypto_session_ = new MockCryptoSession(&crypto_metrics_);
 
-    usage_table_header_ = new UsageTableHeader();
+    usage_table_ = new CdmUsageTable();
 
-    // usage_table_header_ object takes ownership of these objects
-    usage_table_header_->SetDeviceFiles(device_files_);
-    usage_table_header_->SetCryptoSession(crypto_session_);
+    // usage_table_ object takes ownership of these objects
+    usage_table_->SetDeviceFiles(device_files_);
+    usage_table_->SetCryptoSession(crypto_session_);
 
-    // Several UsageTableHeader methods will make calls to GetCurrentTime(),
+    // Several CdmUsageTable methods will make calls to GetCurrentTime(),
     // but the test expectations require a fixed value.  Frozen clock provides
     // the test cases with a fixed value of 0, without needing to set
     // EXPECT_CALL() in every test case.
     test_clock_.reset(new FrozenClock());
-    usage_table_header_->SetClock(test_clock_.get());
+    usage_table_->SetClock(test_clock_.get());
   }
 
-  // UsageTableHeaderTest maintains ownership of returned pointer
-  MockUsageTableHeader* SetUpMock() {
+  // CdmUsageTableTest maintains ownership of returned pointer
+  MockCdmUsageTable* SetUpMock() {
     // Release non-mocked usage table header
-    if (usage_table_header_ != nullptr) {
-      delete usage_table_header_;
-      usage_table_header_ = nullptr;
+    if (usage_table_ != nullptr) {
+      delete usage_table_;
+      usage_table_ = nullptr;
     }
 
-    // Create new mock objects if using MockUsageTableHeader
+    // Create new mock objects if using MockCdmUsageTable
     device_files_ = new MockDeviceFiles();
     crypto_session_ = new MockCryptoSession(&crypto_metrics_);
 
-    MockUsageTableHeader* mock_usage_table_header = new MockUsageTableHeader();
+    MockCdmUsageTable* mock_usage_table = new MockCdmUsageTable();
 
-    // mock_usage_table_header_ object takes ownership of these objects
-    mock_usage_table_header->SetDeviceFiles(device_files_);
-    mock_usage_table_header->SetCryptoSession(crypto_session_);
+    // mock_usage_table_ object takes ownership of these objects
+    mock_usage_table->SetDeviceFiles(device_files_);
+    mock_usage_table->SetCryptoSession(crypto_session_);
 
-    usage_table_header_ = mock_usage_table_header;
-    usage_table_header_->SetClock(test_clock_.get());
-    return mock_usage_table_header;
+    usage_table_ = mock_usage_table;
+    usage_table_->SetClock(test_clock_.get());
+    return mock_usage_table;
   }
 
   void TearDown() override {
-    if (usage_table_header_ != nullptr) delete usage_table_header_;
+    if (usage_table_ != nullptr) delete usage_table_;
   }
 
   void Init(CdmSecurityLevel security_level,
-            const CdmUsageTableHeader& usage_table_header,
-            const std::vector<CdmUsageEntryInfo>& usage_entry_info_vector) {
+            const UsageTableHeader& table_header,
+            const std::vector<CdmUsageEntryInfo>& entry_info_list) {
     EXPECT_CALL(*crypto_session_, GetNumberOfOpenSessions(_, NotNull()))
         .WillOnce(
             DoAll(SetArgPointee<1>(0), Return(CdmResponseType(NO_ERROR))));
     EXPECT_CALL(*device_files_,
                 RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
-        .WillOnce(DoAll(SetArgPointee<0>(usage_table_header),
-                        SetArgPointee<1>(usage_entry_info_vector),
+        .WillOnce(DoAll(SetArgPointee<0>(table_header),
+                        SetArgPointee<1>(entry_info_list),
                         SetArgPointee<2>(false), Return(true)));
-    EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(_, usage_table_header))
+    EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(_, table_header))
         .WillOnce(Return(CdmResponseType(NO_ERROR)));
-    EXPECT_TRUE(usage_table_header_->Init(security_level, crypto_session_));
+    EXPECT_TRUE(usage_table_->Init(security_level, crypto_session_));
   }
 
   void ExpectToDeleteUsageTableFiles() {
@@ -594,22 +590,21 @@ class UsageTableHeaderTest : public WvCdmTestBase {
   MockDeviceFiles* device_files_;
   metrics::CryptoMetrics crypto_metrics_;
   MockCryptoSession* crypto_session_;
-  UsageTableHeader* usage_table_header_;
+  CdmUsageTable* usage_table_;
   std::unique_ptr<wvutil::Clock> test_clock_;
 };
 
-TEST_F(UsageTableHeaderTest, InitError) {
+TEST_F(CdmUsageTableTest, InitError) {
   EXPECT_FALSE(
-      usage_table_header_->Init(kSecurityLevelUninitialized, crypto_session_));
-  EXPECT_FALSE(usage_table_header_->Init(kSecurityLevelL2, crypto_session_));
-  EXPECT_FALSE(
-      usage_table_header_->Init(kSecurityLevelUnknown, crypto_session_));
-  EXPECT_FALSE(usage_table_header_->Init(kSecurityLevelL1, nullptr));
-  EXPECT_FALSE(usage_table_header_->Init(kSecurityLevelL2, nullptr));
+      usage_table_->Init(kSecurityLevelUninitialized, crypto_session_));
+  EXPECT_FALSE(usage_table_->Init(kSecurityLevelL2, crypto_session_));
+  EXPECT_FALSE(usage_table_->Init(kSecurityLevelUnknown, crypto_session_));
+  EXPECT_FALSE(usage_table_->Init(kSecurityLevelL1, nullptr));
+  EXPECT_FALSE(usage_table_->Init(kSecurityLevelL2, nullptr));
 }
 
-class UsageTableHeaderInitializationTest
-    : public UsageTableHeaderTest,
+class CdmUsageTableInitializationTest
+    : public CdmUsageTableTest,
       public ::testing::WithParamInterface<CdmSecurityLevel> {
  public:
   static void SetUpTestCase() { InitVectorConstants(); }
@@ -619,7 +614,7 @@ class UsageTableHeaderInitializationTest
   }
 };
 
-TEST_P(UsageTableHeaderInitializationTest, RestoreUsageTable_Success) {
+TEST_P(CdmUsageTableInitializationTest, RestoreUsageTable_Success) {
   const RequestedSecurityLevel security_level = GetSecurityLevel();
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(security_level, NotNull()))
@@ -633,13 +628,12 @@ TEST_P(UsageTableHeaderInitializationTest, RestoreUsageTable_Success) {
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(CdmResponseType(NO_ERROR)));
-  EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
+  EXPECT_TRUE(usage_table_->Init(GetParam(), crypto_session_));
 }
 
 // First attempt at initializing the table succeeds, however, attempting
 // to reinitialize the usage table should result in a failure.
-TEST_P(UsageTableHeaderInitializationTest,
-       RestoreUsageTable_FailureDueToReInit) {
+TEST_P(CdmUsageTableInitializationTest, RestoreUsageTable_FailureDueToReInit) {
   const RequestedSecurityLevel security_level = GetSecurityLevel();
 
   // First run, success.
@@ -655,25 +649,25 @@ TEST_P(UsageTableHeaderInitializationTest,
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(CdmResponseType(NO_ERROR)));
-  EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
+  EXPECT_TRUE(usage_table_->Init(GetParam(), crypto_session_));
 
   // Second run, failure.
-  EXPECT_FALSE(usage_table_header_->Init(GetParam(), crypto_session_));
+  EXPECT_FALSE(usage_table_->Init(GetParam(), crypto_session_));
 }
 
 // Table MUST not be initialized before another session has been opened.
-TEST_P(UsageTableHeaderInitializationTest,
+TEST_P(CdmUsageTableInitializationTest,
        RestoreUsageTable_FailureDueToExistingSessions) {
   const RequestedSecurityLevel security_level = GetSecurityLevel();
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(security_level, NotNull()))
       .WillRepeatedly(
           DoAll(SetArgPointee<1>(1), Return(CdmResponseType(NO_ERROR))));
-  EXPECT_FALSE(usage_table_header_->Init(GetParam(), crypto_session_));
+  EXPECT_FALSE(usage_table_->Init(GetParam(), crypto_session_));
 }
 
 // No existing usage table in storage, creating a new table succeeds.
-TEST_P(UsageTableHeaderInitializationTest,
+TEST_P(CdmUsageTableInitializationTest,
        RestoreUsageTable_CreateNew_AfterRetrieveFails) {
   const RequestedSecurityLevel security_level = GetSecurityLevel();
 
@@ -700,12 +694,12 @@ TEST_P(UsageTableHeaderInitializationTest,
                                                   kEmptyUsageEntryInfoVector))
       .WillOnce(Return(true));
 
-  EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
+  EXPECT_TRUE(usage_table_->Init(GetParam(), crypto_session_));
 }
 
 // A table exists in storage, but it cannot be loaded due to generation
 // skew.  Creating a new table succeeds.
-TEST_P(UsageTableHeaderInitializationTest,
+TEST_P(CdmUsageTableInitializationTest,
        RestoreUsageTable_CreateNew_AfterLoadFails) {
   const RequestedSecurityLevel security_level = GetSecurityLevel();
 
@@ -738,12 +732,12 @@ TEST_P(UsageTableHeaderInitializationTest,
                                                   kEmptyUsageEntryInfoVector))
       .WillOnce(Return(true));
 
-  EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
+  EXPECT_TRUE(usage_table_->Init(GetParam(), crypto_session_));
 }
 
 // No existing table in storage, and attempting to create a new usage
 // table fails for unknown reason.  Initialization MUST fail.
-TEST_P(UsageTableHeaderInitializationTest,
+TEST_P(CdmUsageTableInitializationTest,
        RestoreUsageTable_CreateNew_CreateFails) {
   const RequestedSecurityLevel security_level = GetSecurityLevel();
   // Expectations for restore:
@@ -762,13 +756,13 @@ TEST_P(UsageTableHeaderInitializationTest,
               CreateUsageTableHeader(security_level, NotNull()))
       .WillOnce(Return(CdmResponseType(CREATE_USAGE_TABLE_ERROR)));
 
-  EXPECT_FALSE(usage_table_header_->Init(GetParam(), crypto_session_));
+  EXPECT_FALSE(usage_table_->Init(GetParam(), crypto_session_));
 }
 
 // No existing table in storage, attempting to create a new usage
 // table succeeds; however, storing the new table header fails.
 // Initialization MUST fail.
-TEST_P(UsageTableHeaderInitializationTest,
+TEST_P(CdmUsageTableInitializationTest,
        RestoreUsageTable_CreateNew_StoreFails) {
   const RequestedSecurityLevel security_level = GetSecurityLevel();
   // Expectations for restore:
@@ -791,12 +785,12 @@ TEST_P(UsageTableHeaderInitializationTest,
   EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader,
                                                   kEmptyUsageEntryInfoVector))
       .WillOnce(Return(false));
-  EXPECT_FALSE(usage_table_header_->Init(GetParam(), crypto_session_));
+  EXPECT_FALSE(usage_table_->Init(GetParam(), crypto_session_));
 }
 
 // Restoring table succeeds, and the current table is at capacity.
 // No special action needs to be taken.
-TEST_P(UsageTableHeaderInitializationTest, RestoreUsageTable_AtCapacity) {
+TEST_P(CdmUsageTableInitializationTest, RestoreUsageTable_AtCapacity) {
   std::vector<CdmUsageEntryInfo> usage_entries = kOverFullUsageEntryInfoVector;
   usage_entries.resize(kDefaultTableCapacity);
   const RequestedSecurityLevel security_level = GetSecurityLevel();
@@ -815,13 +809,13 @@ TEST_P(UsageTableHeaderInitializationTest, RestoreUsageTable_AtCapacity) {
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(CdmResponseType(NO_ERROR)));
-  EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
+  EXPECT_TRUE(usage_table_->Init(GetParam(), crypto_session_));
 }
 
 // Restoring table succeeds, OEMCrypto does not specify an absolute
 // capacity, existing table is under the minimum required capacity.
 // No special action needs to be taken.
-TEST_P(UsageTableHeaderInitializationTest,
+TEST_P(CdmUsageTableInitializationTest,
        RestoreUsageTable_NoCapacity_UnderMinimum) {
   crypto_session_->SetMaximumUsageTableEntries(0);  // Unlimited.
   std::vector<CdmUsageEntryInfo> usage_entries = kOverFullUsageEntryInfoVector;
@@ -844,14 +838,14 @@ TEST_P(UsageTableHeaderInitializationTest,
               LoadUsageTableHeader(security_level, kUsageTableHeader))
       .WillOnce(Return(CdmResponseType(NO_ERROR)));
 
-  EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
+  EXPECT_TRUE(usage_table_->Init(GetParam(), crypto_session_));
 }
 
 // Restoring table succeeds, OEMCrypto does not specify an absolute
 // capacity, existing table is above the minimum required capacity.
 // After restoring, the header class must check that new entries can
 // be added.  This capacity check succeeds.
-TEST_P(UsageTableHeaderInitializationTest,
+TEST_P(CdmUsageTableInitializationTest,
        RestoreUsageTable_NoCapacity_AboveMinimum) {
   crypto_session_->SetMaximumUsageTableEntries(0);  // Unlimited.
   ASSERT_LT(kDefaultTableCapacity, kOverFullUsageEntryInfoVector.size());
@@ -885,9 +879,9 @@ TEST_P(UsageTableHeaderInitializationTest,
   //  7) Table state is stored
   EXPECT_CALL(*crypto_session_, Open(security_level))
       .WillOnce(Return(CdmResponseType(NO_ERROR)));
-  const uint32_t expect_usage_entry_number = table_start_size;
+  const uint32_t expect_entry_index = table_start_size;
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(expect_usage_entry_number),
+      .WillOnce(DoAll(SetArgPointee<0>(expect_entry_index),
                       Return(CdmResponseType(NO_ERROR))));
   EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader),
@@ -904,7 +898,7 @@ TEST_P(UsageTableHeaderInitializationTest,
                                                   SizeIs(table_start_size)))
       .WillOnce(Return(true));
 
-  EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
+  EXPECT_TRUE(usage_table_->Init(GetParam(), crypto_session_));
 }
 
 // Restoring table succeeds, OEMCrypto does not specify an absolute
@@ -912,7 +906,7 @@ TEST_P(UsageTableHeaderInitializationTest,
 // After restoring, the header class must check that new entries can
 // be added.  This capacity check fails due to adding an entry.
 // The result is a new usage table.
-TEST_P(UsageTableHeaderInitializationTest,
+TEST_P(CdmUsageTableInitializationTest,
        RestoreUsageTable_AboveCapacity_AddEntryFails) {
   ASSERT_LT(kDefaultTableCapacity, kOverFullUsageEntryInfoVector.size());
   const RequestedSecurityLevel security_level = GetSecurityLevel();
@@ -954,7 +948,7 @@ TEST_P(UsageTableHeaderInitializationTest,
                                                   kEmptyUsageEntryInfoVector))
       .WillOnce(Return(true));
 
-  EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
+  EXPECT_TRUE(usage_table_->Init(GetParam(), crypto_session_));
 }
 
 // Restoring table succeeds, OEMCrypto does not specify an absolute
@@ -962,7 +956,7 @@ TEST_P(UsageTableHeaderInitializationTest,
 // After restoring, the header class must check that new entries can
 // be added.  This capacity check fails due to invalidating an entry.
 // The result is a new usage table.
-TEST_P(UsageTableHeaderInitializationTest,
+TEST_P(CdmUsageTableInitializationTest,
        RestoreUsageTable_NoCapacity_AboveMinimum_InvalidateEntryFails) {
   crypto_session_->SetMaximumUsageTableEntries(0);  // Unlimited.
   ASSERT_LT(kDefaultTableCapacity, kOverFullUsageEntryInfoVector.size());
@@ -995,9 +989,9 @@ TEST_P(UsageTableHeaderInitializationTest,
   //  6) Shrinking table fails
   EXPECT_CALL(*crypto_session_, Open(security_level))
       .WillOnce(Return(CdmResponseType(NO_ERROR)));
-  const uint32_t expect_usage_entry_number = table_start_size;
+  const UsageEntryIndex expect_entry_index = table_start_size;
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(expect_usage_entry_number),
+      .WillOnce(DoAll(SetArgPointee<0>(expect_entry_index),
                       Return(CdmResponseType(NO_ERROR))));
   EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader),
@@ -1026,47 +1020,47 @@ TEST_P(UsageTableHeaderInitializationTest,
                                                   kEmptyUsageEntryInfoVector))
       .WillOnce(Return(true));
 
-  EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
+  EXPECT_TRUE(usage_table_->Init(GetParam(), crypto_session_));
 }
 
-INSTANTIATE_TEST_SUITE_P(Cdm, UsageTableHeaderInitializationTest,
+INSTANTIATE_TEST_SUITE_P(Cdm, CdmUsageTableInitializationTest,
                          ::testing::Values(kSecurityLevelL1, kSecurityLevelL3));
 
-TEST_F(UsageTableHeaderTest, AddEntry_CreateUsageEntryFailed_UnknownError) {
+TEST_F(CdmUsageTableTest, AddEntry_CreateUsageEntryFailed_UnknownError) {
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  const uint32_t expect_usage_entry_number =
-      static_cast<uint32_t>(kUsageEntryInfoVector.size());
+  const UsageEntryIndex expect_entry_index =
+      static_cast<UsageEntryIndex>(kUsageEntryInfoVector.size());
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
       .WillOnce(
-          DoAll(SetArgPointee<0>(expect_usage_entry_number),
+          DoAll(SetArgPointee<0>(expect_entry_index),
                 Return(CdmResponseType(CREATE_USAGE_ENTRY_UNKNOWN_ERROR))));
 
-  uint32_t usage_entry_number = 0;
+  UsageEntryIndex entry_index = 0;
   EXPECT_NE(NO_ERROR,
-            usage_table_header_->AddEntry(
+            usage_table_->AddEntry(
                 crypto_session_,
                 kUsageEntryInfoOfflineLicense1.storage_type == kStorageLicense,
                 kUsageEntryInfoOfflineLicense1.key_set_id,
                 kUsageEntryInfoOfflineLicense1.usage_info_file_name,
-                kEmptyString /* license */, &usage_entry_number));
+                kEmptyString /* license */, &entry_index));
 }
 
-TEST_F(UsageTableHeaderTest, AddEntry_UsageEntryTooSmall) {
+TEST_F(CdmUsageTableTest, AddEntry_UsageEntryTooSmall) {
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  const uint32_t expect_usage_entry_number =
-      static_cast<uint32_t>(kUsageEntryInfoVector.size()) - 1;
+  const UsageEntryIndex expect_entry_index =
+      static_cast<UsageEntryIndex>(kUsageEntryInfoVector.size()) - 1;
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(expect_usage_entry_number),
+      .WillOnce(DoAll(SetArgPointee<0>(expect_entry_index),
                       Return(CdmResponseType(NO_ERROR))));
 
-  uint32_t usage_entry_number = 0;
+  UsageEntryIndex entry_index = 0;
   EXPECT_NE(NO_ERROR,
-            usage_table_header_->AddEntry(
+            usage_table_->AddEntry(
                 crypto_session_,
                 kUsageEntryInfoOfflineLicense1.storage_type == kStorageLicense,
                 kUsageEntryInfoOfflineLicense1.key_set_id,
                 kUsageEntryInfoOfflineLicense1.usage_info_file_name,
-                kEmptyString /* license */, &usage_entry_number));
+                kEmptyString /* license */, &entry_index));
 }
 
 // Initial Test state:
@@ -1091,45 +1085,42 @@ TEST_F(UsageTableHeaderTest, AddEntry_UsageEntryTooSmall) {
 // DNE = Does Not Exist
 //
 // # of usage entries           3          3
-TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveOfflineUsageEntry) {
+TEST_F(CdmUsageTableTest, AddEntry_NextConsecutiveOfflineUsageEntry) {
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  const uint32_t initial_usage_entry_number =
-      static_cast<uint32_t>(kUsageEntryInfoVector.size());
-  const uint32_t final_usage_entry_number =
-      static_cast<uint32_t>(kUsageEntryInfoVector.size()) - 1;
-  std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector =
-      kUsageEntryInfoVector;
-  expect_usage_entry_info_vector[final_usage_entry_number] =
-      kUsageEntryInfoOfflineLicense2;
+  const UsageEntryIndex initial_entry_index =
+      static_cast<UsageEntryIndex>(kUsageEntryInfoVector.size());
+  const UsageEntryIndex final_entry_index =
+      static_cast<UsageEntryIndex>(kUsageEntryInfoVector.size()) - 1;
+  std::vector<CdmUsageEntryInfo> expect_entry_info_list = kUsageEntryInfoVector;
+  expect_entry_info_list[final_entry_index] = kUsageEntryInfoOfflineLicense2;
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(initial_usage_entry_number),
+      .WillOnce(DoAll(SetArgPointee<0>(initial_entry_index),
                       Return(CdmResponseType(NO_ERROR))));
-  EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_usage_entry_number))
+  EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_entry_index))
       .WillOnce(Return(CdmResponseType(NO_ERROR)));
-  EXPECT_CALL(*crypto_session_,
-              ShrinkUsageTableHeader(
-                  kLevelDefault,
-                  static_cast<uint32_t>(expect_usage_entry_info_vector.size()),
-                  NotNull()))
+  EXPECT_CALL(
+      *crypto_session_,
+      ShrinkUsageTableHeader(
+          kLevelDefault, static_cast<uint32_t>(expect_entry_info_list.size()),
+          NotNull()))
       .WillOnce(DoAll(SetArgPointee<2>(kAnotherUsageTableHeader),
                       Return(CdmResponseType(NO_ERROR))));
   EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kYetAnotherUsageTableHeader),
                       Return(CdmResponseType(NO_ERROR))));
-  EXPECT_CALL(*device_files_,
-              StoreUsageTableInfo(kYetAnotherUsageTableHeader,
-                                  expect_usage_entry_info_vector))
+  EXPECT_CALL(*device_files_, StoreUsageTableInfo(kYetAnotherUsageTableHeader,
+                                                  expect_entry_info_list))
       .WillOnce(Return(true));
 
-  uint32_t usage_entry_number = 0;
+  UsageEntryIndex entry_index = 0;
   EXPECT_EQ(NO_ERROR,
-            usage_table_header_->AddEntry(
+            usage_table_->AddEntry(
                 crypto_session_,
                 kUsageEntryInfoOfflineLicense2.storage_type == kStorageLicense,
                 kUsageEntryInfoOfflineLicense2.key_set_id,
                 kUsageEntryInfoOfflineLicense2.usage_info_file_name,
-                kEmptyString /* license */, &usage_entry_number));
-  EXPECT_EQ(final_usage_entry_number, usage_entry_number);
+                kEmptyString /* license */, &entry_index));
+  EXPECT_EQ(final_entry_index, entry_index);
 }
 
 // Initial Test state:
@@ -1154,46 +1145,43 @@ TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveOfflineUsageEntry) {
 // DNE = Does Not Exist
 //
 // # of usage entries           3          3
-TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveSecureStopUsageEntry) {
+TEST_F(CdmUsageTableTest, AddEntry_NextConsecutiveSecureStopUsageEntry) {
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  const uint32_t initial_usage_entry_number =
-      static_cast<uint32_t>(kUsageEntryInfoVector.size());
-  const uint32_t final_usage_entry_number =
-      static_cast<uint32_t>(kUsageEntryInfoVector.size()) - 1;
-  std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector =
-      kUsageEntryInfoVector;
-  expect_usage_entry_info_vector[final_usage_entry_number] =
-      kUsageEntryInfoSecureStop2;
+  const UsageEntryIndex initial_entry_index =
+      static_cast<UsageEntryIndex>(kUsageEntryInfoVector.size());
+  const UsageEntryIndex final_entry_index =
+      static_cast<UsageEntryIndex>(kUsageEntryInfoVector.size()) - 1;
+  std::vector<CdmUsageEntryInfo> expect_entry_info_list = kUsageEntryInfoVector;
+  expect_entry_info_list[final_entry_index] = kUsageEntryInfoSecureStop2;
 
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(initial_usage_entry_number),
+      .WillOnce(DoAll(SetArgPointee<0>(initial_entry_index),
                       Return(CdmResponseType(NO_ERROR))));
-  EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_usage_entry_number))
+  EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_entry_index))
       .WillOnce(Return(CdmResponseType(NO_ERROR)));
-  EXPECT_CALL(*crypto_session_,
-              ShrinkUsageTableHeader(
-                  kLevelDefault,
-                  static_cast<uint32_t>(expect_usage_entry_info_vector.size()),
-                  NotNull()))
+  EXPECT_CALL(
+      *crypto_session_,
+      ShrinkUsageTableHeader(
+          kLevelDefault, static_cast<uint32_t>(expect_entry_info_list.size()),
+          NotNull()))
       .WillOnce(DoAll(SetArgPointee<2>(kAnotherUsageTableHeader),
                       Return(CdmResponseType(NO_ERROR))));
   EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kYetAnotherUsageTableHeader),
                       Return(CdmResponseType(NO_ERROR))));
-  EXPECT_CALL(*device_files_,
-              StoreUsageTableInfo(kYetAnotherUsageTableHeader,
-                                  expect_usage_entry_info_vector))
+  EXPECT_CALL(*device_files_, StoreUsageTableInfo(kYetAnotherUsageTableHeader,
+                                                  expect_entry_info_list))
       .WillOnce(Return(true));
 
-  uint32_t usage_entry_number = 0;
+  UsageEntryIndex entry_index = 0;
   EXPECT_EQ(NO_ERROR,
-            usage_table_header_->AddEntry(
+            usage_table_->AddEntry(
                 crypto_session_,
                 kUsageEntryInfoSecureStop2.storage_type == kStorageLicense,
                 kUsageEntryInfoSecureStop2.key_set_id,
                 kUsageEntryInfoSecureStop2.usage_info_file_name,
-                kEmptyString /* license */, &usage_entry_number));
-  EXPECT_EQ(final_usage_entry_number, usage_entry_number);
+                kEmptyString /* license */, &entry_index));
+  EXPECT_EQ(final_entry_index, entry_index);
 }
 
 // Initial Test state:
@@ -1224,49 +1212,46 @@ TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveSecureStopUsageEntry) {
 // DNE = Does Not Exist
 //
 // # of usage entries           3          3
-TEST_F(UsageTableHeaderTest, AddEntry_SkipUsageEntries) {
+TEST_F(CdmUsageTableTest, AddEntry_SkipUsageEntries) {
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  const uint32_t next_usage_entry_number =
-      static_cast<uint32_t>(kUsageEntryInfoVector.size());
+  const UsageEntryIndex next_entry_index =
+      static_cast<UsageEntryIndex>(kUsageEntryInfoVector.size());
   const size_t skip_usage_entries = 3;
-  const uint32_t initial_usage_entry_number =
-      next_usage_entry_number + skip_usage_entries;
-  const uint32_t final_usage_entry_number =
-      static_cast<uint32_t>(kUsageEntryInfoVector.size()) - 1;
-  std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector =
-      kUsageEntryInfoVector;
-  expect_usage_entry_info_vector[final_usage_entry_number] =
-      kUsageEntryInfoSecureStop2;
+  const UsageEntryIndex initial_entry_index =
+      next_entry_index + skip_usage_entries;
+  const UsageEntryIndex final_entry_index =
+      static_cast<UsageEntryIndex>(kUsageEntryInfoVector.size()) - 1;
+  std::vector<CdmUsageEntryInfo> expect_entry_info_list = kUsageEntryInfoVector;
+  expect_entry_info_list[final_entry_index] = kUsageEntryInfoSecureStop2;
 
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(initial_usage_entry_number),
+      .WillOnce(DoAll(SetArgPointee<0>(initial_entry_index),
                       Return(CdmResponseType(NO_ERROR))));
-  EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_usage_entry_number))
+  EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_entry_index))
       .WillOnce(Return(CdmResponseType(NO_ERROR)));
-  EXPECT_CALL(*crypto_session_,
-              ShrinkUsageTableHeader(
-                  kLevelDefault,
-                  static_cast<uint32_t>(expect_usage_entry_info_vector.size()),
-                  NotNull()))
+  EXPECT_CALL(
+      *crypto_session_,
+      ShrinkUsageTableHeader(
+          kLevelDefault, static_cast<uint32_t>(expect_entry_info_list.size()),
+          NotNull()))
       .WillOnce(DoAll(SetArgPointee<2>(kAnotherUsageTableHeader),
                       Return(CdmResponseType(NO_ERROR))));
   EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kYetAnotherUsageTableHeader),
                       Return(CdmResponseType(NO_ERROR))));
-  EXPECT_CALL(*device_files_,
-              StoreUsageTableInfo(kYetAnotherUsageTableHeader,
-                                  expect_usage_entry_info_vector))
+  EXPECT_CALL(*device_files_, StoreUsageTableInfo(kYetAnotherUsageTableHeader,
+                                                  expect_entry_info_list))
       .WillOnce(Return(true));
 
-  uint32_t usage_entry_number = 0;
+  UsageEntryIndex entry_index = 0;
   EXPECT_EQ(NO_ERROR,
-            usage_table_header_->AddEntry(
+            usage_table_->AddEntry(
                 crypto_session_,
                 kUsageEntryInfoSecureStop2.storage_type == kStorageLicense,
                 kUsageEntryInfoSecureStop2.key_set_id,
                 kUsageEntryInfoSecureStop2.usage_info_file_name,
-                kEmptyString /* license */, &usage_entry_number));
-  EXPECT_EQ(final_usage_entry_number, usage_entry_number);
+                kEmptyString /* license */, &entry_index));
+  EXPECT_EQ(final_entry_index, entry_index);
 }
 
 // Initial Test state:
@@ -1291,38 +1276,36 @@ TEST_F(UsageTableHeaderTest, AddEntry_SkipUsageEntries) {
 // DNE = Does Not Exist
 //
 // # of usage entries           3          4
-TEST_F(UsageTableHeaderTest, AddEntry_CannotMoveNewEntry) {
+TEST_F(CdmUsageTableTest, AddEntry_CannotMoveNewEntry) {
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  const uint32_t final_usage_entry_number =
-      static_cast<uint32_t>(kUsageEntryInfoVector.size());
-  const uint32_t attempted_usage_entry_number =
-      static_cast<uint32_t>(kUsageEntryInfoVector.size()) - 1;
-  std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector =
-      kUsageEntryInfoVector;
-  expect_usage_entry_info_vector.push_back(kUsageEntryInfoSecureStop2);
+  const UsageEntryIndex final_entry_index =
+      static_cast<UsageEntryIndex>(kUsageEntryInfoVector.size());
+  const UsageEntryIndex attempted_entry_index =
+      static_cast<UsageEntryIndex>(kUsageEntryInfoVector.size()) - 1;
+  std::vector<CdmUsageEntryInfo> expect_entry_info_list = kUsageEntryInfoVector;
+  expect_entry_info_list.push_back(kUsageEntryInfoSecureStop2);
 
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(final_usage_entry_number),
+      .WillOnce(DoAll(SetArgPointee<0>(final_entry_index),
                       Return(CdmResponseType(NO_ERROR))));
-  EXPECT_CALL(*crypto_session_, MoveUsageEntry(attempted_usage_entry_number))
+  EXPECT_CALL(*crypto_session_, MoveUsageEntry(attempted_entry_index))
       .WillOnce(Return(CdmResponseType(MOVE_USAGE_ENTRY_DESTINATION_IN_USE)));
   EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader),
                       Return(CdmResponseType(NO_ERROR))));
-  EXPECT_CALL(*device_files_,
-              StoreUsageTableInfo(kAnotherUsageTableHeader,
-                                  expect_usage_entry_info_vector))
+  EXPECT_CALL(*device_files_, StoreUsageTableInfo(kAnotherUsageTableHeader,
+                                                  expect_entry_info_list))
       .WillOnce(Return(true));
 
-  uint32_t usage_entry_number = 0;
+  UsageEntryIndex entry_index = 0;
   EXPECT_EQ(NO_ERROR,
-            usage_table_header_->AddEntry(
+            usage_table_->AddEntry(
                 crypto_session_,
                 kUsageEntryInfoSecureStop2.storage_type == kStorageLicense,
                 kUsageEntryInfoSecureStop2.key_set_id,
                 kUsageEntryInfoSecureStop2.usage_info_file_name,
-                kEmptyString /* license */, &usage_entry_number));
-  EXPECT_EQ(final_usage_entry_number, usage_entry_number);
+                kEmptyString /* license */, &entry_index));
+  EXPECT_EQ(final_entry_index, entry_index);
 }
 
 // Initial Test state:
@@ -1348,48 +1331,44 @@ TEST_F(UsageTableHeaderTest, AddEntry_CannotMoveNewEntry) {
 // DNE = Does Not Exist
 //
 // # of usage entries           3          4
-TEST_F(UsageTableHeaderTest, AddEntry_CannotShinkAfterMove) {
+TEST_F(CdmUsageTableTest, AddEntry_CannotShinkAfterMove) {
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  const uint32_t initial_usage_entry_number =
-      static_cast<uint32_t>(kUsageEntryInfoVector.size());
-  const uint32_t final_usage_entry_number =
-      static_cast<uint32_t>(kUsageEntryInfoVector.size()) - 1;
-  std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector =
-      kUsageEntryInfoVector;
-  expect_usage_entry_info_vector[final_usage_entry_number] =
-      kUsageEntryInfoSecureStop2;
-  expect_usage_entry_info_vector.push_back(kUsageEntryInfoStorageTypeUnknown);
+  const UsageEntryIndex initial_entry_index =
+      static_cast<UsageEntryIndex>(kUsageEntryInfoVector.size());
+  const UsageEntryIndex final_entry_index =
+      static_cast<UsageEntryIndex>(kUsageEntryInfoVector.size()) - 1;
+  std::vector<CdmUsageEntryInfo> expect_entry_info_list = kUsageEntryInfoVector;
+  expect_entry_info_list[final_entry_index] = kUsageEntryInfoSecureStop2;
+  expect_entry_info_list.push_back(kUsageEntryInfoStorageTypeUnknown);
 
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(initial_usage_entry_number),
+      .WillOnce(DoAll(SetArgPointee<0>(initial_entry_index),
                       Return(CdmResponseType(NO_ERROR))));
-  EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_usage_entry_number))
+  EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_entry_index))
       .WillOnce(Return(CdmResponseType(NO_ERROR)));
   EXPECT_CALL(
       *crypto_session_,
       ShrinkUsageTableHeader(
           kLevelDefault,
-          static_cast<uint32_t>(expect_usage_entry_info_vector.size()) - 1,
-          NotNull()))
+          static_cast<uint32_t>(expect_entry_info_list.size()) - 1, NotNull()))
       .WillOnce(
           Return(CdmResponseType(SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE)));
   EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader),
                       Return(CdmResponseType(NO_ERROR))));
-  EXPECT_CALL(*device_files_,
-              StoreUsageTableInfo(kAnotherUsageTableHeader,
-                                  expect_usage_entry_info_vector))
+  EXPECT_CALL(*device_files_, StoreUsageTableInfo(kAnotherUsageTableHeader,
+                                                  expect_entry_info_list))
       .WillOnce(Return(true));
 
-  uint32_t usage_entry_number = 0;
+  UsageEntryIndex entry_index = 0;
   EXPECT_EQ(NO_ERROR,
-            usage_table_header_->AddEntry(
+            usage_table_->AddEntry(
                 crypto_session_,
                 kUsageEntryInfoSecureStop2.storage_type == kStorageLicense,
                 kUsageEntryInfoSecureStop2.key_set_id,
                 kUsageEntryInfoSecureStop2.usage_info_file_name,
-                kEmptyString /* license */, &usage_entry_number));
-  EXPECT_EQ(final_usage_entry_number, usage_entry_number);
+                kEmptyString /* license */, &entry_index));
+  EXPECT_EQ(final_entry_index, entry_index);
 }
 
 // Initial Test state:
@@ -1404,30 +1383,30 @@ TEST_F(UsageTableHeaderTest, AddEntry_CannotShinkAfterMove) {
 // c. Table will be stored
 // d. Second call to OEMCrypto to create an entry will succeed
 // e. Storing the new updated usage table
-TEST_F(UsageTableHeaderTest,
+TEST_F(CdmUsageTableTest,
        AddEntry_CreateUsageEntryFailsOnce_SucceedsSecondTime) {
   // Initialize and setup
-  MockUsageTableHeader* mock_usage_table_header = SetUpMock();
+  MockCdmUsageTable* mock_usage_table = SetUpMock();
   Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector);
-  std::vector<CdmUsageEntryInfo> usage_entry_info_vector_at_start =
+  std::vector<CdmUsageEntryInfo> entry_info_list_at_start =
       k10UsageEntryInfoVector;
 
-  uint32_t invalidated_entry = 0;  // Randomly chosen by UsageTableHeader
+  UsageEntryIndex invalidated_entry = 0;  // Randomly chosen by CdmUsageTable
 
-  const uint32_t expected_usage_entry_number =
-      static_cast<uint32_t>(k10UsageEntryInfoVector.size()) - 1;
+  const UsageEntryIndex expected_entry_index =
+      static_cast<UsageEntryIndex>(k10UsageEntryInfoVector.size()) - 1;
 
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
       // First call fails
       .WillOnce(Return(CdmResponseType(INSUFFICIENT_CRYPTO_RESOURCES)))
       // Second call succeeds
-      .WillOnce(DoAll(SetArgPointee<0>(expected_usage_entry_number),
+      .WillOnce(DoAll(SetArgPointee<0>(expected_entry_index),
                       Return(CdmResponseType(NO_ERROR))));
   // Covers all other expectations.
-  EXPECT_CALL(*mock_usage_table_header,
+  EXPECT_CALL(*mock_usage_table,
               InvalidateEntryInternal(_, true, device_files_, NotNull()))
       .WillOnce(DoAll(SaveArg<0>(&invalidated_entry),
-                      Invoke(this, &UsageTableHeaderTest::InvalidateEntry),
+                      Invoke(this, &CdmUsageTableTest::InvalidateEntry),
                       Return(CdmResponseType(NO_ERROR))));
 
   EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
@@ -1438,17 +1417,17 @@ TEST_F(UsageTableHeaderTest,
       .WillOnce(DoAll(SaveArg<1>(&final_usage_entries), Return(true)));
 
   // Now invoke the method under test
-  uint32_t usage_entry_number = 0;
+  UsageEntryIndex entry_index = 0;
   EXPECT_EQ(NO_ERROR,
-            mock_usage_table_header->SuperAddEntry(
+            mock_usage_table->SuperAddEntry(
                 crypto_session_,
                 kUsageEntryInfoOfflineLicense6.storage_type == kStorageLicense,
                 kUsageEntryInfoOfflineLicense6.key_set_id,
                 kUsageEntryInfoOfflineLicense6.usage_info_file_name,
-                kEmptyString /* license */, &usage_entry_number));
+                kEmptyString /* license */, &entry_index));
 
-  // Verify added/deleted usage entry number and entries
-  EXPECT_EQ(expected_usage_entry_number, usage_entry_number);
+  // Verify added/deleted of usage entry index and entry info.
+  EXPECT_EQ(expected_entry_index, entry_index);
 
   EXPECT_LE(0u, invalidated_entry);
   EXPECT_LE(invalidated_entry, k10UsageEntryInfoVector.size() - 1);
@@ -1464,15 +1443,15 @@ TEST_F(UsageTableHeaderTest,
 
 // The usage table should only delete/invalidate a single entry.
 // After which, it should fail.
-TEST_F(UsageTableHeaderTest, AddEntry_CreateUsageEntryFailsEveryTime) {
+TEST_F(CdmUsageTableTest, AddEntry_CreateUsageEntryFailsEveryTime) {
   // Initialize and setup
-  MockUsageTableHeader* mock_usage_table_header = SetUpMock();
+  MockCdmUsageTable* mock_usage_table = SetUpMock();
   Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector);
 
   // Setup expectations
-  EXPECT_CALL(*mock_usage_table_header,
+  EXPECT_CALL(*mock_usage_table,
               InvalidateEntryInternal(_, true, device_files_, NotNull()))
-      .WillOnce(DoAll(Invoke(this, &UsageTableHeaderTest::InvalidateEntry),
+      .WillOnce(DoAll(Invoke(this, &CdmUsageTableTest::InvalidateEntry),
                       Return(CdmResponseType(NO_ERROR))));
 
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
@@ -1480,19 +1459,19 @@ TEST_F(UsageTableHeaderTest, AddEntry_CreateUsageEntryFailsEveryTime) {
       .WillRepeatedly(Return(CdmResponseType(INSUFFICIENT_CRYPTO_RESOURCES)));
 
   // Now invoke the method under test
-  uint32_t usage_entry_number;
+  UsageEntryIndex entry_index;
   EXPECT_EQ(INSUFFICIENT_CRYPTO_RESOURCES,
-            mock_usage_table_header->SuperAddEntry(
+            mock_usage_table->SuperAddEntry(
                 crypto_session_, true /* persistent */,
                 kUsageEntryInfoOfflineLicense6.key_set_id,
                 kUsageEntryInfoOfflineLicense6.usage_info_file_name,
-                kEmptyString /* license */, &usage_entry_number));
+                kEmptyString /* license */, &entry_index));
 
   // Verify the number of entries deleted.
   constexpr uint32_t kExpectedEntriesDeleted = 1;
 
   const std::vector<CdmUsageEntryInfo>& final_usage_entries =
-      mock_usage_table_header->usage_entry_info();
+      mock_usage_table->entry_info_list();
   uint32_t invalid_entries = 0;
   for (const CdmUsageEntryInfo& usage_entry_info : final_usage_entries) {
     if (usage_entry_info.storage_type == kStorageTypeUnknown) {
@@ -1508,40 +1487,40 @@ TEST_F(UsageTableHeaderTest, AddEntry_CreateUsageEntryFailsEveryTime) {
   EXPECT_EQ(kExpectedEntriesDeleted, entries_deleted);
 }
 
-TEST_F(UsageTableHeaderTest, LoadEntry_InvalidEntryNumber) {
+TEST_F(CdmUsageTableTest, LoadEntry_InvalidEntryNumber) {
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  const uint32_t usage_entry_number =
-      static_cast<uint32_t>(kUsageEntryInfoVector.size()) + 3;
+  const UsageEntryIndex entry_index =
+      static_cast<UsageEntryIndex>(kUsageEntryInfoVector.size()) + 3;
 
-  EXPECT_NE(NO_ERROR, usage_table_header_->LoadEntry(
-                          crypto_session_, kUsageEntry, usage_entry_number));
+  EXPECT_NE(NO_ERROR,
+            usage_table_->LoadEntry(crypto_session_, kUsageEntry, entry_index));
 }
 
-TEST_F(UsageTableHeaderTest, LoadEntry_CryptoSessionError) {
+TEST_F(CdmUsageTableTest, LoadEntry_CryptoSessionError) {
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  const uint32_t usage_entry_number = 1;
+  const UsageEntryIndex entry_index = 1;
 
-  EXPECT_CALL(*crypto_session_, LoadUsageEntry(usage_entry_number, kUsageEntry))
+  EXPECT_CALL(*crypto_session_, LoadUsageEntry(entry_index, kUsageEntry))
       .WillOnce(Return(CdmResponseType(LOAD_USAGE_ENTRY_GENERATION_SKEW)));
 
-  EXPECT_NE(NO_ERROR, usage_table_header_->LoadEntry(
-                          crypto_session_, kUsageEntry, usage_entry_number));
+  EXPECT_NE(NO_ERROR,
+            usage_table_->LoadEntry(crypto_session_, kUsageEntry, entry_index));
 }
 
-TEST_F(UsageTableHeaderTest, LoadEntry) {
+TEST_F(CdmUsageTableTest, LoadEntry) {
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  const uint32_t usage_entry_number = 1;
+  const UsageEntryIndex entry_index = 1;
 
-  EXPECT_CALL(*crypto_session_, LoadUsageEntry(usage_entry_number, kUsageEntry))
+  EXPECT_CALL(*crypto_session_, LoadUsageEntry(entry_index, kUsageEntry))
       .WillOnce(Return(CdmResponseType(NO_ERROR)));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->LoadEntry(
-                          crypto_session_, kUsageEntry, usage_entry_number));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->LoadEntry(crypto_session_, kUsageEntry, entry_index));
 }
 
-TEST_F(UsageTableHeaderTest, UpdateEntry_CryptoSessionError) {
+TEST_F(CdmUsageTableTest, UpdateEntry_CryptoSessionError) {
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  CdmUsageEntry usage_entry;
+  UsageEntry usage_entry;
 
   EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
       .WillOnce(DoAll(
@@ -1549,12 +1528,12 @@ TEST_F(UsageTableHeaderTest, UpdateEntry_CryptoSessionError) {
           Return(CdmResponseType(UPDATE_USAGE_ENTRY_UNKNOWN_ERROR))));
 
   EXPECT_NE(NO_ERROR,
-            usage_table_header_->UpdateEntry(0, crypto_session_, &usage_entry));
+            usage_table_->UpdateEntry(0, crypto_session_, &usage_entry));
 }
 
-TEST_F(UsageTableHeaderTest, UpdateEntry) {
+TEST_F(CdmUsageTableTest, UpdateEntry) {
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  CdmUsageEntry usage_entry;
+  UsageEntry usage_entry;
 
   EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
@@ -1568,17 +1547,17 @@ TEST_F(UsageTableHeaderTest, UpdateEntry) {
       .WillOnce(Return(true));
 
   EXPECT_EQ(NO_ERROR,
-            usage_table_header_->UpdateEntry(0, crypto_session_, &usage_entry));
+            usage_table_->UpdateEntry(0, crypto_session_, &usage_entry));
 }
 
-TEST_F(UsageTableHeaderTest, InvalidateEntry_InvalidUsageEntryNumber) {
+TEST_F(CdmUsageTableTest, InvalidateEntry_InvalidUsageEntryNumber) {
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  const uint32_t usage_entry_number =
-      static_cast<uint32_t>(kUsageEntryInfoVector.size());
+  const UsageEntryIndex entry_index =
+      static_cast<UsageEntryIndex>(kUsageEntryInfoVector.size());
   metrics::CryptoMetrics metrics;
 
-  EXPECT_NE(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number, true, device_files_, &metrics));
+  EXPECT_NE(NO_ERROR, usage_table_->InvalidateEntry(entry_index, true,
+                                                    device_files_, &metrics));
 }
 
 // Initial Test state:
@@ -1605,13 +1584,13 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_InvalidUsageEntryNumber) {
 // Offline License 2            3          3 (Storage Type Unknown)
 //
 // # of usage entries           4          4
-TEST_F(UsageTableHeaderTest, InvalidateEntry_CryptoSessionError) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_CryptoSessionError) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoOfflineLicense1, kUsageEntryInfoSecureStop1,
       kUsageEntryInfoStorageTypeUnknown, kUsageEntryInfoOfflineLicense2};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       3;  // kUsageEntryInfoOfflineLicense2
   metrics::CryptoMetrics metrics;
 
@@ -1631,12 +1610,12 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_CryptoSessionError) {
                                       kUsageEntryInfoStorageTypeUnknown)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check that the list is unchanged.
   constexpr size_t expected_size = 4;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
@@ -1657,13 +1636,13 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_CryptoSessionError) {
 // Offline License 2            3    Deleted
 //
 // # of usage entries           4          2
-TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntry_OfflineEntry) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_LastEntry_OfflineEntry) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoOfflineLicense1, kUsageEntryInfoSecureStop1,
       kUsageEntryInfoStorageTypeUnknown, kUsageEntryInfoOfflineLicense2};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       3;  // kUsageEntryInfoOfflineLicense2
   metrics::CryptoMetrics metrics;
 
@@ -1679,12 +1658,12 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntry_OfflineEntry) {
                                               kUsageEntryInfoSecureStop1)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 2;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
@@ -1705,13 +1684,13 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntry_OfflineEntry) {
 // Secure Stop 2                3    Deleted
 //
 // # of usage entries           4          2
-TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntry_SecureStopEntry) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_LastEntry_SecureStopEntry) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoOfflineLicense1, kUsageEntryInfoSecureStop1,
       kUsageEntryInfoStorageTypeUnknown, kUsageEntryInfoSecureStop2};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       3;  // kUsageEntryInfoSecureStop2
   metrics::CryptoMetrics metrics;
 
@@ -1727,12 +1706,12 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntry_SecureStopEntry) {
                                               kUsageEntryInfoSecureStop1)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 2;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
@@ -1761,15 +1740,15 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntry_SecureStopEntry) {
 // Offline License 3            4    Deleted (because missing)
 //
 // # of usage entries           5          1
-TEST_F(UsageTableHeaderTest,
+TEST_F(CdmUsageTableTest,
        InvalidateEntry_LastOfflineEntriesHaveMissingLicenses) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoSecureStop1, kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoOfflineLicense1, kUsageEntryInfoOfflineLicense2,
       kUsageEntryInfoOfflineLicense3};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoOfflineLicense1
   metrics::CryptoMetrics metrics;
 
@@ -1794,12 +1773,12 @@ TEST_F(UsageTableHeaderTest,
                                   ElementsAre(kUsageEntryInfoSecureStop1)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 1;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
@@ -1828,14 +1807,14 @@ TEST_F(UsageTableHeaderTest,
 // Secure stop 3                4    Deleted (because missing)
 //
 // # of usage entries           5          1
-TEST_F(UsageTableHeaderTest, InvalidateEntry_LastSecureStopEntriesAreMissing) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_LastSecureStopEntriesAreMissing) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoOfflineLicense1, kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoSecureStop1, kUsageEntryInfoSecureStop2,
       kUsageEntryInfoSecureStop3};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoSecureStop1
   metrics::CryptoMetrics metrics;
 
@@ -1864,17 +1843,17 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastSecureStopEntriesAreMissing) {
                                   ElementsAre(kUsageEntryInfoOfflineLicense1)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 1;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
 // 1. Last few entries are offline licenses, but have incorrect usage
-//    entry number stored in persistent file store.
+//    entry index stored in persistent file store.
 // 2. Usage entry to be deleted precedes those in (1).
 //
 // Attempting to delete the entry in (2) will result in:
@@ -1882,7 +1861,7 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastSecureStopEntriesAreMissing) {
 // b. While defragging, the last two entries will be selected to
 //    move.
 // c. Getting the usage entry for the selected entries will fail due
-//    to a mismatch in usage entry number and result in them being set
+//    to a mismatch in usage entry index and result in them being set
 //    as kStorageTypeUnknown.
 // d. No entries will be moved due to (c).
 // e. Usage table will be resized to have only one entry.
@@ -1899,18 +1878,18 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastSecureStopEntriesAreMissing) {
 // Offline License 3            4    Deleted (because incorrect #)
 //
 // # of usage entries           5          1
-TEST_F(UsageTableHeaderTest,
+TEST_F(CdmUsageTableTest,
        InvalidateEntry_LastOfflineEntriesHaveIncorrectUsageEntryNumber) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoSecureStop1, kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoOfflineLicense1, kUsageEntryInfoOfflineLicense2,
       kUsageEntryInfoOfflineLicense3};
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoOfflineLicense1
   metrics::CryptoMetrics metrics;
 
-  // Set offline license file data with mismatched usage entry numbers.
+  // Set offline license file data with mismatched usage entry indexes.
   const DeviceFiles::CdmLicenseData offline_license_3_data{
       kUsageEntryInfoOfflineLicense3.key_set_id,
       kActiveLicenseState,
@@ -1925,7 +1904,7 @@ TEST_F(UsageTableHeaderTest,
       kGracePeriodEndTime,
       kEmptyAppParameters,
       kUsageEntry,
-      static_cast<uint32_t>(3) /* Mismatch */,
+      static_cast<UsageEntryIndex>(3) /* Mismatch */,
       kDrmCertificate,
       kCryptoWrappedKey};
   EXPECT_CALL(*device_files_,
@@ -1947,7 +1926,7 @@ TEST_F(UsageTableHeaderTest,
       kGracePeriodEndTime,
       kEmptyAppParameters,
       kUsageEntry,
-      static_cast<uint32_t>(2) /* Mismatch */,
+      static_cast<UsageEntryIndex>(2) /* Mismatch */,
       kDrmCertificate,
       kCryptoWrappedKey};
   EXPECT_CALL(*device_files_,
@@ -1965,17 +1944,17 @@ TEST_F(UsageTableHeaderTest,
                                   ElementsAre(kUsageEntryInfoSecureStop1)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 1;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
 // 1. Last few entries are secure stops, but have incorrect usage
-//    entry number stored in persistent file store.
+//    entry index stored in persistent file store.
 // 2. Usage entry to be deleted precedes those in (1).
 //
 // Attempting to delete the entry in (2) will result in:
@@ -1983,7 +1962,7 @@ TEST_F(UsageTableHeaderTest,
 // b. While defragging, the last two entries will be selected to
 //    move.
 // c. Getting the usage entry for the selected entries will fail due
-//    to a mismatch in usage entry number and result in them being set
+//    to a mismatch in usage entry index and result in them being set
 //    as kStorageTypeUnknown.
 // d. No entries will be moved due to (c).
 // e. Usage table will be resized to have only one entry.
@@ -2000,19 +1979,19 @@ TEST_F(UsageTableHeaderTest,
 // Secure stop 3                4    Deleted (because incorrect #)
 //
 // # of usage entries           5          1
-TEST_F(UsageTableHeaderTest,
+TEST_F(CdmUsageTableTest,
        InvalidateEntry_LastSecureStopEntriesHaveIncorrectUsageEntryNumber) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoOfflineLicense1, kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoSecureStop1, kUsageEntryInfoSecureStop2,
       kUsageEntryInfoSecureStop3};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoSecureStop1
   metrics::CryptoMetrics metrics;
 
-  // Set streaming license file data with mismatched usage entry numbers.
+  // Set streaming license file data with mismatched usage entry indexes.
   EXPECT_CALL(*device_files_,
               RetrieveUsageInfoByKeySetId(
                   kUsageEntryInfoSecureStop2.usage_info_file_name,
@@ -2048,12 +2027,12 @@ TEST_F(UsageTableHeaderTest,
                                   ElementsAre(kUsageEntryInfoOfflineLicense1)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 1;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
@@ -2085,15 +2064,15 @@ TEST_F(UsageTableHeaderTest,
 // Storage Type Unknown         6    Deleted
 //
 // # of usage entries           7          3
-TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntriesAreStorageTypeUnknown) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_LastEntriesAreStorageTypeUnknown) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoSecureStop1,       kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoOfflineLicense1,   kUsageEntryInfoOfflineLicense2,
       kUsageEntryInfoOfflineLicense3,   kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoStorageTypeUnknown};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       4;  // kUsageEntryInfoOfflineLicense3
   metrics::CryptoMetrics metrics;
 
@@ -2112,7 +2091,7 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntriesAreStorageTypeUnknown) {
       kGracePeriodEndTime,
       kEmptyAppParameters,
       kUsageEntry,
-      static_cast<uint32_t>(3),
+      static_cast<UsageEntryIndex>(3),
       kDrmCertificate,
       kCryptoWrappedKey};
   EXPECT_CALL(*device_files_,
@@ -2150,12 +2129,12 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntriesAreStorageTypeUnknown) {
                                               kUsageEntryInfoOfflineLicense1)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 3;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
@@ -2185,15 +2164,15 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntriesAreStorageTypeUnknown) {
 // Offline License 3            4          4
 //
 // # of usage entries           5          5
-TEST_F(UsageTableHeaderTest,
+TEST_F(CdmUsageTableTest,
        InvalidateEntry_LastEntryIsOffline_MoveOfflineEntryFailed) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoSecureStop1, kUsageEntryInfoSecureStop2,
       kUsageEntryInfoOfflineLicense1, kUsageEntryInfoOfflineLicense2,
       kUsageEntryInfoOfflineLicense3};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoOfflineLicense1
   metrics::CryptoMetrics metrics;
 
@@ -2213,7 +2192,7 @@ TEST_F(UsageTableHeaderTest,
       kGracePeriodEndTime,
       kEmptyAppParameters,
       kUsageEntry,
-      /* usage_entry_number = */ 4,
+      /* usage_entry_index = */ 4,
       kDrmCertificate,
       kCryptoWrappedKey};
   EXPECT_CALL(*device_files_,
@@ -2240,12 +2219,12 @@ TEST_F(UsageTableHeaderTest,
                                               kUsageEntryInfoOfflineLicense3)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check that the table has been updated as expected.
   constexpr size_t expected_size = 5;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
@@ -2274,15 +2253,15 @@ TEST_F(UsageTableHeaderTest,
 // Secure Stop 3                4          4
 //
 // # of usage entries           5          5
-TEST_F(UsageTableHeaderTest,
+TEST_F(CdmUsageTableTest,
        InvalidateEntry_LastEntryIsSecureStop_MoveSecureStopEntryFailed) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoOfflineLicense1, kUsageEntryInfoOfflineLicense2,
       kUsageEntryInfoSecureStop1, kUsageEntryInfoSecureStop2,
       kUsageEntryInfoSecureStop3};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoSecureStop1
   metrics::CryptoMetrics metrics;
 
@@ -2319,11 +2298,11 @@ TEST_F(UsageTableHeaderTest,
                                               kUsageEntryInfoSecureStop3)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   constexpr size_t expected_size = 5;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
@@ -2356,16 +2335,16 @@ TEST_F(UsageTableHeaderTest,
 // Storage Type Unknown         6    Deleted
 //
 // # of usage entries           7          5
-TEST_F(UsageTableHeaderTest,
+TEST_F(CdmUsageTableTest,
        InvalidateEntry_LastEntriesAreOfflineAndUnknown_MoveOfflineEntryFailed) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoSecureStop1,       kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoOfflineLicense1,   kUsageEntryInfoOfflineLicense2,
       kUsageEntryInfoOfflineLicense3,   kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoStorageTypeUnknown};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoOfflineLicense1
   metrics::CryptoMetrics metrics;
 
@@ -2443,12 +2422,12 @@ TEST_F(UsageTableHeaderTest,
                                               kUsageEntryInfoOfflineLicense3)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 5;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
@@ -2482,16 +2461,16 @@ TEST_F(UsageTableHeaderTest,
 //
 // # of usage entries           7          5
 TEST_F(
-    UsageTableHeaderTest,
+    CdmUsageTableTest,
     InvalidateEntry_LastEntriesAreSecureStopAndUnknown_MoveOfflineEntryFailed) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoOfflineLicense1,   kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoSecureStop1,       kUsageEntryInfoSecureStop2,
       kUsageEntryInfoSecureStop3,       kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoStorageTypeUnknown};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoSecureStop1
   metrics::CryptoMetrics metrics;
 
@@ -2549,12 +2528,12 @@ TEST_F(
                                               kUsageEntryInfoSecureStop3)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 5;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
@@ -2580,14 +2559,14 @@ TEST_F(
 // Offline License 3            4          1 (moved)
 //
 // # of usage entries           5          3
-TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntryIsOffline) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_LastEntryIsOffline) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoSecureStop1, kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoOfflineLicense1, kUsageEntryInfoOfflineLicense2,
       kUsageEntryInfoOfflineLicense3};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoOfflineLicense1
   metrics::CryptoMetrics metrics;
 
@@ -2606,7 +2585,7 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntryIsOffline) {
       kGracePeriodEndTime,
       kEmptyAppParameters,
       kUsageEntry,
-      static_cast<uint32_t>(4),
+      static_cast<UsageEntryIndex>(4),
       kDrmCertificate,
       kCryptoWrappedKey};
   EXPECT_CALL(*device_files_,
@@ -2635,7 +2614,7 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntryIsOffline) {
       kGracePeriodEndTime,
       kEmptyAppParameters,
       kUsageEntry,
-      static_cast<uint32_t>(3),
+      static_cast<UsageEntryIndex>(3),
       kDrmCertificate,
       kCryptoWrappedKey};
   EXPECT_CALL(*device_files_,
@@ -2677,12 +2656,12 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntryIsOffline) {
                                               kUsageEntryInfoOfflineLicense2)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 3;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
@@ -2708,14 +2687,14 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntryIsOffline) {
 // Secure stop 3                4          1 (moved)
 //
 // # of usage entries           5          3
-TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntryIsSecureStop) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_LastEntryIsSecureStop) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoOfflineLicense1, kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoSecureStop1, kUsageEntryInfoSecureStop2,
       kUsageEntryInfoSecureStop3};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoSecureStop1
   metrics::CryptoMetrics metrics;
 
@@ -2796,12 +2775,12 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntryIsSecureStop) {
                                               kUsageEntryInfoSecureStop2)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 3;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
@@ -2830,16 +2809,15 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntryIsSecureStop) {
 // Storage Type Unknown         6    Deleted
 //
 // # of usage entries           7          4
-TEST_F(UsageTableHeaderTest,
-       InvalidateEntry_LastEntriesAreOfflineAndUnknknown) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_LastEntriesAreOfflineAndUnknknown) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoSecureStop1,       kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoOfflineLicense1,   kUsageEntryInfoOfflineLicense2,
       kUsageEntryInfoOfflineLicense3,   kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoStorageTypeUnknown};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoOfflineLicense1
   metrics::CryptoMetrics metrics;
 
@@ -2858,7 +2836,7 @@ TEST_F(UsageTableHeaderTest,
       kGracePeriodEndTime,
       kEmptyAppParameters,
       kUsageEntry,
-      static_cast<uint32_t>(4),
+      static_cast<UsageEntryIndex>(4),
       kDrmCertificate,
       kCryptoWrappedKey};
   EXPECT_CALL(*device_files_,
@@ -2887,7 +2865,7 @@ TEST_F(UsageTableHeaderTest,
       kGracePeriodEndTime,
       kEmptyAppParameters,
       kUsageEntry,
-      static_cast<uint32_t>(3),
+      static_cast<UsageEntryIndex>(3),
       kDrmCertificate,
       kCryptoWrappedKey};
   EXPECT_CALL(*device_files_,
@@ -2929,12 +2907,12 @@ TEST_F(UsageTableHeaderTest,
                                               kUsageEntryInfoOfflineLicense2)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 3;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
@@ -2962,16 +2940,16 @@ TEST_F(UsageTableHeaderTest,
 // Storage Type unknown         6    Deleted
 //
 // # of usage entries           7          3
-TEST_F(UsageTableHeaderTest,
+TEST_F(CdmUsageTableTest,
        InvalidateEntry_LastEntriesAreSecureStopAndUnknknown) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoOfflineLicense1,   kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoSecureStop1,       kUsageEntryInfoSecureStop2,
       kUsageEntryInfoSecureStop3,       kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoStorageTypeUnknown};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoSecureStop1
   metrics::CryptoMetrics metrics;
 
@@ -3053,12 +3031,12 @@ TEST_F(UsageTableHeaderTest,
                                               kUsageEntryInfoSecureStop2)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 3;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // Initial Test state:
@@ -3084,15 +3062,15 @@ TEST_F(UsageTableHeaderTest,
 // Storage Type Unknown         6    Deleted
 //
 // # of usage entries           7          0
-TEST_F(UsageTableHeaderTest, InvalidateEntry_NoValidSessionsAfter) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_NoValidSessionsAfter) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoStorageTypeUnknown, kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoStorageTypeUnknown, kUsageEntryInfoSecureStop1,
       kUsageEntryInfoStorageTypeUnknown, kUsageEntryInfoStorageTypeUnknown,
       kUsageEntryInfoStorageTypeUnknown};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       3;  // kUsageEntryInfoSecureStop1
   metrics::CryptoMetrics metrics;
 
@@ -3106,10 +3084,10 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_NoValidSessionsAfter) {
                                                   kEmptyUsageEntryInfoVector))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
-  EXPECT_TRUE(usage_table_header_->usage_entry_info().empty());
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
+  EXPECT_TRUE(usage_table_->entry_info_list().empty());
 }
 
 // 1. Usage entry to be deleted is last valid entry (Secure stop 1)
@@ -3135,13 +3113,13 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_NoValidSessionsAfter) {
 // Storage Type Unknown         3    Deleted
 //
 // # of usage entries           4          2
-TEST_F(UsageTableHeaderTest, InvalidateEntry_MaxSessionReached) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_MaxSessionReached) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoStorageTypeUnknown, kUsageEntryInfoOfflineLicense1,
       kUsageEntryInfoSecureStop1, kUsageEntryInfoStorageTypeUnknown};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoSecureStop1
   metrics::CryptoMetrics metrics;
 
@@ -3161,7 +3139,7 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_MaxSessionReached) {
       kGracePeriodEndTime,
       kEmptyAppParameters,
       kUsageEntry,
-      static_cast<uint32_t>(1),
+      static_cast<UsageEntryIndex>(1),
       kDrmCertificate,
       kCryptoWrappedKey};
   EXPECT_CALL(*device_files_,
@@ -3183,12 +3161,12 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_MaxSessionReached) {
                                               kUsageEntryInfoOfflineLicense1)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 2;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // 1. Usage entry to be deleted is first valid entry (Secure stop 1)
@@ -3214,13 +3192,13 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_MaxSessionReached) {
 // Storage Type Unknown         3    Deleted
 //
 // # of usage entries           4          2
-TEST_F(UsageTableHeaderTest, InvalidateEntry_FirstEntry_MaxSessionReached) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_FirstEntry_MaxSessionReached) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoSecureStop1, kUsageEntryInfoOfflineLicense1,
       kUsageEntryInfoStorageTypeUnknown, kUsageEntryInfoStorageTypeUnknown};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       0;  // kUsageEntryInfoSecureStop1
   metrics::CryptoMetrics metrics;
 
@@ -3240,7 +3218,7 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_FirstEntry_MaxSessionReached) {
       kGracePeriodEndTime,
       kEmptyAppParameters,
       kUsageEntry,
-      static_cast<uint32_t>(1),
+      static_cast<UsageEntryIndex>(1),
       kDrmCertificate,
       kCryptoWrappedKey};
   EXPECT_CALL(*device_files_,
@@ -3262,12 +3240,12 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_FirstEntry_MaxSessionReached) {
                                               kUsageEntryInfoOfflineLicense1)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 2;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // 1. Usage entry to be deleted is last valid entry (Secure stop 1)
@@ -3291,13 +3269,13 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_FirstEntry_MaxSessionReached) {
 // Storage Type Unknown         3          3
 //
 // # of usage entries           4          4
-TEST_F(UsageTableHeaderTest, InvalidateEntry_SystemInvalidation_OnMove) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_SystemInvalidation_OnMove) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoStorageTypeUnknown, kUsageEntryInfoOfflineLicense1,
       kUsageEntryInfoSecureStop1, kUsageEntryInfoStorageTypeUnknown};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoSecureStop1
   metrics::CryptoMetrics metrics;
 
@@ -3317,7 +3295,7 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_SystemInvalidation_OnMove) {
       kGracePeriodEndTime,
       kEmptyAppParameters,
       kUsageEntry,
-      static_cast<uint32_t>(1),
+      static_cast<UsageEntryIndex>(1),
       kDrmCertificate,
       kCryptoWrappedKey};
   EXPECT_CALL(*device_files_,
@@ -3340,12 +3318,12 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_SystemInvalidation_OnMove) {
                                       kUsageEntryInfoStorageTypeUnknown)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(SYSTEM_INVALIDATED_ERROR, usage_table_header_->InvalidateEntry(
-                                          usage_entry_number_to_be_deleted,
-                                          true, device_files_, &metrics));
+  EXPECT_EQ(SYSTEM_INVALIDATED_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 4;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // 1. Usage entry to be deleted is last valid entry (Secure stop 1)
@@ -3373,13 +3351,13 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_SystemInvalidation_OnMove) {
 // Storage Type Unknown         3          3
 //
 // # of usage entries           4          4
-TEST_F(UsageTableHeaderTest, InvalidateEntry_SessionInvalidation_OnMove) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_SessionInvalidation_OnMove) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoStorageTypeUnknown, kUsageEntryInfoOfflineLicense1,
       kUsageEntryInfoSecureStop1, kUsageEntryInfoStorageTypeUnknown};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoSecureStop1
   metrics::CryptoMetrics metrics;
 
@@ -3399,7 +3377,7 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_SessionInvalidation_OnMove) {
       kGracePeriodEndTime,
       kEmptyAppParameters,
       kUsageEntry,
-      static_cast<uint32_t>(1),
+      static_cast<UsageEntryIndex>(1),
       kDrmCertificate,
       kCryptoWrappedKey};
   EXPECT_CALL(*device_files_,
@@ -3423,12 +3401,12 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_SessionInvalidation_OnMove) {
       .WillOnce(Return(true));
 
   // The underlying error should not be returned to the caller.
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 4;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // 1. Usage entry to be deleted is last valid entry (Secure stop 1)
@@ -3453,13 +3431,13 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_SessionInvalidation_OnMove) {
 // Storage Type Unknown         3          3
 //
 // # of usage entries           4          4
-TEST_F(UsageTableHeaderTest, InvalidateEntry_ShrinkFails) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_ShrinkFails) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoStorageTypeUnknown, kUsageEntryInfoOfflineLicense1,
       kUsageEntryInfoSecureStop1, kUsageEntryInfoStorageTypeUnknown};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoSecureStop1
   metrics::CryptoMetrics metrics;
 
@@ -3478,7 +3456,7 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_ShrinkFails) {
       kGracePeriodEndTime,
       kEmptyAppParameters,
       kUsageEntry,
-      static_cast<uint32_t>(1),
+      static_cast<UsageEntryIndex>(1),
       kDrmCertificate,
       kCryptoWrappedKey};
   EXPECT_CALL(*device_files_,
@@ -3514,12 +3492,12 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_ShrinkFails) {
       .WillOnce(
           Return(CdmResponseType(SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE)));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 4;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // 1. Usage entry to be deleted is last valid entry (Secure stop 1)
@@ -3544,13 +3522,13 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_ShrinkFails) {
 // Storage Type Unknown         3    Deleted
 //
 // # of usage entries           4          2
-TEST_F(UsageTableHeaderTest, InvalidateEntry_DestinationInUse_OnMove) {
-  const std::vector<CdmUsageEntryInfo> usage_entry_info_vector = {
+TEST_F(CdmUsageTableTest, InvalidateEntry_DestinationInUse_OnMove) {
+  const std::vector<CdmUsageEntryInfo> entry_info_list = {
       kUsageEntryInfoStorageTypeUnknown, kUsageEntryInfoOfflineLicense1,
       kUsageEntryInfoSecureStop1, kUsageEntryInfoStorageTypeUnknown};
 
-  Init(kSecurityLevelL1, kUsageTableHeader, usage_entry_info_vector);
-  const uint32_t usage_entry_number_to_be_deleted =
+  Init(kSecurityLevelL1, kUsageTableHeader, entry_info_list);
+  const UsageEntryIndex entry_index_to_be_deleted =
       2;  // kUsageEntryInfoSecureStop1
   metrics::CryptoMetrics metrics;
 
@@ -3570,7 +3548,7 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_DestinationInUse_OnMove) {
       kGracePeriodEndTime,
       kEmptyAppParameters,
       kUsageEntry,
-      static_cast<uint32_t>(1),
+      static_cast<UsageEntryIndex>(1),
       kDrmCertificate,
       kCryptoWrappedKey};
   EXPECT_CALL(*device_files_,
@@ -3596,21 +3574,21 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_DestinationInUse_OnMove) {
                                               kUsageEntryInfoOfflineLicense1)))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(NO_ERROR, usage_table_header_->InvalidateEntry(
-                          usage_entry_number_to_be_deleted, true, device_files_,
-                          &metrics));
+  EXPECT_EQ(NO_ERROR,
+            usage_table_->InvalidateEntry(entry_index_to_be_deleted, true,
+                                          device_files_, &metrics));
   // Check the end state of the usage table.
   constexpr size_t expected_size = 2;
-  EXPECT_EQ(expected_size, usage_table_header_->usage_entry_info().size());
+  EXPECT_EQ(expected_size, usage_table_->entry_info_list().size());
 }
 
 // If the crypto session says the usage table header is stale, init should fail.
-TEST_F(UsageTableHeaderTest, StaleHeader) {
-  std::vector<CdmUsageEntryInfo> usage_entry_info_vector;
+TEST_F(CdmUsageTableTest, StaleHeader) {
+  std::vector<CdmUsageEntryInfo> entry_info_list;
   const CdmUsageEntryInfo usage_entry_info_array[] = {
       kUsageEntryInfoOfflineLicense1, kUsageEntryInfoSecureStop1,
       kUsageEntryInfoStorageTypeUnknown, kUsageEntryInfoOfflineLicense2};
-  ToVector(usage_entry_info_vector, usage_entry_info_array,
+  ToVector(entry_info_list, usage_entry_info_array,
            sizeof(usage_entry_info_array));
 
   EXPECT_CALL(*crypto_session_,
@@ -3620,7 +3598,7 @@ TEST_F(UsageTableHeaderTest, StaleHeader) {
   EXPECT_CALL(*device_files_,
               RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
-                      SetArgPointee<1>(usage_entry_info_vector),
+                      SetArgPointee<1>(entry_info_list),
                       SetArgPointee<2>(false), Return(true)));
   EXPECT_CALL(*crypto_session_,
               LoadUsageTableHeader(kLevelDefault, kUsageTableHeader))
@@ -3634,12 +3612,12 @@ TEST_F(UsageTableHeaderTest, StaleHeader) {
                                                   kEmptyUsageEntryInfoVector))
       .WillOnce(Return(true));
 
-  EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_));
+  EXPECT_TRUE(usage_table_->Init(kSecurityLevelL1, crypto_session_));
 }
 
-// Testing of the private function UsageTableHeader::Shrink.
+// Testing of the private function CdmUsageTable::Shrink.
 // Don't shrink any entries.
-TEST_F(UsageTableHeaderTest, Shrink_NoneOfTable) {
+TEST_F(CdmUsageTableTest, Shrink_NoneOfTable) {
   Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector);
   metrics::CryptoMetrics metrics;
 
@@ -3650,12 +3628,11 @@ TEST_F(UsageTableHeaderTest, Shrink_NoneOfTable) {
       .Times(0);
   EXPECT_CALL(*device_files_, StoreUsageTableInfo(_, _)).Times(0);
 
-  EXPECT_EQ(usage_table_header_->Shrink(&metrics, 0),
-            CdmResponseType(NO_ERROR));
+  EXPECT_EQ(usage_table_->Shrink(&metrics, 0), CdmResponseType(NO_ERROR));
 }
 
 // Shrink some of the table, but not all of it.
-TEST_F(UsageTableHeaderTest, Shrink_PartOfTable) {
+TEST_F(CdmUsageTableTest, Shrink_PartOfTable) {
   Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector);
   const uint32_t to_shink = 5;
   const std::vector<CdmUsageEntryInfo> shrunken_entries(
@@ -3672,12 +3649,12 @@ TEST_F(UsageTableHeaderTest, Shrink_PartOfTable) {
               StoreUsageTableInfo(kUsageTableHeader, shrunken_entries))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(usage_table_header_->Shrink(&metrics, to_shink),
+  EXPECT_EQ(usage_table_->Shrink(&metrics, to_shink),
             CdmResponseType(NO_ERROR));
 }
 
 // Shrink all of the table, no entries left.
-TEST_F(UsageTableHeaderTest, Shrink_AllOfTable) {
+TEST_F(CdmUsageTableTest, Shrink_AllOfTable) {
   Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector);
   metrics::CryptoMetrics metrics;
 
@@ -3688,15 +3665,14 @@ TEST_F(UsageTableHeaderTest, Shrink_AllOfTable) {
                                                   kEmptyUsageEntryInfoVector))
       .WillOnce(Return(true));
 
-  EXPECT_EQ(
-      usage_table_header_->Shrink(
-          &metrics, static_cast<uint32_t>(k10UsageEntryInfoVector.size())),
-      CdmResponseType(NO_ERROR));
+  EXPECT_EQ(usage_table_->Shrink(&metrics, static_cast<uint32_t>(
+                                               k10UsageEntryInfoVector.size())),
+            CdmResponseType(NO_ERROR));
 }
 
 // Request to shrink more entries than there are in the table; should remove
 // all entries, but log a warning.
-TEST_F(UsageTableHeaderTest, Shrink_MoreThanTable) {
+TEST_F(CdmUsageTableTest, Shrink_MoreThanTable) {
   Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector);
   metrics::CryptoMetrics metrics;
   EXPECT_CALL(*crypto_session_,
@@ -3707,7 +3683,7 @@ TEST_F(UsageTableHeaderTest, Shrink_MoreThanTable) {
       .WillOnce(Return(true));
 
   EXPECT_EQ(
-      usage_table_header_->Shrink(
+      usage_table_->Shrink(
           &metrics, static_cast<uint32_t>(k10UsageEntryInfoVector.size()) + 10),
       CdmResponseType(NO_ERROR));
 }
@@ -3718,7 +3694,7 @@ TEST_F(UsageTableHeaderTest, Shrink_MoreThanTable) {
 // 1. Table info is load from device files and device files reports that
 //    the table header and entries are configured for LRU.
 // 2. No upgrading action is taken.
-TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_NoAction) {
+TEST_F(CdmUsageTableTest, LruUsageTableUpgrade_NoAction) {
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(kLevelDefault, NotNull()))
       .WillRepeatedly(
@@ -3739,9 +3715,8 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_NoAction) {
               RetrieveUsageInfoByKeySetId(_, _, _, _, _, _, _, _, _))
       .Times(0);
 
-  EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_));
-  EXPECT_EQ(usage_table_header_->usage_entry_info(),
-            kUpgradableUsageEntryInfoList);
+  EXPECT_TRUE(usage_table_->Init(kSecurityLevelL1, crypto_session_));
+  EXPECT_EQ(usage_table_->entry_info_list(), kUpgradableUsageEntryInfoList);
 }
 
 // Initial Test state:
@@ -3749,7 +3724,7 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_NoAction) {
 //    that the table has not been configured for upgrade.
 // 2. The usage table header will load license or usage information to
 //    determine appropriate expiry and last_used times.
-TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_Succeed) {
+TEST_F(CdmUsageTableTest, LruUsageTableUpgrade_Succeed) {
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(kLevelDefault, NotNull()))
       .WillRepeatedly(
@@ -3779,15 +3754,14 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_Succeed) {
                                               NotNull(), NotNull(), NotNull(),
                                               NotNull(), NotNull(), NotNull()))
           .WillOnce(DoAll(SetArgPointee<4>(kUpgradableLicenseInfoList[i]),
-                          SetArgPointee<6>(static_cast<uint32_t>(i)),
+                          SetArgPointee<6>(static_cast<UsageEntryIndex>(i)),
                           SetArgPointee<7>(kDrmCertificate),
                           SetArgPointee<8>(kCryptoWrappedKey), Return(true)));
     }
   }
 
-  EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_));
-  EXPECT_EQ(usage_table_header_->usage_entry_info(),
-            kUpgradedUsageEntryInfoList);
+  EXPECT_TRUE(usage_table_->Init(kSecurityLevelL1, crypto_session_));
+  EXPECT_EQ(usage_table_->entry_info_list(), kUpgradedUsageEntryInfoList);
 }
 
 // Initial Test state:
@@ -3801,7 +3775,7 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_Succeed) {
 //      0   Offline         Upgraded
 //      1   Unknown         Cleared
 //      2   Invalid (99)    Cleared
-TEST_F(UsageTableHeaderTest,
+TEST_F(CdmUsageTableTest,
        LruUsageTableUpgrade_PartialSucceedWithUnknownStorageTypes) {
   std::vector<CdmUsageEntryInfo> upgradable_usage_entry_info_list =
       kUpgradableUsageEntryInfoList;
@@ -3841,9 +3815,8 @@ TEST_F(UsageTableHeaderTest,
       .WillOnce(
           DoAll(SetArgPointee<1>(kUpgradableLicenseDataList[0]), Return(true)));
 
-  EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_));
-  EXPECT_EQ(upgraded_usage_entry_info_list,
-            usage_table_header_->usage_entry_info());
+  EXPECT_TRUE(usage_table_->Init(kSecurityLevelL1, crypto_session_));
+  EXPECT_EQ(upgraded_usage_entry_info_list, usage_table_->entry_info_list());
 }
 
 // Initial Test state:
@@ -3857,7 +3830,7 @@ TEST_F(UsageTableHeaderTest,
 //      0   Offline         No signature    Cleared
 //      1   Streaming       Wrong type      Cleared
 //      2   Offline                         Upgraded
-TEST_F(UsageTableHeaderTest,
+TEST_F(CdmUsageTableTest,
        LruUsageTableUpgrade_PartialSucceedWithLicenseParseIssues) {
   std::vector<DeviceFiles::CdmLicenseData> license_data_list =
       kUpgradableLicenseDataList;
@@ -3912,7 +3885,7 @@ TEST_F(UsageTableHeaderTest,
                                               NotNull(), NotNull(), NotNull(),
                                               NotNull(), NotNull(), NotNull()))
           .WillOnce(DoAll(SetArgPointee<4>(upgradable_license_info_list[i]),
-                          SetArgPointee<6>(static_cast<uint32_t>(i)),
+                          SetArgPointee<6>(static_cast<UsageEntryIndex>(i)),
                           SetArgPointee<7>(kDrmCertificate),
                           SetArgPointee<8>(kCryptoWrappedKey), Return(true)));
     }
@@ -3933,16 +3906,15 @@ TEST_F(UsageTableHeaderTest,
                   ContainerEq(corrupted_usage_info_key_set_ids)))
       .WillOnce(Return(true));
 
-  EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_));
-  EXPECT_EQ(upgraded_usage_entry_info_list,
-            usage_table_header_->usage_entry_info());
+  EXPECT_TRUE(usage_table_->Init(kSecurityLevelL1, crypto_session_));
+  EXPECT_EQ(upgraded_usage_entry_info_list, usage_table_->entry_info_list());
 }
 
 // Initial Test state:
 // 1. Table info is load from device files; however, device files reports
 //    that the table has not been configured for upgrade.
 // 2. None of the entries can have their license info loaded.
-TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_AllFailure) {
+TEST_F(CdmUsageTableTest, LruUsageTableUpgrade_AllFailure) {
   EXPECT_CALL(*crypto_session_,
               GetNumberOfOpenSessions(kLevelDefault, NotNull()))
       .WillRepeatedly(
@@ -3985,16 +3957,16 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_AllFailure) {
                                                   kEmptyUsageEntryInfoVector))
       .WillOnce(Return(true));
 
-  EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_));
+  EXPECT_TRUE(usage_table_->Init(kSecurityLevelL1, crypto_session_));
 }
 
-TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateLicenseEntry) {
+TEST_F(CdmUsageTableTest, LruLastUsedTime_CreateLicenseEntry) {
   Init(kSecurityLevelL1, kUpgradedUsageTableHeader,
        kUpgradedUsageEntryInfoList);
 
   // Expected values.
-  const uint32_t expected_usage_entry_number =
-      static_cast<uint32_t>(kUpgradedUsageEntryInfoList.size());
+  const UsageEntryIndex expected_entry_index =
+      static_cast<UsageEntryIndex>(kUpgradedUsageEntryInfoList.size());
   const CdmUsageEntryInfo expected_new_entry = {
       kStorageLicense, "offline_key_set_4", "", kLruBaseTime,
       kLruBaseTime + kDefaultExpireDuration};
@@ -4004,10 +3976,10 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateLicenseEntry) {
 
   // AddKey expectations
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(expected_usage_entry_number),
+      .WillOnce(DoAll(SetArgPointee<0>(expected_entry_index),
                       Return(CdmResponseType(NO_ERROR))));
   MockClock mock_clock;
-  usage_table_header_->SetClock(&mock_clock);
+  usage_table_->SetClock(&mock_clock);
   EXPECT_CALL(mock_clock, GetCurrentTime()).WillOnce(Return(kLruBaseTime));
   EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader),
@@ -4015,24 +3987,24 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateLicenseEntry) {
   EXPECT_CALL(*device_files_, StoreUsageTableInfo(kAnotherUsageTableHeader, _));
 
   // The Call.
-  uint32_t usage_entry_number = 0;
-  EXPECT_EQ(NO_ERROR, usage_table_header_->AddEntry(
+  UsageEntryIndex entry_index = 0;
+  EXPECT_EQ(NO_ERROR, usage_table_->AddEntry(
                           crypto_session_, true /* persistent_license */,
                           expected_new_entry.key_set_id,
                           expected_new_entry.usage_info_file_name, kEmptyString,
-                          &usage_entry_number));
+                          &entry_index));
 
-  EXPECT_EQ(expected_usage_entry_number, usage_entry_number);
-  EXPECT_EQ(expected_usage_info_list, usage_table_header_->usage_entry_info());
+  EXPECT_EQ(expected_entry_index, entry_index);
+  EXPECT_EQ(expected_usage_info_list, usage_table_->entry_info_list());
 }
 
-TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateUsageInfoEntry) {
+TEST_F(CdmUsageTableTest, LruLastUsedTime_CreateUsageInfoEntry) {
   Init(kSecurityLevelL1, kUpgradedUsageTableHeader,
        kUpgradedUsageEntryInfoList);
 
   // Expected values.
-  const uint32_t expected_usage_entry_number =
-      static_cast<uint32_t>(kUpgradedUsageEntryInfoList.size());
+  const UsageEntryIndex expected_entry_index =
+      static_cast<UsageEntryIndex>(kUpgradedUsageEntryInfoList.size());
   const CdmUsageEntryInfo expected_new_entry = {
       kStorageUsageInfo, "secure_stop_key_set_5", "streaming_license_file_4",
       kLruBaseTime, 0 /* No set for streaming license. */
@@ -4043,10 +4015,10 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateUsageInfoEntry) {
 
   // AddKey expectations
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(expected_usage_entry_number),
+      .WillOnce(DoAll(SetArgPointee<0>(expected_entry_index),
                       Return(CdmResponseType(NO_ERROR))));
   MockClock mock_clock;
-  usage_table_header_->SetClock(&mock_clock);
+  usage_table_->SetClock(&mock_clock);
   EXPECT_CALL(mock_clock, GetCurrentTime()).WillOnce(Return(kLruBaseTime));
   EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader),
@@ -4054,33 +4026,31 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateUsageInfoEntry) {
   EXPECT_CALL(*device_files_, StoreUsageTableInfo(kAnotherUsageTableHeader, _));
 
   // The Call.
-  uint32_t usage_entry_number = 0;
-  EXPECT_EQ(NO_ERROR, usage_table_header_->AddEntry(
+  UsageEntryIndex entry_index = 0;
+  EXPECT_EQ(NO_ERROR, usage_table_->AddEntry(
                           crypto_session_, false /* persistent_license */,
                           expected_new_entry.key_set_id,
                           expected_new_entry.usage_info_file_name, kEmptyString,
-                          &usage_entry_number));
+                          &entry_index));
 
-  EXPECT_EQ(expected_usage_entry_number, usage_entry_number);
-  EXPECT_EQ(expected_usage_info_list, usage_table_header_->usage_entry_info());
+  EXPECT_EQ(expected_entry_index, entry_index);
+  EXPECT_EQ(expected_usage_info_list, usage_table_->entry_info_list());
 }
 
-TEST_F(UsageTableHeaderTest, LruLastUsedTime_UpdateEntry) {
+TEST_F(CdmUsageTableTest, LruLastUsedTime_UpdateEntry) {
   Init(kSecurityLevelL1, kUpgradedUsageTableHeader,
        kUpgradedUsageEntryInfoList);
 
   std::vector<CdmUsageEntryInfo> expected_usage_info_list =
       kUpgradedUsageEntryInfoList;
   MockClock mock_clock;
-  usage_table_header_->SetClock(&mock_clock);
+  usage_table_->SetClock(&mock_clock);
   const int64_t expected_update_time =
       kLruBaseTime + 60 * 60;  // Any value larger than the original works.
-  for (uint32_t usage_entry_number = 0;
-       usage_entry_number < expected_usage_info_list.size();
-       ++usage_entry_number) {
+  for (UsageEntryIndex entry_index = 0;
+       entry_index < expected_usage_info_list.size(); ++entry_index) {
     // Update expected values.
-    expected_usage_info_list[usage_entry_number].last_use_time =
-        expected_update_time;
+    expected_usage_info_list[entry_index].last_use_time = expected_update_time;
 
     // Update expectations
     EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
@@ -4091,43 +4061,39 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_UpdateEntry) {
                 StoreUsageTableInfo(kUpgradedUsageTableHeader, _));
 
     // The Call.
-    CdmUsageEntry usage_entry;
-    EXPECT_EQ(NO_ERROR, usage_table_header_->UpdateEntry(
-                            usage_entry_number, crypto_session_, &usage_entry));
-    EXPECT_EQ(expected_usage_info_list,
-              usage_table_header_->usage_entry_info());
+    UsageEntry usage_entry;
+    EXPECT_EQ(NO_ERROR, usage_table_->UpdateEntry(entry_index, crypto_session_,
+                                                  &usage_entry));
+    EXPECT_EQ(expected_usage_info_list, usage_table_->entry_info_list());
   }
 }
 
-TEST_F(UsageTableHeaderTest, LruLastUsedTime_LoadEntry) {
+TEST_F(CdmUsageTableTest, LruLastUsedTime_LoadEntry) {
   Init(kSecurityLevelL1, kUpgradedUsageTableHeader,
        kUpgradedUsageEntryInfoList);
 
   std::vector<CdmUsageEntryInfo> expected_usage_info_list =
       kUpgradedUsageEntryInfoList;
   MockClock mock_clock;
-  usage_table_header_->SetClock(&mock_clock);
+  usage_table_->SetClock(&mock_clock);
   const int64_t expected_update_time =
       kLruBaseTime + 60 * 60;  // Any value larger than the original works.
-  for (uint32_t usage_entry_number = 0;
-       usage_entry_number < expected_usage_info_list.size();
-       ++usage_entry_number) {
+  for (UsageEntryIndex entry_index = 0;
+       entry_index < expected_usage_info_list.size(); ++entry_index) {
     // Update expected values.
-    expected_usage_info_list[usage_entry_number].last_use_time =
-        expected_update_time;
+    expected_usage_info_list[entry_index].last_use_time = expected_update_time;
 
     // Update expectations
-    EXPECT_CALL(*crypto_session_, LoadUsageEntry(usage_entry_number, _))
+    EXPECT_CALL(*crypto_session_, LoadUsageEntry(entry_index, _))
         .WillOnce(Return(CdmResponseType(NO_ERROR)));
     EXPECT_CALL(mock_clock, GetCurrentTime())
         .WillOnce(Return(expected_update_time));
 
     // The Call.
-    CdmUsageEntry usage_entry;
-    EXPECT_EQ(NO_ERROR, usage_table_header_->LoadEntry(
-                            crypto_session_, kEmptyString, usage_entry_number));
-    EXPECT_EQ(expected_usage_info_list,
-              usage_table_header_->usage_entry_info());
+    UsageEntry usage_entry;
+    EXPECT_EQ(NO_ERROR, usage_table_->LoadEntry(crypto_session_, kEmptyString,
+                                                entry_index));
+    EXPECT_EQ(expected_usage_info_list, usage_table_->entry_info_list());
   }
 }
 
@@ -4136,17 +4102,17 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_LoadEntry) {
 // This testcase is intended to push the boundaries of valid inputs to
 // the LRU algorithm.  None of these are expected inputs under normal
 // operations.
-TEST_F(UsageTableHeaderTest, DetermineLicenseToRemove_InvalidInput) {
+TEST_F(CdmUsageTableTest, DetermineLicenseToRemove_InvalidInput) {
   constexpr size_t kUnexpiredThreshold = 50;  // Arbitrary
   std::vector<CdmUsageEntryInfo> usage_entry_info_list;
-  uint32_t entry_to_remove = 0;
+  UsageEntryIndex entry_to_remove = 0;
   // Empty list.
-  EXPECT_FALSE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  EXPECT_FALSE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kLruBaseTime, kUnexpiredThreshold,
       &entry_to_remove));
   // Output is null.
   usage_entry_info_list = kUpgradedUsageEntryInfoList;
-  EXPECT_FALSE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  EXPECT_FALSE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kLruBaseTime, kUnexpiredThreshold, nullptr));
 }
 
@@ -4154,10 +4120,10 @@ TEST_F(UsageTableHeaderTest, DetermineLicenseToRemove_InvalidInput) {
 // Expects that unknown entries to be chosen above all others.
 // Unexpired licenses should only be considered if the threshold
 // is met.
-TEST_F(UsageTableHeaderTest, DetermineLicenseToRemove_BasicPriorities) {
+TEST_F(CdmUsageTableTest, DetermineLicenseToRemove_BasicPriorities) {
   constexpr int64_t kOneDay = 24 * 60 * 60;
   constexpr int64_t kCurrentTime = kLruBaseTime + kOneDay;
-  constexpr uint32_t kInvalidEntry = 9999;
+  constexpr UsageEntryIndex kInvalidEntry = 9999;
   std::vector<CdmUsageEntryInfo> usage_entry_info_list;
 
   // Unexpired offline license.
@@ -4166,7 +4132,7 @@ TEST_F(UsageTableHeaderTest, DetermineLicenseToRemove_BasicPriorities) {
   unexpired_entry_info.last_use_time = kLruBaseTime;
   unexpired_entry_info.offline_license_expiry_time = kLruBaseTime + 2 * kOneDay;
   usage_entry_info_list.push_back(unexpired_entry_info);
-  constexpr uint32_t unexpired_entry_number = 0;
+  constexpr UsageEntryIndex unexpired_entry_index = 0;
 
   // Expired offline license.
   CdmUsageEntryInfo expired_entry_info;
@@ -4174,14 +4140,14 @@ TEST_F(UsageTableHeaderTest, DetermineLicenseToRemove_BasicPriorities) {
   expired_entry_info.last_use_time = kLruBaseTime;
   expired_entry_info.offline_license_expiry_time = kLruBaseTime;
   usage_entry_info_list.push_back(expired_entry_info);
-  constexpr uint32_t expired_entry_number = 1;
+  constexpr UsageEntryIndex expired_entry_index = 1;
 
   // Streaming license.
   CdmUsageEntryInfo streaming_entry_info;
   streaming_entry_info.storage_type = kStorageUsageInfo;
   streaming_entry_info.last_use_time = kLruBaseTime;
   usage_entry_info_list.push_back(streaming_entry_info);
-  constexpr uint32_t streaming_entry_number = 2;
+  constexpr UsageEntryIndex streaming_entry_index = 2;
 
   // Unknown entry.
   CdmUsageEntryInfo unknown_entry_info;
@@ -4189,35 +4155,35 @@ TEST_F(UsageTableHeaderTest, DetermineLicenseToRemove_BasicPriorities) {
   // Should be chosen regardless of |last_use_time|.
   unknown_entry_info.last_use_time = kCurrentTime;
   usage_entry_info_list.push_back(unknown_entry_info);
-  constexpr uint32_t unknown_entry_number = 3;
+  constexpr UsageEntryIndex unknown_entry_index = 3;
 
   // Case 1: If there is an entry with unknown storage type, it should
   // be selected above any other entry.
-  uint32_t entry_to_remove = kInvalidEntry;
+  UsageEntryIndex entry_to_remove = kInvalidEntry;
 
   // Expect the unknown entry.
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kCurrentTime,
       /* unexpired_threshold = */ 3, &entry_to_remove));
-  EXPECT_EQ(unknown_entry_number, entry_to_remove);
+  EXPECT_EQ(unknown_entry_index, entry_to_remove);
 
   usage_entry_info_list.pop_back();  // Removing unknown.
 
   // Case 2a: Threshold not met, all entries are equally stale.
   // The expired entry should be selected over the streaming license.
   entry_to_remove = kInvalidEntry;
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kCurrentTime,
       /* unexpired_threshold = */ 3, &entry_to_remove));
-  EXPECT_EQ(expired_entry_number, entry_to_remove);
+  EXPECT_EQ(expired_entry_index, entry_to_remove);
 
   // Case 2b: Threshold not met, streaming license is most stale.
-  usage_entry_info_list[streaming_entry_number].last_use_time--;
+  usage_entry_info_list[streaming_entry_index].last_use_time--;
   entry_to_remove = kInvalidEntry;
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kCurrentTime,
       /* unexpired_threshold = */ 3, &entry_to_remove));
-  EXPECT_EQ(streaming_entry_number, entry_to_remove);
+  EXPECT_EQ(streaming_entry_index, entry_to_remove);
 
   usage_entry_info_list.pop_back();  // Removing streaming.
   // |usage_entry_info_list| only contains 1 expired and 1 unexpired offline
@@ -4226,72 +4192,71 @@ TEST_F(UsageTableHeaderTest, DetermineLicenseToRemove_BasicPriorities) {
   // Case 2c: Threshold met, equally stale entries.  Expect the expired
   // entry over the unexpired.
   entry_to_remove = kInvalidEntry;
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kCurrentTime,
       /* unexpired_threshold = */ 0, &entry_to_remove));
-  EXPECT_EQ(expired_entry_number, entry_to_remove);
+  EXPECT_EQ(expired_entry_index, entry_to_remove);
 
   // Case 3a: Threshold not met, expired entry is the most stale.
   entry_to_remove = kInvalidEntry;
-  usage_entry_info_list[expired_entry_number].last_use_time--;
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  usage_entry_info_list[expired_entry_index].last_use_time--;
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kCurrentTime,
       /* unexpired_threshold = */ 3, &entry_to_remove));
-  EXPECT_EQ(expired_entry_number, entry_to_remove);
+  EXPECT_EQ(expired_entry_index, entry_to_remove);
 
   // Case 3b: Threshold not met, unexpired entry is the most stale.
   entry_to_remove = kInvalidEntry;
-  usage_entry_info_list[expired_entry_number].last_use_time++;
-  usage_entry_info_list[unexpired_entry_number].last_use_time--;
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  usage_entry_info_list[expired_entry_index].last_use_time++;
+  usage_entry_info_list[unexpired_entry_index].last_use_time--;
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kCurrentTime,
       /* unexpired_threshold = */ 3, &entry_to_remove));
-  EXPECT_EQ(expired_entry_number, entry_to_remove);
+  EXPECT_EQ(expired_entry_index, entry_to_remove);
 
   // Case 3c: Threshold met, unexpired entry is the most stale.
   entry_to_remove = kInvalidEntry;
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kCurrentTime,
       /* unexpired_threshold = */ 0, &entry_to_remove));
-  EXPECT_EQ(unexpired_entry_number, entry_to_remove);
+  EXPECT_EQ(unexpired_entry_index, entry_to_remove);
 
   // Case 3d: Threshold met, expired entry is the most stale.
   entry_to_remove = kInvalidEntry;
-  usage_entry_info_list[expired_entry_number].last_use_time--;
-  usage_entry_info_list[unexpired_entry_number].last_use_time++;
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  usage_entry_info_list[expired_entry_index].last_use_time--;
+  usage_entry_info_list[unexpired_entry_index].last_use_time++;
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kCurrentTime,
       /* unexpired_threshold = */ 0, &entry_to_remove));
-  EXPECT_EQ(expired_entry_number, entry_to_remove);
+  EXPECT_EQ(expired_entry_index, entry_to_remove);
 
   usage_entry_info_list.pop_back();  // Removing expired offline.
 
   // Case 4a: Threshold met, and only an unexpired offline license
   // is available.
   entry_to_remove = kInvalidEntry;  // Invalidate value.
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kCurrentTime,
       /* unexpired_threshold = */ 0, &entry_to_remove));
-  EXPECT_EQ(unexpired_entry_number, entry_to_remove);
+  EXPECT_EQ(unexpired_entry_index, entry_to_remove);
 
   // Case 4b (stability check): Threshold not met, and only an
   // unexpired offline license is available.  This is an unexpected
   // condition in normal operation, but the algorithm should still
   // return an entry.
   entry_to_remove = kInvalidEntry;
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kCurrentTime,
       /* unexpired_threshold = */ 3, &entry_to_remove));
-  EXPECT_EQ(unexpired_entry_number, entry_to_remove);
+  EXPECT_EQ(unexpired_entry_index, entry_to_remove);
 }
 
 // Testing algorithm with unexpired offline and streaming license.  The
 // sum of offline licenses is below the threshold for consideration.
 // Only the streaming license should be considered for removal.
-TEST_F(UsageTableHeaderTest,
-       DetermineLicenseToRemove_NoExpiredAndBelowThreshold) {
+TEST_F(CdmUsageTableTest, DetermineLicenseToRemove_NoExpiredAndBelowThreshold) {
   constexpr int64_t kOneDay = 24 * 60 * 60;
-  constexpr uint32_t kInvalidEntry = 9999;
+  constexpr UsageEntryIndex kInvalidEntry = 9999;
   std::vector<CdmUsageEntryInfo> usage_entry_info_list =
       kUpgradedUsageEntryInfoList;
   const size_t offline_threshold = usage_entry_info_list.size() + 1;
@@ -4312,8 +4277,8 @@ TEST_F(UsageTableHeaderTest,
   // Must exist at least one streaming license for test to work.
   ASSERT_LT(0ull, usage_info_count);
 
-  uint32_t entry_to_remove = kInvalidEntry;
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  UsageEntryIndex entry_to_remove = kInvalidEntry;
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kLruBaseTime, offline_threshold,
       &entry_to_remove));
 
@@ -4326,20 +4291,20 @@ TEST_F(UsageTableHeaderTest,
 // should be considered.
 // Providing only offline licenses, only the expired license should be
 // considered for removal.
-TEST_F(UsageTableHeaderTest,
+TEST_F(CdmUsageTableTest,
        DetermineLicenseToRemove_SomeExpiredAndBelowThreshold) {
   constexpr int64_t kOneDay = 24 * 60 * 60;
   constexpr size_t kSetSize = 10;
   constexpr int64_t kCurrentTime = kLruBaseTime + kOneDay * 2;
   // A threshold larger than the possible number of offline entries.
   constexpr size_t kUnexpiredThreshold = kSetSize + 1;
-  constexpr uint32_t kInvalidEntry = 9999;
+  constexpr UsageEntryIndex kInvalidEntry = 9999;
 
   std::vector<CdmUsageEntryInfo> usage_entry_info_list;
   usage_entry_info_list.resize(kSetSize);
 
   // Create a set of all offline licenses.
-  for (uint32_t i = 0; i < kSetSize; ++i) {
+  for (size_t i = 0; i < kSetSize; ++i) {
     CdmUsageEntryInfo& usage_entry_info = usage_entry_info_list[i];
     usage_entry_info.storage_type = kStorageLicense;
     usage_entry_info.key_set_id = "nothing_unusual";
@@ -4349,10 +4314,10 @@ TEST_F(UsageTableHeaderTest,
   }
 
   // Mark 3 as expired.
-  std::vector<uint32_t> expired_license_numbers;
-  while (expired_license_numbers.size() < 3) {
-    const uint32_t i =
-        static_cast<uint32_t>(wvutil::CdmRandom::RandomInRange(kSetSize - 1));
+  std::vector<UsageEntryIndex> expired_license_indexes;
+  while (expired_license_indexes.size() < 3) {
+    const UsageEntryIndex i = static_cast<UsageEntryIndex>(
+        wvutil::CdmRandom::RandomInRange(kSetSize - 1));
     CdmUsageEntryInfo& usage_entry_info = usage_entry_info_list[i];
     // Skip already expired ones
     if (usage_entry_info.key_set_id != "nothing_unusual") continue;
@@ -4360,15 +4325,15 @@ TEST_F(UsageTableHeaderTest,
     usage_entry_info.last_use_time = kLruBaseTime + kOneDay;
     usage_entry_info.offline_license_expiry_time = kCurrentTime - kOneDay;
     usage_entry_info.key_set_id = "expired_offline";
-    expired_license_numbers.push_back(i);
+    expired_license_indexes.push_back(i);
   }
 
-  uint32_t entry_to_remove = kInvalidEntry;
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  UsageEntryIndex entry_to_remove = kInvalidEntry;
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kCurrentTime, kUnexpiredThreshold,
       &entry_to_remove));
 
-  EXPECT_THAT(expired_license_numbers, Contains(entry_to_remove));
+  EXPECT_THAT(expired_license_indexes, Contains(entry_to_remove));
 }
 
 // This test primarily tests the robustness of the algorithm for a full
@@ -4381,16 +4346,16 @@ TEST_F(UsageTableHeaderTest,
 //
 // Second, with the stale offline license marked as expired, checks that
 // offline licenses are selected over the streaming.
-TEST_F(UsageTableHeaderTest, DetermineLicenseToRemove_LargeMixedSet) {
+TEST_F(CdmUsageTableTest, DetermineLicenseToRemove_LargeMixedSet) {
   constexpr int64_t kOneDay = 24 * 60 * 60;
   constexpr size_t kLargeSetSize = 200;
   constexpr int64_t kCurrentTime = kLruBaseTime + kOneDay * 2;
-  constexpr uint32_t kInvalidEntry = 9999;
+  constexpr UsageEntryIndex kInvalidEntry = 9999;
   std::vector<CdmUsageEntryInfo> usage_entry_info_list;
   usage_entry_info_list.resize(kLargeSetSize);
 
   // Create a set of usage entries.
-  for (uint32_t i = 0; i < kLargeSetSize; ++i) {
+  for (size_t i = 0; i < kLargeSetSize; ++i) {
     CdmUsageEntryInfo& usage_entry_info = usage_entry_info_list[i];
     usage_entry_info.key_set_id = "nothing_unusual";
     usage_entry_info.last_use_time = kLruBaseTime + kOneDay;
@@ -4405,95 +4370,95 @@ TEST_F(UsageTableHeaderTest, DetermineLicenseToRemove_LargeMixedSet) {
   }
 
   // Select a streaming license to be more stale than the rest.
-  uint32_t modified_usage_info_number = kInvalidEntry;
-  while (modified_usage_info_number == kInvalidEntry) {
-    const uint32_t i = static_cast<uint32_t>(
+  UsageEntryIndex modified_usage_info_index = kInvalidEntry;
+  while (modified_usage_info_index == kInvalidEntry) {
+    const UsageEntryIndex i = static_cast<UsageEntryIndex>(
         wvutil::CdmRandom::RandomInRange(kLargeSetSize - 1));
     CdmUsageEntryInfo& usage_entry_info = usage_entry_info_list[i];
     // Skip offline licenses.
     if (usage_entry_info.storage_type != kStorageUsageInfo) continue;
     usage_entry_info.last_use_time = kLruBaseTime + 10;
     usage_entry_info.key_set_id = "stale_streaming";
-    modified_usage_info_number = i;
+    modified_usage_info_index = i;
   }
 
   // Select a offline license to be even more stale, but unexpired.
-  uint32_t modified_offline_license_number = kInvalidEntry;
-  while (modified_offline_license_number == kInvalidEntry) {
-    const uint32_t i = static_cast<uint32_t>(
+  UsageEntryIndex modified_offline_license_index = kInvalidEntry;
+  while (modified_offline_license_index == kInvalidEntry) {
+    const UsageEntryIndex i = static_cast<UsageEntryIndex>(
         wvutil::CdmRandom::RandomInRange(kLargeSetSize - 1));
     CdmUsageEntryInfo& usage_entry_info = usage_entry_info_list[i];
     // Skip streaming licenses.
     if (usage_entry_info.storage_type != kStorageLicense) continue;
     usage_entry_info.last_use_time = kLruBaseTime;
     usage_entry_info.key_set_id = "stale_offline";
-    modified_offline_license_number = i;
+    modified_offline_license_index = i;
   }
 
   // Test using only streaming and expired offline licenses
   // (which there are none).
-  uint32_t entry_to_remove = kInvalidEntry;
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  UsageEntryIndex entry_to_remove = kInvalidEntry;
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kCurrentTime,
       /* unexpired_threshold = */ kLargeSetSize, &entry_to_remove));
-  EXPECT_EQ(modified_usage_info_number, entry_to_remove);
+  EXPECT_EQ(modified_usage_info_index, entry_to_remove);
 
   // Test where the equality threshold is met, now the stale unexpired
   // license should be selected.
   entry_to_remove = kInvalidEntry;
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kCurrentTime,
       /* unexpired_threshold = */ 0, &entry_to_remove));
-  EXPECT_EQ(modified_offline_license_number, entry_to_remove);
+  EXPECT_EQ(modified_offline_license_index, entry_to_remove);
 
   // Make the stale offline license expired.
   CdmUsageEntryInfo& offline_usage_entry_info =
-      usage_entry_info_list[modified_offline_license_number];
+      usage_entry_info_list[modified_offline_license_index];
   offline_usage_entry_info.offline_license_expiry_time = kLruBaseTime;
 
   // Test again, expecting that the expired license should be considered.
   entry_to_remove = kInvalidEntry;
-  EXPECT_TRUE(UsageTableHeader::DetermineLicenseToRemoveForTesting(
+  EXPECT_TRUE(CdmUsageTable::DetermineLicenseToRemoveForTesting(
       usage_entry_info_list, kCurrentTime,
       /* unexpired_threshold = */ kLargeSetSize, &entry_to_remove));
-  EXPECT_EQ(modified_offline_license_number, entry_to_remove);
+  EXPECT_EQ(modified_offline_license_index, entry_to_remove);
 }
 
-TEST_F(UsageTableHeaderTest, PotentialTableCapacity_Unavailable) {
+TEST_F(CdmUsageTableTest, PotentialTableCapacity_Unavailable) {
   crypto_session_->UnsetMaximumUsageTableEntries();
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  EXPECT_EQ(usage_table_header_->potential_table_capacity(),
+  EXPECT_EQ(usage_table_->potential_table_capacity(),
             kMinimumUsageTableEntriesSupported);
-  EXPECT_FALSE(usage_table_header_->HasUnlimitedTableCapacity());
+  EXPECT_FALSE(usage_table_->HasUnlimitedTableCapacity());
 }
 
-TEST_F(UsageTableHeaderTest, PotentialTableCapacity_TooSmall) {
+TEST_F(CdmUsageTableTest, PotentialTableCapacity_TooSmall) {
   // This will issue a warning about the reported capacity is unexpected,
   // and will default to the version's required minimum.
   crypto_session_->SetMaximumUsageTableEntries(
       kMinimumUsageTableEntriesSupported / 2);
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  EXPECT_EQ(usage_table_header_->potential_table_capacity(),
+  EXPECT_EQ(usage_table_->potential_table_capacity(),
             kMinimumUsageTableEntriesSupported);
-  EXPECT_FALSE(usage_table_header_->HasUnlimitedTableCapacity());
+  EXPECT_FALSE(usage_table_->HasUnlimitedTableCapacity());
 }
 
-TEST_F(UsageTableHeaderTest, PotentialTableCapacity_Unlimited) {
-  MockUsageTableHeader* mock_usage_table_header = SetUpMock();
+TEST_F(CdmUsageTableTest, PotentialTableCapacity_Unlimited) {
+  MockCdmUsageTable* mock_usage_table = SetUpMock();
   // Zero indicates that the table size is unlimited.
   crypto_session_->SetMaximumUsageTableEntries(0u);
 
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
   constexpr size_t kZero = 0u;
-  EXPECT_EQ(mock_usage_table_header->potential_table_capacity(), kZero);
-  EXPECT_TRUE(mock_usage_table_header->HasUnlimitedTableCapacity());
+  EXPECT_EQ(mock_usage_table->potential_table_capacity(), kZero);
+  EXPECT_TRUE(mock_usage_table->HasUnlimitedTableCapacity());
 }
 
-TEST_F(UsageTableHeaderTest, PotentialTableCapacity_Available) {
+TEST_F(CdmUsageTableTest, PotentialTableCapacity_Available) {
   constexpr size_t kTableCapacity = 2000u;
   crypto_session_->SetMaximumUsageTableEntries(kTableCapacity);
   Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
-  EXPECT_EQ(usage_table_header_->potential_table_capacity(), kTableCapacity);
-  EXPECT_FALSE(usage_table_header_->HasUnlimitedTableCapacity());
+  EXPECT_EQ(usage_table_->potential_table_capacity(), kTableCapacity);
+  EXPECT_FALSE(usage_table_->HasUnlimitedTableCapacity());
 }
 }  // namespace wvcdm
diff --git a/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp b/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp
index 2076d922..ce9173ab 100644
--- a/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp
@@ -63,21 +63,21 @@ class MockCryptoSession : public TestCryptoSession {
               (override));
   // Usage Table Header.
   MOCK_METHOD(CdmResponseType, CreateUsageTableHeader,
-              (wvcdm::RequestedSecurityLevel, CdmUsageTableHeader*),
-              (override));
+              (wvcdm::RequestedSecurityLevel, UsageTableHeader*), (override));
   MOCK_METHOD(CdmResponseType, LoadUsageTableHeader,
-              (wvcdm::RequestedSecurityLevel, const CdmUsageTableHeader&),
+              (wvcdm::RequestedSecurityLevel, const UsageTableHeader&),
               (override));
   MOCK_METHOD(CdmResponseType, ShrinkUsageTableHeader,
-              (wvcdm::RequestedSecurityLevel, uint32_t, CdmUsageTableHeader*),
+              (wvcdm::RequestedSecurityLevel, uint32_t, UsageTableHeader*),
               (override));
   // Usage Entry.
-  MOCK_METHOD(CdmResponseType, CreateUsageEntry, (uint32_t*), (override));
-  MOCK_METHOD(CdmResponseType, LoadUsageEntry, (uint32_t, const CdmUsageEntry&),
+  MOCK_METHOD(CdmResponseType, CreateUsageEntry, (UsageEntryIndex*),
               (override));
+  MOCK_METHOD(CdmResponseType, LoadUsageEntry,
+              (UsageEntryIndex, const UsageEntry&), (override));
   MOCK_METHOD(CdmResponseType, UpdateUsageEntry,
-              (CdmUsageTableHeader*, CdmUsageEntry*), (override));
-  MOCK_METHOD(CdmResponseType, MoveUsageEntry, (uint32_t), (override));
+              (UsageTableHeader*, UsageEntry*), (override));
+  MOCK_METHOD(CdmResponseType, MoveUsageEntry, (UsageEntryIndex), (override));
 };
 
 class TestStubCryptoSessionFactory : public CryptoSessionFactory {
diff --git a/libwvdrmengine/cdm/core/test/crypto_session_unittest.cpp b/libwvdrmengine/cdm/core/test/crypto_session_unittest.cpp
index 3e67165b..0a5545a2 100644
--- a/libwvdrmengine/cdm/core/test/crypto_session_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/crypto_session_unittest.cpp
@@ -62,7 +62,7 @@ TEST_F(CryptoSessionMetricsTest, OpenSessionValidMetrics) {
   session->Open(wvcdm::kLevelDefault);
   // Exercise a method that will touch a metric.
   bool supports_usage_table;
-  ASSERT_TRUE(session->HasUsageInfoSupport(&supports_usage_table));
+  ASSERT_TRUE(session->HasUsageTableSupport(&supports_usage_table));
 
   drm_metrics::WvCdmMetrics::CryptoMetrics metrics_proto;
   crypto_metrics.Serialize(&metrics_proto);
diff --git a/libwvdrmengine/cdm/core/test/device_files_unittest.cpp b/libwvdrmengine/cdm/core/test/device_files_unittest.cpp
index 8c6acb66..3f50765a 100644
--- a/libwvdrmengine/cdm/core/test/device_files_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/device_files_unittest.cpp
@@ -1627,7 +1627,7 @@ struct LicenseInfo {
   int64_t grace_period_end_time;
   std::string app_parameters;
   std::string usage_entry;
-  uint32_t usage_entry_number;
+  uint32_t usage_entry_index;
   std::string drm_certificate;
   CryptoWrappedKey::Type key_type;
   std::string private_key;
@@ -3657,7 +3657,7 @@ const CdmUsageEntryInfo kUsageEntriesTestData[] = {
 };
 
 struct UsageTableTestInfo {
-  CdmUsageTableHeader usage_table_header;
+  UsageTableHeader usage_table_header;
   std::string file_data;
 };
 
@@ -4560,7 +4560,7 @@ TEST_P(DeviceFilesStoreTest, StoreLicense) {
       kLicenseTestData[license_num].grace_period_end_time,
       app_parameters,
       kLicenseTestData[license_num].usage_entry,
-      kLicenseTestData[license_num].usage_entry_number,
+      kLicenseTestData[license_num].usage_entry_index,
       kLicenseTestData[license_num].drm_certificate,
       CryptoWrappedKey(kLicenseTestData[license_num].key_type,
                        kLicenseTestData[license_num].private_key)};
@@ -4629,7 +4629,7 @@ TEST_F(DeviceFilesTest, StoreLicenses) {
         kLicenseTestData[i].grace_period_end_time,
         app_parameters,
         kLicenseTestData[i].usage_entry,
-        kLicenseTestData[i].usage_entry_number,
+        kLicenseTestData[i].usage_entry_index,
         kLicenseTestData[i].drm_certificate,
         CryptoWrappedKey(kLicenseTestData[i].key_type,
                          kLicenseTestData[i].private_key)};
@@ -4689,8 +4689,8 @@ TEST_F(DeviceFilesTest, RetrieveLicenses) {
     EXPECT_EQ(kLicenseTestData[i].grace_period_end_time,
               license_data.grace_period_end_time);
     EXPECT_EQ(kLicenseTestData[i].usage_entry, license_data.usage_entry);
-    EXPECT_EQ(kLicenseTestData[i].usage_entry_number,
-              license_data.usage_entry_number);
+    EXPECT_EQ(kLicenseTestData[i].usage_entry_index,
+              license_data.usage_entry_index);
     EXPECT_EQ(kLicenseTestData[i].drm_certificate,
               license_data.drm_certificate);
     EXPECT_EQ(kLicenseTestData[i].key_type,
@@ -4755,7 +4755,7 @@ TEST_F(DeviceFilesTest, AppParametersBackwardCompatibility) {
             license_data.grace_period_end_time);
   EXPECT_EQ(0u, license_data.app_parameters.size());
   EXPECT_EQ(test_data->usage_entry, license_data.usage_entry);
-  EXPECT_EQ(test_data->usage_entry_number, license_data.usage_entry_number);
+  EXPECT_EQ(test_data->usage_entry_index, license_data.usage_entry_index);
   EXPECT_EQ(test_data->drm_certificate, license_data.drm_certificate);
   EXPECT_EQ(test_data->key_type, license_data.wrapped_private_key.type());
   EXPECT_EQ(test_data->private_key, license_data.wrapped_private_key.key());
@@ -4794,7 +4794,7 @@ TEST_F(DeviceFilesTest, UpdateLicenseState) {
         kLicenseUpdateTestData[0].grace_period_end_time,
         GetAppParameters(kLicenseTestData[0].app_parameters),
         kLicenseUpdateTestData[0].usage_entry,
-        kLicenseUpdateTestData[0].usage_entry_number,
+        kLicenseUpdateTestData[0].usage_entry_index,
         kLicenseUpdateTestData[0].drm_certificate,
         CryptoWrappedKey(kLicenseTestData[0].key_type,
                          kLicenseTestData[0].private_key)};
@@ -4860,8 +4860,8 @@ TEST_F(DeviceFilesTest, DeleteLicense) {
               std::string::npos);
   }
   EXPECT_EQ(kLicenseTestData[0].usage_entry, license_data.usage_entry);
-  EXPECT_EQ(kLicenseTestData[0].usage_entry_number,
-            license_data.usage_entry_number);
+  EXPECT_EQ(kLicenseTestData[0].usage_entry_index,
+            license_data.usage_entry_index);
   EXPECT_EQ(kLicenseTestData[0].drm_certificate, license_data.drm_certificate);
   EXPECT_EQ(kLicenseTestData[0].key_type,
             license_data.wrapped_private_key.type());
@@ -5408,8 +5408,8 @@ TEST_P(DeviceFilesUsageInfoTest, Retrieve) {
                   usage_data_list[i].key_set_id);
         EXPECT_EQ(kUsageInfoTestData[j].usage_data.usage_entry,
                   usage_data_list[i].usage_entry);
-        EXPECT_EQ(kUsageInfoTestData[j].usage_data.usage_entry_number,
-                  usage_data_list[i].usage_entry_number);
+        EXPECT_EQ(kUsageInfoTestData[j].usage_data.usage_entry_index,
+                  usage_data_list[i].usage_entry_index);
         EXPECT_EQ(kUsageInfoTestData[j].usage_data.drm_certificate,
                   usage_data_list[i].drm_certificate);
         EXPECT_EQ(kUsageInfoTestData[j].usage_data.wrapped_private_key.type(),
@@ -5581,8 +5581,8 @@ TEST_P(DeviceFilesUsageInfoTest, RetrieveByProviderSessionToken) {
               usage_data.key_set_id);
     EXPECT_EQ(kUsageInfoTestData[index].usage_data.usage_entry,
               usage_data.usage_entry);
-    EXPECT_EQ(kUsageInfoTestData[index].usage_data.usage_entry_number,
-              usage_data.usage_entry_number);
+    EXPECT_EQ(kUsageInfoTestData[index].usage_data.usage_entry_index,
+              usage_data.usage_entry_index);
   }
 }
 
@@ -5813,7 +5813,7 @@ TEST_P(DeviceFilesUsageTableTest, Read) {
   EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
 
   std::vector<CdmUsageEntryInfo> usage_entry_info;
-  CdmUsageTableHeader usage_table_header;
+  UsageTableHeader usage_table_header;
   bool lru_upgrade;
   ASSERT_TRUE(device_files.RetrieveUsageTableInfo(
       &usage_table_header, &usage_entry_info, &lru_upgrade));
@@ -5861,7 +5861,7 @@ TEST_F(DeviceFilesUsageTableTest, ReadWithoutLruData) {
   EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
 
   std::vector<CdmUsageEntryInfo> usage_entry_info;
-  CdmUsageTableHeader usage_table_header;
+  UsageTableHeader usage_table_header;
   bool lru_upgrade;
   ASSERT_TRUE(device_files.RetrieveUsageTableInfo(
       &usage_table_header, &usage_entry_info, &lru_upgrade));
diff --git a/libwvdrmengine/cdm/core/test/license_unittest.cpp b/libwvdrmengine/cdm/core/test/license_unittest.cpp
index dbe54dca..87c3fb59 100644
--- a/libwvdrmengine/cdm/core/test/license_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/license_unittest.cpp
@@ -143,7 +143,7 @@ class MockCryptoSession : public TestCryptoSession {
       : TestCryptoSession(crypto_metrics) {}
   MOCK_METHOD(bool, IsOpen, (), (override));
   MOCK_METHOD(const std::string&, request_id, (), (override));
-  MOCK_METHOD(bool, HasUsageInfoSupport, (bool*), (override));
+  MOCK_METHOD(bool, HasUsageTableSupport, (bool*), (override));
   MOCK_METHOD(CdmResponseType, GetHdcpCapabilities,
               (HdcpCapability*, HdcpCapability*), (override));
   MOCK_METHOD(bool, GetSupportedCertificateTypes, (SupportedCertificateTypes*),
@@ -306,7 +306,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidation) {
   EXPECT_CALL(*crypto_session_, IsOpen()).WillOnce(Return(true));
   EXPECT_CALL(*crypto_session_, request_id())
       .WillOnce(ReturnRef(kCryptoRequestId));
-  EXPECT_CALL(*crypto_session_, HasUsageInfoSupport(NotNull()))
+  EXPECT_CALL(*crypto_session_, HasUsageTableSupport(NotNull()))
       .WillOnce(
           DoAll(SetArgPointee<0>(usage_information_support), Return(true)));
   EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
@@ -441,7 +441,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) {
   EXPECT_CALL(*crypto_session_, IsOpen()).WillOnce(Return(true));
   EXPECT_CALL(*crypto_session_, request_id())
       .WillOnce(ReturnRef(kCryptoRequestId));
-  EXPECT_CALL(*crypto_session_, HasUsageInfoSupport(NotNull()))
+  EXPECT_CALL(*crypto_session_, HasUsageTableSupport(NotNull()))
       .WillOnce(
           DoAll(SetArgPointee<0>(usage_information_support), Return(true)));
   EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
diff --git a/libwvdrmengine/cdm/test/Android.mk b/libwvdrmengine/cdm/test/Android.mk
index 80945a91..017d9076 100644
--- a/libwvdrmengine/cdm/test/Android.mk
+++ b/libwvdrmengine/cdm/test/Android.mk
@@ -45,6 +45,11 @@ test_src_dir := ../core/test
 test_main := ../core/test/test_main.cpp
 include $(LOCAL_PATH)/integration-test.mk
 
+test_name := cdm_usage_table_unittest
+test_src_dir := ../core/test
+test_main := ../core/test/test_main.cpp
+include $(LOCAL_PATH)/integration-test.mk
+
 test_name := certificate_provisioning_unittest
 test_src_dir := ../core/test
 test_main := ../core/test/test_main.cpp
@@ -169,11 +174,6 @@ test_name := timer_unittest
 test_src_dir := .
 include $(LOCAL_PATH)/unit-test.mk
 
-test_name := usage_table_header_unittest
-test_src_dir := ../core/test
-test_main := ../core/test/test_main.cpp
-include $(LOCAL_PATH)/integration-test.mk
-
 test_name := value_metric_unittest
 test_src_dir := ../metrics/test
 include $(LOCAL_PATH)/unit-test.mk
diff --git a/libwvdrmengine/run_all_unit_tests.sh b/libwvdrmengine/run_all_unit_tests.sh
index b1a22eff..a620ac10 100755
--- a/libwvdrmengine/run_all_unit_tests.sh
+++ b/libwvdrmengine/run_all_unit_tests.sh
@@ -99,6 +99,7 @@ adb_shell_run buffer_reader_test
 adb_shell_run cdm_engine_metrics_decorator_unittest
 adb_shell_run cdm_engine_test
 adb_shell_run cdm_session_unittest
+adb_shell_run cdm_usage_table_unittest
 adb_shell_run certificate_provisioning_unittest
 adb_shell_run counter_metric_unittest
 adb_shell_run crypto_session_unittest
@@ -125,6 +126,5 @@ adb_shell_run rw_lock_test
 adb_shell_run service_certificate_unittest
 adb_shell_run system_id_extractor_unittest
 adb_shell_run timer_unittest
-adb_shell_run usage_table_header_unittest
 adb_shell_run value_metric_unittest
 adb_shell_run wv_cdm_metrics_test
diff --git a/tests/Android.mk b/tests/Android.mk
index 84832660..f49b4c21 100644
--- a/tests/Android.mk
+++ b/tests/Android.mk
@@ -19,6 +19,7 @@ WIDEVINE_TEST_MAKE_TARGETS += \
     cdm_extended_duration_test \
     cdm_feature_test \
     cdm_session_unittest \
+    cdm_usage_table_unittest \
     certificate_provisioning_unittest \
     counter_metric_unittest \
     crypto_session_unittest \
@@ -49,7 +50,6 @@ WIDEVINE_TEST_MAKE_TARGETS += \
     rw_lock_test \
     service_certificate_unittest \
     timer_unittest \
-    usage_table_header_unittest \
     value_metric_unittest \
     wv_cdm_metrics_test \