From bdcb79a4420c641777903981f9fd5d3774db01a1 Mon Sep 17 00:00:00 2001 From: Alex Dale Date: Wed, 2 Oct 2019 11:55:27 -0700 Subject: [PATCH] Ran clang-format on android/cdm/ files. [ Merge of http://go/wvgerrit/87123 ] Certain android files have yet to be formated since we introduced clang-formatting. Test: built for android Bug: 134365840 Change-Id: Ia316b039e7469f7cf803464ee95a919fe7966450 --- libwvdrmengine/cdm/include/ami_adapter.h | 2 - libwvdrmengine/cdm/include/cdm_identifier.h | 33 +- .../cdm/include/properties_configuration.h | 4 +- libwvdrmengine/cdm/include/timer.h | 6 +- .../include/wv_content_decryption_module.h | 19 +- libwvdrmengine/cdm/src/ami_adapter.cpp | 47 +- libwvdrmengine/cdm/src/properties_android.cpp | 20 +- libwvdrmengine/cdm/src/timer.cpp | 45 +- .../cdm/src/wv_content_decryption_module.cpp | 54 +- libwvdrmengine/cdm/test/cdm_feature_test.cpp | 16 +- .../cdm/test/request_license_test.cpp | 1762 ++++++++--------- libwvdrmengine/cdm/test/timer_unittest.cpp | 7 +- .../cdm/test/wv_cdm_metrics_test.cpp | 89 +- 13 files changed, 1023 insertions(+), 1081 deletions(-) diff --git a/libwvdrmengine/cdm/include/ami_adapter.h b/libwvdrmengine/cdm/include/ami_adapter.h index 9aa5f387..e0c3c338 100644 --- a/libwvdrmengine/cdm/include/ami_adapter.h +++ b/libwvdrmengine/cdm/include/ami_adapter.h @@ -13,7 +13,6 @@ namespace wvcdm { class AmiAdapter { - public: AmiAdapter(); AmiAdapter(int64_t parent); @@ -26,7 +25,6 @@ class AmiAdapter { private: android::MediaAnalyticsItem analytics_item_; - }; } // namespace wvcdm diff --git a/libwvdrmengine/cdm/include/cdm_identifier.h b/libwvdrmengine/cdm/include/cdm_identifier.h index 61ffdb75..ee553727 100644 --- a/libwvdrmengine/cdm/include/cdm_identifier.h +++ b/libwvdrmengine/cdm/include/cdm_identifier.h @@ -43,17 +43,16 @@ struct CdmIdentifier { // comparison in lieu of the == operator when checking to see if the // identifier would cause the default provisioned certificate to be used. bool IsEquivalentToDefault() { - return spoid == EMPTY_SPOID - && origin == EMPTY_ORIGIN - && app_package_name == EMPTY_APP_PACKAGE_NAME; + return spoid == EMPTY_SPOID && origin == EMPTY_ORIGIN && + app_package_name == EMPTY_APP_PACKAGE_NAME; } }; // Provide comparison operators inline bool operator==(const CdmIdentifier& lhs, const CdmIdentifier& rhs) { - return lhs.spoid == rhs.spoid && lhs.origin == rhs.origin - && lhs.app_package_name == rhs.app_package_name - && lhs.unique_id == rhs.unique_id; + return lhs.spoid == rhs.spoid && lhs.origin == rhs.origin && + lhs.app_package_name == rhs.app_package_name && + lhs.unique_id == rhs.unique_id; } inline bool operator!=(const CdmIdentifier& lhs, const CdmIdentifier& rhs) { @@ -61,13 +60,13 @@ inline bool operator!=(const CdmIdentifier& lhs, const CdmIdentifier& rhs) { } inline bool operator<(const CdmIdentifier& lhs, const CdmIdentifier& rhs) { - return (lhs.spoid < rhs.spoid) - || ((lhs.spoid == rhs.spoid) - && (lhs.origin < rhs.origin - || (lhs.origin == rhs.origin - && (lhs.app_package_name < rhs.app_package_name - || (lhs.app_package_name == rhs.app_package_name - && lhs.unique_id < rhs.unique_id))))); + return (lhs.spoid < rhs.spoid) || + ((lhs.spoid == rhs.spoid) && + (lhs.origin < rhs.origin || + (lhs.origin == rhs.origin && + (lhs.app_package_name < rhs.app_package_name || + (lhs.app_package_name == rhs.app_package_name && + lhs.unique_id < rhs.unique_id))))); } inline bool operator>(const CdmIdentifier& lhs, const CdmIdentifier& rhs) { @@ -83,12 +82,8 @@ inline bool operator>=(const CdmIdentifier& lhs, const CdmIdentifier& rhs) { } // Provide default -static const CdmIdentifier kDefaultCdmIdentifier = { - EMPTY_SPOID, - EMPTY_ORIGIN, - EMPTY_APP_PACKAGE_NAME, - 0 -}; +static const CdmIdentifier kDefaultCdmIdentifier = {EMPTY_SPOID, EMPTY_ORIGIN, + EMPTY_APP_PACKAGE_NAME, 0}; } // namespace wvcdm diff --git a/libwvdrmengine/cdm/include/properties_configuration.h b/libwvdrmengine/cdm/include/properties_configuration.h index a013fe57..e4300814 100644 --- a/libwvdrmengine/cdm/include/properties_configuration.h +++ b/libwvdrmengine/cdm/include/properties_configuration.h @@ -5,8 +5,8 @@ #ifndef CDM_BASE_PROPERTIES_CONFIGURATION_H_ #define CDM_BASE_PROPERTIES_CONFIGURATION_H_ -#include "wv_cdm_constants.h" #include "properties.h" +#include "wv_cdm_constants.h" namespace wvcdm { @@ -39,6 +39,6 @@ const bool kDeviceFilesIsARealFileSystem = true; // will be treated as a release request. If false, a restoration will fail. const bool kAllowRestoreOfflineLicenseWithRelease = false; -} // namespace wvcdm +} // namespace wvcdm #endif // CDM_BASE_WV_PROPERTIES_CONFIGURATION_H_ diff --git a/libwvdrmengine/cdm/include/timer.h b/libwvdrmengine/cdm/include/timer.h index a9643a72..e9ebdfab 100644 --- a/libwvdrmengine/cdm/include/timer.h +++ b/libwvdrmengine/cdm/include/timer.h @@ -22,8 +22,8 @@ namespace wvcdm { class TimerHandler { public: - TimerHandler() {}; - virtual ~TimerHandler() {}; + TimerHandler() {} + virtual ~TimerHandler() {} virtual void OnTimerEvent() = 0; }; @@ -42,7 +42,7 @@ class Timer { Timer(); ~Timer(); - bool Start(TimerHandler *handler, uint32_t time_in_secs); + bool Start(TimerHandler* handler, uint32_t time_in_secs); void Stop(); bool IsRunning(); diff --git a/libwvdrmengine/cdm/include/wv_content_decryption_module.h b/libwvdrmengine/cdm/include/wv_content_decryption_module.h index fa95269c..39fc2c29 100644 --- a/libwvdrmengine/cdm/include/wv_content_decryption_module.h +++ b/libwvdrmengine/cdm/include/wv_content_decryption_module.h @@ -108,8 +108,7 @@ class WvContentDecryptionModule : public android::RefBase, public TimerHandler { virtual CdmResponseType RemoveAllUsageInfo(const std::string& app_id, const CdmIdentifier& identifier); virtual CdmResponseType RemoveUsageInfo( - const std::string& app_id, - const CdmIdentifier& identifier, + const std::string& app_id, const CdmIdentifier& identifier, const CdmSecureStopId& secure_stop_id); virtual CdmResponseType ReleaseUsageInfo( const CdmUsageInfoReleaseMessage& message, @@ -151,22 +150,18 @@ class WvContentDecryptionModule : public android::RefBase, public TimerHandler { // Return the list of key_set_ids stored on the current (origin-specific) // file system. virtual CdmResponseType ListStoredLicenses( - CdmSecurityLevel security_level, - const CdmIdentifier& identifier, + CdmSecurityLevel security_level, const CdmIdentifier& identifier, std::vector* key_set_ids); // Retrieve offline license state using key_set_id. virtual CdmResponseType GetOfflineLicenseState( - const CdmKeySetId& key_set_id, - CdmSecurityLevel security_level, - const CdmIdentifier& identifier, - CdmOfflineLicenseState* licenseState); + const CdmKeySetId& key_set_id, CdmSecurityLevel security_level, + const CdmIdentifier& identifier, CdmOfflineLicenseState* licenseState); // Remove offline license using key_set_id. - virtual CdmResponseType RemoveOfflineLicense( - const CdmKeySetId& key_set_id, - CdmSecurityLevel security_level, - const CdmIdentifier& identifier); + virtual CdmResponseType RemoveOfflineLicense(const CdmKeySetId& key_set_id, + CdmSecurityLevel security_level, + const CdmIdentifier& identifier); private: struct CdmInfo { diff --git a/libwvdrmengine/cdm/src/ami_adapter.cpp b/libwvdrmengine/cdm/src/ami_adapter.cpp index 98c33013..40df96d6 100644 --- a/libwvdrmengine/cdm/src/ami_adapter.cpp +++ b/libwvdrmengine/cdm/src/ami_adapter.cpp @@ -8,59 +8,40 @@ namespace wvcdm { -AmiAdapter::AmiAdapter() : - analytics_item_("widevine") { +AmiAdapter::AmiAdapter() : analytics_item_("widevine") { analytics_item_.generateSessionID(); } -AmiAdapter::AmiAdapter(int64_t parent) : - analytics_item_("widevine") { +AmiAdapter::AmiAdapter(int64_t parent) : analytics_item_("widevine") { analytics_item_.generateSessionID(); analytics_item_.setInt64("/drm/widevine/parent/external", parent); } -AmiAdapter::~AmiAdapter() { - analytics_item_.selfrecord(); -} +AmiAdapter::~AmiAdapter() { analytics_item_.selfrecord(); } void AmiAdapter::UpdateString(const std::string& metric_id, const std::string& value) { analytics_item_.setCString(metric_id.c_str(), value.c_str()); - LOGV( - "AmiAdapter (%lld) %s : %s", - analytics_item_.getSessionID(), - metric_id.c_str(), - value.c_str()); + LOGV("AmiAdapter (%lld) %s : %s", analytics_item_.getSessionID(), + metric_id.c_str(), value.c_str()); } -void AmiAdapter::UpdateInt32(const std::string& metric_id, - int32_t value) { +void AmiAdapter::UpdateInt32(const std::string& metric_id, int32_t value) { analytics_item_.setInt32(metric_id.c_str(), value); - LOGV( - "AmiAdapter (%lld) %s : %ld", - analytics_item_.getSessionID(), - metric_id.c_str(), - value); + LOGV("AmiAdapter (%lld) %s : %ld", analytics_item_.getSessionID(), + metric_id.c_str(), value); } -void AmiAdapter::UpdateInt64(const std::string& metric_id, - int64_t value) { +void AmiAdapter::UpdateInt64(const std::string& metric_id, int64_t value) { analytics_item_.setInt64(metric_id.c_str(), value); - LOGV( - "AmiAdapter (%lld) %s : %lld", - analytics_item_.getSessionID(), - metric_id.c_str(), - value); + LOGV("AmiAdapter (%lld) %s : %lld", analytics_item_.getSessionID(), + metric_id.c_str(), value); } -void AmiAdapter::UpdateDouble(const std::string& metric_id, - double value) { +void AmiAdapter::UpdateDouble(const std::string& metric_id, double value) { analytics_item_.setDouble(metric_id.c_str(), value); - LOGV( - "AmiAdapter (%lld) %s : %f", - analytics_item_.getSessionID(), - metric_id.c_str(), - value); + LOGV("AmiAdapter (%lld) %s : %f", analytics_item_.getSessionID(), + metric_id.c_str(), value); } } // namespace wvcdm diff --git a/libwvdrmengine/cdm/src/properties_android.cpp b/libwvdrmengine/cdm/src/properties_android.cpp index 2fdfcd92..214175b6 100644 --- a/libwvdrmengine/cdm/src/properties_android.cpp +++ b/libwvdrmengine/cdm/src/properties_android.cpp @@ -121,9 +121,15 @@ bool Properties::GetDeviceFilesBasePath(CdmSecurityLevel security_level, std::stringstream ss; ss << kBasePathPrefix << getuid(); switch (security_level) { - case kSecurityLevelL1: ss << kL1Dir; break; - case kSecurityLevelL2: ss << kL2Dir; break; - case kSecurityLevelL3: ss << kL3Dir; break; + case kSecurityLevelL1: + ss << kL1Dir; + break; + case kSecurityLevelL2: + ss << kL2Dir; + break; + case kSecurityLevelL3: + ss << kL3Dir; + break; default: LOGW("Properties::GetDeviceFilesBasePath: Unknown security level: %d", security_level); @@ -163,12 +169,8 @@ bool Properties::GetSandboxId(std::string* /* sandbox_id */) { return false; } -bool Properties::AlwaysUseKeySetIds() { - return false; -} +bool Properties::AlwaysUseKeySetIds() { return false; } -bool Properties::UseProviderIdInProvisioningRequest() { - return false; -} +bool Properties::UseProviderIdInProvisioningRequest() { return false; } } // namespace wvcdm diff --git a/libwvdrmengine/cdm/src/timer.cpp b/libwvdrmengine/cdm/src/timer.cpp index 7f6a09aa..035a7070 100644 --- a/libwvdrmengine/cdm/src/timer.cpp +++ b/libwvdrmengine/cdm/src/timer.cpp @@ -20,21 +20,21 @@ class Timer::Impl : virtual public android::RefBase { class ImplThread : public android::Thread { public: ImplThread() : Thread(false), handler_(nullptr), period_ns_(0) {} - virtual ~ImplThread() {}; + virtual ~ImplThread() {} - bool Start(TimerHandler *handler, uint32_t time_in_secs) { + bool Start(TimerHandler* handler, uint32_t time_in_secs) { handler_ = handler; period_ns_ = time_in_secs * 1000000000ll; return run("wvcdm::Timer::Impl") == android::NO_ERROR; } - void Stop() { - { - android::Mutex::Autolock autoLock(lock_); - stop_condition_.signal(); - } - requestExitAndWait(); - } + void Stop() { + { + android::Mutex::Autolock autoLock(lock_); + stop_condition_.signal(); + } + requestExitAndWait(); + } private: virtual bool threadLoop() { @@ -44,7 +44,7 @@ class Timer::Impl : virtual public android::RefBase { return true; } - TimerHandler *handler_; + TimerHandler* handler_; uint64_t period_ns_; android::Mutex lock_; android::Condition stop_condition_; @@ -56,9 +56,9 @@ class Timer::Impl : virtual public android::RefBase { public: Impl() {} - virtual ~Impl() {}; + virtual ~Impl(){}; - bool Start(TimerHandler *handler, uint32_t time_in_secs) { + bool Start(TimerHandler* handler, uint32_t time_in_secs) { impl_thread_ = new ImplThread(); return impl_thread_->Start(handler, time_in_secs); } @@ -75,27 +75,20 @@ class Timer::Impl : virtual public android::RefBase { CORE_DISALLOW_COPY_AND_ASSIGN(Impl); }; -Timer::Timer() : impl_(new Timer::Impl()) { -} +Timer::Timer() : impl_(new Timer::Impl()) {} Timer::~Timer() { - if (IsRunning()) - Stop(); + if (IsRunning()) Stop(); } -bool Timer::Start(TimerHandler *handler, uint32_t time_in_secs) { - if (!handler || time_in_secs == 0) - return false; +bool Timer::Start(TimerHandler* handler, uint32_t time_in_secs) { + if (!handler || time_in_secs == 0) return false; return impl_->Start(handler, time_in_secs); } -void Timer::Stop() { - impl_->Stop(); -} +void Timer::Stop() { impl_->Stop(); } -bool Timer::IsRunning() { - return impl_->IsRunning(); -} +bool Timer::IsRunning() { return impl_->IsRunning(); } -} // namespace wvcdm +} // namespace wvcdm diff --git a/libwvdrmengine/cdm/src/wv_content_decryption_module.cpp b/libwvdrmengine/cdm/src/wv_content_decryption_module.cpp index 54527091..f9a6b4a7 100644 --- a/libwvdrmengine/cdm/src/wv_content_decryption_module.cpp +++ b/libwvdrmengine/cdm/src/wv_content_decryption_module.cpp @@ -106,16 +106,14 @@ CdmResponseType WvContentDecryptionModule::GenerateKeyRequest( } const SecurityLevel requested_security_level = - property_set && - property_set->security_level().compare( - wvcdm::QUERY_VALUE_SECURITY_LEVEL_L3) == 0 + property_set && property_set->security_level().compare( + wvcdm::QUERY_VALUE_SECURITY_LEVEL_L3) == 0 ? wvcdm::kLevel3 : wvcdm::kLevelDefault; std::string oec_version; sts = cdm_engine->QueryStatus(requested_security_level, - QUERY_KEY_OEMCRYPTO_API_VERSION, - &oec_version); + QUERY_KEY_OEMCRYPTO_API_VERSION, &oec_version); if (sts != NO_ERROR) { return sts; } @@ -258,8 +256,7 @@ CdmResponseType WvContentDecryptionModule::RemoveAllUsageInfo( } CdmResponseType WvContentDecryptionModule::RemoveUsageInfo( - const std::string& app_id, - const CdmIdentifier& identifier, + const std::string& app_id, const CdmIdentifier& identifier, const CdmSecureStopId& secure_stop_id) { CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier); return cdm_engine->RemoveUsageInfo(app_id, secure_stop_id); @@ -273,12 +270,12 @@ CdmResponseType WvContentDecryptionModule::ReleaseUsageInfo( } CdmResponseType WvContentDecryptionModule::GetSecureStopIds( - const std::string& app_id, - const CdmIdentifier& identifier, + const std::string& app_id, const CdmIdentifier& identifier, std::vector* ssids) { if (ssids == nullptr) { - LOGE("WvContentDecryptionModule::GetSecureStopIds: ssid destination not " - "provided"); + LOGE( + "WvContentDecryptionModule::GetSecureStopIds: " + "ssid destination not provided"); return PARAMETER_NULL; } @@ -337,7 +334,6 @@ bool WvContentDecryptionModule::IsValidServiceCertificate( return cert.has_certificate(); } - CdmResponseType WvContentDecryptionModule::GetMetrics( const CdmIdentifier& identifier, drm_metrics::WvCdmMetrics* metrics) { if (!metrics) { @@ -350,8 +346,8 @@ CdmResponseType WvContentDecryptionModule::GetMetrics( // TODO(blueeyes): Add a better error. return UNKNOWN_ERROR; } - return it->second.cdm_engine->GetMetricsSnapshot(metrics) ? - NO_ERROR : UNKNOWN_ERROR; + return it->second.cdm_engine->GetMetricsSnapshot(metrics) ? NO_ERROR + : UNKNOWN_ERROR; } WvContentDecryptionModule::CdmInfo::CdmInfo() @@ -453,13 +449,13 @@ CdmResponseType WvContentDecryptionModule::SetDecryptHash( } CdmResponseType WvContentDecryptionModule::GetDecryptHashError( - const CdmSessionId& session_id, - std::string* hash_error_string) { + const CdmSessionId& session_id, std::string* hash_error_string) { CdmEngine* cdm_engine = GetCdmForSessionId(session_id); if (!cdm_engine) { - LOGE("WVContentDecryptionModule::GetDecryptHashError: Unable to find " - "CdmEngine"); + LOGE( + "WVContentDecryptionModule::GetDecryptHashError: " + "Unable to find CdmEngine"); return SESSION_NOT_FOUND_20; } return cdm_engine->GetDecryptHashError(session_id, hash_error_string); @@ -491,31 +487,25 @@ uint32_t WvContentDecryptionModule::GenerateSessionSharingId() { } CdmResponseType WvContentDecryptionModule::ListStoredLicenses( - CdmSecurityLevel security_level, - const CdmIdentifier& identifier, + CdmSecurityLevel security_level, const CdmIdentifier& identifier, std::vector* key_set_ids) { CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier); - return cdm_engine->ListStoredLicenses( - security_level, key_set_ids); + return cdm_engine->ListStoredLicenses(security_level, key_set_ids); } CdmResponseType WvContentDecryptionModule::GetOfflineLicenseState( - const CdmKeySetId& key_set_id, - CdmSecurityLevel security_level, - const CdmIdentifier& identifier, - CdmOfflineLicenseState* license_state) { + const CdmKeySetId& key_set_id, CdmSecurityLevel security_level, + const CdmIdentifier& identifier, CdmOfflineLicenseState* license_state) { CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier); - return cdm_engine->GetOfflineLicenseState( - key_set_id, security_level, license_state); + return cdm_engine->GetOfflineLicenseState(key_set_id, security_level, + license_state); } CdmResponseType WvContentDecryptionModule::RemoveOfflineLicense( - const CdmKeySetId& key_set_id, - CdmSecurityLevel security_level, + const CdmKeySetId& key_set_id, CdmSecurityLevel security_level, const CdmIdentifier& identifier) { CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier); - return cdm_engine->RemoveOfflineLicense( - key_set_id, security_level); + return cdm_engine->RemoveOfflineLicense(key_set_id, security_level); } } // namespace wvcdm diff --git a/libwvdrmengine/cdm/test/cdm_feature_test.cpp b/libwvdrmengine/cdm/test/cdm_feature_test.cpp index 4b0ff2a9..b915dad7 100644 --- a/libwvdrmengine/cdm/test/cdm_feature_test.cpp +++ b/libwvdrmengine/cdm/test/cdm_feature_test.cpp @@ -408,11 +408,9 @@ TEST_F(WvCdmFeatureTest, OEMCertificateProvisioning) { std::string cert_authority, cert, wrapped_key; EXPECT_EQ(wvcdm::NO_ERROR, - decryptor_.GetProvisioningRequest(cert_type, cert_authority, - kDefaultCdmIdentifier, - kEmptyServiceCertificate, - &key_msg_, - &provisioning_server_url)); + decryptor_.GetProvisioningRequest( + cert_type, cert_authority, kDefaultCdmIdentifier, + kEmptyServiceCertificate, &key_msg_, &provisioning_server_url)); EXPECT_EQ(provisioning_server_url, config_.provisioning_server()); ClientIdentification_TokenType token_type; @@ -445,11 +443,9 @@ TEST_F(WvCdmFeatureTest, KeyboxProvisioning) { std::string cert_authority, cert, wrapped_key; EXPECT_EQ(wvcdm::NO_ERROR, - decryptor_.GetProvisioningRequest(cert_type, cert_authority, - kDefaultCdmIdentifier, - kEmptyServiceCertificate, - &key_msg_, - &provisioning_server_url)); + decryptor_.GetProvisioningRequest( + cert_type, cert_authority, kDefaultCdmIdentifier, + kEmptyServiceCertificate, &key_msg_, &provisioning_server_url)); EXPECT_EQ(provisioning_server_url, config_.provisioning_server()); ClientIdentification_TokenType token_type; diff --git a/libwvdrmengine/cdm/test/request_license_test.cpp b/libwvdrmengine/cdm/test/request_license_test.cpp index dbdf3a0e..7ce77382 100644 --- a/libwvdrmengine/cdm/test/request_license_test.cpp +++ b/libwvdrmengine/cdm/test/request_license_test.cpp @@ -52,18 +52,10 @@ namespace { const int kHttpOk = 200; const wvcdm::CdmIdentifier kExampleIdentifier = { - wvcdm::EMPTY_SPOID, - "com.example", - "com.example", - 7 -}; + wvcdm::EMPTY_SPOID, "com.example", "com.example", 7}; const wvcdm::CdmIdentifier kAlternateCdmIdentifier1 = { - "alternate_spoid_1", - "alternate_origin_1", - "com.alternate1.url", - 8 -}; + "alternate_spoid_1", "alternate_origin_1", "com.alternate1.url", 8}; const std::string kEmptyServiceCertificate; const std::string kComma = ","; @@ -91,7 +83,11 @@ struct SubSampleInfo { }; SubSampleInfo clear_sub_sample = { - true, 1, true, false, false, + true, + 1, + true, + false, + false, wvcdm::a2bs_hex("371EA35E1A985D75D198A7F41020DC23"), wvcdm::a2b_hex( "217ce9bde99bd91e9733a1a00b9b557ac3a433dc92633546156817fae26b6e1c" @@ -111,44 +107,48 @@ SubSampleInfo clear_sub_sample = { "029359c4cf5906b6ab5bf60fbb3f1a1c7c59acfc7e4fb4ad8e623c04d503a3dd" "4884604c8da8a53ce33db9ff8f1c5bb6bb97f37b39906bf41596555c1bcce9ed" "08a899cd760ff0899a1170c2f224b9c52997a0785b7fe170805fd3e8b1127659"), - wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, + wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), + 0, OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample}; SubSampleInfo clear_sub_samples[2] = { - // block 0, key SD, encrypted, 128b - { true, 1, true, false, false, - wvcdm::a2bs_hex("371EA35E1A985D75D198A7F41020DC23"), - wvcdm::a2b_hex( - "217ce9bde99bd91e9733a1a00b9b557ac3a433dc92633546156817fae26b6e1c" - "942ac20a89ff79f4c2f25fba99d6a44618a8c0420b27d54e3da17b77c9d43cca" - "595d259a1e4a8b6d7744cd98c5d3f921adc252eb7d8af6b916044b676a574747" - "8df21fdc42f166880d97a2225cd5c9ea5e7b752f4cf81bbdbe98e542ee10e1c6"), - wvcdm::a2b_hex( - "217ce9bde99bd91e9733a1a00b9b557ac3a433dc92633546156817fae26b6e1c" - "942ac20a89ff79f4c2f25fba99d6a44618a8c0420b27d54e3da17b77c9d43cca" - "595d259a1e4a8b6d7744cd98c5d3f921adc252eb7d8af6b916044b676a574747" - "8df21fdc42f166880d97a2225cd5c9ea5e7b752f4cf81bbdbe98e542ee10e1c6"), - wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, - OEMCrypto_FirstSubsample}, - // block 1, key SD, encrypted, 128b - { true, 1, true, false, false, - wvcdm::a2bs_hex("371EA35E1A985D75D198A7F41020DC23"), - wvcdm::a2b_hex( - "ad868a6ac55c10d564fc23b8acff407daaf4ed2743520e02cda9680d9ea88e91" - "029359c4cf5906b6ab5bf60fbb3f1a1c7c59acfc7e4fb4ad8e623c04d503a3dd" - "4884604c8da8a53ce33db9ff8f1c5bb6bb97f37b39906bf41596555c1bcce9ed" - "08a899cd760ff0899a1170c2f224b9c52997a0785b7fe170805fd3e8b1127659"), - wvcdm::a2b_hex( - "ad868a6ac55c10d564fc23b8acff407daaf4ed2743520e02cda9680d9ea88e91" - "029359c4cf5906b6ab5bf60fbb3f1a1c7c59acfc7e4fb4ad8e623c04d503a3dd" - "4884604c8da8a53ce33db9ff8f1c5bb6bb97f37b39906bf41596555c1bcce9ed" - "08a899cd760ff0899a1170c2f224b9c52997a0785b7fe170805fd3e8b1127659"), - wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, - OEMCrypto_LastSubsample} -}; + // block 0, key SD, encrypted, 128b + {true, 1, true, false, false, + wvcdm::a2bs_hex("371EA35E1A985D75D198A7F41020DC23"), + wvcdm::a2b_hex( + "217ce9bde99bd91e9733a1a00b9b557ac3a433dc92633546156817fae26b6e1c" + "942ac20a89ff79f4c2f25fba99d6a44618a8c0420b27d54e3da17b77c9d43cca" + "595d259a1e4a8b6d7744cd98c5d3f921adc252eb7d8af6b916044b676a574747" + "8df21fdc42f166880d97a2225cd5c9ea5e7b752f4cf81bbdbe98e542ee10e1c6"), + wvcdm::a2b_hex( + "217ce9bde99bd91e9733a1a00b9b557ac3a433dc92633546156817fae26b6e1c" + "942ac20a89ff79f4c2f25fba99d6a44618a8c0420b27d54e3da17b77c9d43cca" + "595d259a1e4a8b6d7744cd98c5d3f921adc252eb7d8af6b916044b676a574747" + "8df21fdc42f166880d97a2225cd5c9ea5e7b752f4cf81bbdbe98e542ee10e1c6"), + wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, + OEMCrypto_FirstSubsample}, + // block 1, key SD, encrypted, 128b + {true, 1, true, false, false, + wvcdm::a2bs_hex("371EA35E1A985D75D198A7F41020DC23"), + wvcdm::a2b_hex( + "ad868a6ac55c10d564fc23b8acff407daaf4ed2743520e02cda9680d9ea88e91" + "029359c4cf5906b6ab5bf60fbb3f1a1c7c59acfc7e4fb4ad8e623c04d503a3dd" + "4884604c8da8a53ce33db9ff8f1c5bb6bb97f37b39906bf41596555c1bcce9ed" + "08a899cd760ff0899a1170c2f224b9c52997a0785b7fe170805fd3e8b1127659"), + wvcdm::a2b_hex( + "ad868a6ac55c10d564fc23b8acff407daaf4ed2743520e02cda9680d9ea88e91" + "029359c4cf5906b6ab5bf60fbb3f1a1c7c59acfc7e4fb4ad8e623c04d503a3dd" + "4884604c8da8a53ce33db9ff8f1c5bb6bb97f37b39906bf41596555c1bcce9ed" + "08a899cd760ff0899a1170c2f224b9c52997a0785b7fe170805fd3e8b1127659"), + wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, + OEMCrypto_LastSubsample}}; SubSampleInfo clear_sub_sample_no_key = { - false, 1, false, false, false, + false, + 1, + false, + false, + false, wvcdm::a2bs_hex("77777777777777777777777777777777"), wvcdm::a2b_hex( "217ce9bde99bd91e9733a1a00b9b557ac3a433dc92633546156817fae26b6e1c" @@ -168,12 +168,17 @@ SubSampleInfo clear_sub_sample_no_key = { "029359c4cf5906b6ab5bf60fbb3f1a1c7c59acfc7e4fb4ad8e623c04d503a3dd" "4884604c8da8a53ce33db9ff8f1c5bb6bb97f37b39906bf41596555c1bcce9ed" "08a899cd760ff0899a1170c2f224b9c52997a0785b7fe170805fd3e8b1127659"), - wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, + wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), + 0, OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample}; SubSampleInfo single_encrypted_sub_sample = { // key SD, encrypted, 256b - true, 1, true, true, false, + true, + 1, + true, + true, + false, wvcdm::a2bs_hex("371EA35E1A985D75D198A7F41020DC23"), wvcdm::a2b_hex( "64ab17b3e3dfab47245c7cce4543d4fc7a26dcf248f19f9b59f3c92601440b36" @@ -193,12 +198,17 @@ SubSampleInfo single_encrypted_sub_sample = { "029359c4cf5906b6ab5bf60fbb3f1a1c7c59acfc7e4fb4ad8e623c04d503a3dd" "4884604c8da8a53ce33db9ff8f1c5bb6bb97f37b39906bf41596555c1bcce9ed" "08a899cd760ff0899a1170c2f224b9c52997a0785b7fe170805fd3e8b1127659"), - wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, + wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), + 0, OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample}; SubSampleInfo single_encrypted_offline_sub_sample = { // key SD, encrypted, 256b - true, 1, true, true, false, + true, + 1, + true, + true, + false, wvcdm::a2bs_hex("DD003BA34DA3CDA09AA3B6D5CC6C34B2"), wvcdm::a2b_hex( "64ab17b3e3dfab47245c7cce4543d4fc7a26dcf248f19f9b59f3c92601440b36" @@ -218,7 +228,8 @@ SubSampleInfo single_encrypted_offline_sub_sample = { "4287F7AEB30E3FECBDEB2981BD0691FED2D7CFACB92E115A44CADD96843F240E" "236A9F9B2E3CB075912FE15C5056B21D809538C3C19D5B2F5FA242CD7F550306" "6DA2F6A78C5090D9B49F78632FB6F278AC1F680E690BF3AD4933FDE77922CF6A"), - wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, + wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), + 0, OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample}; SubSampleInfo switch_key_encrypted_sub_samples[2] = { @@ -313,7 +324,11 @@ SubSampleInfo partial_encrypted_sub_samples[3] = { SubSampleInfo single_encrypted_sub_sample_short_expiry = { // key 1, encrypted, 256b - true, 1, true, true, false, + true, + 1, + true, + true, + false, wvcdm::a2bs_hex("9714593E1EEE57859D34ECFA821702BB"), wvcdm::a2b_hex( "3b2cbde084973539329bd5656da22d20396249bf4a18a51c38c4743360cc9fea" @@ -333,7 +348,8 @@ SubSampleInfo single_encrypted_sub_sample_short_expiry = { "304d605e21f69615e1b57db18312b6b948725724b74e91d8aea7371e99532469" "1b358bdee873f1936b63efe83d190a53c2d21754d302d63ff285174023473755" "58b938c2e3ca4c2ce48942da97f9e45797f2c074ac6004734e93784a48af6160"), - wvcdm::a2b_hex("4cca615fc013102892f91efee936639b"), 0, + wvcdm::a2b_hex("4cca615fc013102892f91efee936639b"), + 0, OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample}; SubSampleInfo usage_info_sub_samples_icp[] = { @@ -449,100 +465,96 @@ SubSampleInfo usage_info_sub_samples_icp[] = { OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample}}; SubSampleInfo kEntitlementWithKeyRotationSubSampleSinglePssh[] = { - { - true, 1, true, true, false, - wvcdm::a2bs_hex("c8326486bb5d5c4a958f00b1111afc81"), - wvcdm::a2b_hex( - "64ab17b3e3dfab47245c7cce4543d4fc7a26dcf248f19f9b59f3c92601440b36" - "17c8ed0c96c656549e461f38708cd47a434066f8df28ccc28b79252eee3f9c2d" - "7f6c68ebe40141fe818fe082ca523c03d69ddaf183a93c022327fedc5582c5ab" - "ca9d342b71263a67f9cb2336f12108aaaef464f17177e44e9b0c4e56e61da53c" - "2150b4405cc82d994dfd9bf4087c761956d6688a9705db4cf350381085f383c4" - "9666d4aed135c519c1f0b5cba06e287feea96ea367bf54e7368dcf998276c6e4" - "6497e0c50e20fef74e42cb518fe7f22ef27202428688f86404e8278587017012" - "c1d65537c6cbd7dde04aae338d68115a9f430afc100ab83cdadf45dca39db685"), - wvcdm::a2b_hex( - "cb468f067baa5634f83947b921fdb37e66bc5925edc4bdc2424db4c33cfd55a1" - "cd0a96b6634796ddcf5ba8820b83f80d318ff49b7e614779f5e87dd6dfadd8d6" - "cf95c7b0f21e4174e2e91371ebdb69866340a37a581a7c0713eda5168bcfc003" - "12a341a83defa754c4601772ed9171526720b6a2b2b084030f21ef13f2a35dec" - "e93f5c394c56d9ce108c2f5b0e5edb857d322fae24ec22f3ad726496b382306b" - "4fdf5a0a99efc2db2a9458f0bfd6b21869c9acf6ea222fe942af6cd9b38d9a50" - "a96db14ad27d368c5753aa5da8d8507603ed08086e2492bdff267ee64862f159" - "b19d2c72b2f5a39520d5ae2aacae1a192d375d45f3f9ba86d5026cbcacdfecbe"), - wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, - OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample}, - { - true, 1, true, true, false, - wvcdm::a2bs_hex("f8488775a99855ff94b93ec5bd499356"), - wvcdm::a2b_hex( - "64ab17b3e3dfab47245c7cce4543d4fc7a26dcf248f19f9b59f3c92601440b36" - "17c8ed0c96c656549e461f38708cd47a434066f8df28ccc28b79252eee3f9c2d" - "7f6c68ebe40141fe818fe082ca523c03d69ddaf183a93c022327fedc5582c5ab" - "ca9d342b71263a67f9cb2336f12108aaaef464f17177e44e9b0c4e56e61da53c" - "2150b4405cc82d994dfd9bf4087c761956d6688a9705db4cf350381085f383c4" - "9666d4aed135c519c1f0b5cba06e287feea96ea367bf54e7368dcf998276c6e4" - "6497e0c50e20fef74e42cb518fe7f22ef27202428688f86404e8278587017012" - "c1d65537c6cbd7dde04aae338d68115a9f430afc100ab83cdadf45dca39db685"), - wvcdm::a2b_hex( - "51b0133e2e5f40c22d10ec0562799e5e4118aacaa6a820be976acee4b7689280" - "541b56836c454414fbaebf9a3142baa2c8009a4f19ac033665bd3495f2ad19f3" - "3b850d1e8e6957172571e82d3c812d03588c95a1ef49f08b33f21ea4f2d382c9" - "28704e329847e5fe98966949f39e272ec30126f5d7a4ae21d3a0d25aa8ccf637" - "d5f880a6733b07bdd33cfdc3c36dece2bffb6049f218162b024df4f800557568" - "a792e0add16fc388ee13595313c3fbeef28f69737523e449dc2cf893f0566a79" - "8a83110c8d3aaf5c1f7e8e8fe355a294a9a77b5494704b18e27f1315cb19c104" - "3ad2061a2a414d40cc768fc4c8f49a3905e3a82095aa4eef6a1ad8af1029fced"), - wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, - OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample}}; + {true, 1, true, true, false, + wvcdm::a2bs_hex("c8326486bb5d5c4a958f00b1111afc81"), + wvcdm::a2b_hex( + "64ab17b3e3dfab47245c7cce4543d4fc7a26dcf248f19f9b59f3c92601440b36" + "17c8ed0c96c656549e461f38708cd47a434066f8df28ccc28b79252eee3f9c2d" + "7f6c68ebe40141fe818fe082ca523c03d69ddaf183a93c022327fedc5582c5ab" + "ca9d342b71263a67f9cb2336f12108aaaef464f17177e44e9b0c4e56e61da53c" + "2150b4405cc82d994dfd9bf4087c761956d6688a9705db4cf350381085f383c4" + "9666d4aed135c519c1f0b5cba06e287feea96ea367bf54e7368dcf998276c6e4" + "6497e0c50e20fef74e42cb518fe7f22ef27202428688f86404e8278587017012" + "c1d65537c6cbd7dde04aae338d68115a9f430afc100ab83cdadf45dca39db685"), + wvcdm::a2b_hex( + "cb468f067baa5634f83947b921fdb37e66bc5925edc4bdc2424db4c33cfd55a1" + "cd0a96b6634796ddcf5ba8820b83f80d318ff49b7e614779f5e87dd6dfadd8d6" + "cf95c7b0f21e4174e2e91371ebdb69866340a37a581a7c0713eda5168bcfc003" + "12a341a83defa754c4601772ed9171526720b6a2b2b084030f21ef13f2a35dec" + "e93f5c394c56d9ce108c2f5b0e5edb857d322fae24ec22f3ad726496b382306b" + "4fdf5a0a99efc2db2a9458f0bfd6b21869c9acf6ea222fe942af6cd9b38d9a50" + "a96db14ad27d368c5753aa5da8d8507603ed08086e2492bdff267ee64862f159" + "b19d2c72b2f5a39520d5ae2aacae1a192d375d45f3f9ba86d5026cbcacdfecbe"), + wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, + OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample}, + {true, 1, true, true, false, + wvcdm::a2bs_hex("f8488775a99855ff94b93ec5bd499356"), + wvcdm::a2b_hex( + "64ab17b3e3dfab47245c7cce4543d4fc7a26dcf248f19f9b59f3c92601440b36" + "17c8ed0c96c656549e461f38708cd47a434066f8df28ccc28b79252eee3f9c2d" + "7f6c68ebe40141fe818fe082ca523c03d69ddaf183a93c022327fedc5582c5ab" + "ca9d342b71263a67f9cb2336f12108aaaef464f17177e44e9b0c4e56e61da53c" + "2150b4405cc82d994dfd9bf4087c761956d6688a9705db4cf350381085f383c4" + "9666d4aed135c519c1f0b5cba06e287feea96ea367bf54e7368dcf998276c6e4" + "6497e0c50e20fef74e42cb518fe7f22ef27202428688f86404e8278587017012" + "c1d65537c6cbd7dde04aae338d68115a9f430afc100ab83cdadf45dca39db685"), + wvcdm::a2b_hex( + "51b0133e2e5f40c22d10ec0562799e5e4118aacaa6a820be976acee4b7689280" + "541b56836c454414fbaebf9a3142baa2c8009a4f19ac033665bd3495f2ad19f3" + "3b850d1e8e6957172571e82d3c812d03588c95a1ef49f08b33f21ea4f2d382c9" + "28704e329847e5fe98966949f39e272ec30126f5d7a4ae21d3a0d25aa8ccf637" + "d5f880a6733b07bdd33cfdc3c36dece2bffb6049f218162b024df4f800557568" + "a792e0add16fc388ee13595313c3fbeef28f69737523e449dc2cf893f0566a79" + "8a83110c8d3aaf5c1f7e8e8fe355a294a9a77b5494704b18e27f1315cb19c104" + "3ad2061a2a414d40cc768fc4c8f49a3905e3a82095aa4eef6a1ad8af1029fced"), + wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, + OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample}}; SubSampleInfo kEntitlementWithKeyRotationSubSampleDualPssh[] = { - { - true, 1, true, true, false, - wvcdm::a2bs_hex("1D9B8E13B59951169348FF8D5B9394C0"), - wvcdm::a2b_hex( - "64ab17b3e3dfab47245c7cce4543d4fc7a26dcf248f19f9b59f3c92601440b36" - "17c8ed0c96c656549e461f38708cd47a434066f8df28ccc28b79252eee3f9c2d" - "7f6c68ebe40141fe818fe082ca523c03d69ddaf183a93c022327fedc5582c5ab" - "ca9d342b71263a67f9cb2336f12108aaaef464f17177e44e9b0c4e56e61da53c" - "2150b4405cc82d994dfd9bf4087c761956d6688a9705db4cf350381085f383c4" - "9666d4aed135c519c1f0b5cba06e287feea96ea367bf54e7368dcf998276c6e4" - "6497e0c50e20fef74e42cb518fe7f22ef27202428688f86404e8278587017012" - "c1d65537c6cbd7dde04aae338d68115a9f430afc100ab83cdadf45dca39db685"), - wvcdm::a2b_hex( - "4bb2ff540e12e4c97248b63abdf30c4474df11ae8f22ba587e5aa9b64d51f8ce" - "209b13cb24f436ac192060690d13d5a1230fe5207287678a3acbaf59b5381186" - "92dcdec42c770afc0545407c243a452214d0497f1a044adc56ac1dba5530d5a5" - "482f9fc67a5e1d1314e864ad85fec9f78657e10f68ae8720b218339c96e878c1" - "c0f09015172d8a52a85b6f09526b98aad6d7326d3799a418581efadd16f9ba3e" - "454945428a36959a296aa14fe05cb8ae7b44ae68d82950f0742d38d86f167c36" - "75e75390d3cc6cd6db267729b2aa81a7e7c4db186e82d4300c4123c0a5de73e9" - "a6bb238bd351769359d1b46c9702270b756038fd54ef609d985eecde58e9a58e"), - wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, - OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample}, - { - true, 1, true, true, false, - wvcdm::a2bs_hex("A0396729B3795B46A5EA7F9919B96A67"), - wvcdm::a2b_hex( - "64ab17b3e3dfab47245c7cce4543d4fc7a26dcf248f19f9b59f3c92601440b36" - "17c8ed0c96c656549e461f38708cd47a434066f8df28ccc28b79252eee3f9c2d" - "7f6c68ebe40141fe818fe082ca523c03d69ddaf183a93c022327fedc5582c5ab" - "ca9d342b71263a67f9cb2336f12108aaaef464f17177e44e9b0c4e56e61da53c" - "2150b4405cc82d994dfd9bf4087c761956d6688a9705db4cf350381085f383c4" - "9666d4aed135c519c1f0b5cba06e287feea96ea367bf54e7368dcf998276c6e4" - "6497e0c50e20fef74e42cb518fe7f22ef27202428688f86404e8278587017012" - "c1d65537c6cbd7dde04aae338d68115a9f430afc100ab83cdadf45dca39db685"), - wvcdm::a2b_hex( - "49067453f9fe1b36fb2b37a2bba927bfe7f5f81ce715047beb99675da809b502" - "a5638f891cfad95c9fefdb32b6e8614ce3d5528032d51644a6cfaaccea2ad0b6" - "dd8bd36a0fb751bf4b70e1cb02266f373be467d3167aed4f3820eb4af884cc39" - "f60f83e060c8674b7e53d7ec8934ec07750d4677ed14ad6f6bacf46f46cf3ea8" - "560f704220bc3e32b9ad21c74aff6dbdbd64f49f38717ab7a05042dfe6fdc56f" - "47ddc384822b9a3fab3445653fa51f2405fcbcfd6d39a7fb8a99777c41960b94" - "74f1deb4b9b242bef609c625af791cba63e8c184b0312d624daba3889307b48b" - "00c362f246c3bc0b36cd41f9ec8eb72eab603f9517c7948f5e317a93ac1a5631"), - wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, - OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample}}; + {true, 1, true, true, false, + wvcdm::a2bs_hex("1D9B8E13B59951169348FF8D5B9394C0"), + wvcdm::a2b_hex( + "64ab17b3e3dfab47245c7cce4543d4fc7a26dcf248f19f9b59f3c92601440b36" + "17c8ed0c96c656549e461f38708cd47a434066f8df28ccc28b79252eee3f9c2d" + "7f6c68ebe40141fe818fe082ca523c03d69ddaf183a93c022327fedc5582c5ab" + "ca9d342b71263a67f9cb2336f12108aaaef464f17177e44e9b0c4e56e61da53c" + "2150b4405cc82d994dfd9bf4087c761956d6688a9705db4cf350381085f383c4" + "9666d4aed135c519c1f0b5cba06e287feea96ea367bf54e7368dcf998276c6e4" + "6497e0c50e20fef74e42cb518fe7f22ef27202428688f86404e8278587017012" + "c1d65537c6cbd7dde04aae338d68115a9f430afc100ab83cdadf45dca39db685"), + wvcdm::a2b_hex( + "4bb2ff540e12e4c97248b63abdf30c4474df11ae8f22ba587e5aa9b64d51f8ce" + "209b13cb24f436ac192060690d13d5a1230fe5207287678a3acbaf59b5381186" + "92dcdec42c770afc0545407c243a452214d0497f1a044adc56ac1dba5530d5a5" + "482f9fc67a5e1d1314e864ad85fec9f78657e10f68ae8720b218339c96e878c1" + "c0f09015172d8a52a85b6f09526b98aad6d7326d3799a418581efadd16f9ba3e" + "454945428a36959a296aa14fe05cb8ae7b44ae68d82950f0742d38d86f167c36" + "75e75390d3cc6cd6db267729b2aa81a7e7c4db186e82d4300c4123c0a5de73e9" + "a6bb238bd351769359d1b46c9702270b756038fd54ef609d985eecde58e9a58e"), + wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, + OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample}, + {true, 1, true, true, false, + wvcdm::a2bs_hex("A0396729B3795B46A5EA7F9919B96A67"), + wvcdm::a2b_hex( + "64ab17b3e3dfab47245c7cce4543d4fc7a26dcf248f19f9b59f3c92601440b36" + "17c8ed0c96c656549e461f38708cd47a434066f8df28ccc28b79252eee3f9c2d" + "7f6c68ebe40141fe818fe082ca523c03d69ddaf183a93c022327fedc5582c5ab" + "ca9d342b71263a67f9cb2336f12108aaaef464f17177e44e9b0c4e56e61da53c" + "2150b4405cc82d994dfd9bf4087c761956d6688a9705db4cf350381085f383c4" + "9666d4aed135c519c1f0b5cba06e287feea96ea367bf54e7368dcf998276c6e4" + "6497e0c50e20fef74e42cb518fe7f22ef27202428688f86404e8278587017012" + "c1d65537c6cbd7dde04aae338d68115a9f430afc100ab83cdadf45dca39db685"), + wvcdm::a2b_hex( + "49067453f9fe1b36fb2b37a2bba927bfe7f5f81ce715047beb99675da809b502" + "a5638f891cfad95c9fefdb32b6e8614ce3d5528032d51644a6cfaaccea2ad0b6" + "dd8bd36a0fb751bf4b70e1cb02266f373be467d3167aed4f3820eb4af884cc39" + "f60f83e060c8674b7e53d7ec8934ec07750d4677ed14ad6f6bacf46f46cf3ea8" + "560f704220bc3e32b9ad21c74aff6dbdbd64f49f38717ab7a05042dfe6fdc56f" + "47ddc384822b9a3fab3445653fa51f2405fcbcfd6d39a7fb8a99777c41960b94" + "74f1deb4b9b242bef609c625af791cba63e8c184b0312d624daba3889307b48b" + "00c362f246c3bc0b36cd41f9ec8eb72eab603f9517c7948f5e317a93ac1a5631"), + wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f"), 0, + OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample}}; // License duration and uncertainty window const uint32_t kSingleEncryptedSubSampleIcpLicenseDurationExpiration = 5; @@ -629,177 +641,175 @@ std::string kPsshStreamingClip21 = wvcdm::a2bs_hex( "08011a0d7769646576696e655f746573" // pssh data "74221073747265616d696e675f636c69703231"); const std::string kSinglePsshEntitlementWithKeyRotation[] = { - wvcdm::a2bs_hex( - "000001fb7073736800000000" // blob size and pssh - "edef8ba979d64acea3c827dcd51d21ed000001db" // Widevine system id - "220b47726f7570563254657374381448" // pssh data - "e3dc959b065002580272580a10668093" - "381a8c5be48a0168ce372726ac1210c8" - "326486bb5d5c4a958f00b1111afc811a" - "20082cd9d3aed3ebe6239d30fbcf0b22" - "1d28cbb0360ea1295c2363973346ec00" - "512210914781334e864c8eb7f768cf26" - "49073872580a10f872d11d5b1052f2bd" - "a94e60a0e383021210450897c987a85c" - "2e9579f968554a12991a2097e603ceea" - "f35ed8cef1029eae7a0a54701e3d6db6" - "80e7da1de3b22a8db347fb2210b41c34" - "29b7bb96972bbaf6587bc0ddf172580a" - "10bac58b9fce9e5929a42a180e529f19" - "4712103f11f22988d25659b145ce4854" - "3e6b141a20416e22768e5a57b08d155e" - "5210d00658056947ff06d626668bceb3" - "5eb01c6b57221081fb2ff3fef79d332f" - "f98be46233596972580a101261c8036d" - "ae5c8caa968858aa0ca9cc12106d583c" - "b37c1456519843a81cf49912221a20c2" - "1116bb54a226e8d879a4cd41d8879920" - "2ae85b80d83b1b4447e5d7fcad6f6a22" - "100b27a4c3f44771d2b0c7c34c66af35" - "b572580a10ab1c8c259c6b5967991389" - "65bff5ac0c1210b5b4473658565d3786" - "efaf4b85d8e6e21a203ce6a9085285c2" - "ece0b650dc83dd7aa8ac849611a8e3f8" - "3c8f389223c0f3621522101946f0c2a3" - "d543101cc842bbec2d0b30"), - wvcdm::a2bs_hex( - "000001fb7073736800000000" // blob size and pssh - "edef8ba979d64acea3c827dcd51d21ed000001db" // Widevine system id - "220b47726f7570563254657374381548" // pssh data - "e3dc959b065002580272580a10668093" - "381a8c5be48a0168ce372726ac1210f8" - "488775a99855ff94b93ec5bd4993561a" - "20d15ba631c20e95da0d4857f6a1d25a" - "a3bccbd3fde18b3fdc1dd8c4f0ede76f" - "402210d6dd3675f0d1150052e81b9107" - "6d7fc172580a10f872d11d5b1052f2bd" - "a94e60a0e383021210ad1f93ad921e53" - "b097c415b2bf1ef1c61a20b2087b60a2" - "d253ac2158a1bfa789b150b79701b29e" - "c852a2662560f8b8977a4c2210051ed3" - "2628671fbda58f506ba5ea713972580a" - "10bac58b9fce9e5929a42a180e529f19" - "47121027cdda7bfe5e5fd4bff2ebc9c7" - "c020701a20f2cb1184d648a2404517e6" - "7a39d698332aae6bb890a69bf7ddb536" - "75b8ac41c62210a80ed7f9b728fdd566" - "0b01b173ace26372580a101261c8036d" - "ae5c8caa968858aa0ca9cc1210769a70" - "0442a25bf5ae17174c70f4cb8e1a206c" - "7b2012723fc47c83b003ea214204915f" - "9a63dc373bf219f36ccf5697589aa422" - "10bcc3c16e836cca264d5493a0c334d3" - "4872580a10ab1c8c259c6b5967991389" - "65bff5ac0c1210894b04aef78557c6a7" - "e6e8855febbcc91a2025cc545ee3cd0c" - "c323586610ff6a8f8f22a78f5fade2f2" - "1083f152c52208f16d2210257aacacec" - "512a2e769396b10e6d9dfa") -}; + wvcdm::a2bs_hex( + "000001fb7073736800000000" // blob size and pssh + "edef8ba979d64acea3c827dcd51d21ed000001db" // Widevine system id + "220b47726f7570563254657374381448" // pssh data + "e3dc959b065002580272580a10668093" + "381a8c5be48a0168ce372726ac1210c8" + "326486bb5d5c4a958f00b1111afc811a" + "20082cd9d3aed3ebe6239d30fbcf0b22" + "1d28cbb0360ea1295c2363973346ec00" + "512210914781334e864c8eb7f768cf26" + "49073872580a10f872d11d5b1052f2bd" + "a94e60a0e383021210450897c987a85c" + "2e9579f968554a12991a2097e603ceea" + "f35ed8cef1029eae7a0a54701e3d6db6" + "80e7da1de3b22a8db347fb2210b41c34" + "29b7bb96972bbaf6587bc0ddf172580a" + "10bac58b9fce9e5929a42a180e529f19" + "4712103f11f22988d25659b145ce4854" + "3e6b141a20416e22768e5a57b08d155e" + "5210d00658056947ff06d626668bceb3" + "5eb01c6b57221081fb2ff3fef79d332f" + "f98be46233596972580a101261c8036d" + "ae5c8caa968858aa0ca9cc12106d583c" + "b37c1456519843a81cf49912221a20c2" + "1116bb54a226e8d879a4cd41d8879920" + "2ae85b80d83b1b4447e5d7fcad6f6a22" + "100b27a4c3f44771d2b0c7c34c66af35" + "b572580a10ab1c8c259c6b5967991389" + "65bff5ac0c1210b5b4473658565d3786" + "efaf4b85d8e6e21a203ce6a9085285c2" + "ece0b650dc83dd7aa8ac849611a8e3f8" + "3c8f389223c0f3621522101946f0c2a3" + "d543101cc842bbec2d0b30"), + wvcdm::a2bs_hex( + "000001fb7073736800000000" // blob size and pssh + "edef8ba979d64acea3c827dcd51d21ed000001db" // Widevine system id + "220b47726f7570563254657374381548" // pssh data + "e3dc959b065002580272580a10668093" + "381a8c5be48a0168ce372726ac1210f8" + "488775a99855ff94b93ec5bd4993561a" + "20d15ba631c20e95da0d4857f6a1d25a" + "a3bccbd3fde18b3fdc1dd8c4f0ede76f" + "402210d6dd3675f0d1150052e81b9107" + "6d7fc172580a10f872d11d5b1052f2bd" + "a94e60a0e383021210ad1f93ad921e53" + "b097c415b2bf1ef1c61a20b2087b60a2" + "d253ac2158a1bfa789b150b79701b29e" + "c852a2662560f8b8977a4c2210051ed3" + "2628671fbda58f506ba5ea713972580a" + "10bac58b9fce9e5929a42a180e529f19" + "47121027cdda7bfe5e5fd4bff2ebc9c7" + "c020701a20f2cb1184d648a2404517e6" + "7a39d698332aae6bb890a69bf7ddb536" + "75b8ac41c62210a80ed7f9b728fdd566" + "0b01b173ace26372580a101261c8036d" + "ae5c8caa968858aa0ca9cc1210769a70" + "0442a25bf5ae17174c70f4cb8e1a206c" + "7b2012723fc47c83b003ea214204915f" + "9a63dc373bf219f36ccf5697589aa422" + "10bcc3c16e836cca264d5493a0c334d3" + "4872580a10ab1c8c259c6b5967991389" + "65bff5ac0c1210894b04aef78557c6a7" + "e6e8855febbcc91a2025cc545ee3cd0c" + "c323586610ff6a8f8f22a78f5fade2f2" + "1083f152c52208f16d2210257aacacec" + "512a2e769396b10e6d9dfa")}; const std::string kDualPsshEntitlementWithKeyRotation[] = { - wvcdm::a2bs_hex( - "0000003e7073736800000000" // blob size and pssh - "edef8ba979d64acea3c827dcd51d21ed0000001e" // Widevine system id - "2210426f6f5261646c6579666137613664393800" // pssh data - "48e3dc959b0650126a00000002027073" - "736800000000edef8ba979d64acea3c8" - "27dcd51d21ed000001e22210426f6f52" - "61646c657966613761366439380048e3" - "dc959b06501258026a0072580a109ab3" - "fb7eaffc5ee087568b9581ff0e721210" - "4a2da018480c51358c660c4b1a198721" - "1a20a00425ef5fe538adba59a6c4ce9a" - "fbff394351b79552643e08ed3a0cde2c" - "3ca42210931a2ef95b898d804b9a25ef" - "6d2805f072580a100fba9bd0f8e055d5" - "900bbfaabf5033141210f9bfca8cd3b8" - "593897f0b9283cd768f61a209c1d9a96" - "573a4dbba68327f03e598adfde1bd29f" - "1e709f206c2424d82ca14c1c22108428" - "46cffba58c12742418a702138c3a7258" - "0a109fec6ad1d36e56cdaf5c232480f6" - "3f8812101d9b8e13b59951169348ff8d" - "5b9394c01a2058ee6164ae759802e0b1" - "f9f7eeeaa3606faf21182777fe716c01" - "4c2412621543221039c8a6caab12515e" - "3c744a5447e9b72372580a10cd2e9ebf" - "89c257e2a3196c82ac4c76ba1210d48f" - "8f11c2d853289e981f5775db60441a20" - "3b491980b27587592c86e73da27caa12" - "d95acda2295f768746090b55b81c9d61" - "2210dd7f29944aaeb08826ba4fc0dec6" - "c88d72580a10b3fd79204b9d5cbf8f67" - "2eca27255e9e121023feaaf517585fde" - "bdf0d4693f32c1091a20d18a1c0e54b8" - "fbc189b58ccc0dc5a0c541b628b8fe23" - "34c862944b5555ad7f7f221091269127" - "e4feb6a8fa878c6e9781a55f"), - wvcdm::a2bs_hex( - "0000003e7073736800000000ed" // blob size and pssh - "ef8ba979d64acea3c827dcd51d21ed0000001e" // Widevine system id - "2210426f6f5261646c65796661" // pssh data - "3761366439380448e3dc959b0650126a" - "00000002027073736800000000edef8b" - "a979d64acea3c827dcd51d21ed000001" - "e22210426f6f5261646c657966613761" - "366439380448e3dc959b06501258026a" - "0072580a109ab3fb7eaffc5ee087568b" - "9581ff0e721210777bc13c94c4568b84" - "ddaf99de3f03311a2042949649205d0d" - "f4f4a4eec94263561931066a9fc18b61" - "8b3929a168b4c2404222101e7aad142f" - "59edb962816e8d0702356b72580a100f" - "ba9bd0f8e055d5900bbfaabf50331412" - "10537cb8f017ec59e7be3c309e6d7f4b" - "5d1a2089c49c0f0e214c3765cbb37ab5" - "41dc0625c0087fa94317528ee8265431" - "71cabe2210dddba401d4eaaa76437638" - "a29dbdc38472580a109fec6ad1d36e56" - "cdaf5c232480f63f881210a0396729b3" - "795b46a5ea7f9919b96a671a209245a1" - "c821de9c65fb1086d9af8aaca4b7da0e" - "bbd0850a56ab36c23bb71b507e2210b0" - "531d2235575ff9ba5af4545bb43fdd72" - "580a10cd2e9ebf89c257e2a3196c82ac" - "4c76ba121011647820b33352349942cd" - "31ce352e571a20277b4392c76a04335d" - "3eadf22705184eb1adc057a61e372e78" - "30b7a20361d2472210d954557dc853a7" - "42283e6dfe16677a6a72580a10b3fd79" - "204b9d5cbf8f672eca27255e9e1210c4" - "78fb09c0c6531b92c571972c36098b1a" - "20bf17c678ac01685e258192eb4d2d49" - "157c3a07a95342d8be8b2f9f121f596b" - "8622100d9cfe972bc17003b49ecd5f45" - "f3bb28") -}; + wvcdm::a2bs_hex( + "0000003e7073736800000000" // blob size and pssh + "edef8ba979d64acea3c827dcd51d21ed0000001e" // Widevine system id + "2210426f6f5261646c6579666137613664393800" // pssh data + "48e3dc959b0650126a00000002027073" + "736800000000edef8ba979d64acea3c8" + "27dcd51d21ed000001e22210426f6f52" + "61646c657966613761366439380048e3" + "dc959b06501258026a0072580a109ab3" + "fb7eaffc5ee087568b9581ff0e721210" + "4a2da018480c51358c660c4b1a198721" + "1a20a00425ef5fe538adba59a6c4ce9a" + "fbff394351b79552643e08ed3a0cde2c" + "3ca42210931a2ef95b898d804b9a25ef" + "6d2805f072580a100fba9bd0f8e055d5" + "900bbfaabf5033141210f9bfca8cd3b8" + "593897f0b9283cd768f61a209c1d9a96" + "573a4dbba68327f03e598adfde1bd29f" + "1e709f206c2424d82ca14c1c22108428" + "46cffba58c12742418a702138c3a7258" + "0a109fec6ad1d36e56cdaf5c232480f6" + "3f8812101d9b8e13b59951169348ff8d" + "5b9394c01a2058ee6164ae759802e0b1" + "f9f7eeeaa3606faf21182777fe716c01" + "4c2412621543221039c8a6caab12515e" + "3c744a5447e9b72372580a10cd2e9ebf" + "89c257e2a3196c82ac4c76ba1210d48f" + "8f11c2d853289e981f5775db60441a20" + "3b491980b27587592c86e73da27caa12" + "d95acda2295f768746090b55b81c9d61" + "2210dd7f29944aaeb08826ba4fc0dec6" + "c88d72580a10b3fd79204b9d5cbf8f67" + "2eca27255e9e121023feaaf517585fde" + "bdf0d4693f32c1091a20d18a1c0e54b8" + "fbc189b58ccc0dc5a0c541b628b8fe23" + "34c862944b5555ad7f7f221091269127" + "e4feb6a8fa878c6e9781a55f"), + wvcdm::a2bs_hex( + "0000003e7073736800000000ed" // blob size and pssh + "ef8ba979d64acea3c827dcd51d21ed0000001e" // Widevine system id + "2210426f6f5261646c65796661" // pssh data + "3761366439380448e3dc959b0650126a" + "00000002027073736800000000edef8b" + "a979d64acea3c827dcd51d21ed000001" + "e22210426f6f5261646c657966613761" + "366439380448e3dc959b06501258026a" + "0072580a109ab3fb7eaffc5ee087568b" + "9581ff0e721210777bc13c94c4568b84" + "ddaf99de3f03311a2042949649205d0d" + "f4f4a4eec94263561931066a9fc18b61" + "8b3929a168b4c2404222101e7aad142f" + "59edb962816e8d0702356b72580a100f" + "ba9bd0f8e055d5900bbfaabf50331412" + "10537cb8f017ec59e7be3c309e6d7f4b" + "5d1a2089c49c0f0e214c3765cbb37ab5" + "41dc0625c0087fa94317528ee8265431" + "71cabe2210dddba401d4eaaa76437638" + "a29dbdc38472580a109fec6ad1d36e56" + "cdaf5c232480f63f881210a0396729b3" + "795b46a5ea7f9919b96a671a209245a1" + "c821de9c65fb1086d9af8aaca4b7da0e" + "bbd0850a56ab36c23bb71b507e2210b0" + "531d2235575ff9ba5af4545bb43fdd72" + "580a10cd2e9ebf89c257e2a3196c82ac" + "4c76ba121011647820b33352349942cd" + "31ce352e571a20277b4392c76a04335d" + "3eadf22705184eb1adc057a61e372e78" + "30b7a20361d2472210d954557dc853a7" + "42283e6dfe16677a6a72580a10b3fd79" + "204b9d5cbf8f672eca27255e9e1210c4" + "78fb09c0c6531b92c571972c36098b1a" + "20bf17c678ac01685e258192eb4d2d49" + "157c3a07a95342d8be8b2f9f121f596b" + "8622100d9cfe972bc17003b49ecd5f45" + "f3bb28")}; -std::string kProviderSessionTokenStreamingClip3 = wvcdm::a2bs_hex( - "4851305A4A4156485A554936444E4931"); -std::string kProviderSessionTokenStreamingClip4 = wvcdm::a2bs_hex( - "4942524F4355544E5557553145463243"); -std::string kProviderSessionTokenStreamingClip7 = wvcdm::a2bs_hex( - "44434C53524F4E30394C4E5535544B4C"); -std::string kProviderSessionTokenStreamingClip20 = wvcdm::a2bs_hex( - "4851305A4A4156485A554936444E4931"); -std::string kProviderSessionTokenStreamingClip21 = wvcdm::a2bs_hex( - "4851305A4A4156485A554936444E4931"); +std::string kProviderSessionTokenStreamingClip3 = + wvcdm::a2bs_hex("4851305A4A4156485A554936444E4931"); +std::string kProviderSessionTokenStreamingClip4 = + wvcdm::a2bs_hex("4942524F4355544E5557553145463243"); +std::string kProviderSessionTokenStreamingClip7 = + wvcdm::a2bs_hex("44434C53524F4E30394C4E5535544B4C"); +std::string kProviderSessionTokenStreamingClip20 = + wvcdm::a2bs_hex("4851305A4A4156485A554936444E4931"); +std::string kProviderSessionTokenStreamingClip21 = + wvcdm::a2bs_hex("4851305A4A4156485A554936444E4931"); // playback duration is 10 seconds+uncertainty window const std::chrono::milliseconds kExpirationStreamingClip21PlaybackDurationTimeMs = - std::chrono::milliseconds(12*1000); + std::chrono::milliseconds(12 * 1000); UsageLicenseAndSubSampleInfo kUsageLicenseTestVector1[] = { - { kPsshStreamingClip3, &usage_info_sub_samples_icp[0], - kProviderSessionTokenStreamingClip3 }, - { kPsshStreamingClip4, &usage_info_sub_samples_icp[1], - kProviderSessionTokenStreamingClip4 }, + {kPsshStreamingClip3, &usage_info_sub_samples_icp[0], + kProviderSessionTokenStreamingClip3}, + {kPsshStreamingClip4, &usage_info_sub_samples_icp[1], + kProviderSessionTokenStreamingClip4}, }; UsageLicenseAndSubSampleInfo kUsageLicenseTestVector2[] = { - { kPsshStreamingClip7, &usage_info_sub_samples_icp[4], - kProviderSessionTokenStreamingClip7 }, + {kPsshStreamingClip7, &usage_info_sub_samples_icp[4], + kProviderSessionTokenStreamingClip7}, // TODO(rfrias): Add another streaming usage license. Streaming // clip 5 has includes a randomly generated PST, while // streaming clip 6 does not include a PST. @@ -846,12 +856,9 @@ RenewWithClientIdTestConfiguration {true, false, true, true, "Test: Offline renewal/release, service cert provided"}}; -RenewWithClientIdTestConfiguration - usage_client_id_test_configuration[] = { - {false, false, false, false, - "Test: Usage reporting without client Id"}, - {true, false, false, false, - "Test: Usage reporting with client Id"}}; +RenewWithClientIdTestConfiguration usage_client_id_test_configuration[] = { + {false, false, false, false, "Test: Usage reporting without client Id"}, + {true, false, false, false, "Test: Usage reporting with client Id"}}; struct EntitlementTestConfiguration { std::string entitlement_pssh; @@ -951,7 +958,8 @@ struct HlsSegmentInfo { HlsSegmentInfo kAes128SingleSegmentInfo[] = { { - true, wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), + true, + wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex( "AD868A6AC55C10D564FC23B8ACFF407DAAF4ED2743520E02CDA9680D9EA88E9148" "84604C8DA8A53CE33DB9FF8F1C5BB6BB97F37B39906BF41596555C1BCCE9ED0293" @@ -976,7 +984,8 @@ HlsSegmentInfo kAes128SingleSegmentInfo[] = { HlsSegmentInfo kAes128PartialSegmentInfo[] = { { - true, wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), + true, + wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex( "AD868A6AC55C10D564FC23B8ACFF407DAAF4ED2743520E02CDA9680D9EA88E9148" "84604C8DA8A53CE33DB9FF8F1C5BB6BB97F37B39906BF41596555C1BCCE9ED0293" @@ -998,7 +1007,8 @@ HlsSegmentInfo kAes128PartialSegmentInfo[] = { OEMCrypto_FirstSubsample, }, { - false, wvcdm::a2bs_hex("BB1BB2843DA3FC76043E33687BEF3172"), + false, + wvcdm::a2bs_hex("BB1BB2843DA3FC76043E33687BEF3172"), wvcdm::a2bs_hex( "64ab17b3e3dfab47245c7cce4543d4fc7a26dcf248f19f9b59f3c92601440b3617" "c8ed0c96c656549e461f38708cd47a434066f8df28ccc28b79252eee3f9c2d7f6c" @@ -1023,7 +1033,8 @@ HlsSegmentInfo kAes128PartialSegmentInfo[] = { HlsSegmentInfo kAes128MultiSegmentInfo[] = { { - true, wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), + true, + wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex( "AD868A6AC55C10D564FC23B8ACFF407DAAF4ED2743520E02CDA9680D9EA88E9148" "84604C8DA8A53CE33DB9FF8F1C5BB6BB97F37B39906BF41596555C1BCCE9ED0293" @@ -1045,7 +1056,8 @@ HlsSegmentInfo kAes128MultiSegmentInfo[] = { OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample, }, { - true, wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), + true, + wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex( "64AB17B3E3DFAB47245C7CCE4543D4FC7A26DCF248F19F9B59F3C92601440B3617" "C8ED0C96C656549E461F38708CD47A434066F8DF28CCC28B79252EEE3F9C2D7F6C" @@ -1070,7 +1082,8 @@ HlsSegmentInfo kAes128MultiSegmentInfo[] = { HlsSegmentInfo kSampleAes10ByteSegmentInfo[] = { { - true, wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), + true, + wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex("4884604C8DA8A53CE33D"), wvcdm::a2bs_hex("4884604C8DA8A53CE33D"), OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample, @@ -1079,7 +1092,8 @@ HlsSegmentInfo kSampleAes10ByteSegmentInfo[] = { HlsSegmentInfo kSampleAes16ByteSegmentInfo[] = { { - true, wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), + true, + wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex("4884604C8DA8A53CE33DB9FF8F1C5BB6"), wvcdm::a2bs_hex("8E6B884AB604495C675CA38F0425E23E"), OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample, @@ -1088,7 +1102,8 @@ HlsSegmentInfo kSampleAes16ByteSegmentInfo[] = { HlsSegmentInfo kSampleAes18ByteSegmentInfo[] = { { - true, wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), + true, + wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex("4884604C8DA8A53CE33DB9FF8F1C5BB6BB97"), wvcdm::a2bs_hex("8E6B884AB604495C675CA38F0425E23EBB97"), OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample, @@ -1097,7 +1112,8 @@ HlsSegmentInfo kSampleAes18ByteSegmentInfo[] = { HlsSegmentInfo kSampleAes160ByteSegmentInfo[] = { { - true, wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), + true, + wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex("4884604C8DA8A53CE33DB9FF8F1C5BB6BB97F37B39906BF4159655" "5C1BCCE9ED029359C4CF5906B6AB5BF60FBB3F1A1C7C59ACFC7E4F" "B4AD8E623C04D503A3DDAD868A6AC55C10D564FC23B8ACFF407DAA" @@ -1116,14 +1132,15 @@ HlsSegmentInfo kSampleAes160ByteSegmentInfo[] = { HlsSegmentInfo kSampleAes175ByteSegmentInfo[] = { { - true, wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), + true, + wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex( - "4884604C8DA8A53CE33DB9FF8F1C5BB6BB97F37B39906BF41596555C1BCC" - "E9ED029359C4CF5906B6AB5BF60FBB3F1A1C7C59ACFC7E4FB4AD8E623C04" - "D503A3DDAD868A6AC55C10D564FC23B8ACFF407DAAF4ED2743520E02CDA9" - "680D9EA88E918DF21FDC42F166880D97A2225CD5C9EA5E7B752F4CF81BBD" - "BE98E542EE10E1C6595D259A1E4A8B6D7744CD98C5D3F921ADC252EB7D8A" - "F6B916044B676A574747942AC20A89FF79F4C2F25FBA99D6A4"), + "4884604C8DA8A53CE33DB9FF8F1C5BB6BB97F37B39906BF41596555C1BCC" + "E9ED029359C4CF5906B6AB5BF60FBB3F1A1C7C59ACFC7E4FB4AD8E623C04" + "D503A3DDAD868A6AC55C10D564FC23B8ACFF407DAAF4ED2743520E02CDA9" + "680D9EA88E918DF21FDC42F166880D97A2225CD5C9EA5E7B752F4CF81BBD" + "BE98E542EE10E1C6595D259A1E4A8B6D7744CD98C5D3F921ADC252EB7D8A" + "F6B916044B676A574747942AC20A89FF79F4C2F25FBA99D6A4"), wvcdm::a2bs_hex("8E6B884AB604495C675CA38F0425E23EBB97F37B39906BF4159655" "5C1BCCE9ED029359C4CF5906B6AB5BF60FBB3F1A1C7C59ACFC7E4F" "B4AD8E623C04D503A3DDAD868A6AC55C10D564FC23B8ACFF407DAA" @@ -1137,14 +1154,15 @@ HlsSegmentInfo kSampleAes175ByteSegmentInfo[] = { HlsSegmentInfo kSampleAes176ByteSegmentInfo[] = { { - true, wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), + true, + wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex( - "4884604C8DA8A53CE33DB9FF8F1C5BB6BB97F37B39906BF41596555C1BCC" - "E9ED029359C4CF5906B6AB5BF60FBB3F1A1C7C59ACFC7E4FB4AD8E623C04" - "D503A3DDAD868A6AC55C10D564FC23B8ACFF407DAAF4ED2743520E02CDA9" - "680D9EA88E918DF21FDC42F166880D97A2225CD5C9EA5E7B752F4CF81BBD" - "BE98E542EE10E1C6595D259A1E4A8B6D7744CD98C5D3F921ADC252EB7D8A" - "F6B916044B676A574747942AC20A89FF79F4C2F25FBA99D6A446"), + "4884604C8DA8A53CE33DB9FF8F1C5BB6BB97F37B39906BF41596555C1BCC" + "E9ED029359C4CF5906B6AB5BF60FBB3F1A1C7C59ACFC7E4FB4AD8E623C04" + "D503A3DDAD868A6AC55C10D564FC23B8ACFF407DAAF4ED2743520E02CDA9" + "680D9EA88E918DF21FDC42F166880D97A2225CD5C9EA5E7B752F4CF81BBD" + "BE98E542EE10E1C6595D259A1E4A8B6D7744CD98C5D3F921ADC252EB7D8A" + "F6B916044B676A574747942AC20A89FF79F4C2F25FBA99D6A446"), wvcdm::a2bs_hex("8E6B884AB604495C675CA38F0425E23EBB97F37B39906BF4159655" "5C1BCCE9ED029359C4CF5906B6AB5BF60FBB3F1A1C7C59ACFC7E4F" "B4AD8E623C04D503A3DDAD868A6AC55C10D564FC23B8ACFF407DAA" @@ -1158,7 +1176,8 @@ HlsSegmentInfo kSampleAes176ByteSegmentInfo[] = { HlsSegmentInfo kSampleAes192ByteSegmentInfo[] = { { - true, wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), + true, + wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex( "4884604C8DA8A53CE33DB9FF8F1C5BB6BB97F37B39906BF41596555C1BCCE9ED02" "9359C4CF5906B6AB5BF60FBB3F1A1C7C59ACFC7E4FB4AD8E623C04D503A3DDAD86" @@ -1179,7 +1198,8 @@ HlsSegmentInfo kSampleAes192ByteSegmentInfo[] = { HlsSegmentInfo kSampleAes338ByteSegmentInfo[] = { { - true, wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), + true, + wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex( "4884604C8DA8A53CE33DB9FF8F1C5BB6BB97F37B39906BF41596555C1BCCE9ED02" "9359C4CF5906B6AB5BF60FBB3F1A1C7C59ACFC7E4FB4AD8E623C04D503A3DDAD86" @@ -1306,17 +1326,16 @@ const std::string kFullCensPssh = wvcdm::a2bs_hex( "959b06"); const std::string kFullCbc1Pssh = wvcdm::a2bs_hex( - "00000053" // blob size - "70737368" // "pssh" - "00000000" // flags - "edef8ba979d64acea3c827dcd51d21ed" // Widevine system id - "00000033" // pssh data size - "12103030303030303030303030303030" // pssh data + "00000053" // blob size + "70737368" // "pssh" + "00000000" // flags + "edef8ba979d64acea3c827dcd51d21ed" // Widevine system id + "00000033" // pssh data size + "12103030303030303030303030303030" // pssh data "30321a0d7769646576696e655f746573" "74220a323031355f746561727348b1c6" "899b06"); - const std::string kFullCbcsPssh = wvcdm::a2bs_hex( "00000053" // blob size "70737368" // "pssh" @@ -1339,7 +1358,8 @@ struct Cenc30SampleInfo { }; Cenc30SampleInfo kCenc30CencKey33Sample = { - true, wvcdm::a2bs_hex("30303030303030303030303030303033"), + true, + wvcdm::a2bs_hex("30303030303030303030303030303033"), wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex( "011E88387D58EBB8E5CDCC38D431EEF4B6094B9201F200932F8EB5E1A94FB0B977" @@ -1364,7 +1384,8 @@ Cenc30SampleInfo kCenc30CencKey33Sample = { }; Cenc30SampleInfo kCenc30CencKey32Sample = { - true, wvcdm::a2bs_hex("30303030303030303030303030303032"), + true, + wvcdm::a2bs_hex("30303030303030303030303030303032"), wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex( "1B605E32B31D6245BCCC01C4E7720725B6094B9201F200932F8EB5E1A94FB0B977" @@ -1389,7 +1410,8 @@ Cenc30SampleInfo kCenc30CencKey32Sample = { }; Cenc30SampleInfo kCenc30CensKey33Sample = { - true, wvcdm::a2bs_hex("30303030303030303030303030303033"), + true, + wvcdm::a2bs_hex("30303030303030303030303030303033"), wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex( "011E88387D58EBB8E5CDCC38D431EEF4B6094B9201F200932F8EB5E1A94FB0B977" @@ -1414,7 +1436,8 @@ Cenc30SampleInfo kCenc30CensKey33Sample = { }; Cenc30SampleInfo kCenc30Cbc1Key33Sample = { - true, wvcdm::a2bs_hex("30303030303030303030303030303033"), + true, + wvcdm::a2bs_hex("30303030303030303030303030303033"), wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex( "E300F37FEB0CDD9F276E67B971FF423003F3BF21DCF6100BA453A473A4522A19A8" @@ -1439,7 +1462,8 @@ Cenc30SampleInfo kCenc30Cbc1Key33Sample = { }; Cenc30SampleInfo kCenc30Cbc1Key32Sample = { - true, wvcdm::a2bs_hex("30303030303030303030303030303032"), + true, + wvcdm::a2bs_hex("30303030303030303030303030303032"), wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex( "4392E38BAE263267ED15394DE349AD1577F37B7D906C3A61536EE5A288F66F22F2" @@ -1464,7 +1488,8 @@ Cenc30SampleInfo kCenc30Cbc1Key32Sample = { }; Cenc30SampleInfo kCenc30CbcsKey33Sample = { - true, wvcdm::a2bs_hex("30303030303030303030303030303033"), + true, + wvcdm::a2bs_hex("30303030303030303030303030303033"), wvcdm::a2bs_hex("9FBE45DD47DA7EBA09A3E24CBA95C9AF"), wvcdm::a2bs_hex( "E300F37FEB0CDD9F276E67B971FF423003F3BF21DCF6100BA453A473A4522A19A8" @@ -1494,10 +1519,10 @@ struct SingleSampleDecryptionInfo { }; SingleSampleDecryptionInfo kCenc30DecryptionData[4] = { - { kFullCencPssh, kCenc30CencKey33Sample }, - { kFullCensPssh, kCenc30CensKey33Sample }, - { kFullCbc1Pssh, kCenc30Cbc1Key33Sample }, - { kFullCbcsPssh, kCenc30CbcsKey33Sample }, + {kFullCencPssh, kCenc30CencKey33Sample}, + {kFullCensPssh, kCenc30CensKey33Sample}, + {kFullCbc1Pssh, kCenc30Cbc1Key33Sample}, + {kFullCbcsPssh, kCenc30CbcsKey33Sample}, }; struct FourSampleDecryptionInfo { @@ -1507,25 +1532,65 @@ struct FourSampleDecryptionInfo { FourSampleDecryptionInfo kCenc30SwitchCipherData[8] = { // Switch between cipher modes - { kFullCencPssh, { kCenc30CencKey33Sample, kCenc30Cbc1Key33Sample, - kCenc30CencKey33Sample, kCenc30Cbc1Key33Sample, } }, - { kFullCbc1Pssh, { kCenc30Cbc1Key33Sample, kCenc30CencKey33Sample, - kCenc30Cbc1Key33Sample, kCenc30CencKey33Sample, } }, + {kFullCencPssh, + { + kCenc30CencKey33Sample, + kCenc30Cbc1Key33Sample, + kCenc30CencKey33Sample, + kCenc30Cbc1Key33Sample, + }}, + {kFullCbc1Pssh, + { + kCenc30Cbc1Key33Sample, + kCenc30CencKey33Sample, + kCenc30Cbc1Key33Sample, + kCenc30CencKey33Sample, + }}, // Switch between cipher modes, but the first sample has a cipher mode // that differs with the protection scheme in the pssh - { kFullCencPssh, { kCenc30Cbc1Key33Sample, kCenc30CencKey33Sample, - kCenc30Cbc1Key33Sample, kCenc30CencKey33Sample, } }, - { kFullCbc1Pssh, { kCenc30CencKey33Sample, kCenc30Cbc1Key33Sample, - kCenc30CencKey33Sample, kCenc30Cbc1Key33Sample, } }, + {kFullCencPssh, + { + kCenc30Cbc1Key33Sample, + kCenc30CencKey33Sample, + kCenc30Cbc1Key33Sample, + kCenc30CencKey33Sample, + }}, + {kFullCbc1Pssh, + { + kCenc30CencKey33Sample, + kCenc30Cbc1Key33Sample, + kCenc30CencKey33Sample, + kCenc30Cbc1Key33Sample, + }}, // Switch between cipher modes and keys - { kFullCencPssh, { kCenc30CencKey33Sample, kCenc30CencKey32Sample, - kCenc30Cbc1Key33Sample, kCenc30Cbc1Key32Sample, } }, - { kFullCencPssh, { kCenc30Cbc1Key33Sample, kCenc30Cbc1Key32Sample, - kCenc30CencKey33Sample, kCenc30CencKey32Sample, } }, - { kFullCbc1Pssh, { kCenc30Cbc1Key33Sample, kCenc30Cbc1Key32Sample, - kCenc30CencKey33Sample, kCenc30CencKey32Sample, } }, - { kFullCbc1Pssh, { kCenc30CencKey33Sample, kCenc30CencKey32Sample, - kCenc30Cbc1Key33Sample, kCenc30Cbc1Key32Sample, } }, + {kFullCencPssh, + { + kCenc30CencKey33Sample, + kCenc30CencKey32Sample, + kCenc30Cbc1Key33Sample, + kCenc30Cbc1Key32Sample, + }}, + {kFullCencPssh, + { + kCenc30Cbc1Key33Sample, + kCenc30Cbc1Key32Sample, + kCenc30CencKey33Sample, + kCenc30CencKey32Sample, + }}, + {kFullCbc1Pssh, + { + kCenc30Cbc1Key33Sample, + kCenc30Cbc1Key32Sample, + kCenc30CencKey33Sample, + kCenc30CencKey32Sample, + }}, + {kFullCbc1Pssh, + { + kCenc30CencKey33Sample, + kCenc30CencKey32Sample, + kCenc30Cbc1Key33Sample, + kCenc30Cbc1Key32Sample, + }}, }; } // namespace @@ -1598,8 +1663,7 @@ class DecryptCallbackTester { DecryptCallbackTester( const android::sp& decryptor, SubSampleInfo* sub_sample_info) - : decryptor_(decryptor), - sub_sample_info_(sub_sample_info) {} + : decryptor_(decryptor), sub_sample_info_(sub_sample_info) {} void Decrypt(const CdmSessionId& session_id, const CdmKeyStatusMap& /* keys_status */, @@ -1608,18 +1672,18 @@ class DecryptCallbackTester { EXPECT_TRUE(sub_sample_info_ != nullptr); std::vector decrypt_buffer(sub_sample_info_->encrypt_data.size()); - CdmDecryptionParameters decryption_parameters( - &sub_sample_info_->key_id, &sub_sample_info_->encrypt_data.front(), - sub_sample_info_->encrypt_data.size(), &sub_sample_info_->iv, - sub_sample_info_->block_offset, &decrypt_buffer[0]); - decryption_parameters.is_encrypted = sub_sample_info_->is_encrypted; - decryption_parameters.is_secure = sub_sample_info_->is_secure; - decryption_parameters.subsample_flags = sub_sample_info_->subsample_flags; - EXPECT_EQ(NO_ERROR, decryptor_->Decrypt(session_id, - sub_sample_info_->validate_key_id, - decryption_parameters)); - + CdmDecryptionParameters decryption_parameters( + &sub_sample_info_->key_id, &sub_sample_info_->encrypt_data.front(), + sub_sample_info_->encrypt_data.size(), &sub_sample_info_->iv, + sub_sample_info_->block_offset, &decrypt_buffer[0]); + decryption_parameters.is_encrypted = sub_sample_info_->is_encrypted; + decryption_parameters.is_secure = sub_sample_info_->is_secure; + decryption_parameters.subsample_flags = sub_sample_info_->subsample_flags; + EXPECT_EQ(NO_ERROR, + decryptor_->Decrypt(session_id, sub_sample_info_->validate_key_id, + decryption_parameters)); } + private: android::sp decryptor_; SubSampleInfo* sub_sample_info_; @@ -1630,15 +1694,14 @@ class TestWvCdmHlsEventListener : public WvCdmEventListener { TestWvCdmHlsEventListener() : WvCdmEventListener() {} virtual void OnSessionRenewalNeeded(const CdmSessionId&) {} virtual void OnSessionKeysChange(const CdmSessionId&, - const CdmKeyStatusMap& keys_status, - bool) { + const CdmKeyStatusMap& keys_status, bool) { key_status_map_ = keys_status; } - virtual void OnExpirationUpdate(const CdmSessionId&, - int64_t) {} + virtual void OnExpirationUpdate(const CdmSessionId&, int64_t) {} CdmKeyStatusMap GetKeyStatusMap() { return key_status_map_; } + private: CdmKeyStatusMap key_status_map_; }; @@ -1711,16 +1774,17 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { CdmKeyRequest key_request; std::string key_set_id; license_type_ = license_type; - EXPECT_EQ(expected_response, - decryptor_->GenerateKeyRequest( - session_id_, key_set_id, init_data_type, init_data, - license_type, app_parameters, property_set, - cdm_identifier, &key_request)) + EXPECT_EQ( + expected_response, + decryptor_->GenerateKeyRequest( + session_id_, key_set_id, init_data_type, init_data, license_type, + app_parameters, property_set, cdm_identifier, &key_request)) << "session_id_ " << session_id_ << std::endl << "init_data (hex) " << wvcdm::b2a_hex(init_data) << std::endl << "key_set_id " << key_set_id << std::endl << "cdm_identifier.origin " << cdm_identifier.origin << std::endl - << "cdm_identifier.app_package_name " << cdm_identifier.app_package_name << std::endl + << "cdm_identifier.app_package_name " << cdm_identifier.app_package_name + << std::endl << "cdm_identifier.unique_id " << cdm_identifier.unique_id << std::endl; key_msg_ = key_request.message; EXPECT_EQ(0u, key_request.url.size()); @@ -1763,8 +1827,8 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { EXPECT_TRUE(key_request.message.empty()); EXPECT_EQ(kKeyRequestTypeNone, key_request.type); EXPECT_TRUE(key_request.url.empty()); - return wvcdm::KEY_ADDED == status && key_request.message.empty() - && key_request.url.empty(); + return wvcdm::KEY_ADDED == status && key_request.message.empty() && + key_request.url.empty(); } void GenerateKeyRelease(CdmKeySetId key_set_id) { @@ -1779,11 +1843,11 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { CdmInitData init_data; wvcdm::CdmAppParameterMap app_parameters; CdmKeyRequest key_request; - EXPECT_EQ(wvcdm::KEY_MESSAGE, - decryptor_->GenerateKeyRequest( - session_id, key_set_id, "video/mp4", init_data, - kLicenseTypeRelease, app_parameters, property_set, - kDefaultCdmIdentifier, &key_request)); + EXPECT_EQ( + wvcdm::KEY_MESSAGE, + decryptor_->GenerateKeyRequest( + session_id, key_set_id, "video/mp4", init_data, kLicenseTypeRelease, + app_parameters, property_set, kDefaultCdmIdentifier, &key_request)); key_msg_ = key_request.message; EXPECT_EQ(kKeyRequestTypeRelease, key_request.type); if (key_msg) *key_msg = key_request.message; @@ -1799,8 +1863,8 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { const std::string& client_auth) { // Use secure connection and chunk transfer coding. UrlRequest url_request(server_url + client_auth); - EXPECT_TRUE(url_request.is_connected()) << "Fail to connect to " - << server_url << client_auth; + EXPECT_TRUE(url_request.is_connected()) + << "Fail to connect to " << server_url << client_auth; url_request.PostRequest(key_msg_); std::string message; EXPECT_TRUE(url_request.GetResponse(&message)); @@ -1825,8 +1889,8 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { std::string GetCertRequestResponse(const std::string& server_url) { // Use secure connection and chunk transfer coding. UrlRequest url_request(server_url); - EXPECT_TRUE(url_request.is_connected()) << "Fail to connect to " - << server_url; + EXPECT_TRUE(url_request.is_connected()) + << "Fail to connect to " << server_url; url_request.PostCertRequestInQueryString(key_msg_); std::string message; EXPECT_TRUE(url_request.GetResponse(&message)); @@ -1846,8 +1910,8 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { const std::string& usage_info_request) { // Use secure connection and chunk transfer coding. UrlRequest url_request(server_url + client_auth); - EXPECT_TRUE(url_request.is_connected()) << "Fail to connect to " - << server_url << client_auth; + EXPECT_TRUE(url_request.is_connected()) + << "Fail to connect to " << server_url << client_auth; url_request.PostRequest(usage_info_request); std::string message; EXPECT_TRUE(url_request.GetResponse(&message)); @@ -1878,15 +1942,13 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { } void VerifyKeyRequestResponse(const std::string& server_url, - const std::string& client_auth, - bool is_usage) { + const std::string& client_auth, bool is_usage) { std::string response; VerifyKeyRequestResponse(server_url, client_auth, is_usage, &response); } void VerifyKeyRequestResponse(const std::string& server_url, - const std::string& client_auth, - bool is_usage, + const std::string& client_auth, bool is_usage, std::string* response) { VerifyKeyRequestResponse(wvcdm::KEY_ADDED, server_url, client_auth, is_usage, response); @@ -1894,8 +1956,7 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { void VerifyKeyRequestResponse(CdmResponseType expected_response, const std::string& server_url, - const std::string& client_auth, - bool is_usage, + const std::string& client_auth, bool is_usage, std::string* response) { *response = GetKeyRequestResponse(server_url, client_auth); @@ -1920,12 +1981,10 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { decryption_parameters.is_encrypted = data.is_encrypted; decryption_parameters.is_secure = data.is_secure; decryption_parameters.subsample_flags = data.subsample_flags; - CdmResponseType status = decryptor_->Decrypt(session_id, - data.validate_key_id, - decryption_parameters); + CdmResponseType status = decryptor_->Decrypt( + session_id, data.validate_key_id, decryption_parameters); EXPECT_EQ(expected_response, status); - if (status != NO_ERROR) - return false; + if (status != NO_ERROR) return false; bool result = std::equal(data.decrypt_data.begin(), data.decrypt_data.end(), decrypt_buffer.begin()); @@ -1970,10 +2029,9 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { CdmCertificateType cert_type = kCertificateWidevine; std::string cert_authority, cert, wrapped_key; - status = decryptor_->GetProvisioningRequest(cert_type, cert_authority, - identifier, - kEmptyServiceCertificate, - &key_msg_, &provisioning_server); + status = decryptor_->GetProvisioningRequest( + cert_type, cert_authority, identifier, kEmptyServiceCertificate, + &key_msg_, &provisioning_server); EXPECT_EQ(wvcdm::NO_ERROR, status); if (NO_ERROR != status) return; EXPECT_EQ(provisioning_server, config_.provisioning_server()); @@ -1981,9 +2039,8 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { std::string response = GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); - EXPECT_EQ(wvcdm::NO_ERROR, - decryptor_->HandleProvisioningResponse(identifier, response, - &cert, &wrapped_key)); + EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->HandleProvisioningResponse( + identifier, response, &cert, &wrapped_key)); EXPECT_EQ(0, static_cast(cert.size())); EXPECT_EQ(0, static_cast(wrapped_key.size())); decryptor_->CloseSession(session_id_); @@ -2051,19 +2108,17 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningTest) { CdmCertificateType cert_type = kCertificateWidevine; std::string cert_authority, cert, wrapped_key; - EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->GetProvisioningRequest( - cert_type, cert_authority, - kDefaultCdmIdentifier, - kEmptyServiceCertificate, - &key_msg_, &provisioning_server)); + EXPECT_EQ(wvcdm::NO_ERROR, + decryptor_->GetProvisioningRequest( + cert_type, cert_authority, kDefaultCdmIdentifier, + kEmptyServiceCertificate, &key_msg_, &provisioning_server)); EXPECT_EQ(provisioning_server, config_.provisioning_server()); - std::string response = - GetCertRequestResponse(config_.provisioning_server()); + std::string response = GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); - EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->HandleProvisioningResponse( - kDefaultCdmIdentifier, response, &cert, - &wrapped_key)); + EXPECT_EQ(wvcdm::NO_ERROR, + decryptor_->HandleProvisioningResponse( + kDefaultCdmIdentifier, response, &cert, &wrapped_key)); EXPECT_EQ(0, static_cast(cert.size())); EXPECT_EQ(0, static_cast(wrapped_key.size())); decryptor_->CloseSession(session_id_); @@ -2079,19 +2134,18 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningTestWithServiceCertificate) { CdmCertificateType cert_type = kCertificateWidevine; std::string cert_authority, cert, wrapped_key; - EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->GetProvisioningRequest( - cert_type, cert_authority, - kDefaultCdmIdentifier, - config_.provisioning_service_certificate(), - &key_msg_, &provisioning_server)); + EXPECT_EQ(wvcdm::NO_ERROR, + decryptor_->GetProvisioningRequest( + cert_type, cert_authority, kDefaultCdmIdentifier, + config_.provisioning_service_certificate(), &key_msg_, + &provisioning_server)); EXPECT_EQ(provisioning_server, config_.provisioning_server()); - std::string response = - GetCertRequestResponse(config_.provisioning_server()); + std::string response = GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); - EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->HandleProvisioningResponse( - kDefaultCdmIdentifier, response, &cert, - &wrapped_key)); + EXPECT_EQ(wvcdm::NO_ERROR, + decryptor_->HandleProvisioningResponse( + kDefaultCdmIdentifier, response, &cert, &wrapped_key)); EXPECT_EQ(0, static_cast(cert.size())); EXPECT_EQ(0, static_cast(wrapped_key.size())); decryptor_->CloseSession(session_id_); @@ -2109,19 +2163,17 @@ TEST_F(WvCdmRequestLicenseTest, L3ProvisioningTest) { CdmCertificateType cert_type = kCertificateWidevine; std::string cert_authority, cert, wrapped_key; - EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->GetProvisioningRequest( - cert_type, cert_authority, - kDefaultCdmIdentifier, - kEmptyServiceCertificate, &key_msg_, - &provisioning_server)); + EXPECT_EQ(wvcdm::NO_ERROR, + decryptor_->GetProvisioningRequest( + cert_type, cert_authority, kDefaultCdmIdentifier, + kEmptyServiceCertificate, &key_msg_, &provisioning_server)); EXPECT_EQ(provisioning_server, config_.provisioning_server()); - std::string response = - GetCertRequestResponse(config_.provisioning_server()); + std::string response = GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); - EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->HandleProvisioningResponse( - kDefaultCdmIdentifier, response, &cert, - &wrapped_key)); + EXPECT_EQ(wvcdm::NO_ERROR, + decryptor_->HandleProvisioningResponse( + kDefaultCdmIdentifier, response, &cert, &wrapped_key)); EXPECT_EQ(0, static_cast(cert.size())); EXPECT_EQ(0, static_cast(wrapped_key.size())); decryptor_->CloseSession(session_id_); @@ -2165,7 +2217,7 @@ TEST_F(WvCdmRequestLicenseTest, PerOriginProvisioningSupportsOldPaths) { ASSERT_TRUE(FileUtils::List(base_path, &files)); ASSERT_LE(1u, files.size()); bool found_it = false; - for(std::string file: files) { + for (std::string file : files) { if (file == std::string(kOldFileName)) found_it = true; } EXPECT_TRUE(found_it); @@ -2200,27 +2252,24 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningInterposedRetryTest) { std::string cert_authority, cert, wrapped_key; CdmKeyMessage key_msg1, key_msg2; - EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->GetProvisioningRequest( - cert_type, cert_authority, - kDefaultCdmIdentifier, - kEmptyServiceCertificate, &key_msg1, - &provisioning_server)); + EXPECT_EQ(wvcdm::NO_ERROR, + decryptor_->GetProvisioningRequest( + cert_type, cert_authority, kDefaultCdmIdentifier, + kEmptyServiceCertificate, &key_msg1, &provisioning_server)); EXPECT_EQ(provisioning_server, config_.provisioning_server()); - EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->GetProvisioningRequest( - cert_type, cert_authority, - kDefaultCdmIdentifier, - kEmptyServiceCertificate, &key_msg2, - &provisioning_server)); + EXPECT_EQ(wvcdm::NO_ERROR, + decryptor_->GetProvisioningRequest( + cert_type, cert_authority, kDefaultCdmIdentifier, + kEmptyServiceCertificate, &key_msg2, &provisioning_server)); EXPECT_EQ(provisioning_server, config_.provisioning_server()); key_msg_ = key_msg2; - std::string response = - GetCertRequestResponse(config_.provisioning_server()); + std::string response = GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); - EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->HandleProvisioningResponse( - kDefaultCdmIdentifier, response, &cert, - &wrapped_key)); + EXPECT_EQ(wvcdm::NO_ERROR, + decryptor_->HandleProvisioningResponse( + kDefaultCdmIdentifier, response, &cert, &wrapped_key)); EXPECT_EQ(0, static_cast(cert.size())); EXPECT_EQ(0, static_cast(wrapped_key.size())); @@ -2228,9 +2277,8 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningInterposedRetryTest) { response = GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); EXPECT_EQ(wvcdm::NO_ERROR, - decryptor_->HandleProvisioningResponse(kDefaultCdmIdentifier, - response, &cert, - &wrapped_key)); + decryptor_->HandleProvisioningResponse( + kDefaultCdmIdentifier, response, &cert, &wrapped_key)); EXPECT_EQ(0, static_cast(cert.size())); EXPECT_EQ(0, static_cast(wrapped_key.size())); decryptor_->CloseSession(session_id_); @@ -2326,19 +2374,17 @@ TEST_F(WvCdmRequestLicenseTest, DISABLED_X509ProvisioningTest) { std::string cert_authority = "cast.google.com"; std::string cert, wrapped_key; - EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->GetProvisioningRequest( - cert_type, cert_authority, - kDefaultCdmIdentifier, - kEmptyServiceCertificate, &key_msg_, - &provisioning_server)); + EXPECT_EQ(wvcdm::NO_ERROR, + decryptor_->GetProvisioningRequest( + cert_type, cert_authority, kDefaultCdmIdentifier, + kEmptyServiceCertificate, &key_msg_, &provisioning_server)); EXPECT_EQ(provisioning_server, config_.provisioning_server()); - std::string response = - GetCertRequestResponse(config_.provisioning_server()); + std::string response = GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); - EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->HandleProvisioningResponse( - kDefaultCdmIdentifier, response, &cert, - &wrapped_key)); + EXPECT_EQ(wvcdm::NO_ERROR, + decryptor_->HandleProvisioningResponse( + kDefaultCdmIdentifier, response, &cert, &wrapped_key)); EXPECT_NE(0, static_cast(cert.size())); EXPECT_NE(0, static_cast(wrapped_key.size())); decryptor_->CloseSession(session_id_); @@ -2367,17 +2413,17 @@ TEST_F(WvCdmRequestLicenseTest, PropertySetTest) { std::string provisioning_server; CdmCertificateType cert_type = kCertificateWidevine; std::string cert_authority, cert, wrapped_key; - EXPECT_EQ(NO_ERROR, decryptor_->GetProvisioningRequest( - cert_type, cert_authority, kDefaultCdmIdentifier, - kEmptyServiceCertificate, &key_msg_, - &provisioning_server)); + EXPECT_EQ(NO_ERROR, + decryptor_->GetProvisioningRequest( + cert_type, cert_authority, kDefaultCdmIdentifier, + kEmptyServiceCertificate, &key_msg_, &provisioning_server)); EXPECT_EQ(provisioning_server, config_.provisioning_server()); std::string response = GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); - EXPECT_EQ(NO_ERROR, decryptor_->HandleProvisioningResponse( - kDefaultCdmIdentifier, response, &cert, - &wrapped_key)); + EXPECT_EQ(NO_ERROR, + decryptor_->HandleProvisioningResponse( + kDefaultCdmIdentifier, response, &cert, &wrapped_key)); EXPECT_EQ(NO_ERROR, decryptor_->OpenSession( config_.key_system(), &property_set_L3, kDefaultCdmIdentifier, nullptr, &session_id_L3)); @@ -2444,17 +2490,16 @@ TEST_F(WvCdmRequestLicenseTest, ForceL3Test) { std::string provisioning_server; CdmCertificateType cert_type = kCertificateWidevine; std::string cert_authority, cert, wrapped_key; - EXPECT_EQ(NO_ERROR, decryptor_->GetProvisioningRequest( - cert_type, cert_authority, kDefaultCdmIdentifier, - kEmptyServiceCertificate, &key_msg_, - &provisioning_server)); + EXPECT_EQ(NO_ERROR, + decryptor_->GetProvisioningRequest( + cert_type, cert_authority, kDefaultCdmIdentifier, + kEmptyServiceCertificate, &key_msg_, &provisioning_server)); EXPECT_EQ(provisioning_server, config_.provisioning_server()); - std::string response = - GetCertRequestResponse(config_.provisioning_server()); + std::string response = GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); - EXPECT_EQ(NO_ERROR, decryptor_->HandleProvisioningResponse( - kDefaultCdmIdentifier, response, &cert, - &wrapped_key)); + EXPECT_EQ(NO_ERROR, + decryptor_->HandleProvisioningResponse( + kDefaultCdmIdentifier, response, &cert, &wrapped_key)); EXPECT_EQ(NO_ERROR, decryptor_->OpenSession( config_.key_system(), &property_set, @@ -2472,7 +2517,8 @@ TEST_F(WvCdmRequestLicenseTest, PrivacyModeTest) { kDefaultCdmIdentifier, nullptr, &session_id_); GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming); - std::string resp = GetKeyRequestResponse(config_.license_server(), config_.client_auth()); + std::string resp = + GetKeyRequestResponse(config_.license_server(), config_.client_auth()); EXPECT_EQ(decryptor_->AddKey(session_id_, resp, &key_set_id_), wvcdm::NEED_KEY); const std::string empty_init_data; @@ -2488,7 +2534,8 @@ TEST_F(WvCdmRequestLicenseTest, PrivacyModeWithServiceCertificateTest) { property_set.set_use_privacy_mode(true); property_set.set_service_certificate(config_.license_service_certificate()); - // TODO: pass config_.service_certificate() into CdmEngine::SetServiceCertificate() + // TODO: pass config_.service_certificate() into + // CdmEngine::SetServiceCertificate() decryptor_->OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, nullptr, &session_id_); GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming); @@ -2596,7 +2643,7 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseOfflineKeySessionUsageDisabledTest) { std::string key_id; std::string client_auth; GetOfflineConfiguration(&key_id, &client_auth); - key_id[key_id.size()-1] = '1'; + key_id[key_id.size() - 1] = '1'; decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier, nullptr, &session_id_); @@ -2706,17 +2753,17 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryL3OfflineKeyTest) { std::string provisioning_server; CdmCertificateType cert_type = kCertificateWidevine; std::string cert_authority, cert, wrapped_key; - EXPECT_EQ(NO_ERROR, decryptor_->GetProvisioningRequest( - cert_type, cert_authority, kDefaultCdmIdentifier, - kEmptyServiceCertificate, - &key_msg_, &provisioning_server)); + EXPECT_EQ(NO_ERROR, + decryptor_->GetProvisioningRequest( + cert_type, cert_authority, kDefaultCdmIdentifier, + kEmptyServiceCertificate, &key_msg_, &provisioning_server)); EXPECT_EQ(provisioning_server, config_.provisioning_server()); std::string response = GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); - EXPECT_EQ(NO_ERROR, decryptor_->HandleProvisioningResponse( - kDefaultCdmIdentifier, response, &cert, - &wrapped_key)); + EXPECT_EQ(NO_ERROR, + decryptor_->HandleProvisioningResponse( + kDefaultCdmIdentifier, response, &cert, &wrapped_key)); EXPECT_EQ(NO_ERROR, decryptor_->OpenSession( config_.key_system(), &property_set, kDefaultCdmIdentifier, nullptr, &session_id_)); @@ -2772,7 +2819,7 @@ TEST_F(WvCdmRequestLicenseTest, std::string key_id; std::string client_auth; GetOfflineConfiguration(&key_id, &client_auth); - key_id[key_id.size()-1] = '1'; + key_id[key_id.size() - 1] = '1'; CdmResponseType sts = decryptor_->OpenSession(config_.key_system(), &property_set, @@ -2784,15 +2831,15 @@ TEST_F(WvCdmRequestLicenseTest, std::string cert_authority, cert, wrapped_key; EXPECT_EQ(NO_ERROR, decryptor_->GetProvisioningRequest( cert_type, cert_authority, kDefaultCdmIdentifier, - kEmptyServiceCertificate, - &key_msg_, &provisioning_server_url)); + kEmptyServiceCertificate, &key_msg_, + &provisioning_server_url)); EXPECT_EQ(provisioning_server_url, config_.provisioning_server()); std::string response = GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); - EXPECT_EQ(NO_ERROR, decryptor_->HandleProvisioningResponse( - kDefaultCdmIdentifier, response, &cert, - &wrapped_key)); + EXPECT_EQ(NO_ERROR, + decryptor_->HandleProvisioningResponse( + kDefaultCdmIdentifier, response, &cert, &wrapped_key)); EXPECT_EQ(NO_ERROR, decryptor_->OpenSession( config_.key_system(), &property_set, kDefaultCdmIdentifier, nullptr, &session_id_)); @@ -2975,9 +3022,8 @@ TEST_F(WvCdmRequestLicenseTest, OfflineLicenseRenewalAndRelease) { decryption_parameters.is_secure = data->is_secure; decryption_parameters.subsample_flags = data->subsample_flags; - EXPECT_EQ(NO_ERROR, - decryptor_->Decrypt(session_id_, data->validate_key_id, - decryption_parameters)); + EXPECT_EQ(NO_ERROR, decryptor_->Decrypt(session_id_, data->validate_key_id, + decryption_parameters)); EXPECT_TRUE(std::equal(data->decrypt_data.begin(), data->decrypt_data.end(), decrypt_buffer.begin())); @@ -3040,24 +3086,23 @@ TEST_P(WvCdmEntitlementTest, EntitlementWithKeyRotation) { VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); // Verify that we can decrypt a subsample - ASSERT_TRUE(VerifyDecryption(session_id_, - *(config->sub_sample_with_initial_keys))); + ASSERT_TRUE( + VerifyDecryption(session_id_, *(config->sub_sample_with_initial_keys))); // Key rotation - ASSERT_TRUE(KeyRotationRequest(kLicenseTypeStreaming, - config->key_rotation_pssh)); + ASSERT_TRUE( + KeyRotationRequest(kLicenseTypeStreaming, config->key_rotation_pssh)); // Verify that we can decrypt a subsample - ASSERT_TRUE(VerifyDecryption(session_id_, - *(config->sub_sample_with_rotated_keys))); + ASSERT_TRUE( + VerifyDecryption(session_id_, *(config->sub_sample_with_rotated_keys))); decryptor_->CloseSession(session_id_); } -INSTANTIATE_TEST_CASE_P( - Cdm, WvCdmEntitlementTest, - ::testing::Range(&kEntitlementTestConfiguration[0], - &kEntitlementTestConfiguration[2])); +INSTANTIATE_TEST_CASE_P(Cdm, WvCdmEntitlementTest, + ::testing::Range(&kEntitlementTestConfiguration[0], + &kEntitlementTestConfiguration[2])); TEST_F(WvCdmRequestLicenseTest, RemoveKeys) { ASSERT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), nullptr, @@ -3076,18 +3121,16 @@ TEST_F(WvCdmRequestLicenseTest, RemoveKeys) { decryption_parameters.subsample_flags = data->subsample_flags; // Verify that we can decrypt a subsample - EXPECT_EQ(NO_ERROR, - decryptor_->Decrypt(session_id_, data->validate_key_id, - decryption_parameters)); + EXPECT_EQ(NO_ERROR, decryptor_->Decrypt(session_id_, data->validate_key_id, + decryption_parameters)); EXPECT_TRUE(std::equal(data->decrypt_data.begin(), data->decrypt_data.end(), decrypt_buffer.begin())); // Verify that decryption of a subsample fails after the keys are removed ASSERT_EQ(NO_ERROR, decryptor_->RemoveKeys(session_id_)); decrypt_buffer.assign(data->encrypt_data.size(), 0); - EXPECT_EQ(NEED_KEY, - decryptor_->Decrypt(session_id_, data->validate_key_id, - decryption_parameters)); + EXPECT_EQ(NEED_KEY, decryptor_->Decrypt(session_id_, data->validate_key_id, + decryption_parameters)); ASSERT_EQ(NO_ERROR, decryptor_->CloseSession(session_id_)); } @@ -3127,13 +3170,15 @@ TEST_P(WvCdmStreamingLicenseRenewalTest, WithClientId) { property_set.set_service_certificate( config_.license_service_certificate()); } - // TODO: pass config_.service_certificate() into CdmEngine::SetServiceCertificate() + // TODO: pass config_.service_certificate() into + // CdmEngine::SetServiceCertificate() decryptor_->OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, nullptr, &session_id_); GenerateKeyRequest(key_id, app_parameters, kLicenseTypeStreaming, &property_set); if (config->enable_privacy_mode && !config->specify_service_certificate) { - std::string resp = GetKeyRequestResponse(config_.license_server(), config_.client_auth()); + std::string resp = + GetKeyRequestResponse(config_.license_server(), config_.client_auth()); EXPECT_EQ(decryptor_->AddKey(session_id_, resp, &key_set_id_), wvcdm::NEED_KEY); GenerateKeyRequest(key_id, kLicenseTypeStreaming); @@ -3256,21 +3301,24 @@ TEST_P(WvCdmOfflineLicenseReleaseTest, WithClientId) { if (config->enable_privacy_mode) { property_set.set_use_privacy_mode(true); if (config->specify_service_certificate) - property_set.set_service_certificate(config_.license_service_certificate()); + property_set.set_service_certificate( + config_.license_service_certificate()); } - // TODO: pass config_.service_certificate() into CdmEngine::SetServiceCertificate() + // TODO: pass config_.service_certificate() into + // CdmEngine::SetServiceCertificate() decryptor_->OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, nullptr, &session_id_); GenerateKeyRequest(key_id, app_parameters, kLicenseTypeOffline, nullptr); if (config->enable_privacy_mode && !config->specify_service_certificate) { - std::string resp = GetKeyRequestResponse(config_.license_server(), - client_auth); + std::string resp = + GetKeyRequestResponse(config_.license_server(), client_auth); EXPECT_EQ(decryptor_->AddKey(session_id_, resp, &key_set_id_), wvcdm::NEED_KEY); GenerateKeyRequest(key_id, kLicenseTypeOffline); } std::string key_response; - VerifyKeyRequestResponse(config_.license_server(), client_auth, false, &key_response); + VerifyKeyRequestResponse(config_.license_server(), client_auth, false, + &key_response); // Validate signed license SignedMessage signed_message; @@ -3359,10 +3407,9 @@ INSTANTIATE_TEST_CASE_P( ::testing::Range(&offline_release_client_id_test_configuration[0], &offline_release_client_id_test_configuration[4])); -class WvCdmUsageTest - : public WvCdmRequestLicenseTest, - public ::testing::WithParamInterface< - RenewWithClientIdTestConfiguration*> {}; +class WvCdmUsageTest : public WvCdmRequestLicenseTest, + public ::testing::WithParamInterface< + RenewWithClientIdTestConfiguration*> {}; TEST_P(WvCdmUsageTest, WithClientId) { Unprovision(); @@ -3375,8 +3422,7 @@ TEST_P(WvCdmUsageTest, WithClientId) { EXPECT_TRUE(handle.Init(security_level)); std::vector psts; EXPECT_TRUE(handle.DeleteAllUsageInfoForApp( - DeviceFiles::GetUsageInfoFileName(app_id), - &psts)); + DeviceFiles::GetUsageInfoFileName(app_id), &psts)); RenewWithClientIdTestConfiguration* config = GetParam(); std::string key_id; @@ -3405,8 +3451,8 @@ TEST_P(WvCdmUsageTest, WithClientId) { &property_set); std::string key_response; - VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), true, - &key_response); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), + true, &key_response); // Validate signed license SignedMessage signed_message; @@ -3444,8 +3490,8 @@ TEST_P(WvCdmUsageTest, WithClientId) { CdmUsageInfo usage_info; CdmUsageInfoReleaseMessage release_msg; - CdmResponseType status = decryptor_->GetUsageInfo( - app_id, kDefaultCdmIdentifier, &usage_info); + CdmResponseType status = + decryptor_->GetUsageInfo(app_id, kDefaultCdmIdentifier, &usage_info); EXPECT_EQ(KEY_MESSAGE, status); ASSERT_FALSE(usage_info.empty()); @@ -3476,10 +3522,10 @@ TEST_P(WvCdmUsageTest, WithClientId) { 0u, license_renewal.encrypted_client_id().encrypted_client_id().size()); } - release_msg = - GetUsageInfoResponse(config_.license_server(), config_.client_auth(), usage_info[0]); - EXPECT_EQ(NO_ERROR, decryptor_->ReleaseUsageInfo(release_msg, - kDefaultCdmIdentifier)); + release_msg = GetUsageInfoResponse(config_.license_server(), + config_.client_auth(), usage_info[0]); + EXPECT_EQ(NO_ERROR, + decryptor_->ReleaseUsageInfo(release_msg, kDefaultCdmIdentifier)); } INSTANTIATE_TEST_CASE_P( @@ -3498,8 +3544,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfoRetryTest) { EXPECT_TRUE(handle.Init(security_level)); std::vector psts; EXPECT_TRUE(handle.DeleteAllUsageInfoForApp( - DeviceFiles::GetUsageInfoFileName(app_id), - &psts)); + DeviceFiles::GetUsageInfoFileName(app_id), &psts)); SubSampleInfo* data = &usage_info_sub_samples_icp[0]; decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier, @@ -3511,7 +3556,8 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfoRetryTest) { "747265616d696e675f636c697033"); GenerateKeyRequest(key_id, kLicenseTypeStreaming, nullptr); - VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); + VerifyUsageKeyRequestResponse(config_.license_server(), + config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -3529,8 +3575,8 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfoRetryTest) { CdmUsageInfo usage_info; CdmUsageInfoReleaseMessage release_msg; - CdmResponseType status = decryptor_->GetUsageInfo( - app_id, kDefaultCdmIdentifier, &usage_info); + CdmResponseType status = + decryptor_->GetUsageInfo(app_id, kDefaultCdmIdentifier, &usage_info); EXPECT_EQ(usage_info.empty() ? NO_ERROR : KEY_MESSAGE, status); // Discard and retry to verify usage reports can be generated multiple times @@ -3540,17 +3586,16 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfoRetryTest) { int error_count = 0; while (usage_info.size() > 0) { for (size_t i = 0; i < usage_info.size(); ++i) { - release_msg = - GetUsageInfoResponse(config_.license_server(), config_.client_auth(), - usage_info[i]); + release_msg = GetUsageInfoResponse(config_.license_server(), + config_.client_auth(), usage_info[i]); EXPECT_EQ(NO_ERROR, decryptor_->ReleaseUsageInfo(release_msg, kDefaultCdmIdentifier)) << i << "/" << usage_info.size() << " (err " << (error_count++) << ")" << release_msg; } ASSERT_LE(error_count, 100); // Give up after 100 failures. - status = decryptor_->GetUsageInfo( - app_id, kDefaultCdmIdentifier, &usage_info); + status = + decryptor_->GetUsageInfo(app_id, kDefaultCdmIdentifier, &usage_info); switch (status) { case KEY_MESSAGE: EXPECT_FALSE(usage_info.empty()); @@ -3576,8 +3621,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfo_ReleaseThreeRecords) { EXPECT_TRUE(handle.Init(security_level)); std::vector psts; EXPECT_TRUE(handle.DeleteAllUsageInfoForApp( - DeviceFiles::GetUsageInfoFileName(app_id), - &psts)); + DeviceFiles::GetUsageInfoFileName(app_id), &psts)); std::string session_id_clip3, session_id_clip4, session_id_clip7; @@ -3590,8 +3634,8 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfo_ReleaseThreeRecords) { VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); - EXPECT_TRUE(VerifyDecryption(session_id_clip3, - usage_info_sub_samples_icp[0])); + EXPECT_TRUE( + VerifyDecryption(session_id_clip3, usage_info_sub_samples_icp[0])); // Open session for streaming_clip4 and verify decryption is successful decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier, @@ -3602,8 +3646,8 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfo_ReleaseThreeRecords) { VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); - EXPECT_TRUE(VerifyDecryption(session_id_clip4, - usage_info_sub_samples_icp[1])); + EXPECT_TRUE( + VerifyDecryption(session_id_clip4, usage_info_sub_samples_icp[1])); // Open session for streaming_clip7 and verify decryption is successful decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier, @@ -3614,17 +3658,17 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfo_ReleaseThreeRecords) { VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); - EXPECT_TRUE(VerifyDecryption(session_id_clip7, - usage_info_sub_samples_icp[4])); + EXPECT_TRUE( + VerifyDecryption(session_id_clip7, usage_info_sub_samples_icp[4])); // Close session for streaming_clip4 and release usage information decryptor_->CloseSession(session_id_clip4); CdmUsageInfo usage_info; CdmUsageInfoReleaseMessage release_msg; - CdmResponseType status = decryptor_->GetUsageInfo( - app_id, kProviderSessionTokenStreamingClip4, kDefaultCdmIdentifier, - &usage_info); + CdmResponseType status = + decryptor_->GetUsageInfo(app_id, kProviderSessionTokenStreamingClip4, + kDefaultCdmIdentifier, &usage_info); EXPECT_EQ(KEY_MESSAGE, status); EXPECT_EQ(1, usage_info.size()); release_msg = GetUsageInfoResponse(config_.license_server(), @@ -3680,8 +3724,7 @@ TEST_P(WvCdmUsageInfoTest, UsageInfo) { EXPECT_TRUE(handle.Init(security_level)); std::vector psts; EXPECT_TRUE(handle.DeleteAllUsageInfoForApp( - DeviceFiles::GetUsageInfoFileName(usage_info_data->app_id), - &psts)); + DeviceFiles::GetUsageInfoFileName(usage_info_data->app_id), &psts)); for (size_t i = 0; i < usage_info_data->usage_info; ++i) { SubSampleInfo* data = usage_info_data->sub_sample + i; @@ -3700,9 +3743,11 @@ TEST_P(WvCdmUsageInfoTest, UsageInfo) { // TODO(rfrias): streaming_clip6 is a streaming license without a pst if (ch == '6') - VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), false); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), + false); else - VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); + VerifyUsageKeyRequestResponse(config_.license_server(), + config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -3721,17 +3766,16 @@ TEST_P(WvCdmUsageInfoTest, UsageInfo) { CdmUsageInfo usage_info; CdmUsageInfoReleaseMessage release_msg; - CdmResponseType status = - decryptor_->GetUsageInfo(usage_info_data->app_id, kDefaultCdmIdentifier, - &usage_info); + CdmResponseType status = decryptor_->GetUsageInfo( + usage_info_data->app_id, kDefaultCdmIdentifier, &usage_info); EXPECT_EQ(usage_info.empty() ? NO_ERROR : KEY_MESSAGE, status); int error_count = 0; while (usage_info.size() > 0) { for (size_t i = 0; i < usage_info.size(); ++i) { - release_msg = - GetUsageInfoResponse(config_.license_server(), config_.client_auth(), usage_info[i]); - EXPECT_EQ(NO_ERROR, - decryptor_->ReleaseUsageInfo(release_msg, kDefaultCdmIdentifier)) + release_msg = GetUsageInfoResponse(config_.license_server(), + config_.client_auth(), usage_info[i]); + EXPECT_EQ(NO_ERROR, decryptor_->ReleaseUsageInfo(release_msg, + kDefaultCdmIdentifier)) << i << "/" << usage_info.size() << " (err " << (error_count++) << ")" << release_msg; } @@ -3767,7 +3811,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveAllTest) { EXPECT_TRUE(handle.Init(security_level)); std::vector psts; EXPECT_TRUE(handle.DeleteAllUsageInfoForApp( - DeviceFiles::GetUsageInfoFileName(""), &psts)); + DeviceFiles::GetUsageInfoFileName(""), &psts)); for (size_t i = 0; i < ArraySize(usage_info_sub_samples_icp); ++i) { SubSampleInfo* data = usage_info_sub_samples_icp + i; @@ -3787,9 +3831,11 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveAllTest) { // TODO(rfrias): streaming_clip6 is a streaming license without a pst if (ch == '6') - VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), false); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), + false); else - VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); + VerifyUsageKeyRequestResponse(config_.license_server(), + config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -3807,46 +3853,34 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveAllTest) { } CdmUsageInfo usage_info; - EXPECT_EQ( - KEY_MESSAGE, - decryptor_->GetUsageInfo(app_id_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(KEY_MESSAGE, decryptor_->GetUsageInfo( + app_id_empty, kDefaultCdmIdentifier, &usage_info)); EXPECT_TRUE(usage_info.size() > 0); - EXPECT_EQ( - KEY_MESSAGE, - decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(KEY_MESSAGE, + decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, + &usage_info)); EXPECT_TRUE(usage_info.size() > 0); + EXPECT_EQ(NO_ERROR, decryptor_->RemoveAllUsageInfo(app_id_not_empty, + kDefaultCdmIdentifier)); - EXPECT_EQ( - NO_ERROR, - decryptor_->RemoveAllUsageInfo(app_id_not_empty, kDefaultCdmIdentifier)); - - EXPECT_EQ( - NO_ERROR, - decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(NO_ERROR, + decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, + &usage_info)); EXPECT_TRUE(usage_info.empty()); - EXPECT_EQ( - KEY_MESSAGE, - decryptor_->GetUsageInfo(app_id_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(KEY_MESSAGE, decryptor_->GetUsageInfo( + app_id_empty, kDefaultCdmIdentifier, &usage_info)); EXPECT_TRUE(usage_info.size() > 0); - EXPECT_EQ( - NO_ERROR, - decryptor_->RemoveAllUsageInfo(app_id_empty, kDefaultCdmIdentifier)); + EXPECT_EQ(NO_ERROR, decryptor_->RemoveAllUsageInfo(app_id_empty, + kDefaultCdmIdentifier)); - EXPECT_EQ( - NO_ERROR, - decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(NO_ERROR, + decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, + &usage_info)); EXPECT_TRUE(usage_info.empty()); - EXPECT_EQ( - NO_ERROR, - decryptor_->GetUsageInfo(app_id_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(NO_ERROR, decryptor_->GetUsageInfo( + app_id_empty, kDefaultCdmIdentifier, &usage_info)); EXPECT_TRUE(usage_info.empty()); } @@ -3865,7 +3899,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest) { EXPECT_TRUE(handle.Init(security_level)); std::vector psts; EXPECT_TRUE(handle.DeleteAllUsageInfoForApp( - DeviceFiles::GetUsageInfoFileName(""), &psts)); + DeviceFiles::GetUsageInfoFileName(""), &psts)); for (size_t i = 0; i < ArraySize(usage_info_sub_samples_icp); ++i) { SubSampleInfo* data = usage_info_sub_samples_icp + i; @@ -3885,9 +3919,11 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest) { // TODO(rfrias): streaming_clip6 is a streaming license without a pst if (ch == '6') - VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), false); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), + false); else - VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); + VerifyUsageKeyRequestResponse(config_.license_server(), + config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -3905,15 +3941,12 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest) { } CdmUsageInfo usage_info; - EXPECT_EQ( - KEY_MESSAGE, - decryptor_->GetUsageInfo(app_id_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(KEY_MESSAGE, decryptor_->GetUsageInfo( + app_id_empty, kDefaultCdmIdentifier, &usage_info)); EXPECT_TRUE(usage_info.size() > 0); - EXPECT_EQ( - KEY_MESSAGE, - decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(KEY_MESSAGE, + decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, + &usage_info)); EXPECT_TRUE(usage_info.size() > 0); // Read in usage info file @@ -3925,9 +3958,8 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest) { ssize_t file_size = file_system.FileSize(usage_info_not_empty_app_id_file_name); EXPECT_LT(4, file_size); - std::unique_ptr file = - file_system.Open(usage_info_not_empty_app_id_file_name, - FileSystem::kReadOnly); + std::unique_ptr file = file_system.Open( + usage_info_not_empty_app_id_file_name, FileSystem::kReadOnly); EXPECT_TRUE(nullptr != file); std::string file_data; file_data.resize(file_size); @@ -3936,26 +3968,22 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest) { // Corrupt the hash of the usage info file with non-empty app id and write // it back out - memset(&file_data[0]+bytes-4, 0, 4); + memset(&file_data[0] + bytes - 4, 0, 4); file = file_system.Open(usage_info_not_empty_app_id_file_name, FileSystem::kCreate | FileSystem::kTruncate); EXPECT_TRUE(nullptr != file); bytes = file->Write(file_data.data(), file_data.size()); EXPECT_EQ(file_size, bytes); - EXPECT_EQ( - NO_ERROR, - decryptor_->RemoveAllUsageInfo(app_id_not_empty, kDefaultCdmIdentifier)); + EXPECT_EQ(NO_ERROR, decryptor_->RemoveAllUsageInfo(app_id_not_empty, + kDefaultCdmIdentifier)); - EXPECT_EQ( - NO_ERROR, - decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(NO_ERROR, + decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, + &usage_info)); EXPECT_TRUE(usage_info.empty()); - EXPECT_EQ( - KEY_MESSAGE, - decryptor_->GetUsageInfo(app_id_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(KEY_MESSAGE, decryptor_->GetUsageInfo( + app_id_empty, kDefaultCdmIdentifier, &usage_info)); EXPECT_TRUE(usage_info.size() > 0); // Read in usage info file @@ -3973,26 +4001,22 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest) { // Corrupt the hash of the usage info file with empty app id and write it // back out - memset(&file_data[0]+bytes-4, 0, 4); + memset(&file_data[0] + bytes - 4, 0, 4); file = file_system.Open(usage_info_empty_app_id_file_name, FileSystem::kCreate | FileSystem::kTruncate); EXPECT_TRUE(nullptr != file); bytes = file->Write(file_data.data(), file_data.size()); EXPECT_EQ(file_size, bytes); - EXPECT_EQ( - NO_ERROR, - decryptor_->RemoveAllUsageInfo(app_id_empty, kDefaultCdmIdentifier)); + EXPECT_EQ(NO_ERROR, decryptor_->RemoveAllUsageInfo(app_id_empty, + kDefaultCdmIdentifier)); - EXPECT_EQ( - NO_ERROR, - decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(NO_ERROR, + decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, + &usage_info)); EXPECT_TRUE(usage_info.empty()); - EXPECT_EQ( - NO_ERROR, - decryptor_->GetUsageInfo(app_id_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(NO_ERROR, decryptor_->GetUsageInfo( + app_id_empty, kDefaultCdmIdentifier, &usage_info)); EXPECT_TRUE(usage_info.empty()); } @@ -4011,7 +4035,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) { EXPECT_TRUE(handle.Init(security_level)); std::vector psts; EXPECT_TRUE(handle.DeleteAllUsageInfoForApp( - DeviceFiles::GetUsageInfoFileName(""), &psts)); + DeviceFiles::GetUsageInfoFileName(""), &psts)); for (size_t i = 0; i < ArraySize(usage_info_sub_samples_icp); ++i) { SubSampleInfo* data = usage_info_sub_samples_icp + i; @@ -4031,9 +4055,11 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) { // TODO(rfrias): streaming_clip6 is a streaming license without a pst if (ch == '6') - VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), false); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), + false); else - VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); + VerifyUsageKeyRequestResponse(config_.license_server(), + config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -4051,15 +4077,12 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) { } CdmUsageInfo usage_info; - EXPECT_EQ( - KEY_MESSAGE, - decryptor_->GetUsageInfo(app_id_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(KEY_MESSAGE, decryptor_->GetUsageInfo( + app_id_empty, kDefaultCdmIdentifier, &usage_info)); EXPECT_TRUE(usage_info.size() > 0); - EXPECT_EQ( - KEY_MESSAGE, - decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(KEY_MESSAGE, + decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, + &usage_info)); EXPECT_TRUE(usage_info.size() > 0); // Read in usage info file @@ -4071,9 +4094,8 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) { ssize_t file_size = file_system.FileSize(usage_info_not_empty_app_id_file_name); EXPECT_LT(4, file_size); - std::unique_ptr file = - file_system.Open(usage_info_not_empty_app_id_file_name, - FileSystem::kReadOnly); + std::unique_ptr file = file_system.Open( + usage_info_not_empty_app_id_file_name, FileSystem::kReadOnly); EXPECT_TRUE(nullptr != file); std::string file_data; file_data.resize(file_size); @@ -4089,7 +4111,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) { // Corrupt the protobuf key field of the hash of the usage info file // with non-empty app id and write it back out - file_data[pos-1] = 0xff; + file_data[pos - 1] = 0xff; file = file_system.Open(usage_info_not_empty_app_id_file_name, FileSystem::kCreate | FileSystem::kTruncate); @@ -4097,19 +4119,15 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) { bytes = file->Write(file_data.data(), file_data.size()); EXPECT_EQ(file_size, bytes); - EXPECT_EQ( - NO_ERROR, - decryptor_->RemoveAllUsageInfo(app_id_not_empty, kDefaultCdmIdentifier)); + EXPECT_EQ(NO_ERROR, decryptor_->RemoveAllUsageInfo(app_id_not_empty, + kDefaultCdmIdentifier)); - EXPECT_EQ( - NO_ERROR, - decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(NO_ERROR, + decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, + &usage_info)); EXPECT_TRUE(usage_info.empty()); - EXPECT_EQ( - KEY_MESSAGE, - decryptor_->GetUsageInfo(app_id_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(KEY_MESSAGE, decryptor_->GetUsageInfo( + app_id_empty, kDefaultCdmIdentifier, &usage_info)); EXPECT_TRUE(usage_info.size() > 0); // Read in usage info file @@ -4132,7 +4150,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) { // Corrupt the protobuf key field of the hash of the usage info file // with empty app id and write it back out - file_data[pos-1] = 0xff; + file_data[pos - 1] = 0xff; file = file_system.Open(usage_info_empty_app_id_file_name, FileSystem::kCreate | FileSystem::kTruncate); @@ -4140,19 +4158,15 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) { bytes = file->Write(file_data.data(), file_data.size()); EXPECT_EQ(file_size, bytes); - EXPECT_EQ( - NO_ERROR, - decryptor_->RemoveAllUsageInfo(app_id_empty, kDefaultCdmIdentifier)); + EXPECT_EQ(NO_ERROR, decryptor_->RemoveAllUsageInfo(app_id_empty, + kDefaultCdmIdentifier)); - EXPECT_EQ( - NO_ERROR, - decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(NO_ERROR, + decryptor_->GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier, + &usage_info)); EXPECT_TRUE(usage_info.empty()); - EXPECT_EQ( - NO_ERROR, - decryptor_->GetUsageInfo(app_id_empty, kDefaultCdmIdentifier, - &usage_info)); + EXPECT_EQ(NO_ERROR, decryptor_->GetUsageInfo( + app_id_empty, kDefaultCdmIdentifier, &usage_info)); EXPECT_TRUE(usage_info.empty()); } @@ -4170,13 +4184,12 @@ TEST_F(WvCdmRequestLicenseTest, GetSecureStopIdsTest) { EXPECT_TRUE(handle.Init(security_level)); std::vector psts; EXPECT_TRUE(handle.DeleteAllUsageInfoForApp( - DeviceFiles::GetUsageInfoFileName(""), &psts)); + DeviceFiles::GetUsageInfoFileName(""), &psts)); std::vector retrieved_secure_stop_ids; - EXPECT_EQ( - NO_ERROR, - decryptor_->GetSecureStopIds(app_id_empty, kDefaultCdmIdentifier, - &retrieved_secure_stop_ids)); + EXPECT_EQ(NO_ERROR, + decryptor_->GetSecureStopIds(app_id_empty, kDefaultCdmIdentifier, + &retrieved_secure_stop_ids)); EXPECT_TRUE(retrieved_secure_stop_ids.empty()); // First fetch licenses for the default app @@ -4189,7 +4202,8 @@ TEST_F(WvCdmRequestLicenseTest, GetSecureStopIdsTest) { GenerateKeyRequest(kUsageLicenseTestVector1[i].pssh, kLicenseTypeStreaming, &property_set); - VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); + VerifyUsageKeyRequestResponse(config_.license_server(), + config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -4217,20 +4231,17 @@ TEST_F(WvCdmRequestLicenseTest, GetSecureStopIdsTest) { kUsageLicenseTestVector1[i].provider_session_token); } - EXPECT_EQ( - NO_ERROR, - decryptor_->GetSecureStopIds(app_id_empty, kDefaultCdmIdentifier, - &retrieved_secure_stop_ids)); + EXPECT_EQ(NO_ERROR, + decryptor_->GetSecureStopIds(app_id_empty, kDefaultCdmIdentifier, + &retrieved_secure_stop_ids)); EXPECT_EQ(ArraySize(kUsageLicenseTestVector1), retrieved_secure_stop_ids.size()); EXPECT_THAT(retrieved_secure_stop_ids, - UnorderedElementsAreArray(expected_provider_session_tokens)); + UnorderedElementsAreArray(expected_provider_session_tokens)); - EXPECT_EQ( - NO_ERROR, - decryptor_->GetSecureStopIds(kExampleIdentifier.app_package_name, - kDefaultCdmIdentifier, - &retrieved_secure_stop_ids)); + EXPECT_EQ(NO_ERROR, decryptor_->GetSecureStopIds( + kExampleIdentifier.app_package_name, + kDefaultCdmIdentifier, &retrieved_secure_stop_ids)); EXPECT_TRUE(retrieved_secure_stop_ids.empty()); // Now fetch licenses for the other identifier @@ -4248,7 +4259,8 @@ TEST_F(WvCdmRequestLicenseTest, GetSecureStopIdsTest) { kLicenseTypeStreaming, kExampleIdentifier, &property_set); - VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); + VerifyUsageKeyRequestResponse(config_.license_server(), + config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -4267,15 +4279,13 @@ TEST_F(WvCdmRequestLicenseTest, GetSecureStopIdsTest) { // Verify that there are usage records for both the default and // non-default identifier. - EXPECT_EQ( - NO_ERROR, - decryptor_->GetSecureStopIds(kDefaultCdmIdentifier.app_package_name, - kDefaultCdmIdentifier, - &retrieved_secure_stop_ids)); + EXPECT_EQ(NO_ERROR, decryptor_->GetSecureStopIds( + kDefaultCdmIdentifier.app_package_name, + kDefaultCdmIdentifier, &retrieved_secure_stop_ids)); EXPECT_EQ(ArraySize(kUsageLicenseTestVector1), retrieved_secure_stop_ids.size()); EXPECT_THAT(retrieved_secure_stop_ids, - UnorderedElementsAreArray(expected_provider_session_tokens)); + UnorderedElementsAreArray(expected_provider_session_tokens)); retrieved_secure_stop_ids.clear(); expected_provider_session_tokens.clear(); @@ -4285,36 +4295,28 @@ TEST_F(WvCdmRequestLicenseTest, GetSecureStopIdsTest) { kUsageLicenseTestVector2[i].provider_session_token); } - EXPECT_EQ( - NO_ERROR, - decryptor_->GetSecureStopIds(kExampleIdentifier.app_package_name, - kExampleIdentifier, - &retrieved_secure_stop_ids)); + EXPECT_EQ(NO_ERROR, decryptor_->GetSecureStopIds( + kExampleIdentifier.app_package_name, + kExampleIdentifier, &retrieved_secure_stop_ids)); EXPECT_EQ(ArraySize(kUsageLicenseTestVector2), retrieved_secure_stop_ids.size()); EXPECT_THAT(retrieved_secure_stop_ids, - UnorderedElementsAreArray(expected_provider_session_tokens)); + UnorderedElementsAreArray(expected_provider_session_tokens)); - EXPECT_EQ( - NO_ERROR, - decryptor_->RemoveAllUsageInfo(kDefaultCdmIdentifier.app_package_name, - kDefaultCdmIdentifier)); - EXPECT_EQ( - NO_ERROR, - decryptor_->RemoveAllUsageInfo(kExampleIdentifier.app_package_name, - kExampleIdentifier)); + EXPECT_EQ(NO_ERROR, + decryptor_->RemoveAllUsageInfo( + kDefaultCdmIdentifier.app_package_name, kDefaultCdmIdentifier)); + EXPECT_EQ(NO_ERROR, + decryptor_->RemoveAllUsageInfo(kExampleIdentifier.app_package_name, + kExampleIdentifier)); - EXPECT_EQ( - NO_ERROR, - decryptor_->GetSecureStopIds(kDefaultCdmIdentifier.app_package_name, - kDefaultCdmIdentifier, - &retrieved_secure_stop_ids)); + EXPECT_EQ(NO_ERROR, decryptor_->GetSecureStopIds( + kDefaultCdmIdentifier.app_package_name, + kDefaultCdmIdentifier, &retrieved_secure_stop_ids)); EXPECT_TRUE(retrieved_secure_stop_ids.empty()); - EXPECT_EQ( - NO_ERROR, - decryptor_->GetSecureStopIds(kExampleIdentifier.app_package_name, - kExampleIdentifier, - &retrieved_secure_stop_ids)); + EXPECT_EQ(NO_ERROR, decryptor_->GetSecureStopIds( + kExampleIdentifier.app_package_name, + kExampleIdentifier, &retrieved_secure_stop_ids)); EXPECT_TRUE(retrieved_secure_stop_ids.empty()); } @@ -4332,7 +4334,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageRecoveryTest) { EXPECT_TRUE(handle.Init(security_level)); std::vector psts; EXPECT_TRUE(handle.DeleteAllUsageInfoForApp( - DeviceFiles::GetUsageInfoFileName(""), &psts)); + DeviceFiles::GetUsageInfoFileName(""), &psts)); // Fetch a usage license SubSampleInfo* data = kUsageLicenseTestVector1[0].sub_sample; @@ -4343,7 +4345,8 @@ TEST_F(WvCdmRequestLicenseTest, UsageRecoveryTest) { GenerateKeyRequest(kUsageLicenseTestVector1[0].pssh, kLicenseTypeStreaming, &property_set); - VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); + VerifyUsageKeyRequestResponse(config_.license_server(), + config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -4376,7 +4379,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageRecoveryTest) { EXPECT_EQ(file_size, bytes); // Corrupt the hash of the usage info file and write it back out - memset(&file_data[0]+bytes-4, 0, 4); + memset(&file_data[0] + bytes - 4, 0, 4); file = file_system.Open(usage_info_file_name, FileSystem::kCreate | FileSystem::kTruncate); EXPECT_TRUE(nullptr != file); @@ -4392,8 +4395,8 @@ TEST_F(WvCdmRequestLicenseTest, UsageRecoveryTest) { std::string response; VerifyKeyRequestResponse(wvcdm::STORE_USAGE_INFO_ERROR, - config_.license_server(), - config_.client_auth(), true, &response); + config_.license_server(), config_.client_auth(), + true, &response); decryptor_->CloseSession(session_id_); @@ -4403,7 +4406,8 @@ TEST_F(WvCdmRequestLicenseTest, UsageRecoveryTest) { GenerateKeyRequest(kUsageLicenseTestVector1[1].pssh, kLicenseTypeStreaming, &property_set); - VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); + VerifyUsageKeyRequestResponse(config_.license_server(), + config_.client_auth()); data = kUsageLicenseTestVector1[1].sub_sample; @@ -4440,7 +4444,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveSecureStopTest) { EXPECT_TRUE(handle.Init(security_level)); std::vector psts; EXPECT_TRUE(handle.DeleteAllUsageInfoForApp( - DeviceFiles::GetUsageInfoFileName(""), &psts)); + DeviceFiles::GetUsageInfoFileName(""), &psts)); // First fetch licenses for the default app for (size_t i = 0; i < ArraySize(kUsageLicenseTestVector1); ++i) { @@ -4452,7 +4456,8 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveSecureStopTest) { GenerateKeyRequest(kUsageLicenseTestVector1[i].pssh, kLicenseTypeStreaming, &property_set); - VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); + VerifyUsageKeyRequestResponse(config_.license_server(), + config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -4486,7 +4491,8 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveSecureStopTest) { kLicenseTypeStreaming, kExampleIdentifier, &property_set); - VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); + VerifyUsageKeyRequestResponse(config_.license_server(), + config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -4505,42 +4511,36 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveSecureStopTest) { // Release usage records for both the default and non-default identifier. std::vector secure_stop_ids; - EXPECT_EQ( - NO_ERROR, - decryptor_->GetSecureStopIds(kDefaultCdmIdentifier.app_package_name, - kDefaultCdmIdentifier, &secure_stop_ids)); + EXPECT_EQ(NO_ERROR, decryptor_->GetSecureStopIds( + kDefaultCdmIdentifier.app_package_name, + kDefaultCdmIdentifier, &secure_stop_ids)); EXPECT_EQ(ArraySize(kUsageLicenseTestVector1), secure_stop_ids.size()); for (size_t i = 0; i < ArraySize(kUsageLicenseTestVector1); ++i) { - EXPECT_EQ( - NO_ERROR, - decryptor_->RemoveUsageInfo(kDefaultCdmIdentifier.app_package_name, - kDefaultCdmIdentifier, secure_stop_ids[i])); + EXPECT_EQ(NO_ERROR, decryptor_->RemoveUsageInfo( + kDefaultCdmIdentifier.app_package_name, + kDefaultCdmIdentifier, secure_stop_ids[i])); } - EXPECT_EQ( - NO_ERROR, - decryptor_->GetSecureStopIds(kDefaultCdmIdentifier.app_package_name, - kDefaultCdmIdentifier, &secure_stop_ids)); + EXPECT_EQ(NO_ERROR, decryptor_->GetSecureStopIds( + kDefaultCdmIdentifier.app_package_name, + kDefaultCdmIdentifier, &secure_stop_ids)); EXPECT_TRUE(secure_stop_ids.empty()); - EXPECT_EQ( - NO_ERROR, - decryptor_->GetSecureStopIds(kExampleIdentifier.app_package_name, - kExampleIdentifier, &secure_stop_ids)); + EXPECT_EQ(NO_ERROR, + decryptor_->GetSecureStopIds(kExampleIdentifier.app_package_name, + kExampleIdentifier, &secure_stop_ids)); EXPECT_EQ(ArraySize(kUsageLicenseTestVector2), secure_stop_ids.size()); for (size_t i = 0; i < ArraySize(kUsageLicenseTestVector2); ++i) { - EXPECT_EQ( - NO_ERROR, - decryptor_->RemoveUsageInfo(kExampleIdentifier.app_package_name, - kExampleIdentifier, secure_stop_ids[i])); + EXPECT_EQ(NO_ERROR, decryptor_->RemoveUsageInfo( + kExampleIdentifier.app_package_name, + kExampleIdentifier, secure_stop_ids[i])); } - EXPECT_EQ( - NO_ERROR, - decryptor_->GetSecureStopIds(kExampleIdentifier.app_package_name, - kExampleIdentifier, &secure_stop_ids)); + EXPECT_EQ(NO_ERROR, + decryptor_->GetSecureStopIds(kExampleIdentifier.app_package_name, + kExampleIdentifier, &secure_stop_ids)); EXPECT_TRUE(secure_stop_ids.empty()); } @@ -4555,7 +4555,7 @@ TEST_F(WvCdmRequestLicenseTest, VerifyProviderClientToken) { std::string key_id; std::string client_auth; GetOfflineConfiguration(&key_id, &client_auth); - key_id[key_id.size()-1] = '5'; + key_id[key_id.size() - 1] = '5'; // Acquire license decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier, @@ -4656,10 +4656,9 @@ TEST_F(WvCdmRequestLicenseTest, VerifyProviderClientToken) { TEST_F(WvCdmRequestLicenseTest, QueryUnmodifiedSessionStatus) { // Test that the global value is returned when no properties are modifying it. std::string security_level; - ASSERT_EQ(wvcdm::NO_ERROR, - decryptor_->QueryStatus(kLevelDefault, - wvcdm::QUERY_KEY_SECURITY_LEVEL, - &security_level)); + ASSERT_EQ(wvcdm::NO_ERROR, decryptor_->QueryStatus( + kLevelDefault, wvcdm::QUERY_KEY_SECURITY_LEVEL, + &security_level)); EXPECT_EQ(GetSecurityLevel(nullptr), security_level); } @@ -4756,20 +4755,20 @@ TEST_F(WvCdmRequestLicenseTest, QueryStatus) { EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->QueryStatus( kLevelDefault, wvcdm::QUERY_KEY_CURRENT_HDCP_LEVEL, &value)); - EXPECT_TRUE( - value == QUERY_VALUE_HDCP_NONE || value == QUERY_VALUE_HDCP_V1 || - value == QUERY_VALUE_HDCP_V2_0 || value == QUERY_VALUE_HDCP_V2_1 || - value == QUERY_VALUE_HDCP_V2_2 || - value == QUERY_VALUE_HDCP_NO_DIGITAL_OUTPUT); + EXPECT_TRUE(value == QUERY_VALUE_HDCP_NONE || value == QUERY_VALUE_HDCP_V1 || + value == QUERY_VALUE_HDCP_V2_0 || + value == QUERY_VALUE_HDCP_V2_1 || + value == QUERY_VALUE_HDCP_V2_2 || + value == QUERY_VALUE_HDCP_NO_DIGITAL_OUTPUT); EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_MAX_HDCP_LEVEL, &value)); - EXPECT_TRUE( - value == QUERY_VALUE_HDCP_NONE || value == QUERY_VALUE_HDCP_V1 || - value == QUERY_VALUE_HDCP_V2_0 || value == QUERY_VALUE_HDCP_V2_1 || - value == QUERY_VALUE_HDCP_V2_2 || - value == QUERY_VALUE_HDCP_NO_DIGITAL_OUTPUT); + EXPECT_TRUE(value == QUERY_VALUE_HDCP_NONE || value == QUERY_VALUE_HDCP_V1 || + value == QUERY_VALUE_HDCP_V2_0 || + value == QUERY_VALUE_HDCP_V2_1 || + value == QUERY_VALUE_HDCP_V2_2 || + value == QUERY_VALUE_HDCP_NO_DIGITAL_OUTPUT); EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->QueryStatus(kLevelDefault, @@ -4778,9 +4777,8 @@ TEST_F(WvCdmRequestLicenseTest, QueryStatus) { EXPECT_EQ( wvcdm::NO_ERROR, - decryptor_->QueryStatus(kLevelDefault, - wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS, - &value)); + decryptor_->QueryStatus( + kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS, &value)); ss.clear(); ss.str(value); uint32_t open_sessions; @@ -4803,8 +4801,7 @@ TEST_F(WvCdmRequestLicenseTest, QueryStatus) { EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->QueryStatus( - kLevelDefault, wvcdm::QUERY_KEY_OEMCRYPTO_API_VERSION, - &value)); + kLevelDefault, wvcdm::QUERY_KEY_OEMCRYPTO_API_VERSION, &value)); ss.clear(); ss.str(value); uint32_t api_version; @@ -4832,10 +4829,10 @@ TEST_F(WvCdmRequestLicenseTest, QueryStatus) { << "resource rating tier: " << resource_rating_tier; } - EXPECT_EQ(wvcdm::NO_ERROR, - decryptor_->QueryStatus( - kLevelDefault, wvcdm::QUERY_KEY_OEMCRYPTO_BUILD_INFORMATION, - &value)); + EXPECT_EQ( + wvcdm::NO_ERROR, + decryptor_->QueryStatus( + kLevelDefault, wvcdm::QUERY_KEY_OEMCRYPTO_BUILD_INFORMATION, &value)); EXPECT_TRUE(!value.empty()); EXPECT_EQ(wvcdm::NO_ERROR, @@ -4852,10 +4849,9 @@ TEST_F(WvCdmRequestLicenseTest, QueryStatus) { TEST_F(WvCdmRequestLicenseTest, QueryStatusL3) { std::string value; - EXPECT_EQ( - wvcdm::NO_ERROR, - decryptor_->QueryStatus(kLevel3, wvcdm::QUERY_KEY_SECURITY_LEVEL, - &value)); + EXPECT_EQ(wvcdm::NO_ERROR, + decryptor_->QueryStatus(kLevel3, wvcdm::QUERY_KEY_SECURITY_LEVEL, + &value)); EXPECT_EQ(wvcdm::QUERY_VALUE_SECURITY_LEVEL_L3, value); EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->QueryStatus( @@ -4872,10 +4868,9 @@ TEST_F(WvCdmRequestLicenseTest, QueryStatusL3) { EXPECT_TRUE(ss.eof()); std::string default_security_level; - EXPECT_EQ( - wvcdm::NO_ERROR, - decryptor_->QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_SECURITY_LEVEL, - &default_security_level)); + EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->QueryStatus( + kLevelDefault, wvcdm::QUERY_KEY_SECURITY_LEVEL, + &default_security_level)); EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->QueryStatus( kLevel3, wvcdm::QUERY_KEY_SYSTEM_ID, &value)); @@ -4896,24 +4891,22 @@ TEST_F(WvCdmRequestLicenseTest, QueryStatusL3) { << "provisioning id size: " << value.size(); EXPECT_EQ(wvcdm::NO_ERROR, - decryptor_->QueryStatus(kLevel3, - wvcdm::QUERY_KEY_CURRENT_HDCP_LEVEL, - &value)); - EXPECT_TRUE( - value == QUERY_VALUE_HDCP_NONE || value == QUERY_VALUE_HDCP_V1 || - value == QUERY_VALUE_HDCP_V2_0 || value == QUERY_VALUE_HDCP_V2_1 || - value == QUERY_VALUE_HDCP_V2_2 || - value == QUERY_VALUE_HDCP_NO_DIGITAL_OUTPUT); + decryptor_->QueryStatus( + kLevel3, wvcdm::QUERY_KEY_CURRENT_HDCP_LEVEL, &value)); + EXPECT_TRUE(value == QUERY_VALUE_HDCP_NONE || value == QUERY_VALUE_HDCP_V1 || + value == QUERY_VALUE_HDCP_V2_0 || + value == QUERY_VALUE_HDCP_V2_1 || + value == QUERY_VALUE_HDCP_V2_2 || + value == QUERY_VALUE_HDCP_NO_DIGITAL_OUTPUT); - EXPECT_EQ( - wvcdm::NO_ERROR, - decryptor_->QueryStatus(kLevel3, wvcdm::QUERY_KEY_MAX_HDCP_LEVEL, - &value)); - EXPECT_TRUE( - value == QUERY_VALUE_HDCP_NONE || value == QUERY_VALUE_HDCP_V1 || - value == QUERY_VALUE_HDCP_V2_0 || value == QUERY_VALUE_HDCP_V2_1 || - value == QUERY_VALUE_HDCP_V2_2 || - value == QUERY_VALUE_HDCP_NO_DIGITAL_OUTPUT); + EXPECT_EQ(wvcdm::NO_ERROR, + decryptor_->QueryStatus(kLevel3, wvcdm::QUERY_KEY_MAX_HDCP_LEVEL, + &value)); + EXPECT_TRUE(value == QUERY_VALUE_HDCP_NONE || value == QUERY_VALUE_HDCP_V1 || + value == QUERY_VALUE_HDCP_V2_0 || + value == QUERY_VALUE_HDCP_V2_1 || + value == QUERY_VALUE_HDCP_V2_2 || + value == QUERY_VALUE_HDCP_NO_DIGITAL_OUTPUT); EXPECT_EQ( wvcdm::NO_ERROR, @@ -5344,16 +5337,15 @@ TEST_F(WvCdmRequestLicenseTest, DecryptionKeyExpiredTest) { TEST_F(WvCdmRequestLicenseTest, PlaybackExpiry) { StrictMock listener; - DecryptCallbackTester decrypt_callback( - decryptor_, &usage_info_sub_samples_icp[0]); + DecryptCallbackTester decrypt_callback(decryptor_, + &usage_info_sub_samples_icp[0]); decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier, &listener, &session_id_); - EXPECT_CALL( - listener, - OnSessionKeysChange( - session_id_, - AllOf(Each(Pair(_, kKeyStatusUsable)), Not(IsEmpty())), true)) + EXPECT_CALL(listener, + OnSessionKeysChange( + session_id_, + AllOf(Each(Pair(_, kKeyStatusUsable)), Not(IsEmpty())), true)) .WillOnce(Invoke(&decrypt_callback, &DecryptCallbackTester::Decrypt)); EXPECT_CALL(listener, OnExpirationUpdate(session_id_, _)); @@ -5363,8 +5355,8 @@ TEST_F(WvCdmRequestLicenseTest, PlaybackExpiry) { EXPECT_CALL( listener, OnSessionKeysChange( - session_id_, - AllOf(Each(Pair(_, kKeyStatusExpired)), Not(IsEmpty())), false)); + session_id_, AllOf(Each(Pair(_, kKeyStatusExpired)), Not(IsEmpty())), + false)); // Elapse time so that the key should now be considered expired. std::this_thread::sleep_for(kExpirationStreamingClip21PlaybackDurationTimeMs); @@ -5372,22 +5364,21 @@ TEST_F(WvCdmRequestLicenseTest, PlaybackExpiry) { TEST_F(WvCdmRequestLicenseTest, PlaybackExpiry_DecryptBeforeLicense) { StrictMock listener; - DecryptCallbackTester decrypt_callback( - decryptor_, &usage_info_sub_samples_icp[0]); + DecryptCallbackTester decrypt_callback(decryptor_, + &usage_info_sub_samples_icp[0]); decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier, &listener, &session_id_); // Decrypt before license is received is expected to fail but should // not start the playback timer - EXPECT_FALSE(VerifyDecryption(session_id_, - usage_info_sub_samples_icp[0], NEED_KEY)); + EXPECT_FALSE( + VerifyDecryption(session_id_, usage_info_sub_samples_icp[0], NEED_KEY)); std::this_thread::sleep_for(kExpirationStreamingClip21PlaybackDurationTimeMs); - EXPECT_CALL( - listener, - OnSessionKeysChange( - session_id_, - AllOf(Each(Pair(_, kKeyStatusUsable)), Not(IsEmpty())), true)) + EXPECT_CALL(listener, + OnSessionKeysChange( + session_id_, + AllOf(Each(Pair(_, kKeyStatusUsable)), Not(IsEmpty())), true)) .WillOnce(Invoke(&decrypt_callback, &DecryptCallbackTester::Decrypt)); EXPECT_CALL(listener, OnExpirationUpdate(session_id_, _)); @@ -5397,8 +5388,8 @@ TEST_F(WvCdmRequestLicenseTest, PlaybackExpiry_DecryptBeforeLicense) { EXPECT_CALL( listener, OnSessionKeysChange( - session_id_, - AllOf(Each(Pair(_, kKeyStatusExpired)), Not(IsEmpty())), false)); + session_id_, AllOf(Each(Pair(_, kKeyStatusExpired)), Not(IsEmpty())), + false)); // Elapse time so that the key should now be considered expired. std::this_thread::sleep_for(kExpirationStreamingClip21PlaybackDurationTimeMs); @@ -5410,11 +5401,10 @@ TEST_F(WvCdmRequestLicenseTest, SessionKeyChangeNotificationTest) { decryptor_, &single_encrypted_sub_sample_short_expiry); decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier, &listener, &session_id_); - EXPECT_CALL( - listener, - OnSessionKeysChange( - session_id_, - AllOf(Each(Pair(_, kKeyStatusUsable)), Not(IsEmpty())), true)) + EXPECT_CALL(listener, + OnSessionKeysChange( + session_id_, + AllOf(Each(Pair(_, kKeyStatusUsable)), Not(IsEmpty())), true)) .WillOnce(Invoke(&decrypt_callback, &DecryptCallbackTester::Decrypt)); EXPECT_CALL(listener, OnExpirationUpdate(session_id_, _)); @@ -5462,17 +5452,16 @@ TEST_P(WvCdmDecryptionTest, DecryptionTest) { decryption_parameters.decrypt_buffer_length = decrypt_sample_buffer_size; decryption_parameters.decrypt_buffer_offset = decrypt_buffer_offset; expected_decrypt_data.insert(expected_decrypt_data.end(), - (data+i)->decrypt_data.begin(), - (data+i)->decrypt_data.end()); + (data + i)->decrypt_data.begin(), + (data + i)->decrypt_data.end()); EXPECT_EQ(NO_ERROR, decryptor_->Decrypt(session_id_, (data + i)->validate_key_id, decryption_parameters)); - decrypt_buffer_offset += (data +i)->encrypt_data.size(); + decrypt_buffer_offset += (data + i)->encrypt_data.size(); } EXPECT_TRUE(std::equal(expected_decrypt_data.begin(), - expected_decrypt_data.end(), - decrypt_buffer.begin())); + expected_decrypt_data.end(), decrypt_buffer.begin())); decryptor_->CloseSession(session_id_); } @@ -5520,8 +5509,8 @@ TEST_P(WvCdmSessionSharingNoKeyTest, DecryptionTest) { decryption_parameters.subsample_flags = data->subsample_flags; bool can_decrypt = !data->is_encrypted && - data->subsample_flags & OEMCrypto_FirstSubsample && - data->subsample_flags & OEMCrypto_LastSubsample; + data->subsample_flags & OEMCrypto_FirstSubsample && + data->subsample_flags & OEMCrypto_LastSubsample; EXPECT_EQ(can_decrypt ? NO_ERROR : KEY_NOT_FOUND_IN_SESSION, decryptor_->Decrypt(gp_session_id_2, data->validate_key_id, decryption_parameters)); @@ -5565,15 +5554,14 @@ TEST_F(WvCdmRequestLicenseTest, AddHlsStreamingKeyTest) { GenerateKeyRequest(wvcdm::KEY_MESSAGE, HLS_INIT_DATA_FORMAT, kAttributeListSampleAes, app_parameters, kLicenseTypeStreaming, nullptr); - //TODO(rfrias): Remove once we switch to git-on-borg + // TODO(rfrias): Remove once we switch to git-on-borg std::string license_server = "https://proxy.uat.widevine.com/proxy"; VerifyKeyRequestResponse(license_server, config_.client_auth()); decryptor_->CloseSession(session_id_); } -class WvHlsInitDataTest - : public WvCdmRequestLicenseTest, - public ::testing::WithParamInterface {}; +class WvHlsInitDataTest : public WvCdmRequestLicenseTest, + public ::testing::WithParamInterface {}; TEST_P(WvHlsInitDataTest, InvalidHlsFormatTest) { decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier, @@ -5585,12 +5573,12 @@ TEST_P(WvHlsInitDataTest, InvalidHlsFormatTest) { decryptor_->CloseSession(session_id_); } -INSTANTIATE_TEST_CASE_P(Cdm, WvHlsInitDataTest, - ::testing::Values( - kAttributeListKeyFormatNonWidevine, - kAttributeListKeyFormatVersionUnregonized, - kAttributeListUnspecifiedIv, - kAttributeListUnspecifiedMethod)); +INSTANTIATE_TEST_CASE_P( + Cdm, WvHlsInitDataTest, + ::testing::Values(kAttributeListKeyFormatNonWidevine, + kAttributeListKeyFormatVersionUnregonized, + kAttributeListUnspecifiedIv, + kAttributeListUnspecifiedMethod)); class WvHlsDecryptionTest : public WvCdmRequestLicenseTest, @@ -5609,7 +5597,7 @@ TEST_P(WvHlsDecryptionTest, HlsDecryptionTest) { GenerateKeyRequest(wvcdm::KEY_MESSAGE, HLS_INIT_DATA_FORMAT, info->attribute_list, app_parameters, kLicenseTypeStreaming, nullptr); - //TODO(rfrias): Remove once we switch to git-on-borg + // TODO(rfrias): Remove once we switch to git-on-borg std::string license_server = "https://proxy.uat.widevine.com/proxy"; VerifyKeyRequestResponse(license_server, config_.client_auth()); CdmKeyStatusMap key_status_map = listener.GetKeyStatusMap(); @@ -5632,8 +5620,8 @@ TEST_P(WvHlsDecryptionTest, HlsDecryptionTest) { decryption_parameters.pattern_descriptor.skip_blocks = 9; } decryption_parameters.subsample_flags = data->subsample_flags; - EXPECT_EQ(NO_ERROR, decryptor_->Decrypt(session_id_, false, - decryption_parameters)); + EXPECT_EQ(NO_ERROR, + decryptor_->Decrypt(session_id_, false, decryption_parameters)); EXPECT_EQ(data->clear_data, std::string(reinterpret_cast(&output_buffer[0]), output_buffer.size())); @@ -5663,7 +5651,7 @@ TEST_P(WvHlsFourCCBackwardCompatibilityTest, HlsDecryptionTest) { GenerateKeyRequest(wvcdm::KEY_MESSAGE, ISO_BMFF_VIDEO_MIME_TYPE, info->attribute_list, app_parameters, kLicenseTypeStreaming, nullptr); - //TODO(rfrias): Remove once we switch to git-on-borg + // TODO(rfrias): Remove once we switch to git-on-borg std::string license_server = "https://proxy.uat.widevine.com/proxy"; VerifyKeyRequestResponse(license_server, config_.client_auth()); CdmKeyStatusMap key_status_map = listener.GetKeyStatusMap(); @@ -5686,8 +5674,8 @@ TEST_P(WvHlsFourCCBackwardCompatibilityTest, HlsDecryptionTest) { decryption_parameters.pattern_descriptor.skip_blocks = 9; } decryption_parameters.subsample_flags = data->subsample_flags; - EXPECT_EQ(NO_ERROR, decryptor_->Decrypt(session_id_, false, - decryption_parameters)); + EXPECT_EQ(NO_ERROR, + decryptor_->Decrypt(session_id_, false, decryption_parameters)); EXPECT_EQ(data->clear_data, std::string(reinterpret_cast(&output_buffer[0]), output_buffer.size())); @@ -5722,8 +5710,7 @@ TEST_P(WvCenc30Test, DecryptionTest) { // Ability to switch between cipher modes without re-requesting a license // was introduced in OEMCrypto v14 - if (api_version < 14u) - return; + if (api_version < 14u) return; SingleSampleDecryptionInfo* info = GetParam(); @@ -5752,8 +5739,8 @@ TEST_P(WvCenc30Test, DecryptionTest) { decryption_parameters.pattern_descriptor.skip_blocks = 9; } decryption_parameters.subsample_flags = data->subsample_flags; - EXPECT_EQ(NO_ERROR, decryptor_->Decrypt(session_id_, false, - decryption_parameters)); + EXPECT_EQ(NO_ERROR, + decryptor_->Decrypt(session_id_, false, decryption_parameters)); EXPECT_EQ(data->clear_data, std::string(reinterpret_cast(&output_buffer[0]), output_buffer.size())); @@ -5761,10 +5748,9 @@ TEST_P(WvCenc30Test, DecryptionTest) { decryptor_->CloseSession(session_id_); } -INSTANTIATE_TEST_CASE_P( - Cdm, WvCenc30Test, - ::testing::Range(&kCenc30DecryptionData[0], - &kCenc30DecryptionData[4])); +INSTANTIATE_TEST_CASE_P(Cdm, WvCenc30Test, + ::testing::Range(&kCenc30DecryptionData[0], + &kCenc30DecryptionData[4])); class WvCenc30SwitchCipherModeTest : public WvCdmRequestLicenseTest, @@ -5787,8 +5773,7 @@ TEST_P(WvCenc30SwitchCipherModeTest, DecryptionTest) { // Ability to switch between cipher modes without re-requesting a license // was introduced in OEMCrypto v14 - if (api_version < 14) - return; + if (api_version < 14) return; FourSampleDecryptionInfo* info = GetParam(); @@ -5818,8 +5803,8 @@ TEST_P(WvCenc30SwitchCipherModeTest, DecryptionTest) { decryption_parameters.pattern_descriptor.skip_blocks = 9; } decryption_parameters.subsample_flags = data->subsample_flags; - EXPECT_EQ(NO_ERROR, decryptor_->Decrypt(session_id_, false, - decryption_parameters)); + EXPECT_EQ(NO_ERROR, + decryptor_->Decrypt(session_id_, false, decryption_parameters)); EXPECT_EQ(data->clear_data, std::string(reinterpret_cast(&output_buffer[0]), output_buffer.size())); @@ -5828,10 +5813,9 @@ TEST_P(WvCenc30SwitchCipherModeTest, DecryptionTest) { decryptor_->CloseSession(session_id_); } -INSTANTIATE_TEST_CASE_P( - Cdm, WvCenc30SwitchCipherModeTest, - ::testing::Range(&kCenc30SwitchCipherData[0], - &kCenc30SwitchCipherData[8])); +INSTANTIATE_TEST_CASE_P(Cdm, WvCenc30SwitchCipherModeTest, + ::testing::Range(&kCenc30SwitchCipherData[0], + &kCenc30SwitchCipherData[8])); TEST_F(WvCdmRequestLicenseTest, CloseCdmReleaseResourcesTest) { Provision(kAlternateCdmIdentifier1, kLevelDefault); @@ -5888,7 +5872,7 @@ TEST_F(WvCdmRequestLicenseTest, DISABLED_DecryptPathTest) { CdmSessionId invalid_session_id = session_id_ + "more"; std::string frame_number = std::to_string(5); - std::vector binary_hash{ 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38 }; + std::vector binary_hash{0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38}; const std::string hash = Base64Encode(binary_hash); // Invalid session id @@ -6006,7 +5990,7 @@ TEST_F(WvCdmRequestLicenseRollbackTest, Streaming_ExpireAfterRollback) { ASSERT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier, nullptr, - &session_id_)); + &session_id_)); GenerateKeyRequest(init_data_with_expiry_, kLicenseTypeStreaming); VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); diff --git a/libwvdrmengine/cdm/test/timer_unittest.cpp b/libwvdrmengine/cdm/test/timer_unittest.cpp index b474531c..3cc636b5 100644 --- a/libwvdrmengine/cdm/test/timer_unittest.cpp +++ b/libwvdrmengine/cdm/test/timer_unittest.cpp @@ -3,14 +3,15 @@ // License Agreement. #include + #include "timer.h" namespace wvcdm { class TestTimerHandler : public TimerHandler { public: - TestTimerHandler() : timer_events_(0) {}; - virtual ~TestTimerHandler() {}; + TestTimerHandler() : timer_events_(0){}; + virtual ~TestTimerHandler(){}; virtual void OnTimerEvent() { timer_events_++; } @@ -49,4 +50,4 @@ TEST(TimerTest, TimerCheck) { EXPECT_LE(duration - 1, handler.timer_events()); EXPECT_LE(handler.timer_events(), duration + 1); } -} +} // namespace wvcdm diff --git a/libwvdrmengine/cdm/test/wv_cdm_metrics_test.cpp b/libwvdrmengine/cdm/test/wv_cdm_metrics_test.cpp index 17daad22..b16680b3 100644 --- a/libwvdrmengine/cdm/test/wv_cdm_metrics_test.cpp +++ b/libwvdrmengine/cdm/test/wv_cdm_metrics_test.cpp @@ -16,10 +16,10 @@ #include "wv_content_decryption_module.h" using ::testing::Eq; -using ::testing::StrEq; using ::testing::Ge; using ::testing::Gt; using ::testing::Lt; +using ::testing::StrEq; using ::testing::Test; using wvcdm::CdmResponseType; @@ -58,41 +58,45 @@ TEST_F(WvContentDecryptionModuleMetricsTest, EngineOnlyMetrics) { EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.GetProvisioningRequest( cert_type, cert_authority, kDefaultCdmIdentifier, - kEmptyServiceCertificate, &request, - &provisioning_server_url)); + kEmptyServiceCertificate, &request, &provisioning_server_url)); drm_metrics::WvCdmMetrics metrics; ASSERT_EQ(wvcdm::NO_ERROR, decryptor_.GetMetrics(kDefaultCdmIdentifier, &metrics)); // 100 is an arbitrary high value that shouldn't ever occur. - EXPECT_THAT( - metrics.engine_metrics().level3_oemcrypto_initialization_error() - .int_value(), Lt(100)); - EXPECT_THAT( - metrics.engine_metrics().level3_oemcrypto_initialization_error() - .int_value(), Ge(0)); + EXPECT_THAT(metrics.engine_metrics() + .level3_oemcrypto_initialization_error() + .int_value(), + Lt(100)); + EXPECT_THAT(metrics.engine_metrics() + .level3_oemcrypto_initialization_error() + .int_value(), + Ge(0)); EXPECT_THAT( metrics.engine_metrics().oemcrypto_initialization_mode().int_value(), Lt(100)); EXPECT_THAT( metrics.engine_metrics().oemcrypto_initialization_mode().int_value(), Ge(0)); - EXPECT_THAT( - metrics.engine_metrics().previous_oemcrypto_initialization_failure() - .int_value(), Lt(100)); - EXPECT_THAT( - metrics.engine_metrics().previous_oemcrypto_initialization_failure() - .int_value(), Ge(0)); + EXPECT_THAT(metrics.engine_metrics() + .previous_oemcrypto_initialization_failure() + .int_value(), + Lt(100)); + EXPECT_THAT(metrics.engine_metrics() + .previous_oemcrypto_initialization_failure() + .int_value(), + Ge(0)); ASSERT_THAT(metrics.engine_metrics() - .cdm_engine_get_provisioning_request_time_us().size(), Eq(1)); + .cdm_engine_get_provisioning_request_time_us() + .size(), + Eq(1)); EXPECT_THAT(metrics.engine_metrics() .cdm_engine_get_provisioning_request_time_us(0) .operation_count(), - Eq(1u)); + Eq(1u)); } - TEST_F(WvContentDecryptionModuleMetricsTest, EngineAndSessionMetrics) { CdmSessionId session_id; wvcdm::CdmKeySystem key_system("com.widevine"); @@ -112,36 +116,38 @@ TEST_F(WvContentDecryptionModuleMetricsTest, EngineAndSessionMetrics) { // Spot check some metric values. // Validate engine-level metrics. - EXPECT_TRUE(metrics.engine_metrics() - .has_level3_oemcrypto_initialization_error()); + EXPECT_TRUE( + metrics.engine_metrics().has_level3_oemcrypto_initialization_error()); EXPECT_TRUE(metrics.engine_metrics().has_oemcrypto_initialization_mode()); - EXPECT_TRUE(metrics.engine_metrics() - .has_previous_oemcrypto_initialization_failure()); + EXPECT_TRUE( + metrics.engine_metrics().has_previous_oemcrypto_initialization_failure()); ASSERT_THAT(metrics.engine_metrics().cdm_engine_open_session().size(), Eq(1)); EXPECT_THAT(metrics.engine_metrics().cdm_engine_open_session(0).count(), Eq(1)); EXPECT_THAT(metrics.engine_metrics() - .cdm_engine_open_session(0).attributes().error_code(), - Eq(CdmResponseType::NEED_PROVISIONING)); + .cdm_engine_open_session(0) + .attributes() + .error_code(), + Eq(CdmResponseType::NEED_PROVISIONING)); // Validate a session-level metric. ASSERT_THAT(metrics.session_metrics().size(), Eq(1)); EXPECT_THAT( metrics.session_metrics(0).cdm_session_life_span_ms().double_value(), Gt(0.0)) - << "Unexpected failure with session_metrics: " - << wvcdm::b2a_hex(serialized_metrics); + << "Unexpected failure with session_metrics: " + << wvcdm::b2a_hex(serialized_metrics); } TEST_F(WvContentDecryptionModuleMetricsTest, DifferentCdmIdentifiersHaveDifferentMetrics) { CdmSessionId session_id; wvcdm::CdmKeySystem key_system("com.widevine"); - CdmIdentifier identifiers[] = { kDefaultCdmIdentifier, - { "foo", "bar", "baz", 7 }, - // Note that this has all the same parameters - // as the one above except for the unique_id. - { "foo", "bar", "baz", 8 }}; + CdmIdentifier identifiers[] = {kDefaultCdmIdentifier, + {"foo", "bar", "baz", 7}, + // Note that this has all the same parameters + // as the one above except for the unique_id. + {"foo", "bar", "baz", 8}}; const int cdm_engine_count = 3; // Force Unprovision. @@ -153,7 +159,7 @@ TEST_F(WvContentDecryptionModuleMetricsTest, // To make sure we can detect different engine metrics, // make the open session call a different number of times for // each identifier. - for (int j = 0; j <= i; j ++) { + for (int j = 0; j <= i; j++) { EXPECT_EQ(CdmResponseType::NEED_PROVISIONING, decryptor_.OpenSession(key_system, nullptr, identifiers[i], nullptr, &session_id)); @@ -163,8 +169,7 @@ TEST_F(WvContentDecryptionModuleMetricsTest, for (int i = 0; i < cdm_engine_count; i++) { drm_metrics::WvCdmMetrics metrics; metrics.Clear(); - ASSERT_EQ(wvcdm::NO_ERROR, - decryptor_.GetMetrics(identifiers[i], &metrics)); + ASSERT_EQ(wvcdm::NO_ERROR, decryptor_.GetMetrics(identifiers[i], &metrics)); std::string serialized_metrics; ASSERT_TRUE(metrics.SerializeToString(&serialized_metrics)); @@ -174,20 +179,22 @@ TEST_F(WvContentDecryptionModuleMetricsTest, // of the identifier EXPECT_THAT(metrics.engine_metrics().cdm_engine_open_session(0).count(), Eq(i + 1)); - EXPECT_THAT( - metrics.engine_metrics() - .cdm_engine_open_session(0).attributes().error_code(), - Eq(CdmResponseType::NEED_PROVISIONING)); + EXPECT_THAT(metrics.engine_metrics() + .cdm_engine_open_session(0) + .attributes() + .error_code(), + Eq(CdmResponseType::NEED_PROVISIONING)); // Spot check a session-level metric. ASSERT_THAT(metrics.session_metrics().size(), Eq(i + 1)) << "Unexpected failure with session_metrics: " << wvcdm::b2a_hex(serialized_metrics); - EXPECT_THAT(metrics.session_metrics(0) - .cdm_session_life_span_ms().double_value(), Gt(0.0)) + EXPECT_THAT( + metrics.session_metrics(0).cdm_session_life_span_ms().double_value(), + Gt(0.0)) << "Unexpected failure with session_metrics: " << wvcdm::b2a_hex(serialized_metrics); } } -} // wvcdm namespace +} // namespace wvcdm