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

Renaming of Usage Table related variables and types.

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

This CL makes major changes to the names of variables and types that
are related to the usage table, header, entries, entry indexes, and
other related data.

The renaming followed these rules:
1)  "Usage table header" will exclusively refer to the header blob
    that is OEMCrypto specific.  The CDM class "UsageTableHeader"
    is the CDM-layer's abstraction around the "usage table" concept.
    The name has been updated to reflect that.
2)  The "Cdm" prefix is only used for the CDM-specific data types for
    the usage table and entry info.  It has been removed from
    OEMCrypto-specific types.
    - UsageTableHeader -> CdmUsageTable
    - CdmUsageTableHeader -> UsageTableHeader
    - CdmUsageEntry -> UsageEntry
3)  The "usage_" prefix has been removed from variables when the usage
    table or usage entries are the subject of the function or class.
4)  UsageEntryIndex is the type for entry indexes, instead of directly
    using uint32_t.  This matches how we wrap other types in
    "wv_cdm_types.h"
5)  Changed entry "number" to entry "index".
6)  Vectors of elements have been renamed to be either pluralized or
    have a suffix "_list".
7)  "Usage info" was occasionally being used to refer to the usage
    table or entries generally, rather than specifically secure-stop.
    - CryptoSession::HasUsageInfoSupport() -> HasUsageTableSupport()

The most major change is that the files "usage_table_header*" have
been renamed to be "cdm_usage_table*".

Bug: 242914226
Test: run_x86_64_tests and request_license_test
Change-Id: Iee98446b71f4f2934d3c9e0fb949eb05b84d1f8c
This commit is contained in:
Alex Dale
2022-12-20 15:21:10 -08:00
parent 0080d04579
commit 1603ba127f
24 changed files with 1321 additions and 1382 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp
View File

