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.
metrics_->oemcrypto_maximum_usage_table_header_size_.Record(
*number_of_entries);
static_cast<uint32_t>(*number_of_entries));
if (*number_of_entries == 0) {
// 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_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()) {
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<int>(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<uint32_t>(
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<uint32_t>(
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<uint32_t>(
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<uint32_t>(
file.usage_info().sessions(index).usage_entry_number());
if (!file.usage_info().sessions(index).has_drm_certificate_id()) {
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) {
// 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<uint32_t>(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<uint32_t>(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<uint32_t>(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<uint32_t>(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<uint32_t>(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<uint32_t>(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<uint32_t>(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<uint32_t>(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<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
// 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<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) {
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<int>(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;

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.state = kActiveLicenseState;
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);
}
}
@@ -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<uint32_t>(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<uint32_t>(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<uint32_t>(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<uint32_t>(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<uint32_t>(kUsageEntryInfoVector.size());
const uint32_t final_usage_entry_number =
static_cast<uint32_t>(kUsageEntryInfoVector.size()) - 1;
std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector =
kUsageEntryInfoVector;
expect_usage_entry_info_vector[final_usage_entry_number] =
@@ -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<uint32_t>(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<uint32_t>(kUsageEntryInfoVector.size());
const uint32_t final_usage_entry_number =
static_cast<uint32_t>(kUsageEntryInfoVector.size()) - 1;
std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector =
kUsageEntryInfoVector;
expect_usage_entry_info_vector[final_usage_entry_number] =
@@ -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<uint32_t>(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<uint32_t>(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<uint32_t>(kUsageEntryInfoVector.size()) - 1;
std::vector<CdmUsageEntryInfo> 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<uint32_t>(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<uint32_t>(kUsageEntryInfoVector.size());
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 =
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<uint32_t>(kUsageEntryInfoVector.size());
const uint32_t final_usage_entry_number =
static_cast<uint32_t>(kUsageEntryInfoVector.size()) - 1;
std::vector<CdmUsageEntryInfo> expect_usage_entry_info_vector =
kUsageEntryInfoVector;
expect_usage_entry_info_vector[final_usage_entry_number] =
@@ -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<uint32_t>(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<uint32_t>(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<uint32_t>(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<uint32_t>(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<uint32_t>(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<CdmUsageEntryInfo> shunken_entries(
const std::vector<CdmUsageEntryInfo> 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<uint32_t>(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<uint32_t>(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<uint32_t>(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<uint32_t>(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<uint32_t>(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<uint32_t> expired_license_numbers;
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];
// 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<uint32_t>(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<uint32_t>(CdmRandom::RandomInRange(kLargeSetSize - 1));
CdmUsageEntryInfo& usage_entry_info = usage_entry_info_list[i];
// Skip streaming licenses.
if (usage_entry_info.storage_type != kStorageLicense) continue;