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

Usage table header operations no longer need an open session.

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

There are several OEMCrypto functions that do not require an open
session to be called.  This change updates the OEMCrypto functions
related to the Usage Table Header.

Bug: 150888316
Test: Linux unit tests and Android build
Change-Id: Ic879876dd190fb3e058bbe8e0cce37273030b105
This commit is contained in:
Alex Dale
2020-03-06 17:46:50 -08:00
parent c9e4dd2495
commit 193d5c384d
5 changed files with 267 additions and 238 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,

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

@@ -708,12 +708,10 @@ uint8_t CryptoSession::GetSecurityPatchLevel() {
}
CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
LOGD(
"Opening crypto session: requested_security_level: "
"requested_security_level = %s",
requested_security_level == kLevel3
? QUERY_VALUE_SECURITY_LEVEL_L3.c_str()
: QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str());
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());
RETURN_IF_UNINITIALIZED(UNKNOWN_ERROR);
if (open_) return NO_ERROR;
@@ -802,35 +800,33 @@ 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");
std::unique_lock<shared_mutex> auto_lock(static_field_mutex_);
// This block cannot use |WithStaticFieldWriteLock| because it needs
// to unlock the lock partway through.
LOGV("Static field write lock: Open() initializing usage table");
std::unique_lock<shared_mutex> auto_lock(static_field_mutex_);
UsageTableHeader** header = security_level == kSecurityLevelL1
? &usage_table_header_l1_
: &usage_table_header_l3_;
if (*header == nullptr) {
*header = new UsageTableHeader();
// Ignore errors since we do not know when a session is opened,
// if it is intended to be used for offline/usage session related
// or otherwise.
auto_lock.unlock();
bool is_usage_table_header_inited =
(*header)->Init(security_level, this);
auto_lock.lock();
if (!is_usage_table_header_inited) {
delete *header;
*header = nullptr;
usage_table_header_ = nullptr;
return NO_ERROR;
}
UsageTableHeader** header = security_level == kSecurityLevelL1
? &usage_table_header_l1_
: &usage_table_header_l3_;
if (*header == nullptr) {
*header = new UsageTableHeader();
// Ignore errors since we do not know when a session is opened,
// if it is intended to be used for offline/usage session related
// or otherwise.
auto_lock.unlock();
bool is_usage_table_header_inited =
(*header)->Init(security_level, this);
auto_lock.lock();
if (!is_usage_table_header_inited) {
delete *header;
*header = nullptr;
usage_table_header_ = nullptr;
return NO_ERROR;
}
usage_table_header_ = *header;
metrics_->usage_table_header_initial_size_.Record((*header)->size());
}
}
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) {
usage_table_header->resize(usage_table_header_size);
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");
}
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_);
@@ -2534,46 +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);
});
}
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::MoveUsageEntry(uint32_t new_entry_number) {
LOGV("Moving usage entry: id = %u", oec_session_id_);

27
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;
const CdmResponseType status = crypto_session->ShrinkUsageTableHeader(
requested_security_level_, usage_entry_info_.size(),
&usage_table_header_);
status = crypto_session->ShrinkUsageTableHeader(usage_entry_info_.size(),
&usage_table_header_);
if (status != NO_ERROR) return status;
file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_);
return NO_ERROR;
if (status == NO_ERROR) {
file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_);
}
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 {

281
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,14 +758,11 @@ 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(Return(SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR));
EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_));
@@ -752,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
@@ -770,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,
@@ -1301,10 +1321,9 @@ 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()))
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,
@@ -1340,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(
@@ -1388,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(
@@ -1439,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(
@@ -1497,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(
@@ -1598,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,
@@ -1656,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(
@@ -1732,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_,
@@ -1968,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_,
@@ -2043,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));
@@ -2063,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_,
@@ -2138,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));
@@ -2150,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_,
@@ -2243,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));
@@ -2255,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(
@@ -2366,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));
@@ -2379,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_,
@@ -2476,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));
@@ -2489,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(
@@ -2556,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));
@@ -2579,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);
@@ -2594,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))
@@ -2610,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))
@@ -2627,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))
@@ -2653,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.
@@ -2679,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) {
@@ -2743,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.
@@ -2803,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) {
@@ -2856,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) {
@@ -2880,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(_, _));
@@ -2895,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_));
@@ -2939,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_));
@@ -2984,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_));
@@ -3026,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_));