From 193d5c384d3e8c15f562ba9345ec88344fe56607 Mon Sep 17 00:00:00 2001 From: Alex Dale Date: Fri, 6 Mar 2020 17:46:50 -0800 Subject: [PATCH] Usage table header operations no longer need an open session. [ 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 --- .../cdm/core/include/crypto_session.h | 10 +- .../cdm/core/src/crypto_session.cpp | 174 +++++------ .../cdm/core/src/usage_table_header.cpp | 27 +- .../certificate_provisioning_unittest.cpp | 13 +- .../core/test/usage_table_header_unittest.cpp | 281 +++++++++--------- 5 files changed, 267 insertions(+), 238 deletions(-) diff --git a/libwvdrmengine/cdm/core/include/crypto_session.h b/libwvdrmengine/cdm/core/include/crypto_session.h index 80566042..c26810fb 100644 --- a/libwvdrmengine/cdm/core/include/crypto_session.h +++ b/libwvdrmengine/cdm/core/include/crypto_session.h @@ -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, diff --git a/libwvdrmengine/cdm/core/src/crypto_session.cpp b/libwvdrmengine/cdm/core/src/crypto_session.cpp index bef1d361..0563e4e9 100644 --- a/libwvdrmengine/cdm/core/src/crypto_session.cpp +++ b/libwvdrmengine/cdm/core/src/crypto_session.cpp @@ -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 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 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( const_cast(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( const_cast(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(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( + const_cast(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( - const_cast(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_); diff --git a/libwvdrmengine/cdm/core/src/usage_table_header.cpp b/libwvdrmengine/cdm/core/src/usage_table_header.cpp index 74b5d08e..ac45ea77 100644 --- a/libwvdrmengine/cdm/core/src/usage_table_header.cpp +++ b/libwvdrmengine/cdm/core/src/usage_table_header.cpp @@ -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 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. diff --git a/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp b/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp index 13ff2464..5a0a01b2 100644 --- a/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp @@ -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 { diff --git a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp b/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp index b5578901..e4a633ab 100644 --- a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp @@ -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 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 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 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_));