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

Snap for 6337755 from c0d7f16b78 to sc-release

Browse Source 
Change-Id: I8992f4a53204c098b8170b8ffdd499055ab141b1
This commit is contained in:
android-build-team Robot
2020-03-27 02:06:01 +00:00
parent 6d4e10c482 c0d7f16b78
commit 2b1cca5274
14 changed files with 340 additions and 285 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
libwvdrmengine/cdm/core/include/crypto_session.h
View File

@@ -254,11 +254,17 @@ class CryptoSession {
virtual UsageTableHeader* GetUsageTableHeader() {
return usage_table_header_;
}
// The following crypto methods do not require an open session to
// complete the operations.
virtual CdmResponseType CreateUsageTableHeader(
SecurityLevel requested_security_level,
CdmUsageTableHeader* usage_table_header);
virtual CdmResponseType LoadUsageTableHeader(
SecurityLevel requested_security_level,
const CdmUsageTableHeader& usage_table_header);
virtual CdmResponseType ShrinkUsageTableHeader(
SecurityLevel requested_security_level, uint32_t new_entry_count,
CdmUsageTableHeader* usage_table_header);
// Usage entry.
virtual CdmResponseType CreateUsageEntry(uint32_t* entry_number);
@@ -268,8 +274,6 @@ class CryptoSession {
CdmUsageTableHeader* usage_table_header, CdmUsageEntry* usage_entry);
// Adjust usage entries in usage table header.
virtual CdmResponseType ShrinkUsageTableHeader(
uint32_t new_entry_count, CdmUsageTableHeader* usage_table_header);
virtual CdmResponseType MoveUsageEntry(uint32_t new_entry_number);
virtual bool GetAnalogOutputCapabilities(bool* can_support_output,

5
libwvdrmengine/cdm/core/include/wv_cdm_types.h
View File

@@ -281,7 +281,7 @@ enum CdmResponseType {
/* previsouly INVALID_PARAMETERS_ENG_20 = 227, */
UPDATE_USAGE_ENTRY_UNKNOWN_ERROR = 228,
/* previously INVALID_PARAMETERS_ENG_21 = 229, */
SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR = 230,
SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR = 230,
MOVE_USAGE_ENTRY_UNKNOWN_ERROR = 231,
COPY_OLD_USAGE_ENTRY_UNKNOWN_ERROR = 232,
INVALID_PARAMETERS_ENG_22 = 233,
@@ -408,6 +408,9 @@ enum CdmResponseType {
CANNOT_DECRYPT_ZERO_SUBSAMPLES = 354,
SAMPLE_AND_SUBSAMPLE_SIZE_MISMATCH = 355,
INVALID_IV_SIZE = 356,
LOAD_USAGE_ENTRY_INVALID_SESSION = 357,
MOVE_USAGE_ENTRY_DESTINATION_IN_USE = 358,
SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE = 359,
// Don't forget to add new values to
// * core/test/test_printers.cpp.
// * android/include/mapErrors-inl.h

136
libwvdrmengine/cdm/core/src/crypto_session.cpp
View File

@@ -708,9 +708,7 @@ uint8_t CryptoSession::GetSecurityPatchLevel() {
}
CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
LOGD(
"Opening crypto session: requested_security_level: "
"requested_security_level = %s",
LOGD("Opening crypto session: requested_security_level = %s",
requested_security_level == kLevel3
? QUERY_VALUE_SECURITY_LEVEL_L3.c_str()
: QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str());
@@ -802,7 +800,6 @@ CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
CdmSecurityLevel security_level = GetSecurityLevel();
if (security_level == kSecurityLevelL1 ||
security_level == kSecurityLevelL3) {
{
// This block cannot use |WithStaticFieldWriteLock| because it needs
// to unlock the lock partway through.
LOGV("Static field write lock: Open() initializing usage table");
@@ -829,8 +826,7 @@ CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
}
usage_table_header_ = *header;
metrics_->usage_table_header_initial_size_.Record((*header)->size());
}
}
} // End |static_field_mutex_| block.
}
} else {
metrics_->oemcrypto_usage_table_support_.SetError(result);
@@ -2342,18 +2338,20 @@ CdmResponseType CryptoSession::GetUsageSupportType(
}
CdmResponseType CryptoSession::CreateUsageTableHeader(
SecurityLevel requested_security_level,
CdmUsageTableHeader* usage_table_header) {
LOGV("Creating usage table header: id = %u", oec_session_id_);
LOGV("Creating usage table header: requested_security_level = %s",
requested_security_level == kLevel3
? QUERY_VALUE_SECURITY_LEVEL_L3.c_str()
: QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str());
RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
usage_table_header->resize(kEstimatedInitialUsageTableHeader);
size_t usage_table_header_size = usage_table_header->size();
OEMCryptoResult result;
WithOecWriteLock("CreateUsageTableHeader Attempt 1", [&] {
result = OEMCrypto_CreateUsageTableHeader(
requested_security_level_,
requested_security_level,
reinterpret_cast<uint8_t*>(
const_cast<char*>(usage_table_header->data())),
&usage_table_header_size);
@@ -2364,7 +2362,7 @@ CdmResponseType CryptoSession::CreateUsageTableHeader(
usage_table_header->resize(usage_table_header_size);
WithOecWriteLock("CreateUsageTableHeader Attempt 2", [&] {
result = OEMCrypto_CreateUsageTableHeader(
requested_security_level_,
requested_security_level,
reinterpret_cast<uint8_t*>(
const_cast<char*>(usage_table_header->data())),
&usage_table_header_size);
@@ -2372,22 +2370,28 @@ CdmResponseType CryptoSession::CreateUsageTableHeader(
});
}
if (result == OEMCrypto_SUCCESS) {
switch (result) {
case OEMCrypto_SUCCESS:
usage_table_header->resize(usage_table_header_size);
}
return NO_ERROR;
default:
return MapOEMCryptoResult(result, CREATE_USAGE_TABLE_ERROR,
"CreateUsageTableHeader");
}
}
CdmResponseType CryptoSession::LoadUsageTableHeader(
SecurityLevel requested_security_level,
const CdmUsageTableHeader& usage_table_header) {
LOGV("Loading usage table header: id = %u", oec_session_id_);
LOGV("Loading usage table header: requested_security_level = %s",
requested_security_level == kLevel3
? QUERY_VALUE_SECURITY_LEVEL_L3.c_str()
: QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str());
OEMCryptoResult result;
WithOecWriteLock("LoadUsageTableHeader", [&] {
result = OEMCrypto_LoadUsageTableHeader(
requested_security_level_,
requested_security_level,
reinterpret_cast<const uint8_t*>(usage_table_header.data()),
usage_table_header.size());
metrics_->oemcrypto_load_usage_table_header_.Increment(result);
@@ -2420,6 +2424,48 @@ CdmResponseType CryptoSession::LoadUsageTableHeader(
}
}
CdmResponseType CryptoSession::ShrinkUsageTableHeader(
SecurityLevel requested_security_level, uint32_t new_entry_count,
CdmUsageTableHeader* usage_table_header) {
LOGV("Shrinking usage table header: requested_security_level = %s",
requested_security_level == kLevel3
? QUERY_VALUE_SECURITY_LEVEL_L3.c_str()
: QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str());
RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
size_t usage_table_header_len = 0;
OEMCryptoResult result;
WithOecWriteLock("ShrinkUsageTableHeader Attempt 1", [&] {
result = OEMCrypto_ShrinkUsageTableHeader(requested_security_level,
new_entry_count, nullptr,
&usage_table_header_len);
metrics_->oemcrypto_shrink_usage_table_header_.Increment(result);
});
if (result == OEMCrypto_ERROR_SHORT_BUFFER) {
usage_table_header->resize(usage_table_header_len);
WithOecWriteLock("ShrinkUsageTableHeader Attempt 2", [&] {
result = OEMCrypto_ShrinkUsageTableHeader(
requested_security_level, new_entry_count,
reinterpret_cast<uint8_t*>(
const_cast<char*>(usage_table_header->data())),
&usage_table_header_len);
metrics_->oemcrypto_shrink_usage_table_header_.Increment(result);
});
}
switch (result) {
case OEMCrypto_SUCCESS:
usage_table_header->resize(usage_table_header_len);
return NO_ERROR;
case OEMCrypto_ERROR_ENTRY_IN_USE:
return SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE;
default:
return MapOEMCryptoResult(result, SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR,
"ShrinkUsageTableHeader");
}
}
CdmResponseType CryptoSession::CreateUsageEntry(uint32_t* entry_number) {
LOGV("Creating usage entry: id = %u", oec_session_id_);
@@ -2476,18 +2522,19 @@ CdmResponseType CryptoSession::LoadUsageEntry(
case OEMCrypto_SUCCESS:
case OEMCrypto_WARNING_GENERATION_SKEW:
return NO_ERROR;
case OEMCrypto_ERROR_INVALID_SESSION:
// This case is special, as it could imply that the provided
// session ID is invalid (CDM internal bug), or that the entry
// being loaded is already in use in a different session.
// It is up to the caller to handle this.
return LOAD_USAGE_ENTRY_INVALID_SESSION;
case OEMCrypto_ERROR_GENERATION_SKEW:
return LOAD_USAGE_ENTRY_GENERATION_SKEW;
case OEMCrypto_ERROR_SIGNATURE_FAILURE:
return LOAD_USAGE_ENTRY_SIGNATURE_FAILURE;
case OEMCrypto_ERROR_INSUFFICIENT_RESOURCES:
return INSUFFICIENT_CRYPTO_RESOURCES_3;
case OEMCrypto_ERROR_SESSION_LOST_STATE:
return SESSION_LOST_STATE_ERROR;
case OEMCrypto_ERROR_SYSTEM_INVALIDATED:
return SYSTEM_INVALIDATED_ERROR;
default:
return LOAD_USAGE_ENTRY_UNKNOWN_ERROR;
return MapOEMCryptoResult(result, LOAD_USAGE_ENTRY_UNKNOWN_ERROR,
"LoadUsageEntry");
}
}
@@ -2533,42 +2580,6 @@ CdmResponseType CryptoSession::UpdateUsageEntry(
"UpdateUsageEntry");
}
CdmResponseType CryptoSession::ShrinkUsageTableHeader(
uint32_t new_entry_count, CdmUsageTableHeader* usage_table_header) {
LOGV("Shrinking usage table header: id = %u", oec_session_id_);
RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
size_t usage_table_header_len = 0;
OEMCryptoResult result;
WithOecWriteLock("ShrinkUsageTableHeader Attempt 1", [&] {
result = OEMCrypto_ShrinkUsageTableHeader(requested_security_level_,
new_entry_count, nullptr,
&usage_table_header_len);
metrics_->oemcrypto_shrink_usage_table_header_.Increment(result);
});
if (result == OEMCrypto_ERROR_SHORT_BUFFER) {
usage_table_header->resize(usage_table_header_len);
WithOecWriteLock("ShrinkUsageTableHeader Attempt 2", [&] {
result = OEMCrypto_ShrinkUsageTableHeader(
requested_security_level_, new_entry_count,
reinterpret_cast<uint8_t*>(
const_cast<char*>(usage_table_header->data())),
&usage_table_header_len);
metrics_->oemcrypto_shrink_usage_table_header_.Increment(result);
});
}
if (result == OEMCrypto_SUCCESS) {
usage_table_header->resize(usage_table_header_len);
}
return MapOEMCryptoResult(result, SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR,
"ShrinkUsageTableHeader");
}
CdmResponseType CryptoSession::MoveUsageEntry(uint32_t new_entry_number) {
LOGV("Moving usage entry: id = %u", oec_session_id_);
@@ -2578,8 +2589,15 @@ CdmResponseType CryptoSession::MoveUsageEntry(uint32_t new_entry_number) {
metrics_->oemcrypto_move_entry_.Increment(result);
});
switch (result) {
case OEMCrypto_ERROR_ENTRY_IN_USE:
LOGW("OEMCrypto_MoveEntry failed: Destination index in use: index = %u",
new_entry_number);
return MOVE_USAGE_ENTRY_DESTINATION_IN_USE;
default:
return MapOEMCryptoResult(result, MOVE_USAGE_ENTRY_UNKNOWN_ERROR,
"MoveUsageEntry");
}
}
bool CryptoSession::GetAnalogOutputCapabilities(bool* can_support_output,

23
libwvdrmengine/cdm/core/src/usage_table_header.cpp
View File

@@ -186,7 +186,8 @@ bool UsageTableHeader::Init(CdmSecurityLevel security_level,
if (file_handle_->RetrieveUsageTableInfo(
&usage_table_header_, &usage_entry_info_, &run_lru_upgrade)) {
LOGI("Number of usage entries: %zu", usage_entry_info_.size());
status = crypto_session->LoadUsageTableHeader(usage_table_header_);
status = crypto_session->LoadUsageTableHeader(requested_security_level_,
usage_table_header_);
bool lru_success = true;
if (status == NO_ERROR && run_lru_upgrade) {
@@ -250,12 +251,14 @@ bool UsageTableHeader::Init(CdmSecurityLevel security_level,
file_handle_->DeleteUsageTableInfo();
usage_entry_info_.clear();
usage_table_header_.clear();
status = crypto_session->CreateUsageTableHeader(&usage_table_header_);
status = crypto_session->CreateUsageTableHeader(requested_security_level_,
&usage_table_header_);
if (status != NO_ERROR) return false;
file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_);
}
} else {
status = crypto_session->CreateUsageTableHeader(&usage_table_header_);
status = crypto_session->CreateUsageTableHeader(requested_security_level_,
&usage_table_header_);
if (status != NO_ERROR) return false;
file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_);
}
@@ -537,7 +540,7 @@ CdmResponseType UsageTableHeader::MoveEntry(
std::unique_ptr<CryptoSession> scoped_crypto_session;
CryptoSession* crypto_session = test_crypto_session_.get();
if (crypto_session == nullptr) {
scoped_crypto_session.reset((CryptoSession::MakeCryptoSession(metrics)));
scoped_crypto_session.reset(CryptoSession::MakeCryptoSession(metrics));
crypto_session = scoped_crypto_session.get();
}
@@ -731,6 +734,7 @@ CdmResponseType UsageTableHeader::Shrink(
if (number_of_usage_entries_to_delete == 0) return NO_ERROR;
// TODO(b/150887808): Only resize if the shrink operation is successful.
usage_entry_info_.resize(usage_entry_info_.size() -
number_of_usage_entries_to_delete);
@@ -743,15 +747,14 @@ CdmResponseType UsageTableHeader::Shrink(
crypto_session = scoped_crypto_session.get();
}
CdmResponseType status = crypto_session->Open(requested_security_level_);
if (status != NO_ERROR) return status;
status = crypto_session->ShrinkUsageTableHeader(usage_entry_info_.size(),
const CdmResponseType status = crypto_session->ShrinkUsageTableHeader(
requested_security_level_, usage_entry_info_.size(),
&usage_table_header_);
if (status != NO_ERROR) return status;
if (status == NO_ERROR) {
file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_);
return NO_ERROR;
}
return status;
}
// Test only method.

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

@@ -40,16 +40,19 @@ class MockCryptoSession : public TestCryptoSession {
MockCryptoSession(metrics::CryptoMetrics* metrics)
: TestCryptoSession(metrics) {}
MOCK_METHOD1(Open, CdmResponseType(SecurityLevel));
MOCK_METHOD1(LoadUsageTableHeader,
CdmResponseType(const CdmUsageTableHeader&));
MOCK_METHOD1(CreateUsageTableHeader, CdmResponseType(CdmUsageTableHeader*));
// Usage Table Header.
MOCK_METHOD2(CreateUsageTableHeader,
CdmResponseType(SecurityLevel, CdmUsageTableHeader*));
MOCK_METHOD2(LoadUsageTableHeader,
CdmResponseType(SecurityLevel, const CdmUsageTableHeader&));
MOCK_METHOD3(ShrinkUsageTableHeader,
CdmResponseType(SecurityLevel, uint32_t, CdmUsageTableHeader*));
// Usage Entry.
MOCK_METHOD1(CreateUsageEntry, CdmResponseType(uint32_t*));
MOCK_METHOD2(LoadUsageEntry, CdmResponseType(uint32_t, const CdmUsageEntry&));
MOCK_METHOD2(UpdateUsageEntry,
CdmResponseType(CdmUsageTableHeader*, CdmUsageEntry*));
MOCK_METHOD1(MoveUsageEntry, CdmResponseType(uint32_t));
MOCK_METHOD2(ShrinkUsageTableHeader,
CdmResponseType(uint32_t, CdmUsageTableHeader*));
};
class TestStubCryptoSessionFactory : public CryptoSessionFactory {

13
libwvdrmengine/cdm/core/test/test_printers.cpp
View File

@@ -560,6 +560,9 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
case LOAD_USAGE_ENTRY_GENERATION_SKEW:
*os << "LOAD_USAGE_ENTRY_GENERATION_SKEW";
break;
case LOAD_USAGE_ENTRY_INVALID_SESSION:
*os << "LOAD_USAGE_ENTRY_INVALID_SESSION";
break;
case LOAD_USAGE_ENTRY_SIGNATURE_FAILURE:
*os << "LOAD_USAGE_ENTRY_SIGNATURE_FAILURE";
break;
@@ -578,6 +581,9 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
case LOAD_USAGE_HEADER_UNKNOWN_ERROR:
*os << "LOAD_USAGE_HEADER_UNKNOWN_ERROR";
break;
case MOVE_USAGE_ENTRY_DESTINATION_IN_USE:
*os << "MOVE_USAGE_ENTRY_DESTINATION_IN_USE";
break;
case MOVE_USAGE_ENTRY_UNKNOWN_ERROR:
*os << "MOVE_USAGE_ENTRY_UNKNOWN_ERROR";
break;
@@ -818,8 +824,11 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
case SET_DECRYPT_HASH_ERROR:
*os << "SET_DECRYPT_HASH_ERROR";
break;
case SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR:
*os << "SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR";
case SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE:
*os << "SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE";
break;
case SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR:
*os << "SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR";
break;
case SIGNATURE_NOT_FOUND:
*os << "SIGNATURE_NOT_FOUND";

286
libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp
View File

@@ -424,16 +424,19 @@ class MockCryptoSession : public TestCryptoSession {
MockCryptoSession(metrics::CryptoMetrics* metrics)
: TestCryptoSession(metrics) {}
MOCK_METHOD1(Open, CdmResponseType(SecurityLevel));
MOCK_METHOD1(LoadUsageTableHeader,
CdmResponseType(const CdmUsageTableHeader&));
MOCK_METHOD1(CreateUsageTableHeader, CdmResponseType(CdmUsageTableHeader*));
// Usage Table Header.
MOCK_METHOD2(CreateUsageTableHeader,
CdmResponseType(SecurityLevel, CdmUsageTableHeader*));
MOCK_METHOD2(LoadUsageTableHeader,
CdmResponseType(SecurityLevel, const CdmUsageTableHeader&));
MOCK_METHOD3(ShrinkUsageTableHeader,
CdmResponseType(SecurityLevel, uint32_t, CdmUsageTableHeader*));
// Usage Entry.
MOCK_METHOD1(CreateUsageEntry, CdmResponseType(uint32_t*));
MOCK_METHOD2(LoadUsageEntry, CdmResponseType(uint32_t, const CdmUsageEntry&));
MOCK_METHOD2(UpdateUsageEntry,
CdmResponseType(CdmUsageTableHeader*, CdmUsageEntry*));
MOCK_METHOD1(MoveUsageEntry, CdmResponseType(uint32_t));
MOCK_METHOD2(ShrinkUsageTableHeader,
CdmResponseType(uint32_t, CdmUsageTableHeader*));
// Fake method for testing. Having an EXPECT_CALL causes complexities
// for getting table capacity during initialization.
@@ -561,7 +564,7 @@ class UsageTableHeaderTest : public WvCdmTestBase {
.WillOnce(DoAll(SetArgPointee<0>(usage_table_header),
SetArgPointee<1>(usage_entry_info_vector),
SetArgPointee<2>(false), Return(true)));
EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(usage_table_header))
EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(_, usage_table_header))
.WillOnce(Return(NO_ERROR));
EXPECT_TRUE(usage_table_header_->Init(security_level, crypto_session_));
}
@@ -594,14 +597,17 @@ class UsageTableHeaderInitializationTest
};
TEST_P(UsageTableHeaderInitializationTest, CreateUsageTableHeader) {
const SecurityLevel security_level =
(GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
EXPECT_CALL(*device_files_,
RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
.WillOnce(DoAll(SetArgPointee<0>(kEmptyUsageTableHeader),
SetArgPointee<1>(kEmptyUsageEntryInfoVector),
SetArgPointee<2>(false), Return(false)));
EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
EXPECT_CALL(*crypto_session_,
CreateUsageTableHeader(security_level, NotNull()))
.WillOnce(
DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_, StoreUsageTableInfo(kEmptyUsageTableHeader,
kEmptyUsageEntryInfoVector))
.WillOnce(Return(true));
@@ -610,14 +616,17 @@ TEST_P(UsageTableHeaderInitializationTest, CreateUsageTableHeader) {
}
TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveLicenses) {
const SecurityLevel security_level =
(GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
EXPECT_CALL(*device_files_,
RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
.WillOnce(DoAll(SetArgPointee<0>(kEmptyUsageTableHeader),
SetArgPointee<1>(kEmptyUsageEntryInfoVector),
SetArgPointee<2>(false), Return(false)));
EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
EXPECT_CALL(*crypto_session_,
CreateUsageTableHeader(security_level, NotNull()))
.WillOnce(
DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR)));
// TODO: Why not being called?
//EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true));
EXPECT_CALL(*device_files_, StoreUsageTableInfo(kEmptyUsageTableHeader,
@@ -628,14 +637,17 @@ TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveLicenses) {
}
TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveUsageInfo) {
const SecurityLevel security_level =
(GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
EXPECT_CALL(*device_files_,
RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
.WillOnce(DoAll(SetArgPointee<0>(kEmptyUsageTableHeader),
SetArgPointee<1>(kEmptyUsageEntryInfoVector),
SetArgPointee<2>(false), Return(false)));
EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
EXPECT_CALL(*crypto_session_,
CreateUsageTableHeader(security_level, NotNull()))
.WillOnce(
DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_, StoreUsageTableInfo(kEmptyUsageTableHeader,
kEmptyUsageEntryInfoVector))
.WillOnce(Return(true));
@@ -644,12 +656,15 @@ TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveUsageInfo) {
}
TEST_P(UsageTableHeaderInitializationTest, UsageTableHeaderExists) {
const SecurityLevel security_level =
(GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
EXPECT_CALL(*device_files_,
RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
.WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
SetArgPointee<1>(kUsageEntryInfoVector),
SetArgPointee<2>(false), Return(true)));
EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(security_level, kUsageTableHeader))
.WillOnce(Return(NO_ERROR));
EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
@@ -658,12 +673,15 @@ TEST_P(UsageTableHeaderInitializationTest, UsageTableHeaderExists) {
TEST_P(UsageTableHeaderInitializationTest, 200UsageEntries) {
std::vector<CdmUsageEntryInfo> usage_entries_200 = k201UsageEntryInfoVector;
usage_entries_200.resize(200);
const SecurityLevel security_level =
(GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
EXPECT_CALL(*device_files_,
RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
.WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
SetArgPointee<1>(usage_entries_200),
SetArgPointee<2>(false), Return(true)));
EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(security_level, kUsageTableHeader))
.WillOnce(Return(NO_ERROR));
EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
@@ -681,11 +699,13 @@ TEST_P(UsageTableHeaderInitializationTest,
(GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
EXPECT_CALL(*crypto_session_,
Open(security_level)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(security_level, kUsageTableHeader))
.WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
EXPECT_CALL(*crypto_session_,
CreateUsageTableHeader(security_level, NotNull()))
.WillOnce(
DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true));
EXPECT_CALL(*device_files_, DeleteAllUsageInfo()).WillOnce(Return(true));
EXPECT_CALL(*device_files_, DeleteUsageTableInfo()).WillOnce(Return(true));
@@ -706,17 +726,21 @@ TEST_P(UsageTableHeaderInitializationTest,
201UsageEntries_DeleteEntryFails_UsageTableHeaderRecreated) {
std::vector<CdmUsageEntryInfo> usage_entries_202 = k201UsageEntryInfoVector;
usage_entries_202.push_back(kDummyUsageEntryInfo);
const SecurityLevel security_level =
(GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
EXPECT_CALL(*device_files_,
RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
.WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
SetArgPointee<1>(k201UsageEntryInfoVector),
SetArgPointee<2>(false), Return(true)));
EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(security_level, kUsageTableHeader))
.WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
EXPECT_CALL(*crypto_session_,
CreateUsageTableHeader(security_level, NotNull()))
.WillOnce(
DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true));
EXPECT_CALL(*device_files_, DeleteAllUsageInfo()).WillOnce(Return(true));
EXPECT_CALL(*device_files_, DeleteUsageTableInfo()).WillOnce(Return(true));
@@ -734,16 +758,12 @@ TEST_P(UsageTableHeaderInitializationTest,
.WillOnce(Return(true));
// Expectations for DeleteEntry
const SecurityLevel security_level =
(GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
EXPECT_CALL(*crypto_session_, Open(security_level))
.WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_,
Open(security_level))
.Times(2)
.WillRepeatedly(Return(NO_ERROR));
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(usage_entries_202.size() - 1, NotNull()))
.WillOnce(Return(SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR));
ShrinkUsageTableHeader(security_level,
usage_entries_202.size() - 1, NotNull()))
.WillOnce(Return(SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR));
EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
}
@@ -753,12 +773,16 @@ TEST_P(UsageTableHeaderInitializationTest,
std::vector<CdmUsageEntryInfo> usage_entries_202 = k201UsageEntryInfoVector;
usage_entries_202.push_back(kDummyUsageEntryInfo);
const SecurityLevel security_level =
(GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
EXPECT_CALL(*device_files_,
RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull()))
.WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
SetArgPointee<1>(k201UsageEntryInfoVector),
SetArgPointee<2>(false), Return(true)));
EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(security_level, kUsageTableHeader))
.WillOnce(Return(NO_ERROR));
// Expectations for AddEntry
@@ -771,18 +795,13 @@ TEST_P(UsageTableHeaderInitializationTest,
.WillOnce(Return(true));
// Expectations for DeleteEntry
const SecurityLevel security_level =
(GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
EXPECT_CALL(*crypto_session_, Open(security_level))
.WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_,
Open(security_level))
.Times(2)
.WillRepeatedly(Return(NO_ERROR));
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(usage_entries_202.size() - 1, NotNull()))
ShrinkUsageTableHeader(security_level,
usage_entries_202.size() - 1, NotNull()))
.WillOnce(
DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_,
StoreUsageTableInfo(
kAnotherUsageTableHeader,
@@ -1302,11 +1321,10 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_CryptoSessionError) {
usage_entry_info_vector.size() - 1; // kUsageEntryInfoOfflineLicense2
metrics::CryptoMetrics metrics;
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(usage_entry_info_vector.size() - 1, NotNull()))
.WillOnce(Return(SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR));
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(
kLevelDefault, usage_entry_info_vector.size() - 1, NotNull()))
.WillOnce(Return(SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR));
EXPECT_NE(NO_ERROR,
usage_table_header_->DeleteEntry(usage_entry_number_to_be_deleted,
@@ -1341,12 +1359,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastOfflineEntry) {
usage_entry_info_vector.size() - 1; // kUsageEntryInfoOfflineLicense2
metrics::CryptoMetrics metrics;
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(usage_entry_info_vector.size() - 1, NotNull()))
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(
kLevelDefault, usage_entry_info_vector.size() - 1, NotNull()))
.WillOnce(
DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_,
StoreUsageTableInfo(
@@ -1389,12 +1406,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastSecureStopEntry) {
usage_entry_info_vector.size() - 1; // kUsageEntryInfoSecureStop2
metrics::CryptoMetrics metrics;
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(usage_entry_info_vector.size() - 1, NotNull()))
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(
kLevelDefault, usage_entry_info_vector.size() - 1, NotNull()))
.WillOnce(
DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_,
StoreUsageTableInfo(
@@ -1440,12 +1456,11 @@ TEST_F(UsageTableHeaderTest,
usage_entry_info_vector.size() - 3; // kUsageEntryInfoOfflineLicense1
metrics::CryptoMetrics metrics;
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull()))
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(
kLevelDefault, usage_entry_number_to_be_deleted, NotNull()))
.WillOnce(
DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_,
StoreUsageTableInfo(
@@ -1498,12 +1513,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastSecureStopEntriesAreMissing) {
usage_entry_info_vector.size() - 3; // kUsageEntryInfoSecureStop1
metrics::CryptoMetrics metrics;
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull()))
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(
kLevelDefault, usage_entry_number_to_be_deleted, NotNull()))
.WillOnce(
DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_,
RetrieveUsageInfoByKeySetId(
@@ -1599,12 +1613,11 @@ TEST_F(UsageTableHeaderTest,
device_files_->StoreLicense(offline_license_2_data, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull()))
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(
kLevelDefault, usage_entry_number_to_be_deleted, NotNull()))
.WillOnce(
DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_,
StoreUsageTableInfo(
kAnotherUsageTableHeader,
@@ -1657,12 +1670,11 @@ TEST_F(UsageTableHeaderTest,
usage_entry_number_to_be_deleted + 1;
metrics::CryptoMetrics metrics;
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull()))
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(
kLevelDefault, usage_entry_number_to_be_deleted, NotNull()))
.WillOnce(
DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_,
RetrieveUsageInfoByKeySetId(
@@ -1733,12 +1745,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreStorageTypeUnknown) {
usage_entry_info_vector.size() - 3; // kUsageEntryInfoOfflineLicense3
metrics::CryptoMetrics metrics;
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull()))
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(
kLevelDefault, usage_entry_number_to_be_deleted, NotNull()))
.WillOnce(
DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(
*device_files_,
@@ -1969,20 +1980,18 @@ TEST_F(UsageTableHeaderTest,
EXPECT_TRUE(device_files_->StoreLicense(license_data, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
.Times(2)
.WillRepeatedly(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_,
LoadUsageEntry(last_valid_usage_entry_number, kUsageEntry))
.WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_,
MoveUsageEntry(usage_entry_number_to_be_deleted))
.WillOnce(Return(MOVE_USAGE_ENTRY_UNKNOWN_ERROR));
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(last_valid_usage_entry_number + 1, NotNull()))
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(
kLevelDefault, last_valid_usage_entry_number + 1, NotNull()))
.WillOnce(
DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(
*device_files_,
@@ -2044,9 +2053,7 @@ TEST_F(UsageTableHeaderTest,
usage_entry_info_vector.size() - 3; // kUsageEntryInfoOfflineLicense3
metrics::CryptoMetrics metrics;
EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
.Times(2)
.WillRepeatedly(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_,
LoadUsageEntry(last_valid_usage_entry_number, kUsageEntry))
.WillOnce(Return(NO_ERROR));
@@ -2064,11 +2071,11 @@ TEST_F(UsageTableHeaderTest,
SetArgPointee<3>(kKeyRequest), SetArgPointee<4>(kKeyResponse),
SetArgPointee<5>(kUsageEntry),
SetArgPointee<6>(last_valid_usage_entry_number), Return(true)));
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(last_valid_usage_entry_number + 1, NotNull()))
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(
kLevelDefault, last_valid_usage_entry_number + 1, NotNull()))
.WillOnce(
DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(
*device_files_,
@@ -2139,9 +2146,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsOffline) {
device_files_->StoreLicense(stored_license_data, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
.Times(2)
.WillRepeatedly(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_,
LoadUsageEntry(last_usage_entry_number, kUsageEntry))
.WillOnce(Return(NO_ERROR));
@@ -2151,10 +2156,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsOffline) {
EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
.WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader),
SetArgPointee<1>(kAnotherUsageEntry), Return(NO_ERROR)));
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(last_usage_entry_number, NotNull()))
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(kLevelDefault, last_usage_entry_number, NotNull()))
.WillOnce(
DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(
*device_files_,
@@ -2244,9 +2250,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsSecureStop) {
usage_entry_info_vector.size() - 1; // kUsageEntryInfoSecureStop3
metrics::CryptoMetrics metrics;
EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
.Times(2)
.WillRepeatedly(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_,
LoadUsageEntry(last_usage_entry_number, kUsageEntry))
.WillOnce(Return(NO_ERROR));
@@ -2256,10 +2260,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsSecureStop) {
EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull()))
.WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader),
SetArgPointee<1>(kAnotherUsageEntry), Return(NO_ERROR)));
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(last_usage_entry_number, NotNull()))
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(kLevelDefault, last_usage_entry_number, NotNull()))
.WillOnce(
DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_,
RetrieveUsageInfoByKeySetId(
@@ -2367,9 +2372,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreOfflineAndUnknknown) {
device_files_->StoreLicense(stored_license_data, &sub_error_code));
EXPECT_EQ(DeviceFiles::kNoError, sub_error_code);
EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
.Times(2)
.WillRepeatedly(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_,
LoadUsageEntry(last_valid_usage_entry_number, kUsageEntry))
.WillOnce(Return(NO_ERROR));
@@ -2380,9 +2383,10 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreOfflineAndUnknknown) {
.WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader),
SetArgPointee<1>(kAnotherUsageEntry), Return(NO_ERROR)));
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(last_valid_usage_entry_number, NotNull()))
ShrinkUsageTableHeader(kLevelDefault,
last_valid_usage_entry_number, NotNull()))
.WillOnce(
DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(
*device_files_,
@@ -2477,9 +2481,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreSecureStopAndUnknknown) {
usage_entry_info_vector.size() - 3; // kUsageEntryInfoSecureStop3
metrics::CryptoMetrics metrics;
EXPECT_CALL(*crypto_session_, Open(kLevelDefault))
.Times(2)
.WillRepeatedly(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_,
LoadUsageEntry(last_valid_usage_entry_number, kUsageEntry))
.WillOnce(Return(NO_ERROR));
@@ -2490,9 +2492,10 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreSecureStopAndUnknknown) {
.WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader),
SetArgPointee<1>(kAnotherUsageEntry), Return(NO_ERROR)));
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(last_valid_usage_entry_number, NotNull()))
ShrinkUsageTableHeader(kLevelDefault,
last_valid_usage_entry_number, NotNull()))
.WillOnce(
DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_,
RetrieveUsageInfoByKeySetId(
@@ -2557,11 +2560,13 @@ TEST_F(UsageTableHeaderTest, StaleHeader) {
.WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
SetArgPointee<1>(usage_entry_info_vector),
SetArgPointee<2>(false), Return(true)));
EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(kLevelDefault, kUsageTableHeader))
.WillOnce(Return(LOAD_USAGE_HEADER_GENERATION_SKEW));
EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
EXPECT_CALL(*crypto_session_,
CreateUsageTableHeader(kLevelDefault, NotNull()))
.WillOnce(
DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR)));
EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true));
EXPECT_CALL(*device_files_, DeleteAllUsageInfo()).WillOnce(Return(true));
EXPECT_CALL(*device_files_, DeleteUsageTableInfo()).WillOnce(Return(true));
@@ -2580,7 +2585,9 @@ TEST_F(UsageTableHeaderTest, Shrink_NoneOfTable) {
// These calls are "expensive" and should be avoided if possible.
EXPECT_CALL(*crypto_session_, Open(_)).Times(0);
EXPECT_CALL(*crypto_session_, ShrinkUsageTableHeader(_, NotNull())).Times(0);
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(kLevelDefault, _, NotNull()))
.Times(0);
EXPECT_CALL(*device_files_, StoreUsageTableInfo(_, _)).Times(0);
EXPECT_EQ(usage_table_header_->Shrink(&metrics, 0), NO_ERROR);
@@ -2595,9 +2602,9 @@ TEST_F(UsageTableHeaderTest, Shrink_PartOfTable) {
k10UsageEntryInfoVector.cend() - to_shink);
metrics::CryptoMetrics metrics;
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(shunken_entries.size(), NotNull()))
EXPECT_CALL(
*crypto_session_,
ShrinkUsageTableHeader(kLevelDefault, shunken_entries.size(), NotNull()))
.WillOnce(Return(NO_ERROR));
EXPECT_CALL(*device_files_,
StoreUsageTableInfo(kUsageTableHeader, shunken_entries))
@@ -2611,8 +2618,8 @@ TEST_F(UsageTableHeaderTest, Shrink_AllOfTable) {
Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector);
metrics::CryptoMetrics metrics;
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_, ShrinkUsageTableHeader(0, NotNull()))
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(kLevelDefault, 0, NotNull()))
.WillOnce(Return(NO_ERROR));
EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader,
kEmptyUsageEntryInfoVector))
@@ -2628,8 +2635,8 @@ TEST_F(UsageTableHeaderTest, Shrink_AllOfTable) {
TEST_F(UsageTableHeaderTest, Shrink_MoreThanTable) {
Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector);
metrics::CryptoMetrics metrics;
EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR));
EXPECT_CALL(*crypto_session_, ShrinkUsageTableHeader(0, NotNull()))
EXPECT_CALL(*crypto_session_,
ShrinkUsageTableHeader(kLevelDefault, 0, NotNull()))
.WillOnce(Return(NO_ERROR));
EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader,
kEmptyUsageEntryInfoVector))
@@ -2654,7 +2661,7 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_NoAction) {
SetArgPointee<2>(/* lru_upgrade = */ false),
Return(true)));
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(kUpgradableUsageTableHeader))
LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
.WillOnce(Return(NO_ERROR));
// These function are called specifically by the LRU upgrading system.
@@ -2680,7 +2687,7 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_Succeed) {
SetArgPointee<2>(/* lru_upgrade = */ true),
Return(true)));
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(kUpgradableUsageTableHeader))
LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
.WillOnce(Return(NO_ERROR));
for (size_t i = 0; i < kUpgradableUsageEntryInfoList.size(); ++i) {
@@ -2744,7 +2751,7 @@ TEST_F(UsageTableHeaderTest,
SetArgPointee<2>(/* lru_upgrade = */ true),
Return(true)));
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(kUpgradableUsageTableHeader))
LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
.WillOnce(Return(NO_ERROR));
// Expectations of the one successful license.
@@ -2804,7 +2811,7 @@ TEST_F(UsageTableHeaderTest,
SetArgPointee<2>(/* lru_upgrade = */ true),
Return(true)));
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(kUpgradableUsageTableHeader))
LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
.WillOnce(Return(NO_ERROR));
for (size_t i = 0; i < kUpgradableUsageEntryInfoList.size(); ++i) {
@@ -2857,7 +2864,7 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_AllFailure) {
SetArgPointee<2>(/* lru_upgrade = */ true),
Return(true)));
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(kUpgradableUsageTableHeader))
LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader))
.WillOnce(Return(NO_ERROR));
for (size_t i = 0; i < kUpgradableUsageEntryInfoList.size(); ++i) {
@@ -2881,7 +2888,8 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_AllFailure) {
EXPECT_CALL(*device_files_, DeleteAllLicenses());
EXPECT_CALL(*device_files_, DeleteAllUsageInfo());
EXPECT_CALL(*device_files_, DeleteUsageTableInfo());
EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
EXPECT_CALL(*crypto_session_,
CreateUsageTableHeader(kLevelDefault, NotNull()))
.WillOnce(Return(NO_ERROR));
EXPECT_CALL(*device_files_, StoreUsageTableInfo(_, _));
@@ -2896,7 +2904,8 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateLicenseEntry) {
SetArgPointee<1>(kUpgradedUsageEntryInfoList),
SetArgPointee<2>(/* lru_upgrade = */ false),
Return(true)));
EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUpgradedUsageTableHeader))
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(kLevelDefault, kUpgradedUsageTableHeader))
.WillOnce(Return(NO_ERROR));
EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_));
@@ -2940,7 +2949,8 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateUsageInfoEntry) {
SetArgPointee<1>(kUpgradedUsageEntryInfoList),
SetArgPointee<2>(/* lru_upgrade = */ false),
Return(true)));
EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUpgradedUsageTableHeader))
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(kLevelDefault, kUpgradedUsageTableHeader))
.WillOnce(Return(NO_ERROR));
EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_));
@@ -2985,7 +2995,8 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_UpdateEntry) {
SetArgPointee<1>(kUpgradedUsageEntryInfoList),
SetArgPointee<2>(/* lru_upgrade = */ false),
Return(true)));
EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUpgradedUsageTableHeader))
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(kLevelDefault, kUpgradedUsageTableHeader))
.WillOnce(Return(NO_ERROR));
EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_));
@@ -3027,7 +3038,8 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_LoadEntry) {
SetArgPointee<1>(kUpgradedUsageEntryInfoList),
SetArgPointee<2>(/* lru_upgrade = */ false),
Return(true)));
EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUpgradedUsageTableHeader))
EXPECT_CALL(*crypto_session_,
LoadUsageTableHeader(kLevelDefault, kUpgradedUsageTableHeader))
.WillOnce(Return(NO_ERROR));
EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_));

