widevine-partner/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix -Wshorten-64-to-32 errors in usage table code

Browse Source 
(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
This commit is contained in:
John W. Bruce
2021-10-20 13:54:26 -07:00
committed by John Bruce
parent ef792a4aca
commit 1447eba7bc
5 changed files with 127 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
libwvdrmengine/cdm/core/src/crypto_session.cpp
View File

@@ -2141,7 +2141,7 @@ bool CryptoSession::GetMaximumUsageTableEntries(SecurityLevel security_level,
}); });
// Record the number of entries into the metrics. // Record the number of entries into the metrics.
metrics_->oemcrypto_maximum_usage_table_header_size_.Record( metrics_->oemcrypto_maximum_usage_table_header_size_.Record(
*number_of_entries); static_cast<uint32_t>(*number_of_entries));
if (*number_of_entries == 0) { if (*number_of_entries == 0) {
// Special value, indicating that the table size is not directly // Special value, indicating that the table size is not directly

27
libwvdrmengine/cdm/core/src/device_files.cpp
View File

@@ -804,7 +804,8 @@ bool DeviceFiles::RetrieveLicense(const std::string& key_set_id,
license.app_parameters(i).value(); license.app_parameters(i).value();
} }
license_data->usage_entry = license.usage_entry(); license_data->usage_entry = license.usage_entry();
license_data->usage_entry_number = license.usage_entry_number(); license_data->usage_entry_number =
static_cast<uint32_t>(license.usage_entry_number());
if (!license.has_drm_certificate()) { if (!license.has_drm_certificate()) {
license_data->drm_certificate.clear(); license_data->drm_certificate.clear();
@@ -951,8 +952,8 @@ bool DeviceFiles::ListUsageIds(
if (ksids != nullptr) ksids->clear(); if (ksids != nullptr) ksids->clear();
if (provider_session_tokens != nullptr) provider_session_tokens->clear(); if (provider_session_tokens != nullptr) provider_session_tokens->clear();
size_t num_records = file.usage_info().sessions_size(); const int num_records = file.usage_info().sessions_size();
for (size_t i = 0; i < num_records; ++i) { for (int i = 0; i < num_records; ++i) {
if ((ksids != nullptr) && if ((ksids != nullptr) &&
!file.usage_info().sessions(i).key_set_id().empty()) { !file.usage_info().sessions(i).key_set_id().empty()) {
ksids->push_back(file.usage_info().sessions(i).key_set_id()); 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; return false;
} }
size_t num_records = file.usage_info().sessions_size(); const int num_records = static_cast<int>(file.usage_info().sessions_size());
for (size_t i = 0; i < num_records; ++i) { for (int i = 0; i < num_records; ++i) {
if (file.usage_info().sessions(i).key_set_id() == key_set_id) { if (file.usage_info().sessions(i).key_set_id() == key_set_id) {
*provider_session_token = file.usage_info().sessions(i).token(); *provider_session_token = file.usage_info().sessions(i).token();
return true; 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_request = file.usage_info().sessions(index).license_request();
*license = file.usage_info().sessions(index).license(); *license = file.usage_info().sessions(index).license();
*usage_entry = file.usage_info().sessions(index).usage_entry(); *usage_entry = file.usage_info().sessions(index).usage_entry();
*usage_entry_number = *usage_entry_number = static_cast<uint32_t>(
file.usage_info().sessions(index).usage_entry_number(); file.usage_info().sessions(index).usage_entry_number());
if (!file.usage_info().sessions(index).has_drm_certificate_id()) { if (!file.usage_info().sessions(index).has_drm_certificate_id()) {
drm_certificate->clear(); drm_certificate->clear();
@@ -1180,8 +1181,8 @@ bool DeviceFiles::RetrieveUsageInfoByKeySetId(
*license_request = file.usage_info().sessions(index).license_request(); *license_request = file.usage_info().sessions(index).license_request();
*license = file.usage_info().sessions(index).license(); *license = file.usage_info().sessions(index).license();
*usage_entry = file.usage_info().sessions(index).usage_entry(); *usage_entry = file.usage_info().sessions(index).usage_entry();
*usage_entry_number = *usage_entry_number = static_cast<uint32_t>(
file.usage_info().sessions(index).usage_entry_number(); file.usage_info().sessions(index).usage_entry_number());
if (!file.usage_info().sessions(index).has_drm_certificate_id()) { if (!file.usage_info().sessions(index).has_drm_certificate_id()) {
drm_certificate->clear(); 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].license = file.usage_info().sessions(i).license();
(*usage_data)[i].key_set_id = file.usage_info().sessions(i).key_set_id(); (*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 = file.usage_info().sessions(i).usage_entry();
(*usage_data)[i].usage_entry_number = (*usage_data)[i].usage_entry_number = static_cast<uint32_t>(
file.usage_info().sessions(i).usage_entry_number(); file.usage_info().sessions(i).usage_entry_number());
if (!file.usage_info().sessions(i).has_drm_certificate_id()) { if (!file.usage_info().sessions(i).has_drm_certificate_id()) {
(*usage_data)[i].drm_certificate.clear(); (*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->license = file.usage_info().sessions(index).license();
usage_data->key_set_id = file.usage_info().sessions(index).key_set_id(); 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 = file.usage_info().sessions(index).usage_entry();
usage_data->usage_entry_number = usage_data->usage_entry_number = static_cast<uint32_t>(
file.usage_info().sessions(index).usage_entry_number(); file.usage_info().sessions(index).usage_entry_number());
if (!file.usage_info().sessions(index).has_drm_certificate_id()) { if (!file.usage_info().sessions(index).has_drm_certificate_id()) {
usage_data->drm_certificate.clear(); usage_data->drm_certificate.clear();

47
libwvdrmengine/cdm/core/src/usage_table_header.cpp
View File

@@ -636,13 +636,14 @@ CdmResponseType UsageTableHeader::RefitTable(
CryptoSession* const crypto_session) { CryptoSession* const crypto_session) {
// Remove all unoccupied entries at end of the table. // Remove all unoccupied entries at end of the table.
uint32_t entries_to_remove = 0; uint32_t entries_to_remove = 0;
for (uint32_t i = 0; i < usage_entry_info_.size(); i++) { const uint32_t old_size = static_cast<uint32_t>(usage_entry_info_.size());
const uint32_t usage_entry_number = usage_entry_info_.size() - i - 1; 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; if (!IsEntryUnoccupied(usage_entry_number)) break;
++entries_to_remove; ++entries_to_remove;
} }
if (entries_to_remove == 0) return NO_ERROR; 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( const CdmResponseType status = crypto_session->ShrinkUsageTableHeader(
requested_security_level_, new_size, &usage_table_header_); requested_security_level_, new_size, &usage_table_header_);
if (status == SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE) { 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 " "Cannot delete more entries than the table size, reducing to current "
"table size: table_size = %zu, number_to_delete = %u", "table size: table_size = %zu, number_to_delete = %u",
usage_entry_info_.size(), number_of_usage_entries_to_delete); 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<uint32_t>(usage_entry_info_.size());
} }
if (number_of_usage_entries_to_delete == 0) return NO_ERROR; if (number_of_usage_entries_to_delete == 0) return NO_ERROR;
@@ -898,8 +900,8 @@ CdmResponseType UsageTableHeader::Shrink(
crypto_session = scoped_crypto_session.get(); crypto_session = scoped_crypto_session.get();
} }
const size_t new_size = const uint32_t new_size = static_cast<uint32_t>(usage_entry_info_.size()) -
usage_entry_info_.size() - number_of_usage_entries_to_delete; number_of_usage_entries_to_delete;
const CdmResponseType status = crypto_session->ShrinkUsageTableHeader( const CdmResponseType status = crypto_session->ShrinkUsageTableHeader(
requested_security_level_, new_size, &usage_table_header_); 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(); entries_to_move.size() < entries_to_remove.size();
++i) { ++i) {
// Search from the end of the table. // 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<uint32_t>(usage_entry_info_.size()) - i - 1;
if (usage_entry_info_[entry_index].storage_type != kStorageTypeUnknown) { if (usage_entry_info_[entry_index].storage_type != kStorageTypeUnknown) {
entries_to_move.push_back(entry_index); entries_to_move.push_back(entry_index);
} }
@@ -963,7 +966,7 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
if (entries_to_move.empty()) { if (entries_to_move.empty()) {
LOGD("No valid entries found, shrinking entire table: size = %zu", LOGD("No valid entries found, shrinking entire table: size = %zu",
usage_entry_info_.size()); usage_entry_info_.size());
return Shrink(metrics, usage_entry_info_.size()); return Shrink(metrics, static_cast<uint32_t>(usage_entry_info_.size()));
} }
// Step 3: Ignore invalid entries that are after the last valid // 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 // entry. In this case, no movement is required and the table can just
// be shrunk to the last valid entry. // be shrunk to the last valid entry.
if (entries_to_remove.empty()) { if (entries_to_remove.empty()) {
const size_t to_remove = usage_entry_info_.size() - last_valid_entry - 1; const uint32_t to_remove =
LOGD("Removing all entries after the last valid entry: count = %zu", static_cast<uint32_t>(usage_entry_info_.size()) - last_valid_entry - 1;
LOGD("Removing all entries after the last valid entry: count = %u",
to_remove); to_remove);
return Shrink(metrics, to_remove); return Shrink(metrics, to_remove);
} }
@@ -1095,9 +1099,11 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
} // End while loop. } // End while loop.
// Step 5: Find the new last valid entry. // 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<uint32_t>(usage_entry_info_.size());
for (uint32_t i = 0; i < usage_entry_info_.size(); ++i) { 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<uint32_t>(usage_entry_info_.size()) - i - 1;
if (usage_entry_info_[entry_index].storage_type != kStorageTypeUnknown) { if (usage_entry_info_[entry_index].storage_type != kStorageTypeUnknown) {
new_last_valid_entry = entry_index; new_last_valid_entry = entry_index;
break; break;
@@ -1111,10 +1117,11 @@ CdmResponseType UsageTableHeader::DefragTable(DeviceFiles* device_files,
LOGD( LOGD(
"All entries have been invalidated, shrinking entire table: size = %zu", "All entries have been invalidated, shrinking entire table: size = %zu",
usage_entry_info_.size()); usage_entry_info_.size());
return Shrink(metrics, usage_entry_info_.size()); return Shrink(metrics, static_cast<uint32_t>(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<uint32_t>(usage_entry_info_.size()) -
new_last_valid_entry - 1;
// Special case 6: It is possible that the last entry in the table // Special case 6: It is possible that the last entry in the table
// is valid and currently loaded in the table by another session. // 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. // 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); return Shrink(metrics, to_remove);
} // End Defrag(). } // End Defrag().
@@ -1188,7 +1195,7 @@ bool UsageTableHeader::LruUpgradeAllUsageEntries() {
// end, all problematic licenses will be marked as invalid. // end, all problematic licenses will be marked as invalid.
std::vector<uint32_t> bad_license_file_entries; std::vector<uint32_t> 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) { usage_entry_number < usage_entry_info_.size(); ++usage_entry_number) {
CdmUsageEntryInfo& usage_entry_info = usage_entry_info_[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); bad_license_file_entries.push_back(usage_entry_number);
continue; continue;
default: { 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<int>(usage_entry_info.storage_type), static_cast<int>(usage_entry_info.storage_type),
usage_entry_number); usage_entry_number);
bad_license_file_entries.push_back(usage_entry_number); bad_license_file_entries.push_back(usage_entry_number);
@@ -1221,7 +1228,7 @@ bool UsageTableHeader::LruUpgradeAllUsageEntries() {
} }
} }
if (!retrieve_response) { 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); usage_entry_number);
bad_license_file_entries.push_back(usage_entry_number); bad_license_file_entries.push_back(usage_entry_number);
continue; continue;
@@ -1229,7 +1236,7 @@ bool UsageTableHeader::LruUpgradeAllUsageEntries() {
if (retrieved_entry_number != usage_entry_number) { if (retrieved_entry_number != usage_entry_number) {
LOGW( LOGW(
"Usage entry number mismatched: usage_entry_number = %zu, " "Usage entry number mismatched: usage_entry_number = %u, "
"retrieved_entry_number = %u", "retrieved_entry_number = %u",
usage_entry_number, retrieved_entry_number); usage_entry_number, retrieved_entry_number);
bad_license_file_entries.push_back(usage_entry_number); bad_license_file_entries.push_back(usage_entry_number);
@@ -1238,7 +1245,7 @@ bool UsageTableHeader::LruUpgradeAllUsageEntries() {
video_widevine::License license; video_widevine::License license;
if (!ParseLicenseFromLicenseMessage(license_message, &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); usage_entry_number);
bad_license_file_entries.push_back(usage_entry_number); bad_license_file_entries.push_back(usage_entry_number);
continue; continue;

140
libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp
View File

@@ -359,7 +359,7 @@ void InitVectorConstants() {
license_data.key_set_id = kUpgradableUsageEntryInfoList[i].key_set_id; license_data.key_set_id = kUpgradableUsageEntryInfoList[i].key_set_id;
license_data.state = kActiveLicenseState; license_data.state = kActiveLicenseState;
license_data.license = kUpgradableLicenseInfoList[i]; license_data.license = kUpgradableLicenseInfoList[i];
license_data.usage_entry_number = i; license_data.usage_entry_number = static_cast<uint32_t>(i);
kUpgradableLicenseDataList.push_back(license_data); kUpgradableLicenseDataList.push_back(license_data);
} }
} }
@@ -830,7 +830,8 @@ TEST_P(UsageTableHeaderInitializationTest,
RestoreUsageTable_NoCapacity_AboveMinimum) { RestoreUsageTable_NoCapacity_AboveMinimum) {
crypto_session_->SetMaximumUsageTableEntries(0); // Unlimited. crypto_session_->SetMaximumUsageTableEntries(0); // Unlimited.
ASSERT_LT(kDefaultTableCapacity, kOverFullUsageEntryInfoVector.size()); ASSERT_LT(kDefaultTableCapacity, kOverFullUsageEntryInfoVector.size());
const size_t kTableStartSize = kOverFullUsageEntryInfoVector.size(); const uint32_t table_start_size =
static_cast<uint32_t>(kOverFullUsageEntryInfoVector.size());
const SecurityLevel security_level = GetSecurityLevel(); const SecurityLevel security_level = GetSecurityLevel();
// Expectations for restore: // Expectations for restore:
@@ -858,7 +859,7 @@ TEST_P(UsageTableHeaderInitializationTest,
// 7) Table state is stored // 7) Table state is stored
EXPECT_CALL(*crypto_session_, Open(security_level)) EXPECT_CALL(*crypto_session_, Open(security_level))
.WillOnce(Return(NO_ERROR)); .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())) EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
.WillOnce( .WillOnce(
DoAll(SetArgPointee<0>(expect_usage_entry_number), Return(NO_ERROR))); DoAll(SetArgPointee<0>(expect_usage_entry_number), Return(NO_ERROR)));
@@ -866,14 +867,15 @@ TEST_P(UsageTableHeaderInitializationTest,
.WillOnce( .WillOnce(
DoAll(SetArgPointee<0>(kAnotherUsageTableHeader), Return(NO_ERROR))); DoAll(SetArgPointee<0>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_, StoreUsageTableInfo(kAnotherUsageTableHeader, EXPECT_CALL(*device_files_, StoreUsageTableInfo(kAnotherUsageTableHeader,
SizeIs(kTableStartSize + 1))) SizeIs(table_start_size + 1)))
.WillOnce(Return(true)); .WillOnce(Return(true));
EXPECT_CALL(*crypto_session_, ShrinkUsageTableHeader( EXPECT_CALL(
security_level, kTableStartSize, NotNull())) *crypto_session_,
ShrinkUsageTableHeader(security_level, table_start_size, NotNull()))
.WillOnce(DoAll(SetArgPointee<2>(kYetAnotherUsageTableHeader), .WillOnce(DoAll(SetArgPointee<2>(kYetAnotherUsageTableHeader),
Return(NO_ERROR))); Return(NO_ERROR)));
EXPECT_CALL(*device_files_, StoreUsageTableInfo(kYetAnotherUsageTableHeader, EXPECT_CALL(*device_files_, StoreUsageTableInfo(kYetAnotherUsageTableHeader,
SizeIs(kTableStartSize))) SizeIs(table_start_size)))
.WillOnce(Return(true)); .WillOnce(Return(true));
EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_)); EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
@@ -937,7 +939,8 @@ TEST_P(UsageTableHeaderInitializationTest,
RestoreUsageTable_NoCapacity_AboveMinimum_InvalidateEntryFails) { RestoreUsageTable_NoCapacity_AboveMinimum_InvalidateEntryFails) {
crypto_session_->SetMaximumUsageTableEntries(0); // Unlimited. crypto_session_->SetMaximumUsageTableEntries(0); // Unlimited.
ASSERT_LT(kDefaultTableCapacity, kOverFullUsageEntryInfoVector.size()); ASSERT_LT(kDefaultTableCapacity, kOverFullUsageEntryInfoVector.size());
const size_t kTableStartSize = kOverFullUsageEntryInfoVector.size(); const uint32_t table_start_size =
static_cast<uint32_t>(kOverFullUsageEntryInfoVector.size());
const SecurityLevel security_level = GetSecurityLevel(); const SecurityLevel security_level = GetSecurityLevel();
// Expectations for restore: // Expectations for restore:
@@ -964,7 +967,7 @@ TEST_P(UsageTableHeaderInitializationTest,
// 6) Shrinking table fails // 6) Shrinking table fails
EXPECT_CALL(*crypto_session_, Open(security_level)) EXPECT_CALL(*crypto_session_, Open(security_level))
.WillOnce(Return(NO_ERROR)); .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())) EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
.WillOnce( .WillOnce(
DoAll(SetArgPointee<0>(expect_usage_entry_number), Return(NO_ERROR))); DoAll(SetArgPointee<0>(expect_usage_entry_number), Return(NO_ERROR)));
@@ -973,11 +976,12 @@ TEST_P(UsageTableHeaderInitializationTest,
DoAll(SetArgPointee<0>(kAnotherUsageTableHeader), Return(NO_ERROR))); DoAll(SetArgPointee<0>(kAnotherUsageTableHeader), Return(NO_ERROR)));
// Called twice due to defrag. // Called twice due to defrag.
EXPECT_CALL(*device_files_, StoreUsageTableInfo(kAnotherUsageTableHeader, EXPECT_CALL(*device_files_, StoreUsageTableInfo(kAnotherUsageTableHeader,
SizeIs(kTableStartSize + 1))) SizeIs(table_start_size + 1)))
.Times(2) .Times(2)
.WillRepeatedly(Return(true)); .WillRepeatedly(Return(true));
EXPECT_CALL(*crypto_session_, ShrinkUsageTableHeader( EXPECT_CALL(
security_level, kTableStartSize, NotNull())) *crypto_session_,
ShrinkUsageTableHeader(security_level, table_start_size, NotNull()))
.WillOnce(Return(SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR)); .WillOnce(Return(SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR));
// Expectations for create: // Expectations for create:
@@ -1001,7 +1005,8 @@ INSTANTIATE_TEST_SUITE_P(Cdm, UsageTableHeaderInitializationTest,
TEST_F(UsageTableHeaderTest, AddEntry_CreateUsageEntryFailed_UnknownError) { TEST_F(UsageTableHeaderTest, AddEntry_CreateUsageEntryFailed_UnknownError) {
Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
const uint32_t expect_usage_entry_number = kUsageEntryInfoVector.size(); const uint32_t expect_usage_entry_number =
static_cast<uint32_t>(kUsageEntryInfoVector.size());
EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull())) EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
.WillOnce(DoAll(SetArgPointee<0>(expect_usage_entry_number), .WillOnce(DoAll(SetArgPointee<0>(expect_usage_entry_number),
Return(CREATE_USAGE_ENTRY_UNKNOWN_ERROR))); Return(CREATE_USAGE_ENTRY_UNKNOWN_ERROR)));
@@ -1018,7 +1023,8 @@ TEST_F(UsageTableHeaderTest, AddEntry_CreateUsageEntryFailed_UnknownError) {
TEST_F(UsageTableHeaderTest, AddEntry_UsageEntryTooSmall) { TEST_F(UsageTableHeaderTest, AddEntry_UsageEntryTooSmall) {
Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
const uint32_t expect_usage_entry_number = kUsageEntryInfoVector.size() - 1; const uint32_t expect_usage_entry_number =
static_cast<uint32_t>(kUsageEntryInfoVector.size()) - 1;
EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull())) EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
.WillOnce( .WillOnce(
DoAll(SetArgPointee<0>(expect_usage_entry_number), Return(NO_ERROR))); DoAll(SetArgPointee<0>(expect_usage_entry_number), Return(NO_ERROR)));
@@ -1057,8 +1063,10 @@ TEST_F(UsageTableHeaderTest, AddEntry_UsageEntryTooSmall) {
// # of usage entries 3 3 // # of usage entries 3 3
TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveOfflineUsageEntry) { TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveOfflineUsageEntry) {
Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
const uint32_t initial_usage_entry_number = kUsageEntryInfoVector.size(); const uint32_t initial_usage_entry_number =
const uint32_t final_usage_entry_number = kUsageEntryInfoVector.size() - 1; static_cast<uint32_t>(kUsageEntryInfoVector.size());
const uint32_t final_usage_entry_number =
static_cast<uint32_t>(kUsageEntryInfoVector.size()) - 1;
std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector = std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector =
kUsageEntryInfoVector; kUsageEntryInfoVector;
expect_usage_entry_info_vector[final_usage_entry_number] = expect_usage_entry_info_vector[final_usage_entry_number] =
@@ -1068,10 +1076,11 @@ TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveOfflineUsageEntry) {
Return(NO_ERROR))); Return(NO_ERROR)));
EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_usage_entry_number)) EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_usage_entry_number))
.WillOnce(Return(NO_ERROR)); .WillOnce(Return(NO_ERROR));
EXPECT_CALL( EXPECT_CALL(*crypto_session_,
*crypto_session_, ShrinkUsageTableHeader(
ShrinkUsageTableHeader(kLevelDefault, kLevelDefault,
expect_usage_entry_info_vector.size(), NotNull())) static_cast<uint32_t>(expect_usage_entry_info_vector.size()),
NotNull()))
.WillOnce( .WillOnce(
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull())) EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
@@ -1117,8 +1126,10 @@ TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveOfflineUsageEntry) {
// # of usage entries 3 3 // # of usage entries 3 3
TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveSecureStopUsageEntry) { TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveSecureStopUsageEntry) {
Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
const uint32_t initial_usage_entry_number = kUsageEntryInfoVector.size(); const uint32_t initial_usage_entry_number =
const uint32_t final_usage_entry_number = kUsageEntryInfoVector.size() - 1; static_cast<uint32_t>(kUsageEntryInfoVector.size());
const uint32_t final_usage_entry_number =
static_cast<uint32_t>(kUsageEntryInfoVector.size()) - 1;
std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector = std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector =
kUsageEntryInfoVector; kUsageEntryInfoVector;
expect_usage_entry_info_vector[final_usage_entry_number] = expect_usage_entry_info_vector[final_usage_entry_number] =
@@ -1129,10 +1140,11 @@ TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveSecureStopUsageEntry) {
Return(NO_ERROR))); Return(NO_ERROR)));
EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_usage_entry_number)) EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_usage_entry_number))
.WillOnce(Return(NO_ERROR)); .WillOnce(Return(NO_ERROR));
EXPECT_CALL( EXPECT_CALL(*crypto_session_,
*crypto_session_, ShrinkUsageTableHeader(
ShrinkUsageTableHeader(kLevelDefault, kLevelDefault,
expect_usage_entry_info_vector.size(), NotNull())) static_cast<uint32_t>(expect_usage_entry_info_vector.size()),
NotNull()))
.WillOnce( .WillOnce(
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull())) EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
@@ -1184,11 +1196,13 @@ TEST_F(UsageTableHeaderTest, AddEntry_NextConsecutiveSecureStopUsageEntry) {
// # of usage entries 3 3 // # of usage entries 3 3
TEST_F(UsageTableHeaderTest, AddEntry_SkipUsageEntries) { TEST_F(UsageTableHeaderTest, AddEntry_SkipUsageEntries) {
Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
const uint32_t next_usage_entry_number = kUsageEntryInfoVector.size(); const uint32_t next_usage_entry_number =
static_cast<uint32_t>(kUsageEntryInfoVector.size());
const size_t skip_usage_entries = 3; const size_t skip_usage_entries = 3;
const uint32_t initial_usage_entry_number = const uint32_t initial_usage_entry_number =
next_usage_entry_number + skip_usage_entries; 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<uint32_t>(kUsageEntryInfoVector.size()) - 1;
std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector = std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector =
kUsageEntryInfoVector; kUsageEntryInfoVector;
expect_usage_entry_info_vector[final_usage_entry_number] = expect_usage_entry_info_vector[final_usage_entry_number] =
@@ -1199,10 +1213,11 @@ TEST_F(UsageTableHeaderTest, AddEntry_SkipUsageEntries) {
Return(NO_ERROR))); Return(NO_ERROR)));
EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_usage_entry_number)) EXPECT_CALL(*crypto_session_, MoveUsageEntry(final_usage_entry_number))
.WillOnce(Return(NO_ERROR)); .WillOnce(Return(NO_ERROR));
EXPECT_CALL( EXPECT_CALL(*crypto_session_,
*crypto_session_, ShrinkUsageTableHeader(
ShrinkUsageTableHeader(kLevelDefault, kLevelDefault,
expect_usage_entry_info_vector.size(), NotNull())) static_cast<uint32_t>(expect_usage_entry_info_vector.size()),
NotNull()))
.WillOnce( .WillOnce(
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull())) EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
@@ -1248,9 +1263,10 @@ TEST_F(UsageTableHeaderTest, AddEntry_SkipUsageEntries) {
// # of usage entries 3 4 // # of usage entries 3 4
TEST_F(UsageTableHeaderTest, AddEntry_CannotMoveNewEntry) { TEST_F(UsageTableHeaderTest, AddEntry_CannotMoveNewEntry) {
Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
const uint32_t final_usage_entry_number = kUsageEntryInfoVector.size(); const uint32_t final_usage_entry_number =
static_cast<uint32_t>(kUsageEntryInfoVector.size());
const uint32_t attempted_usage_entry_number = const uint32_t attempted_usage_entry_number =
kUsageEntryInfoVector.size() - 1; static_cast<uint32_t>(kUsageEntryInfoVector.size()) - 1;
std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector = std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector =
kUsageEntryInfoVector; kUsageEntryInfoVector;
expect_usage_entry_info_vector.push_back(kUsageEntryInfoSecureStop2); expect_usage_entry_info_vector.push_back(kUsageEntryInfoSecureStop2);
@@ -1304,8 +1320,10 @@ TEST_F(UsageTableHeaderTest, AddEntry_CannotMoveNewEntry) {
// # of usage entries 3 4 // # of usage entries 3 4
TEST_F(UsageTableHeaderTest, AddEntry_CannotShinkAfterMove) { TEST_F(UsageTableHeaderTest, AddEntry_CannotShinkAfterMove) {
Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
const uint32_t initial_usage_entry_number = kUsageEntryInfoVector.size(); const uint32_t initial_usage_entry_number =
const uint32_t final_usage_entry_number = kUsageEntryInfoVector.size() - 1; static_cast<uint32_t>(kUsageEntryInfoVector.size());
const uint32_t final_usage_entry_number =
static_cast<uint32_t>(kUsageEntryInfoVector.size()) - 1;
std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector = std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector =
kUsageEntryInfoVector; kUsageEntryInfoVector;
expect_usage_entry_info_vector[final_usage_entry_number] = expect_usage_entry_info_vector[final_usage_entry_number] =
@@ -1320,7 +1338,9 @@ TEST_F(UsageTableHeaderTest, AddEntry_CannotShinkAfterMove) {
EXPECT_CALL( EXPECT_CALL(
*crypto_session_, *crypto_session_,
ShrinkUsageTableHeader( ShrinkUsageTableHeader(
kLevelDefault, expect_usage_entry_info_vector.size() - 1, NotNull())) kLevelDefault,
static_cast<uint32_t>(expect_usage_entry_info_vector.size()) - 1,
NotNull()))
.WillOnce(Return(SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE)); .WillOnce(Return(SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE));
EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull())) EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
.WillOnce( .WillOnce(
@@ -1364,7 +1384,7 @@ TEST_F(UsageTableHeaderTest,
uint32_t invalidated_entry = 0; // Randomly chosen by UsageTableHeader uint32_t invalidated_entry = 0; // Randomly chosen by UsageTableHeader
const uint32_t expected_usage_entry_number = const uint32_t expected_usage_entry_number =
k10UsageEntryInfoVector.size() - 1; static_cast<uint32_t>(k10UsageEntryInfoVector.size()) - 1;
EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull())) EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
// First call fails // First call fails
@@ -1452,14 +1472,15 @@ TEST_F(UsageTableHeaderTest, AddEntry_CreateUsageEntryFailsEveryTime) {
// marked as invalid plus the number of fewer entries in the table // marked as invalid plus the number of fewer entries in the table
// at the end of the call. // at the end of the call.
const uint32_t entries_deleted = const uint32_t entries_deleted =
invalid_entries + invalid_entries + static_cast<uint32_t>(k10UsageEntryInfoVector.size() -
(k10UsageEntryInfoVector.size() - final_usage_entries.size()); final_usage_entries.size());
EXPECT_EQ(kExpectedEntriesDeleted, entries_deleted); EXPECT_EQ(kExpectedEntriesDeleted, entries_deleted);
} }
TEST_F(UsageTableHeaderTest, LoadEntry_InvalidEntryNumber) { TEST_F(UsageTableHeaderTest, LoadEntry_InvalidEntryNumber) {
Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
const uint32_t usage_entry_number = kUsageEntryInfoVector.size() + 3; const uint32_t usage_entry_number =
static_cast<uint32_t>(kUsageEntryInfoVector.size()) + 3;
EXPECT_NE(NO_ERROR, usage_table_header_->LoadEntry( EXPECT_NE(NO_ERROR, usage_table_header_->LoadEntry(
crypto_session_, kUsageEntry, usage_entry_number)); crypto_session_, kUsageEntry, usage_entry_number));
@@ -1520,7 +1541,8 @@ TEST_F(UsageTableHeaderTest, UpdateEntry) {
TEST_F(UsageTableHeaderTest, InvalidateEntry_InvalidUsageEntryNumber) { TEST_F(UsageTableHeaderTest, InvalidateEntry_InvalidUsageEntryNumber) {
Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector); Init(kSecurityLevelL1, kUsageTableHeader, kUsageEntryInfoVector);
const uint32_t usage_entry_number = kUsageEntryInfoVector.size(); const uint32_t usage_entry_number =
static_cast<uint32_t>(kUsageEntryInfoVector.size());
metrics::CryptoMetrics metrics; metrics::CryptoMetrics metrics;
EXPECT_NE(NO_ERROR, usage_table_header_->InvalidateEntry( EXPECT_NE(NO_ERROR, usage_table_header_->InvalidateEntry(
@@ -3582,17 +3604,18 @@ TEST_F(UsageTableHeaderTest, Shrink_NoneOfTable) {
TEST_F(UsageTableHeaderTest, Shrink_PartOfTable) { TEST_F(UsageTableHeaderTest, Shrink_PartOfTable) {
Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector); Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector);
const uint32_t to_shink = 5; const uint32_t to_shink = 5;
const std::vector<CdmUsageEntryInfo> shunken_entries( const std::vector<CdmUsageEntryInfo> shrunken_entries(
k10UsageEntryInfoVector.cbegin(), k10UsageEntryInfoVector.cbegin(),
k10UsageEntryInfoVector.cend() - to_shink); k10UsageEntryInfoVector.cend() - to_shink);
metrics::CryptoMetrics metrics; metrics::CryptoMetrics metrics;
EXPECT_CALL( EXPECT_CALL(*crypto_session_,
*crypto_session_, ShrinkUsageTableHeader(
ShrinkUsageTableHeader(kLevelDefault, shunken_entries.size(), NotNull())) kLevelDefault, static_cast<uint32_t>(shrunken_entries.size()),
NotNull()))
.WillOnce(Return(NO_ERROR)); .WillOnce(Return(NO_ERROR));
EXPECT_CALL(*device_files_, EXPECT_CALL(*device_files_,
StoreUsageTableInfo(kUsageTableHeader, shunken_entries)) StoreUsageTableInfo(kUsageTableHeader, shrunken_entries))
.WillOnce(Return(true)); .WillOnce(Return(true));
EXPECT_EQ(usage_table_header_->Shrink(&metrics, to_shink), NO_ERROR); EXPECT_EQ(usage_table_header_->Shrink(&metrics, to_shink), NO_ERROR);
@@ -3611,7 +3634,8 @@ TEST_F(UsageTableHeaderTest, Shrink_AllOfTable) {
.WillOnce(Return(true)); .WillOnce(Return(true));
EXPECT_EQ( EXPECT_EQ(
usage_table_header_->Shrink(&metrics, k10UsageEntryInfoVector.size()), usage_table_header_->Shrink(
&metrics, static_cast<uint32_t>(k10UsageEntryInfoVector.size())),
NO_ERROR); NO_ERROR);
} }
@@ -3627,9 +3651,10 @@ TEST_F(UsageTableHeaderTest, Shrink_MoreThanTable) {
kEmptyUsageEntryInfoVector)) kEmptyUsageEntryInfoVector))
.WillOnce(Return(true)); .WillOnce(Return(true));
EXPECT_EQ(usage_table_header_->Shrink(&metrics, EXPECT_EQ(
k10UsageEntryInfoVector.size() + 10), usage_table_header_->Shrink(
NO_ERROR); &metrics, static_cast<uint32_t>(k10UsageEntryInfoVector.size()) + 10),
NO_ERROR);
} }
// LRU Usage Table Upgrade Test // LRU Usage Table Upgrade Test
@@ -3908,7 +3933,7 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateLicenseEntry) {
// Expected values. // Expected values.
const uint32_t expected_usage_entry_number = const uint32_t expected_usage_entry_number =
kUpgradedUsageEntryInfoList.size(); static_cast<uint32_t>(kUpgradedUsageEntryInfoList.size());
const CdmUsageEntryInfo expected_new_entry = { const CdmUsageEntryInfo expected_new_entry = {
kStorageLicense, "offline_key_set_4", "", kLruBaseTime, kStorageLicense, "offline_key_set_4", "", kLruBaseTime,
kLruBaseTime + kDefaultExpireDuration}; kLruBaseTime + kDefaultExpireDuration};
@@ -3946,7 +3971,7 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateUsageInfoEntry) {
// Expected values. // Expected values.
const uint32_t expected_usage_entry_number = const uint32_t expected_usage_entry_number =
kUpgradedUsageEntryInfoList.size(); static_cast<uint32_t>(kUpgradedUsageEntryInfoList.size());
const CdmUsageEntryInfo expected_new_entry = { const CdmUsageEntryInfo expected_new_entry = {
kStorageUsageInfo, "secure_stop_key_set_5", "streaming_license_file_4", kStorageUsageInfo, "secure_stop_key_set_5", "streaming_license_file_4",
kLruBaseTime, 0 /* No set for streaming license. */ kLruBaseTime, 0 /* No set for streaming license. */
@@ -4265,7 +4290,8 @@ TEST_F(UsageTableHeaderTest,
// Mark 3 as expired. // Mark 3 as expired.
std::vector<uint32_t> expired_license_numbers; std::vector<uint32_t> expired_license_numbers;
while (expired_license_numbers.size() < 3) { while (expired_license_numbers.size() < 3) {
const uint32_t i = CdmRandom::RandomInRange(kSetSize - 1); const uint32_t i =
static_cast<uint32_t>(CdmRandom::RandomInRange(kSetSize - 1));
CdmUsageEntryInfo& usage_entry_info = usage_entry_info_list[i]; CdmUsageEntryInfo& usage_entry_info = usage_entry_info_list[i];
// Skip already expired ones // Skip already expired ones
if (usage_entry_info.key_set_id != "nothing_unusual") continue; 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. // Select a streaming license to be more stale than the rest.
uint32_t modified_usage_info_number = kInvalidEntry; uint32_t modified_usage_info_number = kInvalidEntry;
while (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<uint32_t>(CdmRandom::RandomInRange(kLargeSetSize - 1));
CdmUsageEntryInfo& usage_entry_info = usage_entry_info_list[i]; CdmUsageEntryInfo& usage_entry_info = usage_entry_info_list[i];
// Skip offline licenses. // Skip offline licenses.
if (usage_entry_info.storage_type != kStorageUsageInfo) continue; 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. // Select a offline license to be even more stale, but unexpired.
uint32_t modified_offline_license_number = kInvalidEntry; uint32_t modified_offline_license_number = kInvalidEntry;
while (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<uint32_t>(CdmRandom::RandomInRange(kLargeSetSize - 1));
CdmUsageEntryInfo& usage_entry_info = usage_entry_info_list[i]; CdmUsageEntryInfo& usage_entry_info = usage_entry_info_list[i];
// Skip streaming licenses. // Skip streaming licenses.
if (usage_entry_info.storage_type != kStorageLicense) continue; if (usage_entry_info.storage_type != kStorageLicense) continue;

2
libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp
View File

@@ -8646,7 +8646,7 @@ TEST_P(OEMCryptoUsageTableDefragTest, ManyUsageEntries) {
// Shrink the table a little. // Shrink the table a little.
constexpr size_t small_number = 5; constexpr size_t small_number = 5;
size_t smaller_size = successful_count - small_number; size_t smaller_size = successful_count - small_number;
ASSERT_NO_FATAL_FAILURE(ShrinkHeader(smaller_size)); ASSERT_NO_FATAL_FAILURE(ShrinkHeader(static_cast<uint32_t>(smaller_size)));
// Throw out the last license if it was in the part of the table that was // Throw out the last license if it was in the part of the table that was
// shrunk. // shrunk.
if (entries.back()->session().usage_entry_number() >= smaller_size) { if (entries.back()->session().usage_entry_number() >= smaller_size) {