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

Core CDM: Do not store/retrieve USAGE_INFO entries.

Browse Source 
[ Merge of http://go/wvgerrit/159220 ]

Usage entry info elements of type USAGE_INFO are no longer stored by
DeviceFiles.  An earlier CL removed the ability to store USAGE_INFO
entries; but now tests have been updated to exclude USAGE_INFO from
their test data.

A new DeviceFiles tests verifies that USAGE_INFO entries are not
retrieved and that the |has_usage_info_entries| flag is set when
they are encountered when loading pre-usage-info-deprecation
usage table info.

Bug: 242289743
Test: run_x86_64_tests and device_files_unittest
Change-Id: Iefbfe2dd2b0304b4075bfc7c1aeffe3b6ba52624
This commit is contained in:
Alex Dale
2022-10-14 18:46:59 -07:00
parent 244e6301bd
commit 982ddb042d
3 changed files with 181 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
libwvdrmengine/cdm/core/include/device_files.h
View File

@@ -269,6 +269,7 @@ class DeviceFiles {
FRIEND_TEST(DeviceFilesUsageTableTest, Read);
FRIEND_TEST(DeviceFilesUsageTableTest, Store);
FRIEND_TEST(DeviceFilesUsageTableTest, ReadWithoutLruData);
FRIEND_TEST(DeviceFilesUsageTableTest, ReadWithUsageInfoType);
FRIEND_TEST(RetrieveDefaultCertificateTest, ErrorScenarios);
FRIEND_TEST(RetrieveLegacyCertificateTest, ErrorScenarios);
FRIEND_TEST(StoreCertificateTest, DefaultAndLegacy);

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

@@ -32,17 +32,6 @@ using video_widevine_client::sdk::License_LicenseState_ACTIVE;
using video_widevine_client::sdk::License_LicenseState_RELEASING;
using video_widevine_client::sdk::NameValue;
using video_widevine_client::sdk::OemCertificate;
using video_widevine_client::sdk::UsageInfo;
using video_widevine_client::sdk::UsageInfo_DrmUsageCertificate;
using video_widevine_client::sdk::UsageInfo_ProviderSession;
using video_widevine_client::sdk::UsageTableInfo;
using video_widevine_client::sdk::UsageTableInfo_UsageEntryInfo;
using video_widevine_client::sdk::
UsageTableInfo_UsageEntryInfo_UsageEntryStorage_LICENSE;
using video_widevine_client::sdk::
UsageTableInfo_UsageEntryInfo_UsageEntryStorage_UNKNOWN;
using video_widevine_client::sdk::
UsageTableInfo_UsageEntryInfo_UsageEntryStorage_USAGE_INFO;
// Stringify turns macro arguments into static C strings.
// Example: STRINGIFY(this_argument) -> "this_argument"
@@ -1027,6 +1016,8 @@ bool DeviceFiles::StoreUsageTableInfo(
const CdmUsageTableHeader& usage_table_header,
const std::vector<CdmUsageEntryInfo>& usage_entry_info) {
RETURN_FALSE_IF_UNINITIALIZED();
using video_widevine_client::sdk::UsageTableInfo;
using UsageEntryInfo = UsageTableInfo::UsageEntryInfo;
// Fill in file information
video_widevine_client::sdk::File file;
@@ -1034,35 +1025,22 @@ bool DeviceFiles::StoreUsageTableInfo(
file.set_type(video_widevine_client::sdk::File::USAGE_TABLE_INFO);
file.set_version(video_widevine_client::sdk::File::VERSION_1);
UsageTableInfo* usage_table_info = file.mutable_usage_table_info();
usage_table_info->set_usage_table_header(usage_table_header);
for (size_t i = 0; i < usage_entry_info.size(); ++i) {
UsageTableInfo_UsageEntryInfo* info =
usage_table_info->add_usage_entry_info();
info->set_key_set_id(usage_entry_info[i].key_set_id);
switch (usage_entry_info[i].storage_type) {
case kStorageLicense:
info->set_storage(
UsageTableInfo_UsageEntryInfo_UsageEntryStorage_LICENSE);
info->set_last_use_time(usage_entry_info[i].last_use_time);
info->set_offline_license_expiry_time(
usage_entry_info[i].offline_license_expiry_time);
break;
case kStorageUsageInfo:
info->set_storage(
UsageTableInfo_UsageEntryInfo_UsageEntryStorage_USAGE_INFO);
info->set_usage_info_file_name(
usage_entry_info[i].usage_info_file_name);
info->set_last_use_time(usage_entry_info[i].last_use_time);
break;
case kStorageTypeUnknown:
default:
info->set_storage(
UsageTableInfo_UsageEntryInfo_UsageEntryStorage_UNKNOWN);
break;
UsageTableInfo* stored_table_info = file.mutable_usage_table_info();
stored_table_info->set_usage_table_header(usage_table_header);
for (const auto& entry_info : usage_entry_info) {
UsageEntryInfo* stored_info = stored_table_info->add_usage_entry_info();
if (entry_info.storage_type == kStorageLicense) {
stored_info->set_storage(UsageEntryInfo::LICENSE);
stored_info->set_key_set_id(entry_info.key_set_id);
stored_info->set_last_use_time(entry_info.last_use_time);
stored_info->set_offline_license_expiry_time(
entry_info.offline_license_expiry_time);
} else {
stored_info->set_storage(UsageEntryInfo::UNKNOWN);
}
}
usage_table_info->set_use_lru(true);
stored_table_info->set_use_lru(true);
std::string serialized_file;
file.SerializeToString(&serialized_file);
@@ -1080,6 +1058,8 @@ bool DeviceFiles::RetrieveUsageTableInfo(
RETURN_FALSE_IF_NULL(usage_entry_info);
RETURN_FALSE_IF_NULL(lru_upgrade);
RETURN_FALSE_IF_NULL(has_usage_info_entries);
using video_widevine_client::sdk::UsageTableInfo;
using UsageEntryInfo = UsageTableInfo::UsageEntryInfo;
video_widevine_client::sdk::File file;
if (RetrieveHashedFile(GetUsageTableFileName(), &file) != kNoError) {
@@ -1106,35 +1086,28 @@ bool DeviceFiles::RetrieveUsageTableInfo(
return false;
}
const UsageTableInfo& usage_table_info = file.usage_table_info();
const UsageTableInfo& stored_table_info = file.usage_table_info();
*lru_upgrade = !usage_table_info.use_lru();
*lru_upgrade = !stored_table_info.use_lru();
*has_usage_info_entries = false;
*usage_table_header = stored_table_info.usage_table_header();
usage_entry_info->reserve(stored_table_info.usage_entry_info_size());
*usage_table_header = usage_table_info.usage_table_header();
usage_entry_info->resize(usage_table_info.usage_entry_info_size());
for (int i = 0; i < usage_table_info.usage_entry_info_size(); ++i) {
const UsageTableInfo_UsageEntryInfo& info =
usage_table_info.usage_entry_info(i);
(*usage_entry_info)[i].key_set_id = info.key_set_id();
switch (info.storage()) {
case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_LICENSE:
(*usage_entry_info)[i].storage_type = kStorageLicense;
(*usage_entry_info)[i].last_use_time = info.last_use_time();
(*usage_entry_info)[i].offline_license_expiry_time =
info.offline_license_expiry_time();
break;
case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_USAGE_INFO:
(*usage_entry_info)[i].storage_type = kStorageTypeUnknown;
*has_usage_info_entries = true;
break;
case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_UNKNOWN:
default:
(*usage_entry_info)[i].storage_type = kStorageTypeUnknown;
break;
for (const auto& stored_entry_info : stored_table_info.usage_entry_info()) {
CdmUsageEntryInfo entry_info;
entry_info.Clear();
if (stored_entry_info.storage() == UsageEntryInfo::LICENSE) {
entry_info.storage_type = kStorageLicense;
entry_info.key_set_id = stored_entry_info.key_set_id();
entry_info.last_use_time = stored_entry_info.last_use_time();
entry_info.offline_license_expiry_time =
stored_entry_info.offline_license_expiry_time();
} else if (stored_entry_info.storage() == UsageEntryInfo::USAGE_INFO) {
// USAGE_INFO are deprecated, do not retrieve this entries.
*has_usage_info_entries = true;
}
usage_entry_info->emplace_back(std::move(entry_info));
}
return true;
}

253
libwvdrmengine/cdm/core/test/device_files_unittest.cpp
View File

@@ -2918,19 +2918,19 @@ constexpr size_t kNumberOfHlsAttributes = ArraySize(kHlsAttributesTestData);
// Usage Table and Entry Test Data
// Note: Make sure the number of entries in kUsageEntriesTestData and
// kUsageTableInfoTestData are equal.
const CdmUsageEntryInfo kUsageEntriesTestData[] = {
const std::vector<CdmUsageEntryInfo> kUsageEntriesTestData = {
// usage entry 0
{kStorageLicense, "ksid0", "", 1318402800, 1321254000},
// usage entry 1
{kStorageLicense, "ksid1", "", 1050649200, 1053500400},
// usage entry 2
{kStorageUsageInfo, "", "app_id_2", 694252800, 0},
{kStorageTypeUnknown, "", "", 0, 0},
// usage entry 3
{kStorageUsageInfo, "", "app_id_3", 983001600, 0},
{kStorageTypeUnknown, "", "", 0, 0},
// usage entry 4
{kStorageLicense, "ksid4", "", 316166400, 319017600},
// usage entry 5
{kStorageUsageInfo, "", "app_id_5", 802162800, 0},
{kStorageLicense, "ksid5", "", 316166400, 319017600},
};
struct UsageTableTestInfo {
@@ -2939,54 +2939,73 @@ struct UsageTableTestInfo {
};
const UsageTableTestInfo kUsageTableInfoTestData[] = {
// usage table 0
{a2bs_hex("5574517CCC"),
a2bs_hex("0A26080510013A200A055574517CCC1215080112056B7369643020F0F5D4F404"
"28F0F882F6041801122055C2834976220A2819445B8D6EF5ADE9D7A050006941"
"3EDFB9948F928B317B89")},
// usage table 1
{a2bs_hex("CA870203010001288001"),
a2bs_hex("0A46080510013A400A0ACA8702030100012880011217080112056B736964301A"
"0020F0F5D4F40428F0F882F6041217080112056B736964311A0020F0C4FEF403"
"28F0C7ACF60318011220B000674E4E24E67384C4631DE05CB3C1E07CDE6B0412"
"CACE359DEAED6CF2D566")},
// usage table 2
{a2bs_hex("7A7D507618A5D3A68F05228E023082010A028201"),
a2bs_hex("0A66080510013A600A147A7D507618A5D3A68F05228E023082010A0282011217"
"080112056B736964301A0020F0F5D4F40428F0F882F6041217080112056B7369"
"64311A0020F0C4FEF40328F0C7ACF6031214080212001A086170705F69645F32"
"2080EA85CB02180112202701F8F75537EBA12217796401A81E9E0F59A5B10F51"
"F6C12E3BE3D8747CB745")},
// usage table 3
{a2bs_hex("E83A4902772DAFD2740B7748E9C3B1752D6F12859CED07E82969B4EC"),
a2bs_hex("0A8401080510013A7E0A1CE83A4902772DAFD2740B7748E9C3B1752D6F12859C"
"ED07E82969B4EC1217080112056B736964301A0020F0F5D4F40428F0F882F604"
"1217080112056B736964311A0020F0C4FEF40328F0C7ACF6031214080212001A"
"086170705F69645F322080EA85CB021214080212001A086170705F69645F3320"
"80D4DDD40318011220776BD3D0BBCC573AEC7466A8B0E4F1A013495A3BE492F3"
"FF4BA3D15FC9697902")},
// usage table 4
{a2bs_hex("CA870203010001288001300112800250D1F8B1ECF849B60FF93E37C4DEEF"
"52F1CCFC047EF42300131F9C4758F4"),
a2bs_hex("0AAF01080510013AA8010A2DCA870203010001288001300112800250D1F8B1EC"
"F849B60FF93E37C4DEEF52F1CCFC047EF42300131F9C4758F41217080112056B"
"736964301A0020F0F5D4F40428F0F882F6041217080112056B736964311A0020"
"F0C4FEF40328F0C7ACF6031214080212001A086170705F69645F322080EA85CB"
"021214080212001A086170705F69645F332080D4DDD4031217080112056B7369"
"64341A002080A2E196012880A58F980118011220E7F0F123E513FCF3BC6BC17B"
"1531A8317654C5EF005655348D82FA01FDAD85CB")},
// usage table 5
{a2bs_hex("EC83A4902772DAFD2740B7748E9C3B1752D6F12859CED07E8882969B433E"
"C29AC6FDBE79230B0FAED5D94CF6B829A420BBE3270323941776EE60DD6B"),
a2bs_hex("0AD401080510013ACD010A3CEC83A4902772DAFD2740B7748E9C3B1752D6F128"
"59CED07E8882969B433EC29AC6FDBE79230B0FAED5D94CF6B829A420BBE32703"
"23941776EE60DD6B1217080112056B736964301A0020F0F5D4F40428F0F882F6"
"041217080112056B736964311A0020F0C4FEF40328F0C7ACF603121408021200"
"1A086170705F69645F322080EA85CB021214080212001A086170705F69645F33"
"2080D4DDD4031217080112056B736964341A002080A2E196012880A58F980112"
"14080212001A086170705F69645F3520F090C0FE0218011220A35C771A67AECF"
"06A72468DC2C380E5CFDCD377A8ADF848F26B7F22D24D23872")},
// Table with 0 entries.
{a2bs_hex("5554484541444552b04e49015de15e4c00000000"),
a2bs_hex("0a1e080510013a180a145554484541444552b04e49015de1"
"5e4c0000000018011220332a0eaa459108edc37826adae60"
"cab27bc5f08e26a08224e1b4b4f098ca1397")},
// Table with 1 entry.
{a2bs_hex("55544845414445523830ca323636796201000000267bf482"
"960151e9"),
a2bs_hex("0a3d080510013a370a1c55544845414445523830ca323636"
"796201000000267bf482960151e91215080112056b736964"
"3020f0f5d4f40428f0f882f6041801122029b5fc48129564"
"762fde3aba772c5a57110f91cb11b0f487d8218a62954768"
"d2")},
// Table with 2 entries.
{a2bs_hex("5554484541444552f2013c82c8f49d72020000000f9bf46d"
"e1f6567356e41cc3371e9198"),
a2bs_hex("0a5c080510013a560a245554484541444552f2013c82c8f4"
"9d72020000000f9bf46de1f6567356e41cc3371e91981215"
"080112056b7369643020f0f5d4f40428f0f882f604121508"
"0112056b7369643120f0c4fef40328f0c7acf60318011220"
"5fc76c79febf12fda4c80f6d88654f907db9714d828b565d"
"60d5e14a08a349bc")},
// Table with 3 entries.
{a2bs_hex("5554484541444552069cfae4eae05a37030000002639c56c"
"5558b9d5cf0856dac0d6be3fe590650c33fea3f3"),
a2bs_hex("0a68080510013a620a2c5554484541444552069cfae4eae0"
"5a37030000002639c56c5558b9d5cf0856dac0d6be3fe590"
"650c33fea3f31215080112056b7369643020f0f5d4f40428"
"f0f882f6041215080112056b7369643120f0c4fef40328f0"
"c7acf60312020803180112200877bbef888c18f0ec01baf9"
"3436cd880b722478c870293e474eebba98ef4364")},
// Table with 4 entries.
{a2bs_hex("5554484541444552e66cfceee098a28b040000008a05b042"
"9576c852895697c4fc4cd7764b0f7e34abfa141e28ea7e1b"
"919a77a0"),
a2bs_hex("0a74080510013a6e0a345554484541444552e66cfceee098"
"a28b040000008a05b0429576c852895697c4fc4cd7764b0f"
"7e34abfa141e28ea7e1b919a77a01215080112056b736964"
"3020f0f5d4f40428f0f882f6041215080112056b73696431"
"20f0c4fef40328f0c7acf603120208031202080318011220"
"20319c6050ce7a2dfe34313118db787bcf656cd33912c108"
"b8401f777d4666f7")},
// Table with 5 entries.
{a2bs_hex("555448454144455224282dd66e49e45d05000000c40d9fe1"
"8d50e5e464e4154c9820c3419df965c15e66b2ce4c34ca3e"
"af26ea54f27736909b225b52"),
a2bs_hex("0a9401080510013a8d010a3c555448454144455224282dd6"
"6e49e45d05000000c40d9fe18d50e5e464e4154c9820c341"
"9df965c15e66b2ce4c34ca3eaf26ea54f27736909b225b52"
"1215080112056b7369643020f0f5d4f40428f0f882f60412"
"15080112056b7369643120f0c4fef40328f0c7acf6031202"
"0803120208031215080112056b736964342080a2e1960128"
"80a58f9801180112209f8d25f779bfd4a74e2646ce38d3a6"
"c08c29425ab80ceed3a0dfba8050f573e3")},
// Table with 6 entries.
{a2bs_hex("5554484541444552127016ecb5766ad50600000028f022a1"
"96461e7c534e97a982651e01e9c6936e9d41b8f3fc2f6173"
"2e86edd6232fe7bbd6d19f176a3fe986dd6aeaff"),
a2bs_hex("0ab301080510013aac010a445554484541444552127016ec"
"b5766ad50600000028f022a196461e7c534e97a982651e01"
"e9c6936e9d41b8f3fc2f61732e86edd6232fe7bbd6d19f17"
"6a3fe986dd6aeaff1215080112056b7369643020f0f5d4f4"
"0428f0f882f6041215080112056b7369643120f0c4fef403"
"28f0c7acf60312020803120208031215080112056b736964"
"342080a2e196012880a58f98011215080112056b73696435"
"2080a2e196012880a58f980118011220a22cb4b3e3f1c8f7"
"ce072f3d2ef52febcaddff3040246a638deee994a0862142")},
};
const CdmUsageEntryInfo kUsageEntriesWithoutLruData[] = {
@@ -2997,33 +3016,23 @@ const std::string kUsageTableWithoutLruData = a2bs_hex(
"31122044C964271799F0631AE388BD150A873C5DD16B35F61BFF0300857AEEB8"
"454FA2");
// DeleteMultipleUsageInfoByKeySetIds test data.
// Usage Table Info for ensuring that "USAGE_INFO" types are not retrieved.
const UsageTableTestInfo kUsageTableInfoWithUsageInfoType = {
a2bs_hex("55544845414445524fcba5c758ed81b403000000f0916628"
"8e5b97670118a904727e89358d866224fc6a3500"),
// Entries: {LICENSE, UNKNOWN, USAGE_INFO}
a2bs_hex("0a6a080510013a640a2c55544845414445524fcba5c758ed"
"81b403000000f09166288e5b97670118a904727e89358d86"
"6224fc6a35001215080112056b7369643020f0f5d4f40428"
"f0f882f60412020803121708021a0d757361676531323334"
"2e62696e2080a2e19601180112207a5b76af87fdaf37f579"
"7790d58b826935d2f6a7fa89b4cd036f88f96109e8ca")};
const std::string kHashedUsageInfoFileWithThreeKeySetIds = a2bs_hex(
"0A36080310012A300A0E220C6B65795F7365745F69645F310A0E220C6B65795F"
"7365745F69645F320A0E220C6B65795F7365745F69645F331220781BE848CE8A"
"0CE84FF563D54D30150A115EAB27F7023C19191EC41BDC4EDAA9");
// Only contains key set ID 1 & 2.
const std::string kHashedUsageInfoFileWithTwoKeySetIds = a2bs_hex(
"0A26080310012A200A0E220C6B65795F7365745F69645F310A0E220C6B65795F"
"7365745F69645F321220B693E7142BF263FF51B6F8AF4DD7F20E2701059A841C"
"F947995A7B39354E1CA9");
const std::string kHashedUsageInfoFileWithKeySet1 = a2bs_hex(
"0A16080310012A100A0E220C6B65795F7365745F69645F3112200FBBB47C89DE"
"484D02BFB4CB20B19BA43CBCAD6F4A78EFB295ACC66BA0B83B85");
const std::string kHashedUsageInfoFileWithKeySet2 = a2bs_hex(
"0A16080310012A100A0E220C6B65795F7365745F69645F321220B5F53E5A1D8E"
"860196D2B3E027FFB32F11C1B2269784A904A3EA6E59C2A6A96D");
const std::string kHashedUsageInfoFileWithKeySet3 = a2bs_hex(
"0A16080310012A100A0E220C6B65795F7365745F69645F331220F28C1B20A302"
"543F44659D995A58899A03B9D51C65FD6C05AD1E6D2BACACADA7");
const std::vector<std::string> kHashedUsageInfoFileWithSingleKeySetList = {
kHashedUsageInfoFileWithKeySet1, kHashedUsageInfoFileWithKeySet2,
kHashedUsageInfoFileWithKeySet3};
const std::vector<std::string> kHashedUsageInfoFileKeySetList = {
"key_set_id_1", "key_set_id_2", "key_set_id_3"};
// Expected entries after removal of USAGE_INFO.
const std::vector<CdmUsageEntryInfo> kUsageEntriesWithoutUsageInfoType = {
{kStorageLicense, "ksid0", "", 1318402800, 1321254000},
{kStorageTypeUnknown, "", "", 0, 0},
{kStorageTypeUnknown, "", "", 0, 0}};
// Contains kOemCertificate and kCryptoWrappedKey
const std::string kFakeOemCertificateFile = a2bs_hex(
@@ -4377,17 +4386,16 @@ TEST_P(DeviceFilesUsageTableTest, Store) {
MockFileSystem file_system;
// Call to Open will return a unique_ptr, freeing this object.
MockFile* file = new MockFile();
int index = GetParam();
const int entry_count = GetParam();
std::vector<std::string> entry_data;
std::vector<CdmUsageEntryInfo> usage_entry_info;
usage_entry_info.resize(index + 1);
for (int i = 0; i <= index; ++i) {
usage_entry_info[i] = kUsageEntriesTestData[i];
const std::vector<CdmUsageEntryInfo> usage_entry_info(
kUsageEntriesTestData.begin(),
kUsageEntriesTestData.begin() + entry_count);
for (int i = 0; i < entry_count; ++i) {
entry_data.push_back(kUsageEntriesTestData[i].key_set_id);
entry_data.push_back(kUsageEntriesTestData[i].usage_info_file_name);
}
entry_data.push_back(kUsageTableInfoTestData[index].usage_table_header);
entry_data.push_back(kUsageTableInfoTestData[entry_count].usage_table_header);
std::string path = device_base_path_ + DeviceFiles::GetUsageTableFileName();
@@ -4402,18 +4410,19 @@ TEST_P(DeviceFilesUsageTableTest, Store) {
DeviceFiles device_files(&file_system);
EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
ASSERT_TRUE(device_files.StoreUsageTableInfo(
kUsageTableInfoTestData[index].usage_table_header, usage_entry_info));
kUsageTableInfoTestData[entry_count].usage_table_header,
usage_entry_info));
}
TEST_P(DeviceFilesUsageTableTest, Read) {
MockFileSystem file_system;
// Call to Open will return a unique_ptr, freeing this object.
MockFile* file = new MockFile();
size_t index = GetParam();
const size_t entry_count = GetParam();
std::string path = device_base_path_ + DeviceFiles::GetUsageTableFileName();
const std::string& file_data = kUsageTableInfoTestData[index].file_data;
const std::string& file_data = kUsageTableInfoTestData[entry_count].file_data;
EXPECT_CALL(file_system, Exists(StrEq(path))).WillRepeatedly(Return(true));
EXPECT_CALL(file_system, FileSize(StrEq(path)))
.WillRepeatedly(Return(file_data.size()));
@@ -4435,34 +4444,19 @@ TEST_P(DeviceFilesUsageTableTest, Read) {
ASSERT_TRUE(device_files.RetrieveUsageTableInfo(
&usage_table_header, &usage_entry_info, &lru_upgrade,
&has_usage_info_entries));
EXPECT_EQ(kUsageTableInfoTestData[index].usage_table_header,
EXPECT_EQ(kUsageTableInfoTestData[entry_count].usage_table_header,
usage_table_header);
EXPECT_EQ(index + 1u, usage_entry_info.size());
EXPECT_EQ(entry_count, usage_entry_info.size());
for (size_t i = 0; i <= index; ++i) {
for (size_t i = 0; i < entry_count; ++i) {
// TODO(b/242289743): Update test data to exclude usage info files.
if (kUsageEntriesTestData[i].storage_type == kStorageUsageInfo) {
// Usage info entry types are no longer loaded.
EXPECT_EQ(usage_entry_info[i].storage_type, kStorageTypeUnknown);
continue;
}
EXPECT_EQ(kUsageEntriesTestData[i].storage_type,
usage_entry_info[i].storage_type);
EXPECT_EQ(kUsageEntriesTestData[i].key_set_id,
usage_entry_info[i].key_set_id);
EXPECT_EQ(kUsageEntriesTestData[i].usage_info_file_name,
usage_entry_info[i].usage_info_file_name);
EXPECT_EQ(kUsageEntriesTestData[i].last_use_time,
usage_entry_info[i].last_use_time);
EXPECT_EQ(kUsageEntriesTestData[i].offline_license_expiry_time,
usage_entry_info[i].offline_license_expiry_time);
EXPECT_EQ(usage_entry_info[i], kUsageEntriesTestData[i]);
}
EXPECT_FALSE(lru_upgrade);
}
INSTANTIATE_TEST_SUITE_P(UsageInfo, DeviceFilesUsageTableTest,
::testing::Range(0, 6));
::testing::Range(0, 7));
TEST_F(DeviceFilesUsageTableTest, ReadWithoutLruData) {
// Setup file.
@@ -4503,6 +4497,49 @@ TEST_F(DeviceFilesUsageTableTest, ReadWithoutLruData) {
EXPECT_TRUE(lru_upgrade);
}
// Usage Table Info files containing USAGE_INFO should have the USAGE_INFO
// entries ignored when loading, and the |has_usage_info_entries| flag
// set to true when retrieving the table.
TEST_F(DeviceFilesUsageTableTest, ReadWithUsageInfoType) {
const std::string file_data = kUsageTableInfoWithUsageInfoType.file_data;
// Setup file.
MockFile* file = new MockFile();
EXPECT_CALL(*file, Read(NotNull(), Eq(file_data.size())))
.WillOnce(DoAll(SetArrayArgument<0>(file_data.cbegin(), file_data.cend()),
Return(file_data.size())));
// Setup filesystem.
const std::string path =
device_base_path_ + DeviceFiles::GetUsageTableFileName();
MockFileSystem file_system;
EXPECT_CALL(file_system, Exists(StrEq(path))).WillRepeatedly(Return(true));
EXPECT_CALL(file_system, FileSize(StrEq(path)))
.WillRepeatedly(Return(file_data.size()));
EXPECT_CALL(file_system, Open(StrEq(path), _))
.WillOnce(Return(ByMove(std::unique_ptr<File>(file))));
DeviceFiles device_files(&file_system);
EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
std::vector<CdmUsageEntryInfo> usage_entry_info;
CdmUsageTableHeader usage_table_header;
bool lru_upgrade;
bool has_usage_info_entries;
ASSERT_TRUE(device_files.RetrieveUsageTableInfo(
&usage_table_header, &usage_entry_info, &lru_upgrade,
&has_usage_info_entries));
EXPECT_EQ(kUsageEntriesWithoutUsageInfoType.size(), usage_entry_info.size());
for (size_t i = 0; i < kUsageEntriesWithoutUsageInfoType.size(); ++i) {
const CdmUsageEntryInfo& expected_entry =
kUsageEntriesWithoutUsageInfoType[i];
const CdmUsageEntryInfo& retrieved_entry = usage_entry_info[i];
EXPECT_EQ(expected_entry, retrieved_entry);
}
EXPECT_TRUE(has_usage_info_entries);
}
TEST_F(DeviceFilesTest, StoreOemCertificateSuccess) {
MockFileSystem file_system;
const std::string oem_certificate_path =