From 1447eba7bc1be1da545f5186536084fe1fc322e9 Mon Sep 17 00:00:00 2001 From: "John W. Bruce" Date: Wed, 20 Oct 2021 13:54:26 -0700 Subject: [PATCH 1/3] Fix -Wshorten-64-to-32 errors in usage table code (This is a merge of http://go/wvgerrit/134312.) This patch fixes code that would trigger -Wshorten-64-to-32 by implicitly narrowing a variable from 64 to 32 bits. Most of the time, it does this by making the implicit conversion explicit. There are a lot of these places in the usage table code because we always use uint32_t as the type of a usage entry index, but much of the code that interacts with the usage table system naturally wants to use size_t. Bug: 194971260 Test: OEMCrypto unit tests Test: x86-64 platform tests Change-Id: I3923af40715efe367955a194a9e33be3e9cb014c --- .../cdm/core/src/crypto_session.cpp | 2 +- libwvdrmengine/cdm/core/src/device_files.cpp | 27 ++-- .../cdm/core/src/usage_table_header.cpp | 47 +++--- .../core/test/usage_table_header_unittest.cpp | 140 +++++++++++------- .../oemcrypto/test/oemcrypto_test.cpp | 2 +- 5 files changed, 127 insertions(+), 91 deletions(-) diff --git a/libwvdrmengine/cdm/core/src/crypto_session.cpp b/libwvdrmengine/cdm/core/src/crypto_session.cpp index 349cd368..6776fa8c 100644 --- a/libwvdrmengine/cdm/core/src/crypto_session.cpp +++ b/libwvdrmengine/cdm/core/src/crypto_session.cpp @@ -2141,7 +2141,7 @@ bool CryptoSession::GetMaximumUsageTableEntries(SecurityLevel security_level, }); // Record the number of entries into the metrics. metrics_->oemcrypto_maximum_usage_table_header_size_.Record( - *number_of_entries); + static_cast(*number_of_entries)); if (*number_of_entries == 0) { // Special value, indicating that the table size is not directly diff --git a/libwvdrmengine/cdm/core/src/device_files.cpp b/libwvdrmengine/cdm/core/src/device_files.cpp index 979d287d..95b0ed3b 100644 --- a/libwvdrmengine/cdm/core/src/device_files.cpp +++ b/libwvdrmengine/cdm/core/src/device_files.cpp @@ -804,7 +804,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 = license.usage_entry_number(); + license_data->usage_entry_number = + static_cast(license.usage_entry_number()); if (!license.has_drm_certificate()) { license_data->drm_certificate.clear(); @@ -951,8 +952,8 @@ bool DeviceFiles::ListUsageIds( if (ksids != nullptr) ksids->clear(); if (provider_session_tokens != nullptr) provider_session_tokens->clear(); - size_t num_records = file.usage_info().sessions_size(); - for (size_t i = 0; i < num_records; ++i) { + const int num_records = file.usage_info().sessions_size(); + for (int i = 0; i < num_records; ++i) { if ((ksids != nullptr) && !file.usage_info().sessions(i).key_set_id().empty()) { ksids->push_back(file.usage_info().sessions(i).key_set_id()); @@ -983,8 +984,8 @@ bool DeviceFiles::GetProviderSessionToken(const std::string& app_id, return false; } - size_t num_records = file.usage_info().sessions_size(); - for (size_t i = 0; i < num_records; ++i) { + const int num_records = static_cast(file.usage_info().sessions_size()); + for (int i = 0; i < num_records; ++i) { if (file.usage_info().sessions(i).key_set_id() == key_set_id) { *provider_session_token = file.usage_info().sessions(i).token(); return true; @@ -1130,8 +1131,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 = - file.usage_info().sessions(index).usage_entry_number(); + *usage_entry_number = static_cast( + file.usage_info().sessions(index).usage_entry_number()); if (!file.usage_info().sessions(index).has_drm_certificate_id()) { drm_certificate->clear(); @@ -1180,8 +1181,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 = - file.usage_info().sessions(index).usage_entry_number(); + *usage_entry_number = static_cast( + file.usage_info().sessions(index).usage_entry_number()); if (!file.usage_info().sessions(index).has_drm_certificate_id()) { drm_certificate->clear(); @@ -1319,8 +1320,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 = - file.usage_info().sessions(i).usage_entry_number(); + (*usage_data)[i].usage_entry_number = static_cast( + file.usage_info().sessions(i).usage_entry_number()); if (!file.usage_info().sessions(i).has_drm_certificate_id()) { (*usage_data)[i].drm_certificate.clear(); @@ -1361,8 +1362,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 = - file.usage_info().sessions(index).usage_entry_number(); + usage_data->usage_entry_number = static_cast( + file.usage_info().sessions(index).usage_entry_number()); if (!file.usage_info().sessions(index).has_drm_certificate_id()) { usage_data->drm_certificate.clear(); diff --git a/libwvdrmengine/cdm/core/src/usage_table_header.cpp b/libwvdrmengine/cdm/core/src/usage_table_header.cpp index ee1f58db..5dd98eba 100644 --- a/libwvdrmengine/cdm/core/src/usage_table_header.cpp +++ b/libwvdrmengine/cdm/core/src/usage_table_header.cpp @@ -636,13 +636,14 @@ CdmResponseType UsageTableHeader::RefitTable( CryptoSession* const crypto_session) { // Remove all unoccupied entries at end of the table. uint32_t entries_to_remove = 0; - for (uint32_t i = 0; i < usage_entry_info_.size(); i++) { - const uint32_t usage_entry_number = usage_entry_info_.size() - i - 1; + const uint32_t old_size = static_cast(usage_entry_info_.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; ++entries_to_remove; } if (entries_to_remove == 0) return NO_ERROR; - const uint32_t new_size = usage_entry_info_.size() - entries_to_remove; + const uint32_t new_size = old_size - entries_to_remove; const CdmResponseType status = crypto_session->ShrinkUsageTableHeader( requested_security_level_, new_size, &usage_table_header_); if (status == SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE) { @@ -884,7 +885,8 @@ CdmResponseType UsageTableHeader::Shrink( "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); - number_of_usage_entries_to_delete = usage_entry_info_.size(); + number_of_usage_entries_to_delete = + static_cast(usage_entry_info_.size()); } if (number_of_usage_entries_to_delete == 0) return NO_ERROR; @@ -898,8 +900,8 @@ CdmResponseType UsageTableHeader::Shrink( crypto_session = scoped_crypto_session.get(); } - const size_t new_size = - usage_entry_info_.size() - number_of_usage_entries_to_delete; + const uint32_t new_size = static_cast(usage_entry_info_.size()) - + number_of_usage_entries_to_delete; const CdmResponseType status = crypto_session->ShrinkUsageTableHeader( requested_security_level_, new_size, &usage_table_header_); @@ -952,7 +954,8 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files, entries_to_move.size() < entries_to_remove.size(); ++i) { // Search from the end of the table. - const uint32_t entry_index = usage_entry_info_.size() - i - 1; + const uint32_t entry_index = + static_cast(usage_entry_info_.size()) - i - 1; if (usage_entry_info_[entry_index].storage_type != kStorageTypeUnknown) { entries_to_move.push_back(entry_index); } @@ -963,7 +966,7 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files, if (entries_to_move.empty()) { LOGD("No valid entries found, shrinking entire table: size = %zu", usage_entry_info_.size()); - return Shrink(metrics, usage_entry_info_.size()); + return Shrink(metrics, static_cast(usage_entry_info_.size())); } // Step 3: Ignore invalid entries that are after the last valid @@ -982,8 +985,9 @@ 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 size_t to_remove = usage_entry_info_.size() - last_valid_entry - 1; - LOGD("Removing all entries after the last valid entry: count = %zu", + const uint32_t to_remove = + static_cast(usage_entry_info_.size()) - last_valid_entry - 1; + LOGD("Removing all entries after the last valid entry: count = %u", to_remove); return Shrink(metrics, to_remove); } @@ -1095,9 +1099,11 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files, } // End while loop. // Step 5: Find the new last valid entry. - uint32_t new_last_valid_entry = usage_entry_info_.size(); + 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 = usage_entry_info_.size() - i - 1; + const uint32_t entry_index = + static_cast(usage_entry_info_.size()) - i - 1; if (usage_entry_info_[entry_index].storage_type != kStorageTypeUnknown) { new_last_valid_entry = entry_index; break; @@ -1111,10 +1117,11 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files, LOGD( "All entries have been invalidated, shrinking entire table: size = %zu", usage_entry_info_.size()); - return Shrink(metrics, usage_entry_info_.size()); + return Shrink(metrics, static_cast(usage_entry_info_.size())); } - const size_t to_remove = usage_entry_info_.size() - new_last_valid_entry - 1; + const uint32_t to_remove = static_cast(usage_entry_info_.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. @@ -1127,7 +1134,7 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files, } // Step 6: Shrink table to the new size. - LOGD("Clean up complete, shrinking table: count = %zu", to_remove); + LOGD("Clean up complete, shrinking table: count = %u", to_remove); return Shrink(metrics, to_remove); } // End Defrag(). @@ -1188,7 +1195,7 @@ bool UsageTableHeader::LruUpgradeAllUsageEntries() { // end, all problematic licenses will be marked as invalid. std::vector bad_license_file_entries; - for (size_t usage_entry_number = 0; + 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]; @@ -1213,7 +1220,7 @@ bool UsageTableHeader::LruUpgradeAllUsageEntries() { bad_license_file_entries.push_back(usage_entry_number); continue; default: { - LOGW("Unknown usage entry storage type: %d, usage_entry_number = %zu", + 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); @@ -1221,7 +1228,7 @@ bool UsageTableHeader::LruUpgradeAllUsageEntries() { } } if (!retrieve_response) { - LOGW("Could not retrieve license message: usage_entry_number = %zu", + LOGW("Could not retrieve license message: usage_entry_number = %u", usage_entry_number); bad_license_file_entries.push_back(usage_entry_number); continue; @@ -1229,7 +1236,7 @@ bool UsageTableHeader::LruUpgradeAllUsageEntries() { if (retrieved_entry_number != usage_entry_number) { LOGW( - "Usage entry number mismatched: usage_entry_number = %zu, " + "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); @@ -1238,7 +1245,7 @@ bool UsageTableHeader::LruUpgradeAllUsageEntries() { video_widevine::License license; if (!ParseLicenseFromLicenseMessage(license_message, &license)) { - LOGW("Could not parse license: usage_entry_number = %zu", + LOGW("Could not parse license: usage_entry_number = %u", usage_entry_number); bad_license_file_entries.push_back(usage_entry_number); continue; diff --git a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp b/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp index aef278fd..0c8994ea 100644 --- a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp @@ -359,7 +359,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 = i; + license_data.usage_entry_number = static_cast(i); kUpgradableLicenseDataList.push_back(license_data); } } @@ -830,7 +830,8 @@ TEST_P(UsageTableHeaderInitializationTest, RestoreUsageTable_NoCapacity_AboveMinimum) { crypto_session_->SetMaximumUsageTableEntries(0); // Unlimited. ASSERT_LT(kDefaultTableCapacity, kOverFullUsageEntryInfoVector.size()); - const size_t kTableStartSize = kOverFullUsageEntryInfoVector.size(); + const uint32_t table_start_size = + static_cast(kOverFullUsageEntryInfoVector.size()); const SecurityLevel security_level = GetSecurityLevel(); // Expectations for restore: @@ -858,7 +859,7 @@ TEST_P(UsageTableHeaderInitializationTest, // 7) Table state is stored EXPECT_CALL(*crypto_session_, Open(security_level)) .WillOnce(Return(NO_ERROR)); - const uint32_t expect_usage_entry_number = kTableStartSize; + const uint32_t expect_usage_entry_number = table_start_size; EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull())) .WillOnce( DoAll(SetArgPointee<0>(expect_usage_entry_number), Return(NO_ERROR))); @@ -866,14 +867,15 @@ TEST_P(UsageTableHeaderInitializationTest, .WillOnce( DoAll(SetArgPointee<0>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, StoreUsageTableInfo(kAnotherUsageTableHeader, - SizeIs(kTableStartSize + 1))) + SizeIs(table_start_size + 1))) .WillOnce(Return(true)); - EXPECT_CALL(*crypto_session_, ShrinkUsageTableHeader( - security_level, kTableStartSize, NotNull())) + EXPECT_CALL( + *crypto_session_, + ShrinkUsageTableHeader(security_level, table_start_size, NotNull())) .WillOnce(DoAll(SetArgPointee<2>(kYetAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, StoreUsageTableInfo(kYetAnotherUsageTableHeader, - SizeIs(kTableStartSize))) + SizeIs(table_start_size))) .WillOnce(Return(true)); EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_)); @@ -937,7 +939,8 @@ TEST_P(UsageTableHeaderInitializationTest, RestoreUsageTable_NoCapacity_AboveMinimum_InvalidateEntryFails) { crypto_session_->SetMaximumUsageTableEntries(0); // Unlimited. ASSERT_LT(kDefaultTableCapacity, kOverFullUsageEntryInfoVector.size()); - const size_t kTableStartSize = kOverFullUsageEntryInfoVector.size(); + const uint32_t table_start_size = + static_cast(kOverFullUsageEntryInfoVector.size()); const SecurityLevel security_level = GetSecurityLevel(); // Expectations for restore: @@ -964,7 +967,7 @@ TEST_P(UsageTableHeaderInitializationTest, // 6) Shrinking table fails EXPECT_CALL(*crypto_session_, Open(security_level)) .WillOnce(Return(NO_ERROR)); - const uint32_t expect_usage_entry_number = kTableStartSize; + const uint32_t expect_usage_entry_number = table_start_size; EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull())) .WillOnce( DoAll(SetArgPointee<0>(expect_usage_entry_number), Return(NO_ERROR))); @@ -973,11 +976,12 @@ TEST_P(UsageTableHeaderInitializationTest, DoAll(SetArgPointee<0>(kAnotherUsageTableHeader), Return(NO_ERROR))); // Called twice due to defrag. EXPECT_CALL(*device_files_, StoreUsageTableInfo(kAnotherUsageTableHeader, - SizeIs(kTableStartSize + 1))) + SizeIs(table_start_size + 1))) .Times(2) .WillRepeatedly(Return(true)); - EXPECT_CALL(*crypto_session_, ShrinkUsageTableHeader( - security_level, kTableStartSize, NotNull())) + EXPECT_CALL( + *crypto_session_, + ShrinkUsageTableHeader(security_level, table_start_size, NotNull())) .WillOnce(Return(SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR)); // Expectations for create: @@ -1001,7 +1005,8 @@ INSTANTIATE_TEST_SUITE_P(Cdm, UsageTableHeaderInitializationTest, TEST_F(UsageTableHeaderTest, AddEntry_CreateUsageEntryFailed_UnknownError) { Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); - const uint32_t expect_usage_entry_number = kUsageEntryInfoVector.size(); + const uint32_t expect_usage_entry_number = + static_cast(kUsageEntryInfoVector.size()); EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull())) .WillOnce(DoAll(SetArgPointee<0>(expect_usage_entry_number), Return(CREATE_USAGE_ENTRY_UNKNOWN_ERROR))); @@ -1018,7 +1023,8 @@ TEST_F(UsageTableHeaderTest, AddEntry_CreateUsageEntryFailed_UnknownError) { TEST_F(UsageTableHeaderTest, AddEntry_UsageEntryTooSmall) { Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); - const uint32_t expect_usage_entry_number = kUsageEntryInfoVector.size() - 1; + const uint32_t expect_usage_entry_number = + static_cast(kUsageEntryInfoVector.size()) - 1; EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull())) .WillOnce( DoAll(SetArgPointee<0>(expect_usage_entry_number), Return(NO_ERROR))); @@ -1057,8 +1063,10 @@ TEST_F(UsageTableHeaderTest, AddEntry_UsageEntryTooSmall) { // # of usage entries 3 3 TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveOfflineUsageEntry) { Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); - const uint32_t initial_usage_entry_number = kUsageEntryInfoVector.size(); - const uint32_t final_usage_entry_number = kUsageEntryInfoVector.size() - 1; + 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] = @@ -1068,10 +1076,11 @@ TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveOfflineUsageEntry) { Return(NO_ERROR))); EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_usage_entry_number)) .WillOnce(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(kLevelDefault, - expect_usage_entry_info_vector.size(), NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, + static_cast(expect_usage_entry_info_vector.size()), + NotNull())) .WillOnce( DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull())) @@ -1117,8 +1126,10 @@ TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveOfflineUsageEntry) { // # of usage entries 3 3 TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveSecureStopUsageEntry) { Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); - const uint32_t initial_usage_entry_number = kUsageEntryInfoVector.size(); - const uint32_t final_usage_entry_number = kUsageEntryInfoVector.size() - 1; + 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] = @@ -1129,10 +1140,11 @@ TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveSecureStopUsageEntry) { Return(NO_ERROR))); EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_usage_entry_number)) .WillOnce(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(kLevelDefault, - expect_usage_entry_info_vector.size(), NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, + static_cast(expect_usage_entry_info_vector.size()), + NotNull())) .WillOnce( DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull())) @@ -1184,11 +1196,13 @@ TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveSecureStopUsageEntry) { // # of usage entries 3 3 TEST_F(UsageTableHeaderTest, AddEntry_SkipUsageEntries) { Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); - const uint32_t next_usage_entry_number = kUsageEntryInfoVector.size(); + const uint32_t next_usage_entry_number = + 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 = kUsageEntryInfoVector.size() - 1; + 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] = @@ -1199,10 +1213,11 @@ TEST_F(UsageTableHeaderTest, AddEntry_SkipUsageEntries) { Return(NO_ERROR))); EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_usage_entry_number)) .WillOnce(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(kLevelDefault, - expect_usage_entry_info_vector.size(), NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, + static_cast(expect_usage_entry_info_vector.size()), + NotNull())) .WillOnce( DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull())) @@ -1248,9 +1263,10 @@ TEST_F(UsageTableHeaderTest, AddEntry_SkipUsageEntries) { // # of usage entries 3 4 TEST_F(UsageTableHeaderTest, AddEntry_CannotMoveNewEntry) { Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); - const uint32_t final_usage_entry_number = kUsageEntryInfoVector.size(); + const uint32_t final_usage_entry_number = + static_cast(kUsageEntryInfoVector.size()); const uint32_t attempted_usage_entry_number = - kUsageEntryInfoVector.size() - 1; + static_cast(kUsageEntryInfoVector.size()) - 1; std::vector expect_usage_entry_info_vector = kUsageEntryInfoVector; expect_usage_entry_info_vector.push_back(kUsageEntryInfoSecureStop2); @@ -1304,8 +1320,10 @@ TEST_F(UsageTableHeaderTest, AddEntry_CannotMoveNewEntry) { // # of usage entries 3 4 TEST_F(UsageTableHeaderTest, AddEntry_CannotShinkAfterMove) { Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); - const uint32_t initial_usage_entry_number = kUsageEntryInfoVector.size(); - const uint32_t final_usage_entry_number = kUsageEntryInfoVector.size() - 1; + 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] = @@ -1320,7 +1338,9 @@ TEST_F(UsageTableHeaderTest, AddEntry_CannotShinkAfterMove) { EXPECT_CALL( *crypto_session_, ShrinkUsageTableHeader( - kLevelDefault, expect_usage_entry_info_vector.size() - 1, NotNull())) + kLevelDefault, + static_cast(expect_usage_entry_info_vector.size()) - 1, + NotNull())) .WillOnce(Return(SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE)); EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull())) .WillOnce( @@ -1364,7 +1384,7 @@ TEST_F(UsageTableHeaderTest, uint32_t invalidated_entry = 0; // Randomly chosen by UsageTableHeader const uint32_t expected_usage_entry_number = - k10UsageEntryInfoVector.size() - 1; + static_cast(k10UsageEntryInfoVector.size()) - 1; EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull())) // First call fails @@ -1452,14 +1472,15 @@ TEST_F(UsageTableHeaderTest, AddEntry_CreateUsageEntryFailsEveryTime) { // marked as invalid plus the number of fewer entries in the table // at the end of the call. const uint32_t entries_deleted = - invalid_entries + - (k10UsageEntryInfoVector.size() - final_usage_entries.size()); + invalid_entries + static_cast(k10UsageEntryInfoVector.size() - + final_usage_entries.size()); EXPECT_EQ(kExpectedEntriesDeleted, entries_deleted); } TEST_F(UsageTableHeaderTest, LoadEntry_InvalidEntryNumber) { Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); - const uint32_t usage_entry_number = kUsageEntryInfoVector.size() + 3; + const uint32_t usage_entry_number = + static_cast(kUsageEntryInfoVector.size()) + 3; EXPECT_NE(NO_ERROR, usage_table_header_->LoadEntry( crypto_session_, kUsageEntry, usage_entry_number)); @@ -1520,7 +1541,8 @@ TEST_F(UsageTableHeaderTest, UpdateEntry) { TEST_F(UsageTableHeaderTest, InvalidateEntry_InvalidUsageEntryNumber) { Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); - const uint32_t usage_entry_number = kUsageEntryInfoVector.size(); + const uint32_t usage_entry_number = + static_cast(kUsageEntryInfoVector.size()); metrics::CryptoMetrics metrics; EXPECT_NE(NO_ERROR, usage_table_header_->InvalidateEntry( @@ -3582,17 +3604,18 @@ TEST_F(UsageTableHeaderTest, Shrink_NoneOfTable) { TEST_F(UsageTableHeaderTest, Shrink_PartOfTable) { Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector); const uint32_t to_shink = 5; - const std::vector shunken_entries( + const std::vector shrunken_entries( k10UsageEntryInfoVector.cbegin(), k10UsageEntryInfoVector.cend() - to_shink); metrics::CryptoMetrics metrics; - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(kLevelDefault, shunken_entries.size(), NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, static_cast(shrunken_entries.size()), + NotNull())) .WillOnce(Return(NO_ERROR)); EXPECT_CALL(*device_files_, - StoreUsageTableInfo(kUsageTableHeader, shunken_entries)) + StoreUsageTableInfo(kUsageTableHeader, shrunken_entries)) .WillOnce(Return(true)); EXPECT_EQ(usage_table_header_->Shrink(&metrics, to_shink), NO_ERROR); @@ -3611,7 +3634,8 @@ TEST_F(UsageTableHeaderTest, Shrink_AllOfTable) { .WillOnce(Return(true)); EXPECT_EQ( - usage_table_header_->Shrink(&metrics, k10UsageEntryInfoVector.size()), + usage_table_header_->Shrink( + &metrics, static_cast(k10UsageEntryInfoVector.size())), NO_ERROR); } @@ -3627,9 +3651,10 @@ TEST_F(UsageTableHeaderTest, Shrink_MoreThanTable) { kEmptyUsageEntryInfoVector)) .WillOnce(Return(true)); - EXPECT_EQ(usage_table_header_->Shrink(&metrics, - k10UsageEntryInfoVector.size() + 10), - NO_ERROR); + EXPECT_EQ( + usage_table_header_->Shrink( + &metrics, static_cast(k10UsageEntryInfoVector.size()) + 10), + NO_ERROR); } // LRU Usage Table Upgrade Test @@ -3908,7 +3933,7 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateLicenseEntry) { // Expected values. const uint32_t expected_usage_entry_number = - kUpgradedUsageEntryInfoList.size(); + static_cast(kUpgradedUsageEntryInfoList.size()); const CdmUsageEntryInfo expected_new_entry = { kStorageLicense, "offline_key_set_4", "", kLruBaseTime, kLruBaseTime + kDefaultExpireDuration}; @@ -3946,7 +3971,7 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateUsageInfoEntry) { // Expected values. const uint32_t expected_usage_entry_number = - kUpgradedUsageEntryInfoList.size(); + 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. */ @@ -4265,7 +4290,8 @@ TEST_F(UsageTableHeaderTest, // Mark 3 as expired. std::vector expired_license_numbers; while (expired_license_numbers.size() < 3) { - const uint32_t i = CdmRandom::RandomInRange(kSetSize - 1); + const uint32_t i = + static_cast(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; @@ -4320,7 +4346,8 @@ 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 = CdmRandom::RandomInRange(kLargeSetSize - 1); + const uint32_t i = + static_cast(CdmRandom::RandomInRange(kLargeSetSize - 1)); CdmUsageEntryInfo& usage_entry_info = usage_entry_info_list[i]; // Skip offline licenses. if (usage_entry_info.storage_type != kStorageUsageInfo) continue; @@ -4332,7 +4359,8 @@ TEST_F(UsageTableHeaderTest, DetermineLicenseToRemove_LargeMixedSet) { // 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 = CdmRandom::RandomInRange(kLargeSetSize - 1); + const uint32_t i = + static_cast(CdmRandom::RandomInRange(kLargeSetSize - 1)); CdmUsageEntryInfo& usage_entry_info = usage_entry_info_list[i]; // Skip streaming licenses. if (usage_entry_info.storage_type != kStorageLicense) continue; diff --git a/libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp b/libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp index ccadeb52..0d617d01 100644 --- a/libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp +++ b/libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp @@ -8646,7 +8646,7 @@ TEST_P(OEMCryptoUsageTableDefragTest, ManyUsageEntries) { // Shrink the table a little. constexpr size_t small_number = 5; size_t smaller_size = successful_count - small_number; - ASSERT_NO_FATAL_FAILURE(ShrinkHeader(smaller_size)); + ASSERT_NO_FATAL_FAILURE(ShrinkHeader(static_cast(smaller_size))); // Throw out the last license if it was in the part of the table that was // shrunk. if (entries.back()->session().usage_entry_number() >= smaller_size) { From 921cc2c4a3c94e22fa634b6ac17faa42f5869f65 Mon Sep 17 00:00:00 2001 From: "John W. Bruce" Date: Wed, 20 Oct 2021 13:56:49 -0700 Subject: [PATCH 2/3] Fix -Wshorten-64-to-32 errors in string conversion code (This is a merge of http://go/wvgerrit/134313.) This patch fixes code that would trigger -Wshorten-64-to-32 by implicitly narrowing a variable from 64 to 32 bits. There were two cases of this in string_conversions.cpp: * The implicit conversions in DecodeBase64Char() were made explicit, which required going through both a reinterpret_cast and a static_cast to express fully. * a2b_hex() now uses size_t for the length, as it probably always should have. Bug: 194971260 Test: x86-64 tests Change-Id: Ib9715b8adecc104f1a056ab0ac5faa5be74e5e54 --- libwvdrmengine/cdm/util/src/string_conversions.cpp | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/libwvdrmengine/cdm/util/src/string_conversions.cpp b/libwvdrmengine/cdm/util/src/string_conversions.cpp index 9e822102..f3a0ba4d 100644 --- a/libwvdrmengine/cdm/util/src/string_conversions.cpp +++ b/libwvdrmengine/cdm/util/src/string_conversions.cpp @@ -33,9 +33,11 @@ const char kBase64SafeCodes[] = // Decodes a single Base64 encoded character into its 6-bit value. // The provided |codes| must be a Base64 character map. int DecodeBase64Char(char c, const char* codes) { - const char* it = strchr(codes, c); - if (it == nullptr) return -1; - return it - codes; + const char* c_in_codes = strchr(codes, c); + if (c_in_codes == nullptr) return -1; + const uintptr_t c_in_codes_int = reinterpret_cast(c_in_codes); + const uintptr_t codes_int = reinterpret_cast(codes); + return static_cast(c_in_codes_int - codes_int); } bool DecodeHexChar(char ch, uint8_t* digit) { @@ -158,9 +160,9 @@ std::vector Base64DecodeInternal(const char* encoded, size_t length, // converts an ascii hex string(2 bytes per digit) into a decimal byte string std::vector a2b_hex(const std::string& byte) { std::vector array; - unsigned int count = byte.size(); + size_t count = byte.size(); if (count == 0 || (count % 2) != 0) { - LOGE("Invalid input size %u for string %s", count, byte.c_str()); + LOGE("Invalid input size %zu for string %s", count, byte.c_str()); return array; } From 5619afc5660ef5cdeb3492d70b27b7d0aebc87a8 Mon Sep 17 00:00:00 2001 From: "John W. Bruce" Date: Wed, 20 Oct 2021 14:14:58 -0700 Subject: [PATCH 3/3] Clarify entitled vs. entitlement in OEMCrypto tests (This is a merge of http://go/wvgerrit/133650.) Several places in the OEMCrypto tests refer to entitled keys as entitlement keys. This patch fixes those references. It does not change places that were actually meant to refer to entitlement keys. Test: x86-64 platform tests Bug: 203697187 Change-Id: I2ad2d82a666fd0cc08662e39177313cf36c2ad43 --- .../oemcrypto/test/oemcrypto_test.cpp | 78 +++++++++---------- 1 file changed, 37 insertions(+), 41 deletions(-) diff --git a/libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp b/libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp index 0d617d01..ef5c364a 100644 --- a/libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp +++ b/libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp @@ -1413,7 +1413,7 @@ class OEMCryptoMemoryLicenseTest : public OEMCryptoLicenseTestAPI16 { EntitledMessage entitled_message_; size_t entitlement_response_length_; - void TestLoadEntitlementKeysForHugeBufferLengths( + void TestLoadEntitledKeysForHugeBufferLengths( const std::function f, bool check_status) { size_t entitled_key_data_size = entitled_message_.entitled_key_data_size(); @@ -1679,7 +1679,7 @@ TEST_P(OEMCryptoLicenseTest, LoadKeyWithNonceTwiceAPI16) { } // This verifies that entitlement keys and entitled content keys can be loaded. -TEST_P(OEMCryptoLicenseTest, LoadEntitlementKeysAPI14) { +TEST_P(OEMCryptoLicenseTest, LoadEntitledKeysAPI14) { ASSERT_NO_FATAL_FAILURE(session_.GenerateNonce()); license_messages_.set_license_type(OEMCrypto_EntitlementLicense); ASSERT_NO_FATAL_FAILURE(license_messages_.SignAndVerifyRequest()); @@ -1696,7 +1696,7 @@ TEST_P(OEMCryptoLicenseTest, LoadEntitlementKeysAPI14) { // This verifies that entitled content keys cannot be loaded if we have not yet // loaded the entitlement keys. -TEST_P(OEMCryptoLicenseTest, LoadEntitlementKeysNoEntitlementKeysAPI14) { +TEST_P(OEMCryptoLicenseTest, LoadEntitledKeysNoEntitlementKeysAPI14) { ASSERT_NO_FATAL_FAILURE(session_.GenerateNonce()); license_messages_.set_license_type(OEMCrypto_EntitlementLicense); ASSERT_NO_FATAL_FAILURE(license_messages_.SignAndVerifyRequest()); @@ -1710,7 +1710,7 @@ TEST_P(OEMCryptoLicenseTest, LoadEntitlementKeysNoEntitlementKeysAPI14) { // This verifies that entitled content keys cannot be loaded if we have loaded // the wrong entitlement keys. -TEST_P(OEMCryptoLicenseTest, LoadEntitlementKeysWrongEntitlementKeysAPI14) { +TEST_P(OEMCryptoLicenseTest, LoadEntitledKeysWrongEntitlementKeysAPI14) { ASSERT_NO_FATAL_FAILURE(session_.GenerateNonce()); license_messages_.set_license_type(OEMCrypto_EntitlementLicense); ASSERT_NO_FATAL_FAILURE(license_messages_.SignAndVerifyRequest()); @@ -1757,8 +1757,8 @@ TEST_F(OEMCryptoMemoryLicenseTest, } TEST_F(OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForHugeSubstringContentKeyIdLength) { - TestLoadEntitlementKeysForHugeBufferLengths( + OEMCryptoMemoryLoadEntitledKeysForHugeSubstringContentKeyIdLength) { + TestLoadEntitledKeysForHugeBufferLengths( [](size_t key_id_length, EntitledMessage* entitled_message) { entitled_message->entitled_key_array()[0].content_key_id.length = key_id_length; @@ -1767,8 +1767,8 @@ TEST_F(OEMCryptoMemoryLicenseTest, } TEST_F(OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForHugeSubstringContentKeyIdOffset) { - TestLoadEntitlementKeysForHugeBufferLengths( + OEMCryptoMemoryLoadEntitledKeysForHugeSubstringContentKeyIdOffset) { + TestLoadEntitledKeysForHugeBufferLengths( [](size_t key_id_offset, EntitledMessage* entitled_message) { entitled_message->entitled_key_array()[0].content_key_id.offset = key_id_offset; @@ -1778,7 +1778,7 @@ TEST_F(OEMCryptoMemoryLicenseTest, TEST_F( OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForOutOfRangeSubstringContentKeyIdLength) { + OEMCryptoMemoryLoadEntitledKeysForOutOfRangeSubstringContentKeyIdLength) { auto& content_key_id = entitled_message_.entitled_key_array()[0].content_key_id; content_key_id.length = @@ -1788,7 +1788,7 @@ TEST_F( TEST_F( OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForOutOfRangeSubstringContentKeyIdOffset) { + OEMCryptoMemoryLoadEntitledKeysForOutOfRangeSubstringContentKeyIdOffset) { auto& content_key_id = entitled_message_.entitled_key_array()[0].content_key_id; content_key_id.offset = @@ -1796,10 +1796,9 @@ TEST_F( ASSERT_NE(OEMCrypto_SUCCESS, entitled_message_.LoadKeys()); } -TEST_F( - OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForHugeSubstringEntitlementKeyIdLength) { - TestLoadEntitlementKeysForHugeBufferLengths( +TEST_F(OEMCryptoMemoryLicenseTest, + OEMCryptoMemoryLoadEntitledKeysForHugeSubstringEntitlementKeyIdLength) { + TestLoadEntitledKeysForHugeBufferLengths( [](size_t key_id_length, EntitledMessage* entitled_message) { entitled_message->entitled_key_array()[0].entitlement_key_id.length = key_id_length; @@ -1807,10 +1806,9 @@ TEST_F( !kCheckStatus); } -TEST_F( - OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForHugeSubstringEntitlementKeyIdOffset) { - TestLoadEntitlementKeysForHugeBufferLengths( +TEST_F(OEMCryptoMemoryLicenseTest, + OEMCryptoMemoryLoadEntitledKeysForHugeSubstringEntitlementKeyIdOffset) { + TestLoadEntitledKeysForHugeBufferLengths( [](size_t key_id_offset, EntitledMessage* entitled_message) { entitled_message->entitled_key_array()[0].entitlement_key_id.offset = key_id_offset; @@ -1820,7 +1818,7 @@ TEST_F( TEST_F( OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForOutOfRangeSubstringEntitlementKeyIdLength) { + OEMCryptoMemoryLoadEntitledKeysForOutOfRangeSubstringEntitlementKeyIdLength) { auto& entitlement_key_id = entitled_message_.entitled_key_array()[0].entitlement_key_id; entitlement_key_id.length = @@ -1830,7 +1828,7 @@ TEST_F( TEST_F( OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForOutOfRangeSubstringEntitlementKeyIdOffset) { + OEMCryptoMemoryLoadEntitledKeysForOutOfRangeSubstringEntitlementKeyIdOffset) { auto& entitlement_key_id = entitled_message_.entitled_key_array()[0].entitlement_key_id; entitlement_key_id.offset = @@ -1838,10 +1836,9 @@ TEST_F( ASSERT_NE(OEMCrypto_SUCCESS, entitled_message_.LoadKeys()); } -TEST_F( - OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForHugeSubstringContentKeyDataIvLength) { - TestLoadEntitlementKeysForHugeBufferLengths( +TEST_F(OEMCryptoMemoryLicenseTest, + OEMCryptoMemoryLoadEntitledKeysForHugeSubstringContentKeyDataIvLength) { + TestLoadEntitledKeysForHugeBufferLengths( [](size_t content_key_data_iv_length, EntitledMessage* entitled_message) { entitled_message->entitled_key_array()[0].content_key_data_iv.length = content_key_data_iv_length; @@ -1849,10 +1846,9 @@ TEST_F( !kCheckStatus); } -TEST_F( - OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForHugeSubstringContentKeyDataIvOffset) { - TestLoadEntitlementKeysForHugeBufferLengths( +TEST_F(OEMCryptoMemoryLicenseTest, + OEMCryptoMemoryLoadEntitledKeysForHugeSubstringContentKeyDataIvOffset) { + TestLoadEntitledKeysForHugeBufferLengths( [](size_t content_key_data_iv_offset, EntitledMessage* entitled_message) { entitled_message->entitled_key_array()[0].content_key_data_iv.offset = content_key_data_iv_offset; @@ -1862,7 +1858,7 @@ TEST_F( TEST_F( OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForOutOfRangeSubstringContentKeyDataIvLength) { + OEMCryptoMemoryLoadEntitledKeysForOutOfRangeSubstringContentKeyDataIvLength) { auto& content_key_data_iv = entitled_message_.entitled_key_array()[0].content_key_data_iv; content_key_data_iv.length = @@ -1872,7 +1868,7 @@ TEST_F( TEST_F( OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForOutOfRangeSubstringContentKeyDataIvOffset) { + OEMCryptoMemoryLoadEntitledKeysForOutOfRangeSubstringContentKeyDataIvOffset) { auto& content_key_data_iv = entitled_message_.entitled_key_array()[0].content_key_data_iv; content_key_data_iv.offset = @@ -1881,8 +1877,8 @@ TEST_F( } TEST_F(OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForHugeSubstringContentKeyDataLength) { - TestLoadEntitlementKeysForHugeBufferLengths( + OEMCryptoMemoryLoadEntitledKeysForHugeSubstringContentKeyDataLength) { + TestLoadEntitledKeysForHugeBufferLengths( [](size_t content_key_data_length, EntitledMessage* entitled_message) { entitled_message->entitled_key_array()[0].content_key_data.length = content_key_data_length; @@ -1891,8 +1887,8 @@ TEST_F(OEMCryptoMemoryLicenseTest, } TEST_F(OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForHugeSubstringContentKeyDataOffset) { - TestLoadEntitlementKeysForHugeBufferLengths( + OEMCryptoMemoryLoadEntitledKeysForHugeSubstringContentKeyDataOffset) { + TestLoadEntitledKeysForHugeBufferLengths( [](size_t content_key_data_offset, EntitledMessage* entitled_message) { entitled_message->entitled_key_array()[0].content_key_data.offset = content_key_data_offset; @@ -1902,7 +1898,7 @@ TEST_F(OEMCryptoMemoryLicenseTest, TEST_F( OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForOutOfRangeSubstringContentKeyDataLength) { + OEMCryptoMemoryLoadEntitledKeysForOutOfRangeSubstringContentKeyDataLength) { auto& content_key_data = entitled_message_.entitled_key_array()[0].content_key_data; content_key_data.length = @@ -1912,7 +1908,7 @@ TEST_F( TEST_F( OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForOutOfRangeSubstringContentKeyDataOffset) { + OEMCryptoMemoryLoadEntitledKeysForOutOfRangeSubstringContentKeyDataOffset) { auto& content_key_data = entitled_message_.entitled_key_array()[0].content_key_data; content_key_data.offset = @@ -1921,8 +1917,8 @@ TEST_F( } TEST_F(OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForHugeEntitlementKeyIdLength) { - TestLoadEntitlementKeysForHugeBufferLengths( + OEMCryptoMemoryLoadEntitledKeysForHugeEntitlementKeyIdLength) { + TestLoadEntitledKeysForHugeBufferLengths( [](size_t key_id_length, EntitledMessage* entitled_message) { entitled_message->entitled_key_data()->entitlement_key_id_length = key_id_length; @@ -1931,8 +1927,8 @@ TEST_F(OEMCryptoMemoryLicenseTest, } TEST_F(OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForHugeContentKeyIdLength) { - TestLoadEntitlementKeysForHugeBufferLengths( + OEMCryptoMemoryLoadEntitledKeysForHugeContentKeyIdLength) { + TestLoadEntitledKeysForHugeBufferLengths( [](size_t key_id_length, EntitledMessage* entitled_message) { entitled_message->entitled_key_data()->content_key_id_length = key_id_length; @@ -1943,7 +1939,7 @@ TEST_F(OEMCryptoMemoryLicenseTest, // This verifies that entitled content keys API does not crash for unreasonable // input message buffer lengths. TEST_F(OEMCryptoMemoryLicenseTest, - OEMCryptoMemoryLoadEntitlementKeysForHugeBufferLength) { + OEMCryptoMemoryLoadEntitledKeysForHugeBufferLength) { auto oemcrypto_function = [&](size_t buffer_length) { size_t entitled_key_data_length = entitled_message_.entitled_key_data_size();