@@ -9,6 +9,7 @@
#include <memory>
#include "cdm_usage_table.h"
#include "crypto_key.h"
#include "crypto_wrapped_key.h"
#include "properties.h"
@@ -16,7 +17,6 @@
#include "string_conversions.h"
#include "test_base.h"
#include "test_printers.h"
#include "usage_table_header.h"
#include "wv_cdm_constants.h"
#include "wv_metrics.pb.h"
@@ -123,13 +123,13 @@ class MockDeviceFiles : public DeviceFiles {
MOCK_METHOD(bool, HasCertificate, (bool), (override));
};
class MockUsageTableHeader : public UsageTableHeader {
class MockCdmUsageTable : public CdmUsageTable {
public:
MockUsageTableHeader() : UsageTableHeader() {}
MockCdmUsageTable() : CdmUsageTable() {}
MOCK_METHOD(CdmResponseType, UpdateEntry,
(uint32_t usage_entry_number, CryptoSession* crypto_session,
CdmUsageEntry* usage_entry),
(UsageEntryIndex usage_entry_index, CryptoSession* crypto_session,
UsageEntry* usage_entry),
(override));
};
@@ -137,10 +137,10 @@ class MockCryptoSession : public TestCryptoSession {
public:
MockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
: TestCryptoSession(crypto_metrics) {
// By default, call the concrete implementation of HasUsageInfoSupport.
ON_CALL(*this, HasUsageInfoSupport(_))
// By default, call the concrete implementation of HasUsageTableSupport.
ON_CALL(*this, HasUsageTableSupport(_))
.WillByDefault(
Invoke(this, &MockCryptoSession::BaseHasUsageInfoSupport));
Invoke(this, &MockCryptoSession::BaseHasUsageTableSupport));
}
MOCK_METHOD(CdmResponseType, GetProvisioningToken,
(std::string*, std::string*), (override));
@@ -151,11 +151,11 @@ class MockCryptoSession : public TestCryptoSession {
(override));
MOCK_METHOD(CdmResponseType, LoadCertificatePrivateKey,
(const CryptoWrappedKey&), (override));
MOCK_METHOD(bool, HasUsageInfoSupport, (bool*), (override));
MOCK_METHOD(UsageTableHeader*, GetUsageTableHeader, (), (override));
MOCK_METHOD(bool, HasUsageTableSupport, (bool*), (override));
MOCK_METHOD(CdmUsageTable*, GetUsageTable, (), (override));
bool BaseHasUsageInfoSupport(bool* has_support) {
return CryptoSession::HasUsageInfoSupport(has_support);
bool BaseHasUsageTableSupport(bool* has_support) {
return CryptoSession::HasUsageTableSupport(has_support);
}
};
@@ -209,7 +209,7 @@ class CdmSessionTest : public WvCdmTestBase {
NiceMock<MockCryptoSession>* crypto_session_;
MockPolicyEngine* policy_engine_;
MockDeviceFiles* file_handle_;
MockUsageTableHeader usage_table_header_;
MockCdmUsageTable usage_table_;
};
TEST_F(CdmSessionTest, InitWithBuiltInCertificate) {
@@ -294,22 +294,22 @@ TEST_F(CdmSessionTest, UpdateUsageEntry) {
.WillOnce(Return(level));
EXPECT_CALL(*file_handle_, Init(Eq(level))).WillOnce(Return(true));
EXPECT_CALL(*file_handle_, HasCertificate(false)).WillOnce(Return(true));
EXPECT_CALL(*crypto_session_, GetUsageTableHeader())
.WillOnce(Return(&usage_table_header_));
EXPECT_CALL(*crypto_session_, GetUsageTable())
.WillOnce(Return(&usage_table_));
EXPECT_CALL(*license_parser_, Init(false, Eq(kEmptyString),
Eq(crypto_session_), Eq(policy_engine_)))
.WillOnce(Return(true));
// Set up mocks and expectations for the UpdateUsageEntryInformation call.
EXPECT_CALL(*crypto_session_, HasUsageInfoSupport(_))
EXPECT_CALL(*crypto_session_, HasUsageTableSupport(_))
.WillRepeatedly(DoAll(SetArgPointee<0>(true), Return(true)));
EXPECT_CALL(*license_parser_, provider_session_token())
.WillRepeatedly(Return("Mock provider session token"));
EXPECT_CALL(usage_table_header_, UpdateEntry(_, NotNull(), NotNull()))
EXPECT_CALL(usage_table_, UpdateEntry(_, NotNull(), NotNull()))
.WillRepeatedly(Return(CdmResponseType(NO_ERROR)));
EXPECT_EQ(NO_ERROR, cdm_session_->Init(nullptr));
EXPECT_TRUE(cdm_session_->supports_usage_info());
EXPECT_TRUE(cdm_session_->SupportsUsageTable());
EXPECT_EQ(NO_ERROR, cdm_session_->UpdateUsageEntryInformation());
// Verify the UsageEntry metric is set.

1285
libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp → libwvdrmengine/cdm/core/test/cdm_usage_table_unittest.cpp
View File

File diff suppressed because it is too large Load Diff

16
libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp
View File

@@ -63,21 +63,21 @@ class MockCryptoSession : public TestCryptoSession {
(override));
// Usage Table Header.
MOCK_METHOD(CdmResponseType, CreateUsageTableHeader,
(wvcdm::RequestedSecurityLevel, CdmUsageTableHeader*),
(override));
(wvcdm::RequestedSecurityLevel, UsageTableHeader*), (override));
MOCK_METHOD(CdmResponseType, LoadUsageTableHeader,
(wvcdm::RequestedSecurityLevel, const CdmUsageTableHeader&),
(wvcdm::RequestedSecurityLevel, const UsageTableHeader&),
(override));
MOCK_METHOD(CdmResponseType, ShrinkUsageTableHeader,
(wvcdm::RequestedSecurityLevel, uint32_t, CdmUsageTableHeader*),
(wvcdm::RequestedSecurityLevel, uint32_t, UsageTableHeader*),
(override));
// Usage Entry.
MOCK_METHOD(CdmResponseType, CreateUsageEntry, (uint32_t*), (override));
MOCK_METHOD(CdmResponseType, LoadUsageEntry, (uint32_t, const CdmUsageEntry&),
MOCK_METHOD(CdmResponseType, CreateUsageEntry, (UsageEntryIndex*),
(override));
MOCK_METHOD(CdmResponseType, LoadUsageEntry,
(UsageEntryIndex, const UsageEntry&), (override));
MOCK_METHOD(CdmResponseType, UpdateUsageEntry,
(CdmUsageTableHeader*, CdmUsageEntry*), (override));
MOCK_METHOD(CdmResponseType, MoveUsageEntry, (uint32_t), (override));
(UsageTableHeader*, UsageEntry*), (override));
MOCK_METHOD(CdmResponseType, MoveUsageEntry, (UsageEntryIndex), (override));
};
class TestStubCryptoSessionFactory : public CryptoSessionFactory {

2
libwvdrmengine/cdm/core/test/crypto_session_unittest.cpp
View File

@@ -62,7 +62,7 @@ TEST_F(CryptoSessionMetricsTest, OpenSessionValidMetrics) {
session->Open(wvcdm::kLevelDefault);
// Exercise a method that will touch a metric.
bool supports_usage_table;
ASSERT_TRUE(session->HasUsageInfoSupport(&supports_usage_table));
ASSERT_TRUE(session->HasUsageTableSupport(&supports_usage_table));
drm_metrics::WvCdmMetrics::CryptoMetrics metrics_proto;
crypto_metrics.Serialize(&metrics_proto);

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

@@ -1627,7 +1627,7 @@ struct LicenseInfo {
int64_t grace_period_end_time;
std::string app_parameters;
std::string usage_entry;
uint32_t usage_entry_number;
uint32_t usage_entry_index;
std::string drm_certificate;
CryptoWrappedKey::Type key_type;
std::string private_key;
@@ -3657,7 +3657,7 @@ const CdmUsageEntryInfo kUsageEntriesTestData[] = {
};
struct UsageTableTestInfo {
CdmUsageTableHeader usage_table_header;
UsageTableHeader usage_table_header;
std::string file_data;
};
@@ -4560,7 +4560,7 @@ TEST_P(DeviceFilesStoreTest, StoreLicense) {
kLicenseTestData[license_num].grace_period_end_time,
app_parameters,
kLicenseTestData[license_num].usage_entry,
kLicenseTestData[license_num].usage_entry_number,
kLicenseTestData[license_num].usage_entry_index,
kLicenseTestData[license_num].drm_certificate,
CryptoWrappedKey(kLicenseTestData[license_num].key_type,
kLicenseTestData[license_num].private_key)};
@@ -4629,7 +4629,7 @@ TEST_F(DeviceFilesTest, StoreLicenses) {
kLicenseTestData[i].grace_period_end_time,
app_parameters,
kLicenseTestData[i].usage_entry,
kLicenseTestData[i].usage_entry_number,
kLicenseTestData[i].usage_entry_index,
kLicenseTestData[i].drm_certificate,
CryptoWrappedKey(kLicenseTestData[i].key_type,
kLicenseTestData[i].private_key)};
@@ -4689,8 +4689,8 @@ TEST_F(DeviceFilesTest, RetrieveLicenses) {
EXPECT_EQ(kLicenseTestData[i].grace_period_end_time,
license_data.grace_period_end_time);
EXPECT_EQ(kLicenseTestData[i].usage_entry, license_data.usage_entry);
EXPECT_EQ(kLicenseTestData[i].usage_entry_number,
license_data.usage_entry_number);
EXPECT_EQ(kLicenseTestData[i].usage_entry_index,
license_data.usage_entry_index);
EXPECT_EQ(kLicenseTestData[i].drm_certificate,
license_data.drm_certificate);
EXPECT_EQ(kLicenseTestData[i].key_type,
@@ -4755,7 +4755,7 @@ TEST_F(DeviceFilesTest, AppParametersBackwardCompatibility) {
license_data.grace_period_end_time);
EXPECT_EQ(0u, license_data.app_parameters.size());
EXPECT_EQ(test_data->usage_entry, license_data.usage_entry);
EXPECT_EQ(test_data->usage_entry_number, license_data.usage_entry_number);
EXPECT_EQ(test_data->usage_entry_index, license_data.usage_entry_index);
EXPECT_EQ(test_data->drm_certificate, license_data.drm_certificate);
EXPECT_EQ(test_data->key_type, license_data.wrapped_private_key.type());
EXPECT_EQ(test_data->private_key, license_data.wrapped_private_key.key());
@@ -4794,7 +4794,7 @@ TEST_F(DeviceFilesTest, UpdateLicenseState) {
kLicenseUpdateTestData[0].grace_period_end_time,
GetAppParameters(kLicenseTestData[0].app_parameters),
kLicenseUpdateTestData[0].usage_entry,
kLicenseUpdateTestData[0].usage_entry_number,
kLicenseUpdateTestData[0].usage_entry_index,
kLicenseUpdateTestData[0].drm_certificate,
CryptoWrappedKey(kLicenseTestData[0].key_type,
kLicenseTestData[0].private_key)};
@@ -4860,8 +4860,8 @@ TEST_F(DeviceFilesTest, DeleteLicense) {
std::string::npos);
}
EXPECT_EQ(kLicenseTestData[0].usage_entry, license_data.usage_entry);
EXPECT_EQ(kLicenseTestData[0].usage_entry_number,
license_data.usage_entry_number);
EXPECT_EQ(kLicenseTestData[0].usage_entry_index,
license_data.usage_entry_index);
EXPECT_EQ(kLicenseTestData[0].drm_certificate, license_data.drm_certificate);
EXPECT_EQ(kLicenseTestData[0].key_type,
license_data.wrapped_private_key.type());
@@ -5408,8 +5408,8 @@ TEST_P(DeviceFilesUsageInfoTest, Retrieve) {
usage_data_list[i].key_set_id);
EXPECT_EQ(kUsageInfoTestData[j].usage_data.usage_entry,
usage_data_list[i].usage_entry);
EXPECT_EQ(kUsageInfoTestData[j].usage_data.usage_entry_number,
usage_data_list[i].usage_entry_number);
EXPECT_EQ(kUsageInfoTestData[j].usage_data.usage_entry_index,
usage_data_list[i].usage_entry_index);
EXPECT_EQ(kUsageInfoTestData[j].usage_data.drm_certificate,
usage_data_list[i].drm_certificate);
EXPECT_EQ(kUsageInfoTestData[j].usage_data.wrapped_private_key.type(),
@@ -5581,8 +5581,8 @@ TEST_P(DeviceFilesUsageInfoTest, RetrieveByProviderSessionToken) {
usage_data.key_set_id);
EXPECT_EQ(kUsageInfoTestData[index].usage_data.usage_entry,
usage_data.usage_entry);
EXPECT_EQ(kUsageInfoTestData[index].usage_data.usage_entry_number,
usage_data.usage_entry_number);
EXPECT_EQ(kUsageInfoTestData[index].usage_data.usage_entry_index,
usage_data.usage_entry_index);
}
}
@@ -5813,7 +5813,7 @@ TEST_P(DeviceFilesUsageTableTest, Read) {
EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
std::vector<CdmUsageEntryInfo> usage_entry_info;
CdmUsageTableHeader usage_table_header;
UsageTableHeader usage_table_header;
bool lru_upgrade;
ASSERT_TRUE(device_files.RetrieveUsageTableInfo(
&usage_table_header, &usage_entry_info, &lru_upgrade));
@@ -5861,7 +5861,7 @@ TEST_F(DeviceFilesUsageTableTest, ReadWithoutLruData) {
EXPECT_TRUE(device_files.Init(kSecurityLevelL1));
std::vector<CdmUsageEntryInfo> usage_entry_info;
CdmUsageTableHeader usage_table_header;
UsageTableHeader usage_table_header;
bool lru_upgrade;
ASSERT_TRUE(device_files.RetrieveUsageTableInfo(
&usage_table_header, &usage_entry_info, &lru_upgrade));

6
libwvdrmengine/cdm/core/test/license_unittest.cpp
View File

@@ -143,7 +143,7 @@ class MockCryptoSession : public TestCryptoSession {
: TestCryptoSession(crypto_metrics) {}
MOCK_METHOD(bool, IsOpen, (), (override));
MOCK_METHOD(const std::string&, request_id, (), (override));
MOCK_METHOD(bool, HasUsageInfoSupport, (bool*), (override));
MOCK_METHOD(bool, HasUsageTableSupport, (bool*), (override));
MOCK_METHOD(CdmResponseType, GetHdcpCapabilities,
(HdcpCapability*, HdcpCapability*), (override));
MOCK_METHOD(bool, GetSupportedCertificateTypes, (SupportedCertificateTypes*),
@@ -306,7 +306,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidation) {
EXPECT_CALL(*crypto_session_, IsOpen()).WillOnce(Return(true));
EXPECT_CALL(*crypto_session_, request_id())
.WillOnce(ReturnRef(kCryptoRequestId));
EXPECT_CALL(*crypto_session_, HasUsageInfoSupport(NotNull()))
EXPECT_CALL(*crypto_session_, HasUsageTableSupport(NotNull()))
.WillOnce(
DoAll(SetArgPointee<0>(usage_information_support), Return(true)));
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))
@@ -441,7 +441,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) {
EXPECT_CALL(*crypto_session_, IsOpen()).WillOnce(Return(true));
EXPECT_CALL(*crypto_session_, request_id())
.WillOnce(ReturnRef(kCryptoRequestId));
EXPECT_CALL(*crypto_session_, HasUsageInfoSupport(NotNull()))
EXPECT_CALL(*crypto_session_, HasUsageTableSupport(NotNull()))
.WillOnce(
DoAll(SetArgPointee<0>(usage_information_support), Return(true)));
EXPECT_CALL(*crypto_session_, GetHdcpCapabilities(NotNull(), NotNull()))