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

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;