From 1603ba127fa3934c450b37d358c35fe83cf9fdb8 Mon Sep 17 00:00:00 2001 From: Alex Dale Date: Tue, 20 Dec 2022 15:21:10 -0800 Subject: [PATCH] Renaming of Usage Table related variables and types. [ Merge of http://go/wvgerrit/164077 ] This CL makes major changes to the names of variables and types that are related to the usage table, header, entries, entry indexes, and other related data. The renaming followed these rules: 1) "Usage table header" will exclusively refer to the header blob that is OEMCrypto specific. The CDM class "UsageTableHeader" is the CDM-layer's abstraction around the "usage table" concept. The name has been updated to reflect that. 2) The "Cdm" prefix is only used for the CDM-specific data types for the usage table and entry info. It has been removed from OEMCrypto-specific types. - UsageTableHeader -> CdmUsageTable - CdmUsageTableHeader -> UsageTableHeader - CdmUsageEntry -> UsageEntry 3) The "usage_" prefix has been removed from variables when the usage table or usage entries are the subject of the function or class. 4) UsageEntryIndex is the type for entry indexes, instead of directly using uint32_t. This matches how we wrap other types in "wv_cdm_types.h" 5) Changed entry "number" to entry "index". 6) Vectors of elements have been renamed to be either pluralized or have a suffix "_list". 7) "Usage info" was occasionally being used to refer to the usage table or entries generally, rather than specifically secure-stop. - CryptoSession::HasUsageInfoSupport() -> HasUsageTableSupport() The most major change is that the files "usage_table_header*" have been renamed to be "cdm_usage_table*". Bug: 242914226 Test: run_x86_64_tests and request_license_test Change-Id: Iee98446b71f4f2934d3c9e0fb949eb05b84d1f8c --- libwvdrmengine/build_all_unit_tests.sh | 2 +- libwvdrmengine/cdm/Android.bp | 2 +- libwvdrmengine/cdm/core/include/cdm_session.h | 16 +- ...usage_table_header.h => cdm_usage_table.h} | 123 +- .../cdm/core/include/crypto_session.h | 50 +- .../cdm/core/include/device_files.h | 26 +- .../cdm/core/include/wv_cdm_types.h | 8 +- libwvdrmengine/cdm/core/src/cdm_engine.cpp | 22 +- libwvdrmengine/cdm/core/src/cdm_session.cpp | 123 +- ...e_table_header.cpp => cdm_usage_table.cpp} | 727 +++++----- .../cdm/core/src/client_identification.cpp | 6 +- .../cdm/core/src/crypto_session.cpp | 96 +- libwvdrmengine/cdm/core/src/device_files.cpp | 99 +- .../cdm/core/src/device_files.proto | 8 +- libwvdrmengine/cdm/core/src/license.cpp | 4 +- .../cdm/core/test/cdm_session_unittest.cpp | 36 +- ...ttest.cpp => cdm_usage_table_unittest.cpp} | 1285 ++++++++--------- .../certificate_provisioning_unittest.cpp | 16 +- .../cdm/core/test/crypto_session_unittest.cpp | 2 +- .../cdm/core/test/device_files_unittest.cpp | 32 +- .../cdm/core/test/license_unittest.cpp | 6 +- libwvdrmengine/cdm/test/Android.mk | 10 +- libwvdrmengine/run_all_unit_tests.sh | 2 +- tests/Android.mk | 2 +- 24 files changed, 1321 insertions(+), 1382 deletions(-) rename libwvdrmengine/cdm/core/include/{usage_table_header.h => cdm_usage_table.h} (77%) rename libwvdrmengine/cdm/core/src/{usage_table_header.cpp => cdm_usage_table.cpp} (62%) rename libwvdrmengine/cdm/core/test/{usage_table_header_unittest.cpp => cdm_usage_table_unittest.cpp} (81%) 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 78f97935..5e1a97fe 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 #include @@ -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& usage_entry_info() const { - return usage_entry_info_; + const std::vector& 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& usage_entry_info_list, + const std::vector& 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& usage_entry_info_list, + const std::vector& 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 device_files_; std::unique_ptr file_system_; CdmSecurityLevel security_level_ = kSecurityLevelUninitialized; RequestedSecurityLevel requested_security_level_ = kLevelDefault; - CdmUsageTableHeader usage_table_header_; - std::vector usage_entry_info_; + UsageTableHeader header_; + std::vector 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 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 usage_table_header_l1_; - static std::unique_ptr usage_table_header_l3_; + static std::unique_ptr usage_table_l1_; + static std::unique_ptr usage_table_l3_; std::string request_id_; static std::atomic request_id_index_source_; diff --git a/libwvdrmengine/cdm/core/include/device_files.h b/libwvdrmengine/cdm/core/include/device_files.h index 8b3926ef..1a41a9ff 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; }; @@ -180,7 +180,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. @@ -233,8 +233,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|. @@ -242,8 +242,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 + @@ -271,15 +271,15 @@ class DeviceFiles { virtual bool DeleteHlsAttributes(const std::string& key_set_id); virtual bool StoreUsageTableInfo( - const CdmUsageTableHeader& usage_table_header, - const std::vector& usage_entry_info); + const UsageTableHeader& usage_table_header, + const std::vector& 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* usage_entry_info, bool* lru_upgrade); + UsageTableHeader* usage_table_header, + std::vector* 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 70b91dc2..4eeb8d96 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; @@ -34,8 +33,11 @@ using CdmUsageInfo = std::vector; 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 91c415a8..9ef82a36 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); @@ -1632,7 +1632,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 usage_data; // Retrieve all usage information but delete only one before // refetching. This is because deleting the usage entry @@ -1647,7 +1647,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", @@ -1710,21 +1710,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); @@ -1791,7 +1791,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); @@ -2120,7 +2120,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(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(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(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(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 #include @@ -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 auto_lock(usage_table_header_lock_); + LOGD("entry_index = %u", entry_index); + std::unique_lock 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 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 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(usage_entry_info_.size()); + const uint32_t old_size = static_cast(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(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(usage_entry_info_[usage_entry_number].storage_type)); + static_cast(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(usage_entry_info_[usage_entry_number].storage_type)); + static_cast(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(usage_entry_info_.size()); + static_cast(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(usage_entry_info_.size()) - + const uint32_t new_size = static_cast(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 entries_to_remove; - for (uint32_t i = 0; i < usage_entry_info_.size() && - entries_to_remove.size() < kMaxDefragEntryMoves; + std::vector 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 entries_to_move; - for (uint32_t i = 0; i < usage_entry_info_.size() && + std::vector 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(usage_entry_info_.size()) - i - 1; - if (usage_entry_info_[entry_index].storage_type != kStorageTypeUnknown) { + const UsageEntryIndex entry_index = + static_cast(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(usage_entry_info_.size())); + entry_info_list_.size()); + return Shrink(metrics, static_cast(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(usage_entry_info_.size()) - last_valid_entry - 1; + const UsageEntryIndex to_remove = + static_cast(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(usage_entry_info_.size()); - for (uint32_t i = 0; i < usage_entry_info_.size(); ++i) { - const uint32_t entry_index = - static_cast(usage_entry_info_.size()) - i - 1; - if (usage_entry_info_[entry_index].storage_type != kStorageTypeUnknown) { + UsageEntryIndex new_last_valid_entry = + static_cast(entry_info_list_.size()); + for (size_t i = 0; i < entry_info_list_.size(); ++i) { + const UsageEntryIndex entry_index = + static_cast(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(usage_entry_info_.size())); + entry_info_list_.size()); + return Shrink(metrics, static_cast(entry_info_list_.size())); } - const uint32_t to_remove = static_cast(usage_entry_info_.size()) - - new_last_valid_entry - 1; + const UsageEntryIndex to_remove = + static_cast(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 bad_license_file_entries; + std::vector 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(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(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 -> []. std::map> 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()) .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& usage_entry_info_list, - int64_t current_time, size_t unexpired_threshold, - uint32_t* entry_to_remove) { +bool CdmUsageTable::DetermineLicenseToRemove( + const std::vector& 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::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::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 CryptoSession::usage_table_header_l1_; -std::unique_ptr CryptoSession::usage_table_header_l3_; +std::unique_ptr CryptoSession::usage_table_l1_; +std::unique_ptr CryptoSession::usage_table_l3_; std::recursive_mutex CryptoSession::usage_table_mutex_; std::atomic CryptoSession::request_id_index_source_(0); std::unique_ptr @@ -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& header = security_level == kSecurityLevelL1 - ? usage_table_header_l1_ - : usage_table_header_l3_; - if (!header) { + std::unique_ptr& 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(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 b637b6f2..55aa19f8 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(license.usage_entry_number()); + license_data->usage_entry_index = + static_cast(license.usage_entry_index()); if (!license.has_drm_certificate()) { license_data->drm_certificate.clear(); @@ -1010,8 +1010,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; @@ -1034,7 +1034,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; @@ -1235,15 +1235,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); @@ -1259,8 +1259,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( - file.usage_info().sessions(index).usage_entry_number()); + *usage_entry_index = static_cast( + file.usage_info().sessions(index).usage_entry_index()); if (!file.usage_info().sessions(index).has_drm_certificate_id()) { drm_certificate->clear(); @@ -1285,14 +1285,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); @@ -1309,8 +1309,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( - file.usage_info().sessions(index).usage_entry_number()); + *usage_entry_index = static_cast( + file.usage_info().sessions(index).usage_entry_index()); if (!file.usage_info().sessions(index).has_drm_certificate_id()) { drm_certificate->clear(); @@ -1354,7 +1354,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; @@ -1399,7 +1399,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; @@ -1448,8 +1448,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( - file.usage_info().sessions(i).usage_entry_number()); + (*usage_data)[i].usage_entry_index = static_cast( + file.usage_info().sessions(i).usage_entry_index()); if (!file.usage_info().sessions(i).has_drm_certificate_id()) { (*usage_data)[i].drm_certificate.clear(); @@ -1490,8 +1490,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( - file.usage_info().sessions(index).usage_entry_number()); + usage_data->usage_entry_index = static_cast( + file.usage_info().sessions(index).usage_entry_index()); if (!file.usage_info().sessions(index).has_drm_certificate_id()) { usage_data->drm_certificate.clear(); @@ -1629,8 +1629,8 @@ bool DeviceFiles::DeleteHlsAttributes(const std::string& key_set_id) { } bool DeviceFiles::StoreUsageTableInfo( - const CdmUsageTableHeader& usage_table_header, - const std::vector& usage_entry_info) { + const UsageTableHeader& table_header, + const std::vector& entry_info_list) { RETURN_FALSE_IF_UNINITIALIZED(); // Fill in file information @@ -1640,25 +1640,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: @@ -1677,11 +1676,11 @@ bool DeviceFiles::StoreUsageTableInfo( } bool DeviceFiles::RetrieveUsageTableInfo( - CdmUsageTableHeader* usage_table_header, - std::vector* usage_entry_info, bool* lru_upgrade) { + UsageTableHeader* table_header, + std::vector* 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; @@ -1713,28 +1712,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 +#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* 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 #include @@ -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 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(i); + license_data.usage_entry_index = static_cast(i); kUpgradableLicenseDataList.push_back(license_data); } } @@ -391,12 +388,11 @@ class MockDeviceFiles : public DeviceFiles { } MOCK_METHOD(bool, RetrieveUsageTableInfo, - (CdmUsageTableHeader*, std::vector*, + (UsageTableHeader*, std::vector*, bool* lru_upgrade), (override)); MOCK_METHOD(bool, StoreUsageTableInfo, - (const CdmUsageTableHeader&, - const std::vector&), + (const UsageTableHeader&, const std::vector&), (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*), (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& usage_entry_info_vector) { + const UsageTableHeader& table_header, + const std::vector& 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 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 { 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 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 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(kUsageEntryInfoVector.size()); + const UsageEntryIndex expect_entry_index = + static_cast(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(kUsageEntryInfoVector.size()) - 1; + const UsageEntryIndex expect_entry_index = + static_cast(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(kUsageEntryInfoVector.size()); - const uint32_t final_usage_entry_number = - static_cast(kUsageEntryInfoVector.size()) - 1; - std::vector expect_usage_entry_info_vector = - kUsageEntryInfoVector; - expect_usage_entry_info_vector[final_usage_entry_number] = - kUsageEntryInfoOfflineLicense2; + const UsageEntryIndex initial_entry_index = + static_cast(kUsageEntryInfoVector.size()); + const UsageEntryIndex final_entry_index = + static_cast(kUsageEntryInfoVector.size()) - 1; + std::vector 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(expect_usage_entry_info_vector.size()), - NotNull())) + EXPECT_CALL( + *crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, static_cast(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(kUsageEntryInfoVector.size()); - const uint32_t final_usage_entry_number = - static_cast(kUsageEntryInfoVector.size()) - 1; - std::vector expect_usage_entry_info_vector = - kUsageEntryInfoVector; - expect_usage_entry_info_vector[final_usage_entry_number] = - kUsageEntryInfoSecureStop2; + const UsageEntryIndex initial_entry_index = + static_cast(kUsageEntryInfoVector.size()); + const UsageEntryIndex final_entry_index = + static_cast(kUsageEntryInfoVector.size()) - 1; + std::vector 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(expect_usage_entry_info_vector.size()), - NotNull())) + EXPECT_CALL( + *crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, static_cast(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(kUsageEntryInfoVector.size()); + const UsageEntryIndex next_entry_index = + static_cast(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(kUsageEntryInfoVector.size()) - 1; - std::vector 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(kUsageEntryInfoVector.size()) - 1; + std::vector 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(expect_usage_entry_info_vector.size()), - NotNull())) + EXPECT_CALL( + *crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, static_cast(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(kUsageEntryInfoVector.size()); - const uint32_t attempted_usage_entry_number = - static_cast(kUsageEntryInfoVector.size()) - 1; - std::vector expect_usage_entry_info_vector = - kUsageEntryInfoVector; - expect_usage_entry_info_vector.push_back(kUsageEntryInfoSecureStop2); + const UsageEntryIndex final_entry_index = + static_cast(kUsageEntryInfoVector.size()); + const UsageEntryIndex attempted_entry_index = + static_cast(kUsageEntryInfoVector.size()) - 1; + std::vector 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(kUsageEntryInfoVector.size()); - const uint32_t final_usage_entry_number = - static_cast(kUsageEntryInfoVector.size()) - 1; - std::vector 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(kUsageEntryInfoVector.size()); + const UsageEntryIndex final_entry_index = + static_cast(kUsageEntryInfoVector.size()) - 1; + std::vector 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(expect_usage_entry_info_vector.size()) - 1, - NotNull())) + static_cast(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 usage_entry_info_vector_at_start = + std::vector 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(k10UsageEntryInfoVector.size()) - 1; + const UsageEntryIndex expected_entry_index = + static_cast(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& 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(kUsageEntryInfoVector.size()) + 3; + const UsageEntryIndex entry_index = + static_cast(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(kUsageEntryInfoVector.size()); + const UsageEntryIndex entry_index = + static_cast(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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_CryptoSessionError) { + const std::vector 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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_LastEntry_OfflineEntry) { + const std::vector 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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_LastEntry_SecureStopEntry) { + const std::vector 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 usage_entry_info_vector = { + const std::vector 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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_LastSecureStopEntriesAreMissing) { + const std::vector 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 usage_entry_info_vector = { + const std::vector 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(3) /* Mismatch */, + static_cast(3) /* Mismatch */, kDrmCertificate, kCryptoWrappedKey}; EXPECT_CALL(*device_files_, @@ -1947,7 +1926,7 @@ TEST_F(UsageTableHeaderTest, kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry, - static_cast(2) /* Mismatch */, + static_cast(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 usage_entry_info_vector = { + const std::vector 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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_LastEntriesAreStorageTypeUnknown) { + const std::vector 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(3), + static_cast(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 usage_entry_info_vector = { + const std::vector 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 usage_entry_info_vector = { + const std::vector 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 usage_entry_info_vector = { + const std::vector 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 usage_entry_info_vector = { + const std::vector 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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_LastEntryIsOffline) { + const std::vector 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(4), + static_cast(4), kDrmCertificate, kCryptoWrappedKey}; EXPECT_CALL(*device_files_, @@ -2635,7 +2614,7 @@ TEST_F(UsageTableHeaderTest, InvalidateEntry_LastEntryIsOffline) { kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry, - static_cast(3), + static_cast(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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_LastEntryIsSecureStop) { + const std::vector 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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_LastEntriesAreOfflineAndUnknknown) { + const std::vector 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(4), + static_cast(4), kDrmCertificate, kCryptoWrappedKey}; EXPECT_CALL(*device_files_, @@ -2887,7 +2865,7 @@ TEST_F(UsageTableHeaderTest, kGracePeriodEndTime, kEmptyAppParameters, kUsageEntry, - static_cast(3), + static_cast(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 usage_entry_info_vector = { + const std::vector 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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_NoValidSessionsAfter) { + const std::vector 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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_MaxSessionReached) { + const std::vector 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(1), + static_cast(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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_FirstEntry_MaxSessionReached) { + const std::vector 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(1), + static_cast(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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_SystemInvalidation_OnMove) { + const std::vector 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(1), + static_cast(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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_SessionInvalidation_OnMove) { + const std::vector 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(1), + static_cast(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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_ShrinkFails) { + const std::vector 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(1), + static_cast(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 usage_entry_info_vector = { +TEST_F(CdmUsageTableTest, InvalidateEntry_DestinationInUse_OnMove) { + const std::vector 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(1), + static_cast(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 usage_entry_info_vector; +TEST_F(CdmUsageTableTest, StaleHeader) { + std::vector 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 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(k10UsageEntryInfoVector.size())), - CdmResponseType(NO_ERROR)); + EXPECT_EQ(usage_table_->Shrink(&metrics, static_cast( + 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(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(i)), + SetArgPointee<6>(static_cast(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 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 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(i)), + SetArgPointee<6>(static_cast(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(kUpgradedUsageEntryInfoList.size()); + const UsageEntryIndex expected_entry_index = + static_cast(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(kUpgradedUsageEntryInfoList.size()); + const UsageEntryIndex expected_entry_index = + static_cast(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 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 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 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 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 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 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 expired_license_numbers; - while (expired_license_numbers.size() < 3) { - const uint32_t i = - static_cast(wvutil::CdmRandom::RandomInRange(kSetSize - 1)); + std::vector expired_license_indexes; + while (expired_license_indexes.size() < 3) { + const UsageEntryIndex i = static_cast( + 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 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( + UsageEntryIndex modified_usage_info_index = kInvalidEntry; + while (modified_usage_info_index == kInvalidEntry) { + const UsageEntryIndex i = static_cast( 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( + UsageEntryIndex modified_offline_license_index = kInvalidEntry; + while (modified_offline_license_index == kInvalidEntry) { + const UsageEntryIndex i = static_cast( 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 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 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 \