7
libwvdrmengine/include/WVErrors.h
View File

@@ -206,7 +206,7 @@ enum {
kLoadUsageEntrySignatureFailure = ERROR_DRM_VENDOR_MIN + 218,
kLoadUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 219,
kUpdateUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 222,
kShrinkUsageTablerHeaderUnknownError = ERROR_DRM_VENDOR_MIN + 224,
kShrinkUsageTableHeaderUnknownError = ERROR_DRM_VENDOR_MIN + 224,
kMoveUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 225,
kCopyOldUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 226,
kInvalidParametersEng22 = ERROR_DRM_VENDOR_MIN + 227,
@@ -289,10 +289,13 @@ enum {
kCannotDecryptZeroSubsamples = ERROR_DRM_VENDOR_MIN + 306,
kSampleAndSubsampleSizeMismatch = ERROR_DRM_VENDOR_MIN + 307,
kInvalidIvSize = ERROR_DRM_VENDOR_MIN + 308,
kLoadUsageEntryInvalidSession = ERROR_DRM_VENDOR_MIN + 309,
kMoveUsageEntryDestinationInUse = ERROR_DRM_VENDOR_MIN + 310,
kShrinkUsageTableHeaderEntryInUse = ERROR_DRM_VENDOR_MIN + 311,
// This should always follow the last error code.
// The offset value should be updated each time a new error code is added.
kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 308,
kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 311,
// Used by crypto test mode
kErrorTestMode = ERROR_DRM_VENDOR_MAX,

10
libwvdrmengine/include/mapErrors-inl.h
View File

@@ -378,6 +378,8 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
return kLoadSystemIdError;
case wvcdm::LOAD_USAGE_ENTRY_GENERATION_SKEW:
return kLoadUsageEntryGenerationSkew;
case wvcdm::LOAD_USAGE_ENTRY_INVALID_SESSION:
return kLoadUsageEntryInvalidSession;
case wvcdm::LOAD_USAGE_ENTRY_SIGNATURE_FAILURE:
return kLoadUsageEntrySignatureFailure;
case wvcdm::LOAD_USAGE_ENTRY_UNKNOWN_ERROR:
@@ -394,6 +396,8 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
return kLoadUsageInfoFileError;
case wvcdm::LOAD_USAGE_INFO_MISSING:
return kLoadUsageInfoMissing;
case wvcdm::MOVE_USAGE_ENTRY_DESTINATION_IN_USE:
return kMoveUsageEntryDestinationInUse;
case wvcdm::MOVE_USAGE_ENTRY_UNKNOWN_ERROR:
return kMoveUsageEntryUnknownError;
case wvcdm::NOT_AN_ENTITLEMENT_SESSION:
@@ -492,8 +496,10 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
return kSessionNotFound16;
case wvcdm::SET_DECRYPT_HASH_ERROR:
return kSetDecryptHashError;
case wvcdm::SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR:
return kShrinkUsageTablerHeaderUnknownError;
case wvcdm::SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE:
return kShrinkUsageTableHeaderEntryInUse;
case wvcdm::SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR:
return kShrinkUsageTableHeaderUnknownError;
case wvcdm::SIGNATURE_NOT_FOUND:
return kSignatureNotFound;
case wvcdm::SIGNATURE_NOT_FOUND_2:

5
libwvdrmengine/include_hidl/mapErrors-inl.h
View File

@@ -246,7 +246,7 @@ static Status mapCdmResponseType(wvcdm::CdmResponseType res) {
case wvcdm::LOAD_USAGE_ENTRY_SIGNATURE_FAILURE:
case wvcdm::LOAD_USAGE_ENTRY_UNKNOWN_ERROR:
case wvcdm::UPDATE_USAGE_ENTRY_UNKNOWN_ERROR:
case wvcdm::SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR:
case wvcdm::SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR:
case wvcdm::MOVE_USAGE_ENTRY_UNKNOWN_ERROR:
case wvcdm::COPY_OLD_USAGE_ENTRY_UNKNOWN_ERROR:
case wvcdm::INVALID_PARAMETERS_ENG_22:
@@ -355,6 +355,9 @@ static Status mapCdmResponseType(wvcdm::CdmResponseType res) {
case wvcdm::CANNOT_DECRYPT_ZERO_SUBSAMPLES:
case wvcdm::SAMPLE_AND_SUBSAMPLE_SIZE_MISMATCH:
case wvcdm::INVALID_IV_SIZE:
case wvcdm::LOAD_USAGE_ENTRY_INVALID_SESSION:
case wvcdm::MOVE_USAGE_ENTRY_DESTINATION_IN_USE:
case wvcdm::SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE:
ALOGW("Returns UNKNOWN error for legacy status: %d", res);
return Status::ERROR_DRM_UNKNOWN;

21
libwvdrmengine/oemcrypto/ref/src/oemcrypto_session.cpp
View File

@@ -210,14 +210,6 @@ SessionContext::SessionContext(CryptoEngine* ce, SessionId sid,
}
SessionContext::~SessionContext() {
if (usage_entry_) {
delete usage_entry_;
usage_entry_ = nullptr;
}
if (session_keys_) {
delete session_keys_;
session_keys_ = nullptr;
}
}
// Internal utility function to derive key using CMAC-128
@@ -777,11 +769,11 @@ OEMCryptoResult SessionContext::LoadKeysNoSignature(
if (session_keys_ == nullptr) {
switch (license_type) {
case OEMCrypto_ContentLicense:
session_keys_ = new ContentKeysContext();
session_keys_.reset(new ContentKeysContext());
break;
case OEMCrypto_EntitlementLicense:
session_keys_ = new EntitlementKeysContext();
session_keys_.reset(new EntitlementKeysContext());
break;
default:
@@ -915,7 +907,8 @@ OEMCryptoResult SessionContext::LoadEntitledContentKeys(
if (!key_array) {
return OEMCrypto_ERROR_UNKNOWN_FAILURE;
}
if (!session_keys_ || session_keys_->type() != OEMCrypto_EntitlementLicense) {
if (session_keys_ == nullptr ||
session_keys_->type() != OEMCrypto_EntitlementLicense) {
return OEMCrypto_ERROR_INVALID_CONTEXT;
}
for (size_t i = 0; i < key_array_length; ++i) {
@@ -1494,8 +1487,8 @@ OEMCryptoResult SessionContext::UpdateUsageEntry(uint8_t* header_buffer,
return OEMCrypto_ERROR_INVALID_CONTEXT;
}
return ce_->usage_table().UpdateUsageEntry(
this, usage_entry_, header_buffer, header_buffer_length, entry_buffer,
entry_buffer_length, &clock_values_);
this, usage_entry_.get(), header_buffer, header_buffer_length,
entry_buffer, entry_buffer_length, &clock_values_);
}
OEMCryptoResult SessionContext::DeactivateUsageEntry(
@@ -1514,7 +1507,7 @@ OEMCryptoResult SessionContext::ReportUsage(const std::vector<uint8_t>& pst,
OEMCryptoResult SessionContext::MoveEntry(uint32_t new_index) {
if (!usage_entry_) return OEMCrypto_ERROR_INVALID_CONTEXT;
return ce_->usage_table().MoveEntry(usage_entry_, new_index);
return ce_->usage_table().MoveEntry(usage_entry_.get(), new_index);
}
// Internal utility function to decrypt the message

4
libwvdrmengine/oemcrypto/ref/src/oemcrypto_session.h
View File

@@ -267,7 +267,7 @@ class SessionContext {
std::vector<uint8_t> encryption_key_;
std::vector<uint8_t> session_key_;
const Key* current_content_key_;
SessionContextKeys* session_keys_;
std::unique_ptr<SessionContextKeys> session_keys_;
ODK_NonceValues nonce_values_;
uint8_t license_request_hash_[ODK_SHA256_HASH_SIZE];
RSA_shared_ptr rsa_key_;
@@ -275,7 +275,7 @@ class SessionContext {
bool decrypt_started_; // If the license has been used in this session.
ODK_TimerLimits timer_limits_;
ODK_ClockValues clock_values_;
UsageTableEntry* usage_entry_;
std::unique_ptr<UsageTableEntry> usage_entry_;
SRMVersionStatus srm_requirements_status_;
enum UsageEntryStatus {
kNoUsageEntry, // No entry loaded for this session.

19
libwvdrmengine/oemcrypto/ref/src/oemcrypto_usage_table_ref.cpp
View File

@@ -348,8 +348,8 @@ UsageTableEntry* UsageTable::MakeEntry(uint32_t index) {
return new UsageTableEntry(this, index, master_generation_number_);
}
OEMCryptoResult UsageTable::CreateNewUsageEntry(SessionContext* session,
UsageTableEntry** entry,
OEMCryptoResult UsageTable::CreateNewUsageEntry(
SessionContext* session, std::unique_ptr<UsageTableEntry>* entry,
uint32_t* usage_entry_number) {
if (!header_loaded_) {
LOGE("CreateNewUsageEntry: Header not loaded.");
@@ -367,15 +367,14 @@ OEMCryptoResult UsageTable::CreateNewUsageEntry(SessionContext* session,
generation_numbers_.push_back(master_generation_number_);
sessions_.push_back(session);
master_generation_number_++;
*entry = new_entry;
entry->reset(new_entry);
*usage_entry_number = index;
return OEMCrypto_SUCCESS;
}
OEMCryptoResult UsageTable::LoadUsageEntry(SessionContext* session,
UsageTableEntry** entry,
uint32_t index,
const std::vector<uint8_t>& buffer,
OEMCryptoResult UsageTable::LoadUsageEntry(
SessionContext* session, std::unique_ptr<UsageTableEntry>* entry,
uint32_t index, const std::vector<uint8_t>& buffer,
ODK_ClockValues* clock_values) {
if (!header_loaded_) {
LOGE("CreateNewUsageEntry: Header not loaded.");
@@ -393,12 +392,11 @@ OEMCryptoResult UsageTable::LoadUsageEntry(SessionContext* session,
LOGE("Too many usage entries: %d/%d", index, max);
return OEMCrypto_ERROR_INSUFFICIENT_RESOURCES;
}
UsageTableEntry* new_entry = MakeEntry(index);
std::unique_ptr<UsageTableEntry> new_entry(MakeEntry(index));
OEMCryptoResult status =
new_entry->LoadData(ce_, index, buffer, clock_values);
if (status != OEMCrypto_SUCCESS) {
delete new_entry;
return status;
}
if (new_entry->generation_number() != generation_numbers_[index]) {
@@ -406,13 +404,12 @@ OEMCryptoResult UsageTable::LoadUsageEntry(SessionContext* session,
generation_numbers_[index]);
if ((new_entry->generation_number() + 1 < generation_numbers_[index]) ||
(new_entry->generation_number() - 1 > generation_numbers_[index])) {
delete new_entry;
return OEMCrypto_ERROR_GENERATION_SKEW;
}
status = OEMCrypto_WARNING_GENERATION_SKEW;
}
sessions_[index] = session;
*entry = new_entry;
*entry = std::move(new_entry);
return status;
}

5
libwvdrmengine/oemcrypto/ref/src/oemcrypto_usage_table_ref.h
View File

@@ -88,10 +88,11 @@ class UsageTable {
virtual ~UsageTable();
OEMCryptoResult CreateNewUsageEntry(SessionContext* session,
UsageTableEntry** entry,
std::unique_ptr<UsageTableEntry>* entry,
uint32_t* usage_entry_number);
OEMCryptoResult LoadUsageEntry(SessionContext* session,
UsageTableEntry** entry, uint32_t index,
std::unique_ptr<UsageTableEntry>* entry,
uint32_t index,
const std::vector<uint8_t>& buffer,
ODK_ClockValues* clock_values);
OEMCryptoResult UpdateUsageEntry(