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

Merge "Revert "Core CDM: Do not store/retrieve USAGE_INFO entries.""

Browse Source
This commit is contained in:
Alex Dale
2022-11-30 23:51:37 +00:00
committed by Android (Google) Code Review
parent 0397428512 5ebe8eddeb
commit 5ffa2885c9
3 changed files with 170 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

@@ -32,6 +32,17 @@ using video_widevine_client::sdk::License_LicenseState_ACTIVE;
using video_widevine_client::sdk::License_LicenseState_RELEASING; using video_widevine_client::sdk::License_LicenseState_RELEASING;
using video_widevine_client::sdk::NameValue; using video_widevine_client::sdk::NameValue;
using video_widevine_client::sdk::OemCertificate; 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. // Stringify turns macro arguments into static C strings.
// Example: STRINGIFY(this_argument) -> "this_argument" // Example: STRINGIFY(this_argument) -> "this_argument"
@@ -1016,8 +1027,6 @@ bool DeviceFiles::StoreUsageTableInfo(
const CdmUsageTableHeader& usage_table_header, const CdmUsageTableHeader& usage_table_header,
const std::vector<CdmUsageEntryInfo>& usage_entry_info) { const std::vector<CdmUsageEntryInfo>& usage_entry_info) {
RETURN_FALSE_IF_UNINITIALIZED(); RETURN_FALSE_IF_UNINITIALIZED();
using video_widevine_client::sdk::UsageTableInfo;
using UsageEntryInfo = UsageTableInfo::UsageEntryInfo;
// Fill in file information // Fill in file information
video_widevine_client::sdk::File file; video_widevine_client::sdk::File file;
@@ -1025,22 +1034,35 @@ bool DeviceFiles::StoreUsageTableInfo(
file.set_type(video_widevine_client::sdk::File::USAGE_TABLE_INFO); file.set_type(video_widevine_client::sdk::File::USAGE_TABLE_INFO);
file.set_version(video_widevine_client::sdk::File::VERSION_1); file.set_version(video_widevine_client::sdk::File::VERSION_1);
UsageTableInfo* stored_table_info = file.mutable_usage_table_info(); UsageTableInfo* usage_table_info = file.mutable_usage_table_info();
stored_table_info->set_usage_table_header(usage_table_header); usage_table_info->set_usage_table_header(usage_table_header);
for (size_t i = 0; i < usage_entry_info.size(); ++i) {
for (const auto& entry_info : usage_entry_info) { UsageTableInfo_UsageEntryInfo* info =
UsageEntryInfo* stored_info = stored_table_info->add_usage_entry_info(); usage_table_info->add_usage_entry_info();
if (entry_info.storage_type == kStorageLicense) { info->set_key_set_id(usage_entry_info[i].key_set_id);
stored_info->set_storage(UsageEntryInfo::LICENSE); switch (usage_entry_info[i].storage_type) {
stored_info->set_key_set_id(entry_info.key_set_id); case kStorageLicense:
stored_info->set_last_use_time(entry_info.last_use_time); info->set_storage(
stored_info->set_offline_license_expiry_time( UsageTableInfo_UsageEntryInfo_UsageEntryStorage_LICENSE);
entry_info.offline_license_expiry_time); info->set_last_use_time(usage_entry_info[i].last_use_time);
} else { info->set_offline_license_expiry_time(
stored_info->set_storage(UsageEntryInfo::UNKNOWN); 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;
} }
} }
stored_table_info->set_use_lru(true); usage_table_info->set_use_lru(true);
std::string serialized_file; std::string serialized_file;
file.SerializeToString(&serialized_file); file.SerializeToString(&serialized_file);
@@ -1058,8 +1080,6 @@ bool DeviceFiles::RetrieveUsageTableInfo(
RETURN_FALSE_IF_NULL(usage_entry_info); RETURN_FALSE_IF_NULL(usage_entry_info);
RETURN_FALSE_IF_NULL(lru_upgrade); RETURN_FALSE_IF_NULL(lru_upgrade);
RETURN_FALSE_IF_NULL(has_usage_info_entries); RETURN_FALSE_IF_NULL(has_usage_info_entries);
using video_widevine_client::sdk::UsageTableInfo;
using UsageEntryInfo = UsageTableInfo::UsageEntryInfo;
video_widevine_client::sdk::File file; video_widevine_client::sdk::File file;
if (RetrieveHashedFile(GetUsageTableFileName(), &file) != kNoError) { if (RetrieveHashedFile(GetUsageTableFileName(), &file) != kNoError) {
@@ -1086,28 +1106,35 @@ bool DeviceFiles::RetrieveUsageTableInfo(
return false; return false;
} }
const UsageTableInfo& stored_table_info = file.usage_table_info(); const UsageTableInfo& usage_table_info = file.usage_table_info();
*lru_upgrade = !stored_table_info.use_lru(); *lru_upgrade = !usage_table_info.use_lru();
*has_usage_info_entries = false; *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());
for (const auto& stored_entry_info : stored_table_info.usage_entry_info()) { *usage_table_header = usage_table_info.usage_table_header();
CdmUsageEntryInfo entry_info; usage_entry_info->resize(usage_table_info.usage_entry_info_size());
entry_info.Clear(); for (int i = 0; i < usage_table_info.usage_entry_info_size(); ++i) {
if (stored_entry_info.storage() == UsageEntryInfo::LICENSE) { const UsageTableInfo_UsageEntryInfo& info =
entry_info.storage_type = kStorageLicense; usage_table_info.usage_entry_info(i);
entry_info.key_set_id = stored_entry_info.key_set_id(); (*usage_entry_info)[i].key_set_id = info.key_set_id();
entry_info.last_use_time = stored_entry_info.last_use_time(); switch (info.storage()) {
entry_info.offline_license_expiry_time = case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_LICENSE:
stored_entry_info.offline_license_expiry_time(); (*usage_entry_info)[i].storage_type = kStorageLicense;
} else if (stored_entry_info.storage() == UsageEntryInfo::USAGE_INFO) { (*usage_entry_info)[i].last_use_time = info.last_use_time();
// USAGE_INFO are deprecated, do not retrieve this entries. (*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; *has_usage_info_entries = true;
break;
case UsageTableInfo_UsageEntryInfo_UsageEntryStorage_UNKNOWN:
default:
(*usage_entry_info)[i].storage_type = kStorageTypeUnknown;
break;
} }
usage_entry_info->emplace_back(std::move(entry_info));
} }
return true; 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 // Usage Table and Entry Test Data
// Note: Make sure the number of entries in kUsageEntriesTestData and // Note: Make sure the number of entries in kUsageEntriesTestData and
// kUsageTableInfoTestData are equal. // kUsageTableInfoTestData are equal.
const std::vector<CdmUsageEntryInfo> kUsageEntriesTestData = { const CdmUsageEntryInfo kUsageEntriesTestData[] = {
// usage entry 0 // usage entry 0
{kStorageLicense, "ksid0", "", 1318402800, 1321254000}, {kStorageLicense, "ksid0", "", 1318402800, 1321254000},
// usage entry 1 // usage entry 1
{kStorageLicense, "ksid1", "", 1050649200, 1053500400}, {kStorageLicense, "ksid1", "", 1050649200, 1053500400},
// usage entry 2 // usage entry 2
{kStorageTypeUnknown, "", "", 0, 0}, {kStorageUsageInfo, "", "app_id_2", 694252800, 0},
// usage entry 3 // usage entry 3
{kStorageTypeUnknown, "", "", 0, 0}, {kStorageUsageInfo, "", "app_id_3", 983001600, 0},
// usage entry 4 // usage entry 4
{kStorageLicense, "ksid4", "", 316166400, 319017600}, {kStorageLicense, "ksid4", "", 316166400, 319017600},
// usage entry 5 // usage entry 5
{kStorageLicense, "ksid5", "", 316166400, 319017600}, {kStorageUsageInfo, "", "app_id_5", 802162800, 0},
}; };
struct UsageTableTestInfo { struct UsageTableTestInfo {
@@ -2939,73 +2939,54 @@ struct UsageTableTestInfo {
}; };
const UsageTableTestInfo kUsageTableInfoTestData[] = { const UsageTableTestInfo kUsageTableInfoTestData[] = {
// Table with 0 entries. // usage table 0
{a2bs_hex("5554484541444552b04e49015de15e4c00000000"),
a2bs_hex("0a1e080510013a180a145554484541444552b04e49015de1" {a2bs_hex("5574517CCC"),
"5e4c0000000018011220332a0eaa459108edc37826adae60" a2bs_hex("0A26080510013A200A055574517CCC1215080112056B7369643020F0F5D4F404"
"cab27bc5f08e26a08224e1b4b4f098ca1397")}, "28F0F882F6041801122055C2834976220A2819445B8D6EF5ADE9D7A050006941"
// Table with 1 entry. "3EDFB9948F928B317B89")},
{a2bs_hex("55544845414445523830ca323636796201000000267bf482" // usage table 1
"960151e9"), {a2bs_hex("CA870203010001288001"),
a2bs_hex("0a3d080510013a370a1c55544845414445523830ca323636" a2bs_hex("0A46080510013A400A0ACA8702030100012880011217080112056B736964301A"
"796201000000267bf482960151e91215080112056b736964" "0020F0F5D4F40428F0F882F6041217080112056B736964311A0020F0C4FEF403"
"3020f0f5d4f40428f0f882f6041801122029b5fc48129564" "28F0C7ACF60318011220B000674E4E24E67384C4631DE05CB3C1E07CDE6B0412"
"762fde3aba772c5a57110f91cb11b0f487d8218a62954768" "CACE359DEAED6CF2D566")},
"d2")}, // usage table 2
// Table with 2 entries. {a2bs_hex("7A7D507618A5D3A68F05228E023082010A028201"),
{a2bs_hex("5554484541444552f2013c82c8f49d72020000000f9bf46d" a2bs_hex("0A66080510013A600A147A7D507618A5D3A68F05228E023082010A0282011217"
"e1f6567356e41cc3371e9198"), "080112056B736964301A0020F0F5D4F40428F0F882F6041217080112056B7369"
a2bs_hex("0a5c080510013a560a245554484541444552f2013c82c8f4" "64311A0020F0C4FEF40328F0C7ACF6031214080212001A086170705F69645F32"
"9d72020000000f9bf46de1f6567356e41cc3371e91981215" "2080EA85CB02180112202701F8F75537EBA12217796401A81E9E0F59A5B10F51"
"080112056b7369643020f0f5d4f40428f0f882f604121508" "F6C12E3BE3D8747CB745")},
"0112056b7369643120f0c4fef40328f0c7acf60318011220" // usage table 3
"5fc76c79febf12fda4c80f6d88654f907db9714d828b565d" {a2bs_hex("E83A4902772DAFD2740B7748E9C3B1752D6F12859CED07E82969B4EC"),
"60d5e14a08a349bc")}, a2bs_hex("0A8401080510013A7E0A1CE83A4902772DAFD2740B7748E9C3B1752D6F12859C"
// Table with 3 entries. "ED07E82969B4EC1217080112056B736964301A0020F0F5D4F40428F0F882F604"
{a2bs_hex("5554484541444552069cfae4eae05a37030000002639c56c" "1217080112056B736964311A0020F0C4FEF40328F0C7ACF6031214080212001A"
"5558b9d5cf0856dac0d6be3fe590650c33fea3f3"), "086170705F69645F322080EA85CB021214080212001A086170705F69645F3320"
a2bs_hex("0a68080510013a620a2c5554484541444552069cfae4eae0" "80D4DDD40318011220776BD3D0BBCC573AEC7466A8B0E4F1A013495A3BE492F3"
"5a37030000002639c56c5558b9d5cf0856dac0d6be3fe590" "FF4BA3D15FC9697902")},
"650c33fea3f31215080112056b7369643020f0f5d4f40428" // usage table 4
"f0f882f6041215080112056b7369643120f0c4fef40328f0" {a2bs_hex("CA870203010001288001300112800250D1F8B1ECF849B60FF93E37C4DEEF"
"c7acf60312020803180112200877bbef888c18f0ec01baf9" "52F1CCFC047EF42300131F9C4758F4"),
"3436cd880b722478c870293e474eebba98ef4364")}, a2bs_hex("0AAF01080510013AA8010A2DCA870203010001288001300112800250D1F8B1EC"
// Table with 4 entries. "F849B60FF93E37C4DEEF52F1CCFC047EF42300131F9C4758F41217080112056B"
{a2bs_hex("5554484541444552e66cfceee098a28b040000008a05b042" "736964301A0020F0F5D4F40428F0F882F6041217080112056B736964311A0020"
"9576c852895697c4fc4cd7764b0f7e34abfa141e28ea7e1b" "F0C4FEF40328F0C7ACF6031214080212001A086170705F69645F322080EA85CB"
"919a77a0"), "021214080212001A086170705F69645F332080D4DDD4031217080112056B7369"
a2bs_hex("0a74080510013a6e0a345554484541444552e66cfceee098" "64341A002080A2E196012880A58F980118011220E7F0F123E513FCF3BC6BC17B"
"a28b040000008a05b0429576c852895697c4fc4cd7764b0f" "1531A8317654C5EF005655348D82FA01FDAD85CB")},
"7e34abfa141e28ea7e1b919a77a01215080112056b736964" // usage table 5
"3020f0f5d4f40428f0f882f6041215080112056b73696431" {a2bs_hex("EC83A4902772DAFD2740B7748E9C3B1752D6F12859CED07E8882969B433E"
"20f0c4fef40328f0c7acf603120208031202080318011220" "C29AC6FDBE79230B0FAED5D94CF6B829A420BBE3270323941776EE60DD6B"),
"20319c6050ce7a2dfe34313118db787bcf656cd33912c108" a2bs_hex("0AD401080510013ACD010A3CEC83A4902772DAFD2740B7748E9C3B1752D6F128"
"b8401f777d4666f7")}, "59CED07E8882969B433EC29AC6FDBE79230B0FAED5D94CF6B829A420BBE32703"
// Table with 5 entries. "23941776EE60DD6B1217080112056B736964301A0020F0F5D4F40428F0F882F6"
{a2bs_hex("555448454144455224282dd66e49e45d05000000c40d9fe1" "041217080112056B736964311A0020F0C4FEF40328F0C7ACF603121408021200"
"8d50e5e464e4154c9820c3419df965c15e66b2ce4c34ca3e" "1A086170705F69645F322080EA85CB021214080212001A086170705F69645F33"
"af26ea54f27736909b225b52"), "2080D4DDD4031217080112056B736964341A002080A2E196012880A58F980112"
a2bs_hex("0a9401080510013a8d010a3c555448454144455224282dd6" "14080212001A086170705F69645F3520F090C0FE0218011220A35C771A67AECF"
"6e49e45d05000000c40d9fe18d50e5e464e4154c9820c341" "06A72468DC2C380E5CFDCD377A8ADF848F26B7F22D24D23872")},
"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[] = { const CdmUsageEntryInfo kUsageEntriesWithoutLruData[] = {
@@ -3016,23 +2997,33 @@ const std::string kUsageTableWithoutLruData = a2bs_hex(
"31122044C964271799F0631AE388BD150A873C5DD16B35F61BFF0300857AEEB8" "31122044C964271799F0631AE388BD150A873C5DD16B35F61BFF0300857AEEB8"
"454FA2"); "454FA2");
// Usage Table Info for ensuring that "USAGE_INFO" types are not retrieved. // DeleteMultipleUsageInfoByKeySetIds test data.
const UsageTableTestInfo kUsageTableInfoWithUsageInfoType = {
a2bs_hex("55544845414445524fcba5c758ed81b403000000f0916628"
"8e5b97670118a904727e89358d866224fc6a3500"),
// Entries: {LICENSE, UNKNOWN, USAGE_INFO}
a2bs_hex("0a6a080510013a640a2c55544845414445524fcba5c758ed"
"81b403000000f09166288e5b97670118a904727e89358d86"
"6224fc6a35001215080112056b7369643020f0f5d4f40428"
"f0f882f60412020803121708021a0d757361676531323334"
"2e62696e2080a2e19601180112207a5b76af87fdaf37f579"
"7790d58b826935d2f6a7fa89b4cd036f88f96109e8ca")};
// Expected entries after removal of USAGE_INFO. const std::string kHashedUsageInfoFileWithThreeKeySetIds = a2bs_hex(
const std::vector<CdmUsageEntryInfo> kUsageEntriesWithoutUsageInfoType = { "0A36080310012A300A0E220C6B65795F7365745F69645F310A0E220C6B65795F"
{kStorageLicense, "ksid0", "", 1318402800, 1321254000}, "7365745F69645F320A0E220C6B65795F7365745F69645F331220781BE848CE8A"
{kStorageTypeUnknown, "", "", 0, 0}, "0CE84FF563D54D30150A115EAB27F7023C19191EC41BDC4EDAA9");
{kStorageTypeUnknown, "", "", 0, 0}}; // 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"};
// Contains kOemCertificate and kCryptoWrappedKey // Contains kOemCertificate and kCryptoWrappedKey
const std::string kFakeOemCertificateFile = a2bs_hex( const std::string kFakeOemCertificateFile = a2bs_hex(
@@ -4386,16 +4377,17 @@ TEST_P(DeviceFilesUsageTableTest, Store) {
MockFileSystem file_system; MockFileSystem file_system;
// Call to Open will return a unique_ptr, freeing this object. // Call to Open will return a unique_ptr, freeing this object.
MockFile* file = new MockFile(); MockFile* file = new MockFile();
const int entry_count = GetParam(); int index = GetParam();
std::vector<std::string> entry_data; std::vector<std::string> entry_data;
const std::vector<CdmUsageEntryInfo> usage_entry_info( std::vector<CdmUsageEntryInfo> usage_entry_info;
kUsageEntriesTestData.begin(), usage_entry_info.resize(index + 1);
kUsageEntriesTestData.begin() + entry_count); for (int i = 0; i <= index; ++i) {
for (int i = 0; i < entry_count; ++i) { usage_entry_info[i] = kUsageEntriesTestData[i];
entry_data.push_back(kUsageEntriesTestData[i].key_set_id); entry_data.push_back(kUsageEntriesTestData[i].key_set_id);
entry_data.push_back(kUsageEntriesTestData[i].usage_info_file_name);
} }
entry_data.push_back(kUsageTableInfoTestData[entry_count].usage_table_header); entry_data.push_back(kUsageTableInfoTestData[index].usage_table_header);
std::string path = device_base_path_ + DeviceFiles::GetUsageTableFileName(); std::string path = device_base_path_ + DeviceFiles::GetUsageTableFileName();
@@ -4410,19 +4402,18 @@ TEST_P(DeviceFilesUsageTableTest, Store) {
DeviceFiles device_files(&file_system); DeviceFiles device_files(&file_system);
EXPECT_TRUE(device_files.Init(kSecurityLevelL1)); EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
ASSERT_TRUE(device_files.StoreUsageTableInfo( ASSERT_TRUE(device_files.StoreUsageTableInfo(
kUsageTableInfoTestData[entry_count].usage_table_header, kUsageTableInfoTestData[index].usage_table_header, usage_entry_info));
usage_entry_info));
} }
TEST_P(DeviceFilesUsageTableTest, Read) { TEST_P(DeviceFilesUsageTableTest, Read) {
MockFileSystem file_system; MockFileSystem file_system;
// Call to Open will return a unique_ptr, freeing this object. // Call to Open will return a unique_ptr, freeing this object.
MockFile* file = new MockFile(); MockFile* file = new MockFile();
const size_t entry_count = GetParam(); size_t index = GetParam();
std::string path = device_base_path_ + DeviceFiles::GetUsageTableFileName(); std::string path = device_base_path_ + DeviceFiles::GetUsageTableFileName();
const std::string& file_data = kUsageTableInfoTestData[entry_count].file_data; const std::string& file_data = kUsageTableInfoTestData[index].file_data;
EXPECT_CALL(file_system, Exists(StrEq(path))).WillRepeatedly(Return(true)); EXPECT_CALL(file_system, Exists(StrEq(path))).WillRepeatedly(Return(true));
EXPECT_CALL(file_system, FileSize(StrEq(path))) EXPECT_CALL(file_system, FileSize(StrEq(path)))
.WillRepeatedly(Return(file_data.size())); .WillRepeatedly(Return(file_data.size()));
@@ -4444,19 +4435,34 @@ TEST_P(DeviceFilesUsageTableTest, Read) {
ASSERT_TRUE(device_files.RetrieveUsageTableInfo( ASSERT_TRUE(device_files.RetrieveUsageTableInfo(
&usage_table_header, &usage_entry_info, &lru_upgrade, &usage_table_header, &usage_entry_info, &lru_upgrade,
&has_usage_info_entries)); &has_usage_info_entries));
EXPECT_EQ(kUsageTableInfoTestData[entry_count].usage_table_header, EXPECT_EQ(kUsageTableInfoTestData[index].usage_table_header,
usage_table_header); usage_table_header);
EXPECT_EQ(entry_count, usage_entry_info.size()); EXPECT_EQ(index + 1u, usage_entry_info.size());
for (size_t i = 0; i < entry_count; ++i) { for (size_t i = 0; i <= index; ++i) {
// TODO(b/242289743): Update test data to exclude usage info files. // TODO(b/242289743): Update test data to exclude usage info files.
EXPECT_EQ(usage_entry_info[i], kUsageEntriesTestData[i]); 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_FALSE(lru_upgrade); EXPECT_FALSE(lru_upgrade);
} }
INSTANTIATE_TEST_SUITE_P(UsageInfo, DeviceFilesUsageTableTest, INSTANTIATE_TEST_SUITE_P(UsageInfo, DeviceFilesUsageTableTest,
::testing::Range(0, 7)); ::testing::Range(0, 6));
TEST_F(DeviceFilesUsageTableTest, ReadWithoutLruData) { TEST_F(DeviceFilesUsageTableTest, ReadWithoutLruData) {
// Setup file. // Setup file.
@@ -4497,49 +4503,6 @@ TEST_F(DeviceFilesUsageTableTest, ReadWithoutLruData) {
EXPECT_TRUE(lru_upgrade); 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) { TEST_F(DeviceFilesTest, StoreOemCertificateSuccess) {
MockFileSystem file_system; MockFileSystem file_system;
const std::string oem_certificate_path = const std::string oem_certificate_path =