From e635d4d384beaef0432fa4d9bd22ea6c3462c7ab Mon Sep 17 00:00:00 2001 From: Fred Gylys-Colwell Date: Fri, 3 Aug 2018 17:09:19 -0700 Subject: [PATCH] Common test main Merge from Widevine repo of http://go/wvgerrit/56521 This CL adds a common main routine for integration tests. It sets a default test configuration for the provisioning and license server urls and certificates, and allows the user to set them on the command line. Test: current unit tests still pass. Bug: 72354901 Fix Generic Crypto tests. Change-Id: I604a3d9e15d50da5041794624c4571c0dcb091f5 --- .../cdm/core/test/cdm_engine_test.cpp | 1 + .../cdm/core/test/config_test_env.cpp | 17 + .../cdm/core/test/config_test_env.h | 22 +- libwvdrmengine/cdm/core/test/test_base.cpp | 177 ++++++ libwvdrmengine/cdm/core/test/test_base.h | 16 +- libwvdrmengine/cdm/core/test/test_main.cpp | 17 + libwvdrmengine/cdm/test/Android.mk | 65 +- .../cdm/test/cdm_extended_duration_test.cpp | 358 ++++------- libwvdrmengine/cdm/test/cdm_feature_test.cpp | 172 +----- libwvdrmengine/cdm/test/integration-test.mk | 67 +++ .../cdm/test/request_license_test.cpp | 567 +++++++----------- 11 files changed, 707 insertions(+), 772 deletions(-) create mode 100644 libwvdrmengine/cdm/core/test/test_main.cpp create mode 100644 libwvdrmengine/cdm/test/integration-test.mk diff --git a/libwvdrmengine/cdm/core/test/cdm_engine_test.cpp b/libwvdrmengine/cdm/core/test/cdm_engine_test.cpp index efb31bbf..9989687e 100644 --- a/libwvdrmengine/cdm/core/test/cdm_engine_test.cpp +++ b/libwvdrmengine/cdm/core/test/cdm_engine_test.cpp @@ -39,6 +39,7 @@ namespace { // Http OK response code. const int kHttpOk = 200; +// TODO(fredgc): Move these to test_base.cpp in next CL. // Default license server, can be configured using --server command line option // Default key id (pssh), can be configured using --keyid command line option std::string g_client_auth; diff --git a/libwvdrmengine/cdm/core/test/config_test_env.cpp b/libwvdrmengine/cdm/core/test/config_test_env.cpp index ff20e5ae..7fb9034d 100644 --- a/libwvdrmengine/cdm/core/test/config_test_env.cpp +++ b/libwvdrmengine/cdm/core/test/config_test_env.cpp @@ -260,14 +260,17 @@ const std::string kGpClientOfflineReleaseQueryParameters = const ConfigTestEnv::LicenseServerConfiguration license_servers[] = { {kGooglePlayServer, kGpLicenseServer, "", kGpClientAuth, kGpKeyId, kGpOfflineKeyId, kCpProductionProvisioningServerUrl, ""}, + {kContentProtectionUatServer, kCpUatLicenseServer, kCpUatServiceCertificate, kCpClientAuth, kCpKeyId, kCpOfflineKeyId, // TODO(rfrias): replace when b/62880305 is addressed. For now use production kCpProductionProvisioningServerUrl, kCpProductionProvisioningServiceCertificate}, + {kContentProtectionStagingServer, kCpStagingLicenseServer, kCpStagingServiceCertificate, kCpClientAuth, kCpKeyId, kCpOfflineKeyId, kCpStagingProvisioningServerUrl, kCpStagingProvisioningServiceCertificate}, + {kContentProtectionProductionServer, kCpProductionLicenseServer, kCpProductionServiceCertificate, kCpClientAuth, kCpKeyId, kCpOfflineKeyId, kCpProductionProvisioningServerUrl, @@ -303,7 +306,21 @@ ConfigTestEnv::ConfigTestEnv(ServerConfigurationId server_id, bool streaming, } } +ConfigTestEnv& ConfigTestEnv::operator=(const ConfigTestEnv &other) { + this->server_id_ = other.server_id_; + this->client_auth_ = other.client_auth_; + this->key_id_ = other.key_id_; + this->key_system_ = other.key_system_; + this->license_server_ = other.license_server_; + this->provisioning_server_ = other.provisioning_server_; + this->license_service_certificate_ = other.license_service_certificate_; + this->provisioning_service_certificate_ = + other.provisioning_service_certificate_; + return *this; +} + void ConfigTestEnv::Init(ServerConfigurationId server_id) { + this->server_id_ = server_id; client_auth_ = license_servers[server_id].client_tag; key_id_ = license_servers[server_id].key_id; key_system_ = kWidevineKeySystem; diff --git a/libwvdrmengine/cdm/core/test/config_test_env.h b/libwvdrmengine/cdm/core/test/config_test_env.h index f785c29a..dce0ec65 100644 --- a/libwvdrmengine/cdm/core/test/config_test_env.h +++ b/libwvdrmengine/cdm/core/test/config_test_env.h @@ -49,20 +49,25 @@ class ConfigTestEnv { typedef struct { ServerConfigurationId id; std::string license_server_url; - std::string license_service_certificate; + std::string license_service_certificate; // Binary (not hex). std::string client_tag; - std::string key_id; + std::string key_id; // Hex. std::string offline_key_id; std::string provisioning_server_url; - std::string provisioning_service_certificate; + std::string provisioning_service_certificate; // Binary (not hex). } LicenseServerConfiguration; explicit ConfigTestEnv(ServerConfigurationId server_id); ConfigTestEnv(ServerConfigurationId server_id, bool streaming); ConfigTestEnv(ServerConfigurationId server_id, bool streaming, bool renew, bool release); + // Allow copy and assign. Performance is not an issue in test initialization. + ConfigTestEnv(const ConfigTestEnv &other) { *this = other; }; + ConfigTestEnv& operator=(const ConfigTestEnv &other); + ~ConfigTestEnv() {}; + ServerConfigurationId server_id() { return server_id_; } const std::string& client_auth() const { return client_auth_; } const KeyId& key_id() const { return key_id_; } const CdmKeySystem& key_system() const { return key_system_; } @@ -88,13 +93,22 @@ class ConfigTestEnv { void set_license_server(std::string& license_server) { license_server_.assign(license_server); } + void set_license_service_certificate( + std::string& license_service_certificate) { + license_service_certificate_.assign(license_service_certificate); + } void set_provisioning_server(std::string& provisioning_server) { provisioning_server_.assign(provisioning_server); } + void set_provisioning_service_certificate( + std::string& provisioning_service_certificate) { + provisioning_service_certificate_.assign(provisioning_service_certificate); + } private: void Init(ServerConfigurationId server_id); + ServerConfigurationId server_id_; std::string client_auth_; KeyId key_id_; CdmKeySystem key_system_; @@ -102,8 +116,6 @@ class ConfigTestEnv { std::string provisioning_server_; std::string license_service_certificate_; std::string provisioning_service_certificate_; - - CORE_DISALLOW_COPY_AND_ASSIGN(ConfigTestEnv); }; } // namespace wvcdm diff --git a/libwvdrmengine/cdm/core/test/test_base.cpp b/libwvdrmengine/cdm/core/test/test_base.cpp index ce0aa2f0..48545f5c 100644 --- a/libwvdrmengine/cdm/core/test/test_base.cpp +++ b/libwvdrmengine/cdm/core/test/test_base.cpp @@ -24,6 +24,74 @@ #include "url_request.h" namespace wvcdm { +namespace { +void show_menu(char* prog_name) { + std::cout << std::endl; + std::cout << "usage: " << prog_name << " [options]" << std::endl << std::endl; + std::cout << " enclose multiple arguments in '' when using adb shell" + << std::endl; + std::cout << " e.g. adb shell '" << prog_name << " --server=\"url\"'" + << std::endl; + std::cout << " or adb shell '" << prog_name << " -u\"url\"'" << std::endl + << std::endl; + + std::cout << " -v/--verbose" << std::endl; + std::cout << " increase logging verbosity (may be repeated)" << std::endl + << std::endl; + + std::cout << " -f/--no_filter" << std::endl; + std::cout << " Do not filter out inappropriate tests" << std::endl + << std::endl; + + std::cout << " -c/--cast" << std::endl; + std::cout << " Run tests appropriate for a Cast Receiver" << std::endl + << std::endl; + + std::cout << " -i/--license_server_id=" << std::endl; + std::cout << " specifies which default server settings to use: " + << std::endl; + std::cout << " gp for GooglePlay server" << std::endl; + std::cout << " cp for Content Protection UAT server" << std::endl; + std::cout << " st for Content Protection Staging server" << std::endl + << std::endl; + + std::cout << " -k/--keyid=" << std::endl; + std::cout << " configure the key id or pssh, in hex format" << std::endl + << std::endl; + + std::cout << " -s/--service_certificate=" << std::endl; + std::cout << " configure the signed license service certificate" << std::endl; + std::cout << " Specify the SignedDeviceCertificate (from " + << "device_certificate.proto) " << std::endl; + std::cout << " in hex format." << std::endl; + std::cout << " Due to the length of the argument use, " << std::endl; + std::cout << " echo \"/system/bin/request_license_test -s \\\"" + << "0ABF02...A29914\\\"\" \\" << std::endl; + std::cout << " > run_request_license_test.sh" << std::endl; + std::cout << " chmod +x run_request_license_test.sh" << std::endl; + std::cout << " adb push run_request_license_test.sh /system/bin" + << std::endl; + std::cout << " adb shell sh /system/bin/run_request_license_test.sh" + << std::endl << std::endl; + + std::cout << " -S/--provisioning_certificate=" << std::endl; + std::cout << " configure the signed provisioning service certificate" << std::endl + << " in hex" << std::endl << std::endl; + + std::cout << " -u/--license_server_url=" << std::endl; + std::cout << " configure the license server url, please include http[s]" + << " in the url" << std::endl + << std::endl; + + std::cout << " -p/--provisioning_server_url=" << std::endl; + std::cout << " configure the provisioning server url, please include http[s]" + << " in the url" << std::endl + << std::endl; +} + +} // namespace + +ConfigTestEnv WvCdmTestBase::default_config_(kContentProtectionUatServer); TestCryptoSession::TestCryptoSession(metrics::CryptoMetrics* crypto_metrics) : CryptoSession(crypto_metrics) { @@ -79,4 +147,113 @@ void WvCdmTestBase::InstallTestRootOfTrust() { } } +bool WvCdmTestBase::Initialize(int argc, char **argv) { + Properties::Init(); + bool is_cast_receiver = false; + bool force_load_test_keybox = false; // TODO(fredgc): obsolete. remove. + bool filter_tests = true; + bool show_usage = false; + + static const struct option long_options[] = { + {"license_server_id", required_argument, NULL, 'i'}, + {"keyid", required_argument, NULL, 'k'}, + {"service_certificate", required_argument, NULL, 's'}, + {"provisioning_certificate", required_argument, NULL, 'S'}, + {"license_server_url", required_argument, NULL, 'u'}, + {"provisioning_server_url", required_argument, NULL, 'p'}, + {"cast", no_argument, NULL, 'c'}, + {"no_filter", no_argument, NULL, 'f'}, + {"verbose", no_argument, NULL, 'v'}, + {NULL, 0, NULL, '\0'}}; + + int option_index = 0; + int opt = 0; + int verbosity = 0; + while ((opt = getopt_long(argc, argv, "i:k:s:S:u:p:cfv", long_options, + &option_index)) != -1) { + switch (opt) { + case 'i': { + std::string license_id(optarg); + if (!license_id.compare("gp")) { + default_config_ = ConfigTestEnv(kGooglePlayServer); + } else if (!license_id.compare("cp")) { + default_config_ = ConfigTestEnv(kContentProtectionUatServer); + } else if (!license_id.compare("st")) { + default_config_ = ConfigTestEnv(kContentProtectionStagingServer); + } else { + std::cout << "Invalid license server id" << optarg << std::endl; + show_usage = true; + } + break; + } + case 'k': { + std::string key_id(optarg); + default_config_.set_key_id(key_id); + break; + } + case 's': { + std::string certificate(a2bs_hex(optarg)); + default_config_.set_license_service_certificate(certificate); + break; + } + case 'S': { + std::string certificate(a2bs_hex(optarg)); + default_config_.set_provisioning_service_certificate(certificate); + break; + } + case 'u': { + std::string server(optarg); + default_config_.set_license_server(server); + break; + } + case 'p': { + std::string server(optarg); + default_config_.set_provisioning_server(server); + break; + } + case 'c': { + is_cast_receiver = true; + break; + } + case 'f': { + filter_tests = false; + break; + } + case 'v': { + ++verbosity; + break; + } + case '?': { + show_usage = true; + break; + } + } + } + + if (show_usage) { + show_menu(argv[0]); + return false; + } + + g_cutoff = static_cast(verbosity); + + // Displays server url, port and key Id being used + std::cout << std::endl; + std::cout << "Default Server: " << default_config_.license_server() + << std::endl; + std::cout << "Default KeyID: " << default_config_.key_id() << std::endl + << std::endl; + + // Figure out which tests are appropriate for OEMCrypto, based on features + // supported. + wvoec::global_features.Initialize(is_cast_receiver, force_load_test_keybox); + // If the user requests --no_filter, we don't change the filter, otherwise, we + // filter out features that are not supported. + if (filter_tests) { + ::testing::GTEST_FLAG(filter) = + wvoec::global_features.RestrictFilter(::testing::GTEST_FLAG(filter)); + } + return true; +} + } // namespace wvcdm diff --git a/libwvdrmengine/cdm/core/test/test_base.h b/libwvdrmengine/cdm/core/test/test_base.h index bf2be99d..b19af94e 100644 --- a/libwvdrmengine/cdm/core/test/test_base.h +++ b/libwvdrmengine/cdm/core/test/test_base.h @@ -10,18 +10,32 @@ #include "config_test_env.h" #include "crypto_session.h" #include "metrics_collections.h" +#include "string_conversions.h" namespace wvcdm { // This is the base class for Widevine CDM integration tests. It's main use is // to configure OEMCrypto to use a test keybox. class WvCdmTestBase : public ::testing::Test { public: - WvCdmTestBase() {} + WvCdmTestBase() : config_(default_config_) {} virtual ~WvCdmTestBase() {} virtual void SetUp(); + virtual std::string binary_key_id() const { return a2bs_hex(config_.key_id()); } + // Returns true if the test program should continue, if false, the caller + // should exit. This should be called by main() to allow the user to pass in + // command line switches. + static bool Initialize(int argc, char **argv); // Install a test keybox, if appropriate. static void InstallTestRootOfTrust(); + + // The default test configuration. This is influenced by command line + // arguments before any tests are created. + static ConfigTestEnv default_config_; + + // Configuration for an individual test. This is initialized to be the + // default configuration, but can be modified by the test itself. + ConfigTestEnv config_; }; class TestCryptoSession : public CryptoSession { diff --git a/libwvdrmengine/cdm/core/test/test_main.cpp b/libwvdrmengine/cdm/core/test/test_main.cpp new file mode 100644 index 00000000..92c99b9d --- /dev/null +++ b/libwvdrmengine/cdm/core/test/test_main.cpp @@ -0,0 +1,17 @@ +// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary +// source code may only be used and distributed under the Widevine Master +// License Agreement. + +// Use in place of the gtest_main in order to initialize the WvCdmTestBase using +// command line parameters. + +#include + +#include "log.h" +#include "test_base.h" + +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + if (!wvcdm::WvCdmTestBase::Initialize(argc, argv)) return 0; + return RUN_ALL_TESTS(); +} diff --git a/libwvdrmengine/cdm/test/Android.mk b/libwvdrmengine/cdm/test/Android.mk index b42b99af..65c077b6 100644 --- a/libwvdrmengine/cdm/test/Android.mk +++ b/libwvdrmengine/cdm/test/Android.mk @@ -3,6 +3,11 @@ # LOCAL_PATH := $(call my-dir) +# Integration tests have a special main that does some initialization and +# takes some command line arguments to set the default license server. The +# variable test_main is used to indicate an extra file with the main +# routine. + test_name := base64_test test_src_dir := ../core/test include $(LOCAL_PATH)/unit-test.mk @@ -11,21 +16,25 @@ test_name := buffer_reader_test test_src_dir := ../core/test include $(LOCAL_PATH)/unit-test.mk -test_name := cdm_feature_test -test_src_dir := . -include $(LOCAL_PATH)/unit-test.mk - test_name := cdm_engine_test test_src_dir := ../core/test -include $(LOCAL_PATH)/unit-test.mk +test_main := ../core/test/test_main.cpp +include $(LOCAL_PATH)/integration-test.mk test_name := cdm_extended_duration_test test_src_dir := . -include $(LOCAL_PATH)/unit-test.mk +test_main := ../core/test/test_main.cpp +include $(LOCAL_PATH)/integration-test.mk + +test_name := cdm_feature_test +test_src_dir := . +test_main := ../core/test/test_main.cpp +include $(LOCAL_PATH)/integration-test.mk test_name := cdm_session_unittest test_src_dir := ../core/test -include $(LOCAL_PATH)/unit-test.mk +test_main := ../core/test/test_main.cpp +include $(LOCAL_PATH)/integration-test.mk test_name := counter_metric_unittest test_src_dir := ../metrics/test @@ -33,7 +42,8 @@ include $(LOCAL_PATH)/unit-test.mk test_name := crypto_session_unittest test_src_dir := ../core/test -include $(LOCAL_PATH)/unit-test.mk +test_main := ../core/test/test_main.cpp +include $(LOCAL_PATH)/integration-test.mk test_name := device_files_unittest test_src_dir := ../core/test @@ -55,45 +65,61 @@ test_name := file_utils_unittest test_src_dir := . include $(LOCAL_PATH)/unit-test.mk +# TODO(fredgc): Fix in later CL. +# test_name := generic_crypto_unittest +# test_src_dir := ../core/test +# test_main := ../core/test/test_main.cpp +# include $(LOCAL_PATH)/integration-test.mk + test_name := http_socket_test test_src_dir := ../core/test -include $(LOCAL_PATH)/unit-test.mk +test_main := +include $(LOCAL_PATH)/integration-test.mk test_name := initialization_data_unittest test_src_dir := ../core/test include $(LOCAL_PATH)/unit-test.mk -test_name := license_unittest -test_src_dir := ../core/test -include $(LOCAL_PATH)/unit-test.mk - test_name := license_keys_unittest test_src_dir := ../core/test include $(LOCAL_PATH)/unit-test.mk -test_name := policy_engine_unittest +test_name := license_unittest test_src_dir := ../core/test -include $(LOCAL_PATH)/unit-test.mk +test_main := ../core/test/test_main.cpp +include $(LOCAL_PATH)/integration-test.mk test_name := policy_engine_constraints_unittest test_src_dir := ../core/test -include $(LOCAL_PATH)/unit-test.mk +test_main := ../core/test/test_main.cpp +include $(LOCAL_PATH)/integration-test.mk + +test_name := policy_engine_unittest +test_src_dir := ../core/test +test_main := ../core/test/test_main.cpp +include $(LOCAL_PATH)/integration-test.mk test_name := request_license_test test_src_dir := . -include $(LOCAL_PATH)/unit-test.mk +test_main := ../core/test/test_main.cpp +include $(LOCAL_PATH)/integration-test.mk test_name := service_certificate_unittest test_src_dir := ../core/test include $(LOCAL_PATH)/unit-test.mk +test_name := shared_ptr_test +test_src_dir := ../core/test +include $(LOCAL_PATH)/unit-test.mk + test_name := timer_unittest test_src_dir := . include $(LOCAL_PATH)/unit-test.mk test_name := usage_table_header_unittest test_src_dir := ../core/test -include $(LOCAL_PATH)/unit-test.mk +test_main := ../core/test/test_main.cpp +include $(LOCAL_PATH)/integration-test.mk test_name := value_metric_unittest test_src_dir := ../metrics/test @@ -101,7 +127,8 @@ include $(LOCAL_PATH)/unit-test.mk test_name := wv_cdm_metrics_test test_src_dir := . -include $(LOCAL_PATH)/unit-test.mk +test_main := ../core/test/test_main.cpp +include $(LOCAL_PATH)/integration-test.mk test_name := test_src_dir := diff --git a/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp b/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp index 96b974a4..ff79089a 100644 --- a/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp +++ b/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp @@ -9,6 +9,8 @@ #include #include +#include +#include "OEMCryptoCENC.h" #include "cdm_identifier.h" #include "clock.h" #include "config_test_env.h" @@ -18,13 +20,12 @@ #include "license_request.h" #include "log.h" #include "oemcrypto_adapter.h" -#include "OEMCryptoCENC.h" #include "properties.h" #include "pst_report.h" #include "string_conversions.h" #include "test_base.h" +#include "test_printers.h" #include "url_request.h" -#include #include "wv_cdm_constants.h" #include "wv_content_decryption_module.h" @@ -42,16 +43,6 @@ const uint32_t kClockTolerance = 10; const uint32_t kMaxUsageTableSize = 50; const std::string kEmptyServiceCertificate; -// Default license server, can be configured using --server command line option -// Default key id (pssh), can be configured using --keyid command line option -std::string g_client_auth; -wvcdm::ConfigTestEnv* g_config = NULL; -wvcdm::KeyId g_key_id; -wvcdm::CdmKeySystem g_key_system; -std::string g_license_server; -wvcdm::ServerConfigurationId g_license_server_id = - wvcdm::kContentProtectionUatServer; - // TODO(rfrias): refactor to print out the decryption test names struct SubSampleInfo { bool retrieve_key; @@ -67,6 +58,7 @@ struct SubSampleInfo { uint8_t subsample_flags; }; +// clang-format off SubSampleInfo kEncryptedStreamingNoPstSubSample = { // key SD, encrypted, 256b true, 1, true, true, false, @@ -177,6 +169,7 @@ std::string kOfflineClip4 = wvcdm::a2bs_hex( "EDEF8BA979D64ACEA3C827DCD51D21ED00000020" // Widevine system id "08011a0d7769646576696e655f74657374220d6f" // pssh data "66666c696e655f636c697034"); +// clang-format off std::string kUatLicenseServer = "https://proxy.uat.widevine.com/proxy"; @@ -202,10 +195,10 @@ using ::testing::StrNe; namespace wvcdm { // Protobuf generated classes +using video_widevine::ClientIdentification; using video_widevine::LicenseIdentification; using video_widevine::LicenseRequest_ContentIdentification; using video_widevine::LicenseRequest_ContentIdentification_CencDeprecated; -using video_widevine::ClientIdentification; using video_widevine::SignedMessage; class TestWvCdmClientPropertySet : public CdmClientPropertySet { @@ -261,16 +254,16 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase { protected: void GetOfflineConfiguration(std::string* key_id, std::string* client_auth) { - ConfigTestEnv config(g_license_server_id, false); - if (g_key_id.compare(a2bs_hex(g_config->key_id())) == 0) + ConfigTestEnv config(config_.server_id(), false); + if (config_.key_id().compare(a2bs_hex(config_.key_id())) == 0) key_id->assign(a2bs_hex(config.key_id())); else - key_id->assign(g_key_id); + key_id->assign(config_.key_id()); - if (g_client_auth.compare(g_config->client_auth()) == 0) + if (config_.client_auth().compare(config_.client_auth()) == 0) client_auth->assign(config.client_auth()); else - client_auth->assign(g_client_auth); + client_auth->assign(config_.client_auth()); } void GenerateKeyRequest(const std::string& init_data, @@ -449,9 +442,8 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase { } void Provision() { - CdmResponseType status = - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + CdmResponseType status = decryptor_.OpenSession( + config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); switch (status) { case NO_ERROR: decryptor_.CloseSession(session_id_); @@ -472,10 +464,10 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase { kEmptyServiceCertificate, &key_msg_, &provisioning_server_url); EXPECT_EQ(NO_ERROR, status); if (NO_ERROR != status) return; - EXPECT_EQ(provisioning_server_url, g_config->provisioning_server()); + EXPECT_EQ(provisioning_server_url, config_.provisioning_server()); std::string response = - GetCertRequestResponse(g_config->provisioning_server()); + GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); EXPECT_EQ(NO_ERROR, decryptor_.HandleProvisioningResponse(kDefaultCdmIdentifier, response, @@ -547,13 +539,11 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase { EXPECT_EQ(::video_widevine::LicenseRequest_RequestType_RENEWAL, license_renewal.type()); EXPECT_LT(0, license_renewal.request_time()); - EXPECT_EQ(video_widevine::VERSION_2_1, - license_renewal.protocol_version()); + EXPECT_EQ(video_widevine::VERSION_2_1, license_renewal.protocol_version()); EXPECT_TRUE(license_renewal.has_key_control_nonce()); } - void ValidateReleaseRequest(std::string& usage_msg, - bool license_used, + void ValidateReleaseRequest(std::string& usage_msg, bool license_used, int64_t expected_seconds_since_license_received, int64_t expected_seconds_since_first_playback, int64_t expected_seconds_since_last_playback) { @@ -592,22 +582,21 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase { EXPECT_TRUE(!existing_license.session_usage_table_entry().empty()); // Verify usage report - uint8_t *buffer = reinterpret_cast( - const_cast(existing_license.session_usage_table_entry().data())); + uint8_t* buffer = reinterpret_cast( + const_cast(existing_license.session_usage_table_entry().data())); Unpacked_PST_Report usage_report(buffer); EXPECT_EQ(usage_report.report_size(), existing_license.session_usage_table_entry().size()); EXPECT_EQ(license_used ? kInactiveUsed : kInactiveUnused, usage_report.status()); - EXPECT_EQ(id.provider_session_token().size(), - usage_report.pst_length()); - std::string pst(reinterpret_cast(usage_report.pst()), + EXPECT_EQ(id.provider_session_token().size(), usage_report.pst_length()); + std::string pst(reinterpret_cast(usage_report.pst()), usage_report.pst_length()); EXPECT_EQ(id.provider_session_token(), pst); EXPECT_LE(kInsecureClock, usage_report.clock_security_level()); - int64_t seconds_since_license_received - = usage_report.seconds_since_license_received(); + int64_t seconds_since_license_received = + usage_report.seconds_since_license_received(); int64_t seconds_since_first_decrypt = usage_report.seconds_since_first_decrypt(); int64_t seconds_since_last_decrypt = @@ -631,13 +620,12 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase { EXPECT_EQ(::video_widevine::LicenseRequest_RequestType_RELEASE, license_renewal.type()); EXPECT_LT(0, license_renewal.request_time()); - EXPECT_EQ(video_widevine::VERSION_2_1, - license_renewal.protocol_version()); + EXPECT_EQ(video_widevine::VERSION_2_1, license_renewal.protocol_version()); EXPECT_TRUE(license_renewal.has_key_control_nonce()); } - void ValidateHasUpdateUsageEntry(const drm_metrics::WvCdmMetrics& metrics) - const { + void ValidateHasUpdateUsageEntry( + const drm_metrics::WvCdmMetrics& metrics) const { bool has_update_usage_entry_metrics = false; for (const auto& session : metrics.session_metrics()) { has_update_usage_entry_metrics |= @@ -675,10 +663,10 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase { } std::string key = QUERY_KEY_LICENSE_DURATION_REMAINING; - ASSERT_THAT(query_info, Contains(Pair(key,StrNe("")))); + ASSERT_THAT(query_info, Contains(Pair(key, StrNe("")))); EXPECT_TRUE(StringToInt64(query_info[key], license_duration_remaining)); key = QUERY_KEY_PLAYBACK_DURATION_REMAINING; - ASSERT_THAT(query_info, Contains(Pair(key,StrNe("")))); + ASSERT_THAT(query_info, Contains(Pair(key, StrNe("")))); EXPECT_TRUE(StringToInt64(query_info[key], playback_duration_remaining)); } @@ -696,8 +684,8 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase { } std::string GetSecurityLevel(TestWvCdmClientPropertySet* property_set) { - decryptor_.OpenSession(g_key_system, property_set, kDefaultCdmIdentifier, - NULL, &session_id_); + decryptor_.OpenSession(config_.key_system(), property_set, + kDefaultCdmIdentifier, NULL, &session_id_); CdmQueryMap query_info; EXPECT_EQ(NO_ERROR, decryptor_.QuerySessionStatus(session_id_, &query_info)); @@ -737,14 +725,14 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase { return run("CloseSessionThread") == android::NO_ERROR; } - void Stop() { requestExitAndWait(); } + void Stop() { requestExitAndWait(); } private: virtual bool threadLoop() { struct timespec delay_remaining; int result = nanosleep(&delay_, &delay_remaining); while (result < 0 && - (delay_remaining.tv_sec > 0 || delay_remaining.tv_nsec > 0)) { + (delay_remaining.tv_sec > 0 || delay_remaining.tv_nsec > 0)) { result = nanosleep(&delay_remaining, &delay_remaining); } wv_content_decryption_module_->CloseSession(sess_id_); @@ -767,9 +755,9 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase { TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRequestTest) { Provision(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); + GenerateKeyRequest(config_.key_id(), kLicenseTypeStreaming); EXPECT_TRUE(!key_msg_.empty()); @@ -786,14 +774,14 @@ TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRequestTest) { // Verify Client Identification const ClientIdentification& client_id = license_request.client_id(); - EXPECT_EQ(video_widevine:: - ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE, - client_id.type()); + EXPECT_EQ( + video_widevine::ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE, + client_id.type()); EXPECT_LT(0, client_id.client_info_size()); for (int i = 0; i < client_id.client_info_size(); ++i) { - const ::video_widevine::ClientIdentification_NameValue& - name_value = client_id.client_info(i); + const ::video_widevine::ClientIdentification_NameValue& name_value = + client_id.client_info(i); EXPECT_TRUE(!name_value.name().empty()); EXPECT_TRUE(!name_value.value().empty()); } @@ -819,7 +807,7 @@ TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRequestTest) { const LicenseRequest_ContentIdentification_CencDeprecated& cenc_id = content_id.cenc_id_deprecated(); EXPECT_TRUE(std::equal(cenc_id.pssh(0).begin(), cenc_id.pssh(0).end(), - g_key_id.begin() + 32)); + config_.key_id().begin() + 32)); EXPECT_EQ(video_widevine::STREAMING, cenc_id.license_type()); EXPECT_TRUE(cenc_id.has_request_id()); @@ -827,8 +815,7 @@ TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRequestTest) { EXPECT_EQ(::video_widevine::LicenseRequest_RequestType_NEW, license_request.type()); EXPECT_LT(0, license_request.request_time()); - EXPECT_EQ(video_widevine::VERSION_2_1, - license_request.protocol_version()); + EXPECT_EQ(video_widevine::VERSION_2_1, license_request.protocol_version()); EXPECT_TRUE(license_request.has_key_control_nonce()); decryptor_.CloseSession(session_id_); @@ -836,10 +823,11 @@ TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRequestTest) { TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRenewalTest) { Provision(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth, false); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); + GenerateKeyRequest(config_.key_id(), kLicenseTypeStreaming); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), + false); // Validate signed response SignedMessage signed_message; @@ -903,8 +891,7 @@ TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRenewalTest) { EXPECT_EQ(::video_widevine::LicenseRequest_RequestType_RENEWAL, license_renewal.type()); EXPECT_LT(0, license_renewal.request_time()); - EXPECT_EQ(video_widevine::VERSION_2_1, - license_renewal.protocol_version()); + EXPECT_EQ(video_widevine::VERSION_2_1, license_renewal.protocol_version()); EXPECT_TRUE(license_renewal.has_key_control_nonce()); decryptor_.CloseSession(session_id_); @@ -916,22 +903,23 @@ TEST_F(WvCdmExtendedDurationTest, DecryptionCloseSessionConcurrencyTest) { // Leave session open to avoid CDM termination CdmSessionId session_id; - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id); // Retrieve offline license - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); GenerateKeyRequest(kOfflineClip2PstInitData, kLicenseTypeOffline); - VerifyKeyRequestResponse(g_license_server, g_client_auth, false); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), + false); EXPECT_FALSE(key_set_id_.empty()); decryptor_.CloseSession(session_id_); for (uint32_t j = 0; j < 500; ++j) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); EXPECT_EQ(KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id_)); CdmResponseType status = NO_ERROR; @@ -947,7 +935,7 @@ TEST_F(WvCdmExtendedDurationTest, DecryptionCloseSessionConcurrencyTest) { struct timespec delay_remaining; int result = nanosleep(&decrypt_delay, &delay_remaining); while (result < 0 && - (delay_remaining.tv_sec > 0 || delay_remaining.tv_nsec > 0)) { + (delay_remaining.tv_sec > 0 || delay_remaining.tv_nsec > 0)) { result = nanosleep(&delay_remaining, &delay_remaining); } SubSampleInfo* data = &kEncryptedOfflineClip2SubSample; @@ -995,12 +983,11 @@ TEST_F(WvCdmExtendedDurationTest, DISABLED_UsageOverflowTest) { EXPECT_TRUE(handle.Init(security_level)); std::vector provider_session_tokens; EXPECT_TRUE(handle.DeleteAllUsageInfoForApp( - DeviceFiles::GetUsageInfoFileName(""), - &provider_session_tokens)); + DeviceFiles::GetUsageInfoFileName(""), &provider_session_tokens)); for (size_t i = 0; i < kMaxUsageTableSize + 100; ++i) { - decryptor_.OpenSession(g_key_system, property_set, kDefaultCdmIdentifier, - NULL, &session_id_); + decryptor_.OpenSession(config_.key_system(), property_set, + kDefaultCdmIdentifier, NULL, &session_id_); std::string key_id = a2bs_hex( "000000427073736800000000" // blob size and pssh "EDEF8BA979D64ACEA3C827DCD51D21ED00000022" // Widevine system id @@ -1008,30 +995,35 @@ TEST_F(WvCdmExtendedDurationTest, DISABLED_UsageOverflowTest) { "747265616d696e675f636c697035"); GenerateKeyRequest(key_id, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth, false); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), + false); decryptor_.CloseSession(session_id_); } CdmUsageInfo usage_info; CdmUsageInfoReleaseMessage release_msg; - CdmResponseType status = decryptor_.GetUsageInfo( - "", kDefaultCdmIdentifier, &usage_info); + CdmResponseType status = + decryptor_.GetUsageInfo("", 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(g_license_server, g_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; } ASSERT_LE(error_count, 100); // Give up after 100 failures. status = decryptor_.GetUsageInfo("", kDefaultCdmIdentifier, &usage_info); switch (status) { - case KEY_MESSAGE: EXPECT_FALSE(usage_info.empty()); break; - case NO_ERROR: EXPECT_TRUE(usage_info.empty()); break; + case KEY_MESSAGE: + EXPECT_FALSE(usage_info.empty()); + break; + case NO_ERROR: + EXPECT_TRUE(usage_info.empty()); + break; default: FAIL() << "GetUsageInfo failed with error " << static_cast(status); break; @@ -1048,8 +1040,8 @@ TEST_F(WvCdmExtendedDurationTest, AutomatedOfflineSessionReleaseOnTimerEvent) { // Leave session open to run the CDM timer CdmSessionId streaming_session_id; - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &streaming_session_id); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &streaming_session_id); // override default settings unless configured through the command line std::string key_id; @@ -1059,8 +1051,8 @@ TEST_F(WvCdmExtendedDurationTest, AutomatedOfflineSessionReleaseOnTimerEvent) { uint32_t initial_open_sessions = QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); GenerateKeyRequest(kOfflineClip4, kLicenseTypeOffline); VerifyKeyRequestResponse(kUatLicenseServer, client_auth, false); @@ -1070,8 +1062,8 @@ TEST_F(WvCdmExtendedDurationTest, AutomatedOfflineSessionReleaseOnTimerEvent) { session_id_.clear(); key_set_id_.clear(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id)); decryptor_.CloseSession(session_id_); @@ -1112,8 +1104,8 @@ TEST_F(WvCdmExtendedDurationTest, AutomatedOfflineSessionReleaseOnOpenSession) { uint32_t initial_open_sessions = QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); GenerateKeyRequest(kOfflineClip4, kLicenseTypeOffline); VerifyKeyRequestResponse(kUatLicenseServer, client_auth, false); @@ -1123,16 +1115,16 @@ TEST_F(WvCdmExtendedDurationTest, AutomatedOfflineSessionReleaseOnOpenSession) { session_id_.clear(); key_set_id_.clear(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id)); decryptor_.CloseSession(session_id_); session_id_.clear(); GenerateKeyRelease(key_set_id); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); EXPECT_GT( QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS), @@ -1150,8 +1142,8 @@ TEST_F(WvCdmExtendedDurationTest, AutomatedOfflineSessionReleaseOnOpenSession) { QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS), initial_open_sessions); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); EXPECT_GT( QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS), @@ -1194,8 +1186,8 @@ TEST_F(WvCdmExtendedDurationTest, DISABLED_AutomatedOfflineSessionReleaseTest) { std::set key_set_id_map; for (uint32_t i = 0; i < num_key_set_ids; ++i) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); GenerateKeyRequest(kOfflineClip4, kLicenseTypeOffline); VerifyKeyRequestResponse(kUatLicenseServer, client_auth, false); @@ -1208,8 +1200,8 @@ TEST_F(WvCdmExtendedDurationTest, DISABLED_AutomatedOfflineSessionReleaseTest) { for (iter = key_set_id_map.begin(); iter != key_set_id_map.end(); ++iter) { session_id_.clear(); key_set_id_.clear(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, *iter)); decryptor_.CloseSession(session_id_); } @@ -1251,10 +1243,11 @@ TEST_P(WvCdmStreamingNoPstTest, UsageTest) { Unprovision(); Provision(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth, false); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); + GenerateKeyRequest(config_.key_id(), kLicenseTypeStreaming); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), + false); ValidateResponse(video_widevine::STREAMING, false); @@ -1326,10 +1319,11 @@ TEST_P(WvCdmStreamingPstTest, UsageTest) { Unprovision(); Provision(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); GenerateKeyRequest(kStreamingClip8PstInitData, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth, false); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), + false); ValidateResponse(video_widevine::STREAMING, true); @@ -1392,10 +1386,11 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) { Unprovision(); Provision(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); GenerateKeyRequest(kStreamingClip8PstInitData, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth, false); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), + false); ValidateResponse(video_widevine::STREAMING, true); @@ -1450,8 +1445,8 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) { // Create usage report and validate CdmUsageInfo usage_info; CdmUsageInfoReleaseMessage release_msg; - CdmResponseType status = decryptor_.GetUsageInfo( - "", kDefaultCdmIdentifier, &usage_info); + CdmResponseType status = + decryptor_.GetUsageInfo("", kDefaultCdmIdentifier, &usage_info); EXPECT_EQ(usage_info.empty() ? NO_ERROR : KEY_MESSAGE, status); int error_count = 0; while (usage_info.size() > 0) { @@ -1461,8 +1456,8 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) { expected_seconds_since_license_received, expected_seconds_since_initial_playback, expected_seconds_since_last_playback); - release_msg = - GetUsageInfoResponse(g_license_server, g_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++) << ")" @@ -1500,10 +1495,11 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) { Unprovision(); Provision(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); GenerateKeyRequest(kOfflineClip2PstInitData, kLicenseTypeOffline); - VerifyKeyRequestResponse(g_license_server, g_client_auth, false); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), + false); ValidateResponse(video_widevine::OFFLINE, true); @@ -1524,8 +1520,8 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) { for (size_t i = 0; i < GetParam(); ++i) { session_id_.clear(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); EXPECT_EQ(KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id)); // Query and validate usage information @@ -1568,8 +1564,8 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) { } session_id_.clear(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); EXPECT_EQ(KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id)); // Query and validate usage information @@ -1593,7 +1589,8 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) { expected_seconds_since_initial_playback, expected_seconds_since_last_playback); key_set_id_ = key_set_id; - VerifyKeyRequestResponse(g_license_server, g_client_auth, false); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), + false); } INSTANTIATE_TEST_CASE_P(Cdm, WvCdmOfflineUsageReportTest, @@ -1617,8 +1614,8 @@ TEST_F(WvCdmExtendedDurationTest, MaxUsageEntryOfflineRecoveryTest) { // not encounter an error. CdmResponseType response = NO_ERROR; for (size_t i = 0; i < 2000; ++i) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); GenerateKeyRequest(key_id, kLicenseTypeOffline, &response); if (response != KEY_MESSAGE) { decryptor_.CloseSession(session_id_); @@ -1638,8 +1635,8 @@ TEST_F(WvCdmExtendedDurationTest, MaxUsageEntryOfflineRecoveryTest) { if (response != KEY_ADDED && response != KEY_MESSAGE) { Provision(); for (size_t i = 0; i < 10; ++i) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); GenerateKeyRequest(key_id, kLicenseTypeOffline); VerifyKeyRequestResponse(kUatLicenseServer, client_auth, false); decryptor_.CloseSession(session_id_); @@ -1648,112 +1645,3 @@ TEST_F(WvCdmExtendedDurationTest, MaxUsageEntryOfflineRecoveryTest) { } } // namespace wvcdm - -void show_menu(char* prog_name) { - std::cout << std::endl; - std::cout << "usage: " << prog_name << " [options]" << std::endl << std::endl; - std::cout << " enclose multiple arguments in '' when using adb shell" - << std::endl; - std::cout << " e.g. adb shell '" << prog_name << " --server=\"url\"'" - << std::endl; - std::cout << " or adb shell '" << prog_name << " -u\"url\"'" << std::endl - << std::endl; - - std::cout << std::setw(37) << std::left - << " -i/--license_server_id="; - std::cout << "specifies which default server settings to use: " << std::endl; - std::cout << std::setw(37) << std::left << " "; - std::cout << "gp for GooglePlay server" << std::endl; - std::cout << std::setw(37) << std::left << " "; - std::cout << "cp for Content Protection UAT server" << std::endl; - std::cout << std::setw(37) << std::left << " "; - std::cout << "st for Content Protection Staging server" << std::endl - << std::endl; - - std::cout << std::setw(37) << std::left << " -k/--keyid="; - std::cout << "configure the key id or pssh, in hex format" << std::endl - << std::endl; - - std::cout << std::setw(37) << std::left << " -u/--server="; - std::cout - << "configure the license server url, please include http[s] in the url" - << std::endl << std::endl; -} - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - - bool show_usage = false; - static const struct option long_options[] = { - {"keyid", required_argument, NULL, 'k'}, - {"license_server_id", required_argument, NULL, 'i'}, - {"license_server_url", required_argument, NULL, 'u'}, - {NULL, 0, NULL, '\0'}}; - - int option_index = 0; - int opt = 0; - while ((opt = getopt_long(argc, argv, "i:k:u:", long_options, - &option_index)) != -1) { - switch (opt) { - case 'i': { - std::string license_id(optarg); - if (!license_id.compare("gp")) { - g_license_server_id = wvcdm::kGooglePlayServer; - } else if (!license_id.compare("cp")) { - g_license_server_id = wvcdm::kContentProtectionUatServer; - } else if (!license_id.compare("st")) { - g_license_server_id = wvcdm::kContentProtectionStagingServer; - } else { - std::cout << "Invalid license server id" << optarg << std::endl; - show_usage = true; - } - break; - } - case 'k': { - g_key_id.clear(); - g_key_id.assign(optarg); - break; - } - case 'u': { - g_license_server.clear(); - g_license_server.assign(optarg); - break; - } - case '?': { - show_usage = true; - break; - } - } - } - - if (show_usage) { - show_menu(argv[0]); - return 0; - } - - g_config = new wvcdm::ConfigTestEnv(g_license_server_id); - g_client_auth.assign(g_config->client_auth()); - g_key_system.assign(g_config->key_system()); - - // The following variables are configurable through command line - // options. If the command line arguments are absent, use the settings - // in kLicenseServers[] pointed to by g_config. - if (g_key_id.empty()) { - g_key_id.assign(g_config->key_id()); - } - if (g_license_server.empty()) { - g_license_server.assign(g_config->license_server()); - } - - // Displays server url, port and key Id being used - std::cout << std::endl; - std::cout << "Server: " << g_license_server << std::endl; - std::cout << "KeyID: " << g_key_id << std::endl << std::endl; - - g_key_id = wvcdm::a2bs_hex(g_key_id); - g_config->set_license_server(g_license_server); - - int status = RUN_ALL_TESTS(); - delete g_config; - return status; -} diff --git a/libwvdrmengine/cdm/test/cdm_feature_test.cpp b/libwvdrmengine/cdm/test/cdm_feature_test.cpp index a5b0a697..1d1c5547 100644 --- a/libwvdrmengine/cdm/test/cdm_feature_test.cpp +++ b/libwvdrmengine/cdm/test/cdm_feature_test.cpp @@ -22,12 +22,12 @@ #include #include +#include "OEMCryptoCENC.h" #include "config_test_env.h" #include "license_protocol.pb.h" #include "license_request.h" #include "log.h" #include "oemcrypto_adapter.h" -#include "OEMCryptoCENC.h" #include "string_conversions.h" #include "test_base.h" #include "test_printers.h" @@ -37,13 +37,13 @@ #include "wv_cdm_types.h" #include "wv_content_decryption_module.h" +using ::testing::_; using ::testing::Each; using ::testing::Invoke; using ::testing::IsEmpty; using ::testing::Not; using ::testing::Pair; using ::testing::StrictMock; -using ::testing::_; namespace { @@ -56,17 +56,6 @@ const int kHttpOk = 200; // const int kHttpInternalServerError = 500; const std::string kEmptyServiceCertificate; -// Default license server, can be configured using --server command line option -// Default key id (pssh), can be configured using --keyid command line option -std::string g_client_auth; -wvcdm::ConfigTestEnv* g_config = NULL; -wvcdm::KeyId g_key_id; -wvcdm::CdmKeySystem g_key_system; -std::string g_license_server; -wvcdm::ServerConfigurationId g_license_server_id = - wvcdm::kContentProtectionUatServer; -std::string g_service_certificate; - wvcdm::KeyId kSrmHdKeyId1 = wvcdm::a2bs_hex("30303030303030303030303030303032"); wvcdm::KeyId kSrmHdKeyId2 = wvcdm::a2bs_hex("30303030303030303030303030303033"); wvcdm::KeyId kSrmHdKeyId3 = wvcdm::a2bs_hex("30303030303030303030303030303037"); @@ -410,8 +399,8 @@ class WvCdmFeatureTest : public WvCdmTestBase { // To run this test set options, // * use_keybox 0 TEST_F(WvCdmFeatureTest, OEMCertificateProvisioning) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); std::string provisioning_server_url; CdmCertificateType cert_type = kCertificateWidevine; std::string cert_authority, cert, wrapped_key; @@ -422,7 +411,7 @@ TEST_F(WvCdmFeatureTest, OEMCertificateProvisioning) { kEmptyServiceCertificate, &key_msg_, &provisioning_server_url)); - EXPECT_EQ(provisioning_server_url, g_config->provisioning_server()); + EXPECT_EQ(provisioning_server_url, config_.provisioning_server()); ClientIdentification_TokenType token_type; EXPECT_TRUE(ExtractTokenType(key_msg_, &token_type)); @@ -434,7 +423,7 @@ TEST_F(WvCdmFeatureTest, OEMCertificateProvisioning) { "?key=AIzaSyB-5OLKTx2iU5mko18DfdwK5611JIjbUhE"; std::string response = GetCertRequestResponse(provisioning_server_url); - // GetCertRequestResponse(g_config->provisioning_server_url()); + // GetCertRequestResponse(config_.provisioning_server_url()); EXPECT_NE(0, static_cast(response.size())); EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.HandleProvisioningResponse( @@ -447,8 +436,8 @@ TEST_F(WvCdmFeatureTest, OEMCertificateProvisioning) { // To run this test set options, // * use_keybox 1 TEST_F(WvCdmFeatureTest, KeyboxProvisioning) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + NULL, &session_id_); std::string provisioning_server_url; CdmCertificateType cert_type = kCertificateWidevine; std::string cert_authority, cert, wrapped_key; @@ -459,7 +448,7 @@ TEST_F(WvCdmFeatureTest, KeyboxProvisioning) { kEmptyServiceCertificate, &key_msg_, &provisioning_server_url)); - EXPECT_EQ(provisioning_server_url, g_config->provisioning_server()); + EXPECT_EQ(provisioning_server_url, config_.provisioning_server()); ClientIdentification_TokenType token_type; EXPECT_TRUE(ExtractTokenType(key_msg_, &token_type)); @@ -504,8 +493,8 @@ TEST_P(WvCdmSrmTest, Srm) { StrictMock listener; TestKeyVerifier verify_keys_callback(config->expected_key_ids); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, &listener, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + &listener, &session_id_); EXPECT_CALL(listener, OnSessionKeysChange( @@ -524,7 +513,7 @@ TEST_P(WvCdmSrmTest, Srm) { GenerateKeyRequest(init_data, kLicenseTypeStreaming); VerifyKeyRequestResponse( ConfigTestEnv::GetLicenseServerUrl(kContentProtectionStagingServer), - g_client_auth); + config_.client_auth()); EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.QueryStatus(kLevelDefault, @@ -561,8 +550,8 @@ TEST_P(WvCdmSrmNotSupportedTest, Srm) { StrictMock listener; TestKeyVerifier verify_keys_callback(config->expected_key_ids); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, &listener, - &session_id_); + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, + &listener, &session_id_); EXPECT_CALL(listener, OnSessionKeysChange( @@ -581,7 +570,7 @@ TEST_P(WvCdmSrmNotSupportedTest, Srm) { GenerateKeyRequest(init_data, kLicenseTypeStreaming); VerifyKeyRequestResponse( ConfigTestEnv::GetLicenseServerUrl(kContentProtectionStagingServer), - g_client_auth); + config_.client_auth()); EXPECT_NE(wvcdm::NO_ERROR, decryptor_.QueryStatus(kLevelDefault, @@ -596,134 +585,3 @@ INSTANTIATE_TEST_CASE_P( &kSrmNotSupportedTestConfiguration[N_ELEM( kSrmNotSupportedTestConfiguration)])); } // namespace wvcdm - -void show_menu(char* prog_name) { - std::cout << std::endl; - std::cout << "usage: " << prog_name << " [options]" << std::endl << std::endl; - std::cout << " enclose multiple arguments in '' when using adb shell" - << std::endl; - std::cout << " e.g. adb shell '" << prog_name << " --server=\"url\"'" - << std::endl; - std::cout << " or adb shell '" << prog_name << " -u\"url\"'" << std::endl - << std::endl; - - std::cout << " -i/--license_server_id=" << std::endl; - std::cout << " specifies which default server settings to use: " - << std::endl; - std::cout << " gp for GooglePlay server" << std::endl; - std::cout << " cp for Content Protection UAT server" << std::endl; - std::cout << " st for Content Protection Staging server" << std::endl - << std::endl; - - std::cout << " -k/--keyid=" << std::endl; - std::cout << " configure the key id or pssh, in hex format" << std::endl - << std::endl; - - std::cout << " -s/--cert=" << std::endl; - std::cout << " configure the signed service certificate" << std::endl; - std::cout << " Specify the SignedDeviceCertificate (from " - << "device_certificate.proto) " << std::endl; - std::cout << " in hex format." << std::endl; - std::cout << " Due to the length of the argument use, " << std::endl; - std::cout << " echo \"/system/bin/request_license_test -s \\\"" - << "0ABF02...A29914\\\"\" \\" << std::endl; - std::cout << " > run_request_license_test.sh" << std::endl; - std::cout << " chmod +x run_request_license_test.sh" << std::endl; - std::cout << " adb push run_request_license_test.sh /system/bin" - << std::endl; - std::cout << " adb shell sh /system/bin/run_request_license_test.sh" - << std::endl - << std::endl; - - std::cout << " -u/--server=" << std::endl; - std::cout << " configure the license server url, please include http[s]" - << " in the url" << std::endl - << std::endl; -} - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - - bool show_usage = false; - static const struct option long_options[] = { - {"keyid", required_argument, NULL, 'k'}, - {"license_server_id", required_argument, NULL, 'i'}, - {"service_certificate", required_argument, NULL, 's'}, - {"license_server_url", required_argument, NULL, 'u'}, - {NULL, 0, NULL, '\0'}}; - - int option_index = 0; - int opt = 0; - while ((opt = getopt_long(argc, argv, "i:k:s:u:", long_options, - &option_index)) != -1) { - switch (opt) { - case 'i': { - std::string license_id(optarg); - if (!license_id.compare("gp")) { - g_license_server_id = wvcdm::kGooglePlayServer; - } else if (!license_id.compare("cp")) { - g_license_server_id = wvcdm::kContentProtectionUatServer; - } else if (!license_id.compare("st")) { - g_license_server_id = wvcdm::kContentProtectionStagingServer; - } else { - std::cout << "Invalid license server id" << optarg << std::endl; - show_usage = true; - } - break; - } - case 'k': { - g_key_id.clear(); - g_key_id.assign(optarg); - break; - } - case 's': { - g_service_certificate.clear(); - g_service_certificate.assign(optarg); - break; - } - case 'u': { - g_license_server.clear(); - g_license_server.assign(optarg); - break; - } - case '?': { - show_usage = true; - break; - } - } - } - - if (show_usage) { - show_menu(argv[0]); - return 0; - } - - g_config = new wvcdm::ConfigTestEnv(g_license_server_id); - g_client_auth.assign(g_config->client_auth()); - g_key_system.assign(g_config->key_system()); - - // The following variables are configurable through command line - // options. If the command line arguments are absent, use the settings - // in kLicenseServers[] pointed to by g_config. - if (g_key_id.empty()) { - g_key_id.assign(g_config->key_id()); - } - if (g_service_certificate.empty()) { - g_service_certificate.assign(g_config->license_service_certificate()); - } - if (g_license_server.empty()) { - g_license_server.assign(g_config->license_server()); - } - - // Displays server url, port and key Id being used - std::cout << std::endl; - std::cout << "Server: " << g_license_server << std::endl; - std::cout << "KeyID: " << g_key_id << std::endl << std::endl; - - g_key_id = wvcdm::a2bs_hex(g_key_id); - g_config->set_license_server(g_license_server); - - int status = RUN_ALL_TESTS(); - delete g_config; - return status; -} diff --git a/libwvdrmengine/cdm/test/integration-test.mk b/libwvdrmengine/cdm/test/integration-test.mk new file mode 100644 index 00000000..ede901af --- /dev/null +++ b/libwvdrmengine/cdm/test/integration-test.mk @@ -0,0 +1,67 @@ +# ------------------------------------------------------------------- +# Makes a unit or end to end test. +# test_name must be passed in as the base filename(without the .cpp). +# +$(call assert-not-null,test_name) + +include $(CLEAR_VARS) + +LOCAL_MODULE := $(test_name) +LOCAL_MODULE_TAGS := tests + +LOCAL_SRC_FILES := \ + $(test_main) \ + $(test_src_dir)/$(test_name).cpp \ + ../../oemcrypto/test//oec_device_features.cpp \ + ../core/test/config_test_env.cpp \ + ../core/test/http_socket.cpp \ + ../core/test/license_request.cpp \ + ../core/test/test_base.cpp \ + ../core/test/test_printers.cpp \ + ../core/test/url_request.cpp + +LOCAL_C_INCLUDES := \ + vendor/widevine/libwvdrmengine/android/cdm/test \ + vendor/widevine/libwvdrmengine/cdm/core/include \ + vendor/widevine/libwvdrmengine/cdm/core/test \ + vendor/widevine/libwvdrmengine/cdm/include \ + vendor/widevine/libwvdrmengine/cdm/metrics/include \ + vendor/widevine/libwvdrmengine/cdm/util/include \ + vendor/widevine/libwvdrmengine/oemcrypto/include \ + vendor/widevine/libwvdrmengine/oemcrypto/test \ + +LOCAL_C_INCLUDES += external/protobuf/src + +LOCAL_STATIC_LIBRARIES := \ + libcdm \ + libcdm_protos \ + libcdm_utils \ + libcrypto_static \ + libjsmn \ + libgmock \ + libgtest \ + libwvlevel3 \ + +LOCAL_SHARED_LIBRARIES := \ + libcutils \ + libdl \ + liblog \ + libmedia_omx \ + libprotobuf-cpp-lite \ + libssl \ + libstagefright_foundation \ + libutils \ + +LOCAL_CFLAGS += -DUNIT_TEST + +LOCAL_MODULE_OWNER := widevine +LOCAL_PROPRIETARY_MODULE := true + +# When built, explicitly put it in the DATA/bin directory. +LOCAL_MODULE_PATH := $(TARGET_OUT_DATA)/bin + +ifneq ($(TARGET_ENABLE_MEDIADRM_64), true) +LOCAL_MODULE_TARGET_ARCH := arm x86 mips +endif + +include $(BUILD_EXECUTABLE) diff --git a/libwvdrmengine/cdm/test/request_license_test.cpp b/libwvdrmengine/cdm/test/request_license_test.cpp index a8094967..5b9c0f6b 100644 --- a/libwvdrmengine/cdm/test/request_license_test.cpp +++ b/libwvdrmengine/cdm/test/request_license_test.cpp @@ -3,7 +3,6 @@ // License Agreement. #include -#include #include #include @@ -62,17 +61,6 @@ const std::string kEmptyServiceCertificate; using video_widevine::LicenseIdentification; using video_widevine::LicenseRequest_ContentIdentification; -// Default license server, can be configured using --server command line option -// Default key id (pssh), can be configured using --keyid command line option -std::string g_client_auth; -wvcdm::ConfigTestEnv* g_config = NULL; -wvcdm::KeyId g_key_id; -wvcdm::CdmKeySystem g_key_system; -std::string g_license_server; -wvcdm::ServerConfigurationId g_server_configuration_id = - wvcdm::kContentProtectionUatServer; -std::string g_service_certificate; - // TODO(rfrias): refactor to print out the decryption test names struct SubSampleInfo { bool retrieve_key; @@ -1336,16 +1324,16 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { protected: void GetOfflineConfiguration(std::string* key_id, std::string* client_auth) { - ConfigTestEnv config(g_server_configuration_id, false); - if (g_key_id.compare(a2bs_hex(g_config->key_id())) == 0) + ConfigTestEnv config(config_.server_id(), false); + if (binary_key_id().compare(a2bs_hex(config_.key_id())) == 0) key_id->assign(wvcdm::a2bs_hex(config.key_id())); else - key_id->assign(g_key_id); + key_id->assign(binary_key_id()); - if (g_client_auth.compare(g_config->client_auth()) == 0) + if (config_.client_auth().compare(config_.client_auth()) == 0) client_auth->assign(config.client_auth()); else - client_auth->assign(g_client_auth); + client_auth->assign(config_.client_auth()); } void GenerateKeyRequest(const std::string& init_data, @@ -1507,7 +1495,7 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { if (kHttpOk != http_status_code) { LogResponseError(message, http_status_code); } - EXPECT_EQ(kHttpOk, http_status_code); + EXPECT_EQ(kHttpOk, http_status_code) << "message = " << message; return message; } @@ -1598,7 +1586,7 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { } CdmResponseType status = decryptor_.OpenSession( - g_key_system, property_set, identifier, NULL, &session_id_); + config_.key_system(), property_set, identifier, NULL, &session_id_); switch (status) { case NO_ERROR: decryptor_.CloseSession(session_id_); @@ -1620,10 +1608,10 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { &key_msg_, &provisioning_server); EXPECT_EQ(wvcdm::NO_ERROR, status); if (NO_ERROR != status) return; - EXPECT_EQ(provisioning_server, g_config->provisioning_server()); + EXPECT_EQ(provisioning_server, config_.provisioning_server()); std::string response = - GetCertRequestResponse(g_config->provisioning_server()); + GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.HandleProvisioningResponse(identifier, response, @@ -1636,7 +1624,7 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { std::string GetSecurityLevel(TestWvCdmClientPropertySet* property_set) { EXPECT_EQ(NO_ERROR, - decryptor_.OpenSession(g_key_system, property_set, + decryptor_.OpenSession(config_.key_system(), property_set, kDefaultCdmIdentifier, NULL, &session_id_)); CdmQueryMap query_info; @@ -1689,7 +1677,7 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase { TEST_F(WvCdmRequestLicenseTest, ProvisioningTest) { Unprovision(); EXPECT_EQ(NEED_PROVISIONING, - decryptor_.OpenSession(g_key_system, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_)); std::string provisioning_server; @@ -1701,10 +1689,10 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningTest) { kDefaultCdmIdentifier, kEmptyServiceCertificate, &key_msg_, &provisioning_server)); - EXPECT_EQ(provisioning_server, g_config->provisioning_server()); + EXPECT_EQ(provisioning_server, config_.provisioning_server()); std::string response = - GetCertRequestResponse(g_config->provisioning_server()); + GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.HandleProvisioningResponse( kDefaultCdmIdentifier, response, &cert, @@ -1716,7 +1704,7 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningTest) { TEST_F(WvCdmRequestLicenseTest, ProvisioningTestWithServiceCertificate) { CdmResponseType status = - decryptor_.OpenSession(g_key_system, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); EXPECT_TRUE(status == NEED_PROVISIONING || status == NO_ERROR) @@ -1730,10 +1718,10 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningTestWithServiceCertificate) { kDefaultCdmIdentifier, kGoogleStagingServiceCertificate, &key_msg_, &provisioning_server)); - EXPECT_EQ(provisioning_server, g_config->provisioning_server()); + EXPECT_EQ(provisioning_server, config_.provisioning_server()); std::string response = - GetCertRequestResponse(g_config->provisioning_server()); + GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.HandleProvisioningResponse( kDefaultCdmIdentifier, response, &cert, @@ -1747,7 +1735,7 @@ TEST_F(WvCdmRequestLicenseTest, L3ProvisioningTest) { TestWvCdmClientPropertySet property_set_L3; property_set_L3.set_security_level(QUERY_VALUE_SECURITY_LEVEL_L3); CdmResponseType status = - decryptor_.OpenSession(g_key_system, &property_set_L3, + decryptor_.OpenSession(config_.key_system(), &property_set_L3, kDefaultCdmIdentifier, NULL, &session_id_); EXPECT_TRUE(status == NEED_PROVISIONING || status == NO_ERROR) << "Failure to open session. error: " << status; @@ -1760,10 +1748,10 @@ TEST_F(WvCdmRequestLicenseTest, L3ProvisioningTest) { kDefaultCdmIdentifier, kEmptyServiceCertificate, &key_msg_, &provisioning_server)); - EXPECT_EQ(provisioning_server, g_config->provisioning_server()); + EXPECT_EQ(provisioning_server, config_.provisioning_server()); std::string response = - GetCertRequestResponse(g_config->provisioning_server()); + GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.HandleProvisioningResponse( kDefaultCdmIdentifier, response, &cert, @@ -1779,14 +1767,14 @@ TEST_F(WvCdmRequestLicenseTest, PerOriginProvisioningTest) { // Verify the global identifier is provisioned. EXPECT_EQ(wvcdm::NO_ERROR, - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_)); decryptor_.CloseSession(session_id_); // The other identifier should not be provisioned. EXPECT_EQ( wvcdm::NEED_PROVISIONING, - decryptor_.OpenSession(g_key_system, NULL, kExampleIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kExampleIdentifier, NULL, &session_id_)); } @@ -1840,7 +1828,7 @@ TEST_F(WvCdmRequestLicenseTest, UnprovisionTest) { } TEST_F(WvCdmRequestLicenseTest, ProvisioningInterposedRetryTest) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); std::string provisioning_server; CdmCertificateType cert_type = kCertificateWidevine; @@ -1852,18 +1840,18 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningInterposedRetryTest) { kDefaultCdmIdentifier, kEmptyServiceCertificate, &key_msg1, &provisioning_server)); - EXPECT_EQ(provisioning_server, g_config->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(provisioning_server, g_config->provisioning_server()); + EXPECT_EQ(provisioning_server, config_.provisioning_server()); key_msg_ = key_msg2; std::string response = - GetCertRequestResponse(g_config->provisioning_server()); + GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.HandleProvisioningResponse( kDefaultCdmIdentifier, response, &cert, @@ -1872,7 +1860,7 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningInterposedRetryTest) { EXPECT_EQ(0, static_cast(wrapped_key.size())); key_msg_ = key_msg1; - response = GetCertRequestResponse(g_config->provisioning_server()); + response = GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.HandleProvisioningResponse(kDefaultCdmIdentifier, @@ -1884,7 +1872,7 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningInterposedRetryTest) { } TEST_F(WvCdmRequestLicenseTest, ProvisioningInterspersedRetryTest) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); std::string provisioning_server; CdmCertificateType cert_type = kCertificateWidevine; @@ -1896,18 +1884,18 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningInterspersedRetryTest) { kDefaultCdmIdentifier, kEmptyServiceCertificate, &key_msg1, &provisioning_server)); - EXPECT_EQ(provisioning_server, g_config->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(provisioning_server, g_config->provisioning_server()); + EXPECT_EQ(provisioning_server, config_.provisioning_server()); key_msg_ = key_msg1; std::string response = - GetCertRequestResponse(g_config->provisioning_server()); + GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); EXPECT_EQ(wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_6, decryptor_.HandleProvisioningResponse(kDefaultCdmIdentifier, @@ -1917,7 +1905,7 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningInterspersedRetryTest) { EXPECT_EQ(0, static_cast(wrapped_key.size())); key_msg_ = key_msg2; - response = GetCertRequestResponse(g_config->provisioning_server()); + response = GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.HandleProvisioningResponse( kDefaultCdmIdentifier, response, &cert, @@ -1929,7 +1917,7 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningInterspersedRetryTest) { } TEST_F(WvCdmRequestLicenseTest, DISABLED_X509ProvisioningTest) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); std::string provisioning_server; CdmCertificateType cert_type = kCertificateX509; @@ -1942,10 +1930,10 @@ TEST_F(WvCdmRequestLicenseTest, DISABLED_X509ProvisioningTest) { kDefaultCdmIdentifier, kEmptyServiceCertificate, &key_msg_, &provisioning_server)); - EXPECT_EQ(provisioning_server, g_config->provisioning_server()); + EXPECT_EQ(provisioning_server, config_.provisioning_server()); std::string response = - GetCertRequestResponse(g_config->provisioning_server()); + GetCertRequestResponse(config_.provisioning_server()); EXPECT_NE(0, static_cast(response.size())); EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.HandleProvisioningResponse( kDefaultCdmIdentifier, response, &cert, @@ -1965,13 +1953,13 @@ TEST_F(WvCdmRequestLicenseTest, PropertySetTest) { property_set_L1.set_security_level(QUERY_VALUE_SECURITY_LEVEL_L1); property_set_L1.set_use_privacy_mode(true); - decryptor_.OpenSession(g_key_system, &property_set_L1, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set_L1, kDefaultCdmIdentifier, NULL, &session_id_L1); property_set_L3.set_security_level(QUERY_VALUE_SECURITY_LEVEL_L3); property_set_L3.set_use_privacy_mode(false); CdmResponseType sts = decryptor_.OpenSession( - g_key_system, &property_set_L3, kDefaultCdmIdentifier, NULL, + config_.key_system(), &property_set_L3, kDefaultCdmIdentifier, NULL, &session_id_L3); if (NEED_PROVISIONING == sts) { @@ -1982,15 +1970,15 @@ TEST_F(WvCdmRequestLicenseTest, PropertySetTest) { cert_type, cert_authority, kDefaultCdmIdentifier, kEmptyServiceCertificate, &key_msg_, &provisioning_server)); - EXPECT_EQ(provisioning_server, g_config->provisioning_server()); + EXPECT_EQ(provisioning_server, config_.provisioning_server()); std::string response = - GetCertRequestResponse(g_config->provisioning_server()); + 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_.OpenSession(g_key_system, &property_set_L3, + decryptor_.OpenSession(config_.key_system(), &property_set_L3, kDefaultCdmIdentifier, NULL, &session_id_L3)); } else { @@ -1998,7 +1986,7 @@ TEST_F(WvCdmRequestLicenseTest, PropertySetTest) { } property_set_Ln.set_security_level(""); - decryptor_.OpenSession(g_key_system, &property_set_Ln, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set_Ln, kDefaultCdmIdentifier, NULL, &session_id_Ln); CdmQueryMap query_info; @@ -2050,7 +2038,7 @@ TEST_F(WvCdmRequestLicenseTest, ForceL3Test) { EXPECT_TRUE(handle.DeleteAllFiles()); EXPECT_EQ(NEED_PROVISIONING, - decryptor_.OpenSession(g_key_system, &property_set, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_)); std::string provisioning_server; CdmCertificateType cert_type = kCertificateWidevine; @@ -2059,19 +2047,19 @@ TEST_F(WvCdmRequestLicenseTest, ForceL3Test) { cert_type, cert_authority, kDefaultCdmIdentifier, kEmptyServiceCertificate, &key_msg_, &provisioning_server)); - EXPECT_EQ(provisioning_server, g_config->provisioning_server()); + EXPECT_EQ(provisioning_server, config_.provisioning_server()); std::string response = - GetCertRequestResponse(g_config->provisioning_server()); + 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_.OpenSession(g_key_system, &property_set, + EXPECT_EQ(NO_ERROR, decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_)); - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); decryptor_.CloseSession(session_id_); } @@ -2079,18 +2067,18 @@ TEST_F(WvCdmRequestLicenseTest, PrivacyModeTest) { TestWvCdmClientPropertySet property_set; property_set.set_use_privacy_mode(true); - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); - std::string resp = GetKeyRequestResponse(g_license_server, g_client_auth); + GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming); + 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; // Verify cached initialization data from previous request is used when // empty initialization data is passed. GenerateKeyRequest(empty_init_data, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); decryptor_.CloseSession(session_id_); } @@ -2098,28 +2086,28 @@ TEST_F(WvCdmRequestLicenseTest, PrivacyModeWithServiceCertificateTest) { TestWvCdmClientPropertySet property_set; property_set.set_use_privacy_mode(true); - property_set.set_service_certificate(g_service_certificate); - // TODO: pass g_service_certificate into CdmEngine::SetServiceCertificate() - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + property_set.set_service_certificate(config_.license_service_certificate()); + // TODO: pass config_.service_certificate() into CdmEngine::SetServiceCertificate() + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); decryptor_.CloseSession(session_id_); } TEST_F(WvCdmRequestLicenseTest, BaseMessageTest) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); - GetKeyRequestResponse(g_license_server, g_client_auth); + GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming); + GetKeyRequestResponse(config_.license_server(), config_.client_auth()); decryptor_.CloseSession(session_id_); } TEST_F(WvCdmRequestLicenseTest, AddStreamingKeyTest) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); decryptor_.CloseSession(session_id_); } @@ -2132,10 +2120,10 @@ TEST_F(WvCdmRequestLicenseTest, AddKeyOfflineTest) { std::string client_auth; GetOfflineConfiguration(&key_id, &client_auth); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(key_id, kLicenseTypeOffline); - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); decryptor_.CloseSession(session_id_); } @@ -2148,17 +2136,17 @@ TEST_F(WvCdmRequestLicenseTest, RestoreOfflineKeyTest) { std::string client_auth; GetOfflineConfiguration(&key_id, &client_auth); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(key_id, kLicenseTypeOffline); - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); CdmKeySetId key_set_id = key_set_id_; EXPECT_FALSE(key_set_id_.empty()); decryptor_.CloseSession(session_id_); session_id_.clear(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id)); decryptor_.CloseSession(session_id_); @@ -2173,10 +2161,10 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseOfflineKeyTest) { std::string client_auth; GetOfflineConfiguration(&key_id, &client_auth); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(key_id, kLicenseTypeOffline); - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); CdmKeySetId key_set_id = key_set_id_; EXPECT_FALSE(key_set_id_.empty()); @@ -2184,7 +2172,7 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseOfflineKeyTest) { session_id_.clear(); key_set_id_.clear(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id)); decryptor_.CloseSession(session_id_); @@ -2193,7 +2181,7 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseOfflineKeyTest) { key_set_id_.clear(); GenerateKeyRelease(key_set_id); key_set_id_ = key_set_id; - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); } TEST_F(WvCdmRequestLicenseTest, ReleaseOfflineKeySessionUsageDisabledTest) { @@ -2209,10 +2197,10 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseOfflineKeySessionUsageDisabledTest) { GetOfflineConfiguration(&key_id, &client_auth); key_id[key_id.size()-1] = '1'; - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(key_id, kLicenseTypeOffline); - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); CdmKeySetId key_set_id = key_set_id_; EXPECT_FALSE(key_set_id_.empty()); @@ -2220,7 +2208,7 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseOfflineKeySessionUsageDisabledTest) { session_id_.clear(); key_set_id_.clear(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id)); decryptor_.CloseSession(session_id_); @@ -2230,7 +2218,7 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseOfflineKeySessionUsageDisabledTest) { CdmKeyMessage key_msg; GenerateKeyRelease(key_set_id, NULL, &key_msg); key_set_id_ = key_set_id; - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); SignedMessage signed_message; EXPECT_TRUE(signed_message.ParseFromString(key_msg)); @@ -2264,10 +2252,10 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryOfflineKeyTest) { std::string client_auth; GetOfflineConfiguration(&key_id, &client_auth); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(key_id, kLicenseTypeOffline); - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); CdmKeySetId key_set_id = key_set_id_; EXPECT_FALSE(key_set_id_.empty()); @@ -2275,7 +2263,7 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryOfflineKeyTest) { session_id_.clear(); key_set_id_.clear(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id)); decryptor_.CloseSession(session_id_); @@ -2285,7 +2273,7 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryOfflineKeyTest) { GenerateKeyRelease(key_set_id); session_id_.clear(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); EXPECT_EQ(wvcdm::GET_RELEASED_LICENSE_ERROR, decryptor_.RestoreKey(session_id_, key_set_id)); @@ -2295,7 +2283,7 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryOfflineKeyTest) { key_set_id_.clear(); GenerateKeyRelease(key_set_id); key_set_id_ = key_set_id; - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); } TEST_F(WvCdmRequestLicenseTest, ReleaseRetryL3OfflineKeyTest) { @@ -2310,7 +2298,7 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryL3OfflineKeyTest) { GetOfflineConfiguration(&key_id, &client_auth); CdmResponseType sts = decryptor_.OpenSession( - g_key_system, &property_set, kDefaultCdmIdentifier, NULL, &session_id_); + config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); if (NEED_PROVISIONING == sts) { std::string provisioning_server; @@ -2320,25 +2308,25 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryL3OfflineKeyTest) { cert_type, cert_authority, kDefaultCdmIdentifier, kEmptyServiceCertificate, &key_msg_, &provisioning_server)); - EXPECT_EQ(provisioning_server, g_config->provisioning_server()); + EXPECT_EQ(provisioning_server, config_.provisioning_server()); std::string response = - GetCertRequestResponse(g_config->provisioning_server()); + 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_.OpenSession(g_key_system, &property_set, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_)); } else { EXPECT_EQ(NO_ERROR, sts); } - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(key_id, kLicenseTypeOffline, &property_set); - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); CdmKeySetId key_set_id = key_set_id_; EXPECT_FALSE(key_set_id_.empty()); @@ -2346,7 +2334,7 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryL3OfflineKeyTest) { session_id_.clear(); key_set_id_.clear(); - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id)); decryptor_.CloseSession(session_id_); @@ -2356,7 +2344,7 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryL3OfflineKeyTest) { GenerateKeyRelease(key_set_id, &property_set, NULL); session_id_.clear(); - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); EXPECT_EQ(wvcdm::GET_RELEASED_LICENSE_ERROR, decryptor_.RestoreKey(session_id_, key_set_id)); @@ -2366,7 +2354,7 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryL3OfflineKeyTest) { key_set_id_.clear(); GenerateKeyRelease(key_set_id, &property_set, NULL); key_set_id_ = key_set_id; - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); } TEST_F(WvCdmRequestLicenseTest, @@ -2386,7 +2374,7 @@ TEST_F(WvCdmRequestLicenseTest, key_id[key_id.size()-1] = '1'; CdmResponseType sts = decryptor_.OpenSession( - g_key_system, &property_set, kDefaultCdmIdentifier, NULL, &session_id_); + config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); if (NEED_PROVISIONING == sts) { std::string provisioning_server_url; @@ -2396,25 +2384,25 @@ TEST_F(WvCdmRequestLicenseTest, cert_type, cert_authority, kDefaultCdmIdentifier, kEmptyServiceCertificate, &key_msg_, &provisioning_server_url)); - EXPECT_EQ(provisioning_server_url, g_config->provisioning_server()); + EXPECT_EQ(provisioning_server_url, config_.provisioning_server()); std::string response = - GetCertRequestResponse(g_config->provisioning_server()); + 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_.OpenSession(g_key_system, &property_set, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_)); } else { EXPECT_EQ(NO_ERROR, sts); } - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(key_id, kLicenseTypeOffline, &property_set); - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); CdmKeySetId key_set_id = key_set_id_; EXPECT_FALSE(key_set_id_.empty()); @@ -2422,7 +2410,7 @@ TEST_F(WvCdmRequestLicenseTest, session_id_.clear(); key_set_id_.clear(); - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id)); decryptor_.CloseSession(session_id_); @@ -2432,7 +2420,7 @@ TEST_F(WvCdmRequestLicenseTest, GenerateKeyRelease(key_set_id, &property_set, NULL); session_id_.clear(); - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); EXPECT_EQ(wvcdm::GET_RELEASED_LICENSE_ERROR, decryptor_.RestoreKey(session_id_, key_set_id)); @@ -2442,7 +2430,7 @@ TEST_F(WvCdmRequestLicenseTest, key_set_id_.clear(); GenerateKeyRelease(key_set_id, &property_set, NULL); key_set_id_ = key_set_id; - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); } // This test verifies that repeated generation of the key release message @@ -2457,10 +2445,10 @@ TEST_F(WvCdmRequestLicenseTest, AutomatedOfflineSessionReleaseTest) { std::string client_auth; GetOfflineConfiguration(&key_id, &client_auth); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(key_id, kLicenseTypeOffline); - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); CdmKeySetId key_set_id = key_set_id_; EXPECT_FALSE(key_set_id_.empty()); @@ -2468,7 +2456,7 @@ TEST_F(WvCdmRequestLicenseTest, AutomatedOfflineSessionReleaseTest) { session_id_.clear(); key_set_id_.clear(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id)); decryptor_.CloseSession(session_id_); @@ -2494,7 +2482,7 @@ TEST_F(WvCdmRequestLicenseTest, AutomatedOfflineSessionReleaseTest) { open_sessions, QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS)); - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); EXPECT_EQ( --open_sessions, @@ -2502,20 +2490,20 @@ TEST_F(WvCdmRequestLicenseTest, AutomatedOfflineSessionReleaseTest) { } TEST_F(WvCdmRequestLicenseTest, StreamingLicenseRenewal) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); std::string license_server; GenerateRenewalRequest(kLicenseTypeStreaming, &license_server); - if (license_server.empty()) license_server = g_license_server; - VerifyKeyRequestResponse(license_server, g_client_auth); + if (license_server.empty()) license_server = config_.license_server(); + VerifyKeyRequestResponse(license_server, config_.client_auth()); decryptor_.CloseSession(session_id_); } TEST_F(WvCdmRequestLicenseTest, StreamingLicenseRenewalProhibited) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); std::string key_id = a2bs_hex( // streaming_clip11 "000000437073736800000000" // blob size and pssh @@ -2523,7 +2511,7 @@ TEST_F(WvCdmRequestLicenseTest, StreamingLicenseRenewalProhibited) { "08011a0d7769646576696e655f746573" // pssh data "74221073747265616d696e675f636c69703131"); GenerateKeyRequest(key_id, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); std::string init_data; wvcdm::CdmAppParameterMap app_parameters; @@ -2546,24 +2534,24 @@ TEST_F(WvCdmRequestLicenseTest, OfflineLicenseRenewal) { std::string client_auth; GetOfflineConfiguration(&key_id, &client_auth); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(key_id, kLicenseTypeOffline); - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); std::string license_server; GenerateRenewalRequest(kLicenseTypeOffline, &license_server); - if (license_server.empty()) license_server = g_license_server; + if (license_server.empty()) license_server = config_.license_server(); VerifyKeyRequestResponse(license_server, client_auth); decryptor_.CloseSession(session_id_); } TEST_F(WvCdmRequestLicenseTest, RemoveKeys) { - ASSERT_EQ(NO_ERROR, decryptor_.OpenSession(g_key_system, NULL, + ASSERT_EQ(NO_ERROR, decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_)); - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); SubSampleInfo* data = &single_encrypted_sub_sample; std::vector decrypt_buffer(data->encrypt_data.size()); @@ -2606,7 +2594,7 @@ TEST_P(WvCdmStreamingLicenseRenewalTest, WithClientId) { "08011a0d7769646576696e655f74657374220f73" // pssh data "747265616d696e675f636c697036"); } else { - key_id = g_key_id; + key_id = binary_key_id(); } const uint32_t kNameValueParamSize = 2; @@ -2623,21 +2611,22 @@ TEST_P(WvCdmStreamingLicenseRenewalTest, WithClientId) { if (config->enable_privacy_mode) { property_set.set_use_privacy_mode(true); if (config->specify_service_certificate) - property_set.set_service_certificate(g_service_certificate); + property_set.set_service_certificate( + config_.license_service_certificate()); } - // TODO: pass g_service_certificate into CdmEngine::SetServiceCertificate() - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + // TODO: pass config_.service_certificate() into CdmEngine::SetServiceCertificate() + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(key_id, app_parameters, kLicenseTypeStreaming, &property_set); if (config->enable_privacy_mode && !config->specify_service_certificate) { - std::string resp = GetKeyRequestResponse(g_license_server, g_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); } std::string key_response; - VerifyKeyRequestResponse(g_license_server, g_client_auth, false, + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), false, &key_response); // Validate signed license @@ -2661,7 +2650,7 @@ TEST_P(WvCdmStreamingLicenseRenewalTest, WithClientId) { std::string license_server; CdmKeyMessage key_msg; GenerateRenewalRequest(kLicenseTypeStreaming, &key_msg, &license_server); - if (license_server.empty()) license_server = g_license_server; + if (license_server.empty()) license_server = config_.license_server(); // Validate signed renewal request EXPECT_TRUE(signed_message.ParseFromString(key_msg)) @@ -2705,7 +2694,7 @@ TEST_P(WvCdmStreamingLicenseRenewalTest, WithClientId) { 0u, license_renewal.encrypted_client_id().encrypted_client_id().size()); } - VerifyKeyRequestResponse(license_server, g_client_auth); + VerifyKeyRequestResponse(license_server, config_.client_auth()); decryptor_.CloseSession(session_id_); } @@ -2754,20 +2743,20 @@ 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(g_service_certificate); + property_set.set_service_certificate(config_.license_service_certificate()); } - // TODO: pass g_service_certificate into CdmEngine::SetServiceCertificate() - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + // TODO: pass config_.service_certificate() into CdmEngine::SetServiceCertificate() + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(key_id, app_parameters, kLicenseTypeOffline, NULL); if (config->enable_privacy_mode && !config->specify_service_certificate) { - std::string resp = GetKeyRequestResponse(g_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(g_license_server, client_auth, false, &key_response); + VerifyKeyRequestResponse(config_.license_server(), client_auth, false, &key_response); // Validate signed license SignedMessage signed_message; @@ -2794,7 +2783,7 @@ TEST_P(WvCdmOfflineLicenseReleaseTest, WithClientId) { session_id_.clear(); key_set_id_.clear(); - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id)); decryptor_.CloseSession(session_id_); @@ -2847,7 +2836,7 @@ TEST_P(WvCdmOfflineLicenseReleaseTest, WithClientId) { 0u, license_release.encrypted_client_id().encrypted_client_id().size()); } - VerifyKeyRequestResponse(g_license_server, client_auth); + VerifyKeyRequestResponse(config_.license_server(), client_auth); decryptor_.CloseSession(session_id_); } @@ -2895,14 +2884,14 @@ TEST_P(WvCdmUsageTest, WithClientId) { TestWvCdmClientPropertySet property_set; SubSampleInfo* data = &usage_info_sub_samples_icp[0]; - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(key_id, app_parameters, kLicenseTypeStreaming, &property_set); std::string key_response; - VerifyKeyRequestResponse(g_license_server, g_client_auth, true, + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), true, &key_response); // Validate signed license @@ -2974,7 +2963,7 @@ TEST_P(WvCdmUsageTest, WithClientId) { } release_msg = - GetUsageInfoResponse(g_license_server, g_client_auth, usage_info[0]); + GetUsageInfoResponse(config_.license_server(), config_.client_auth(), usage_info[0]); EXPECT_EQ(NO_ERROR, decryptor_.ReleaseUsageInfo(release_msg, kDefaultCdmIdentifier)); } @@ -2999,7 +2988,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfoRetryTest) { &psts)); SubSampleInfo* data = &usage_info_sub_samples_icp[0]; - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); std::string key_id = a2bs_hex( "000000427073736800000000" // blob size and pssh @@ -3008,7 +2997,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfoRetryTest) { "747265616d696e675f636c697033"); GenerateKeyRequest(key_id, kLicenseTypeStreaming, NULL); - VerifyUsageKeyRequestResponse(g_license_server, g_client_auth); + VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -3038,7 +3027,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfoRetryTest) { while (usage_info.size() > 0) { for (size_t i = 0; i < usage_info.size(); ++i) { release_msg = - GetUsageInfoResponse(g_license_server, g_client_auth, usage_info[i]); + 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++) << ")" @@ -3091,7 +3080,7 @@ TEST_P(WvCdmUsageInfoTest, UsageInfo) { for (size_t i = 0; i < usage_info_data->usage_info; ++i) { SubSampleInfo* data = usage_info_data->sub_sample + i; - decryptor_.OpenSession(g_key_system, property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), property_set, kDefaultCdmIdentifier, NULL, &session_id_); std::string key_id = a2bs_hex( "000000427073736800000000" // blob size and pssh @@ -3106,9 +3095,9 @@ TEST_P(WvCdmUsageInfoTest, UsageInfo) { // TODO(rfrias): streaming_clip6 is a streaming license without a pst if (ch == '6') - VerifyKeyRequestResponse(g_license_server, g_client_auth, false); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), false); else - VerifyUsageKeyRequestResponse(g_license_server, g_client_auth); + VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -3135,7 +3124,7 @@ TEST_P(WvCdmUsageInfoTest, UsageInfo) { while (usage_info.size() > 0) { for (size_t i = 0; i < usage_info.size(); ++i) { release_msg = - GetUsageInfoResponse(g_license_server, g_client_auth, usage_info[i]); + 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++) << ")" @@ -3178,7 +3167,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveAllTest) { for (size_t i = 0; i < N_ELEM(usage_info_sub_samples_icp); ++i) { SubSampleInfo* data = usage_info_sub_samples_icp + i; property_set.set_app_id(i % 2 == 0 ? app_id_empty : app_id_not_empty); - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); std::string key_id = a2bs_hex( "000000427073736800000000" // blob size and pssh @@ -3193,9 +3182,9 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveAllTest) { // TODO(rfrias): streaming_clip6 is a streaming license without a pst if (ch == '6') - VerifyKeyRequestResponse(g_license_server, g_client_auth, false); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), false); else - VerifyUsageKeyRequestResponse(g_license_server, g_client_auth); + VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -3276,7 +3265,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest) { for (size_t i = 0; i < N_ELEM(usage_info_sub_samples_icp); ++i) { SubSampleInfo* data = usage_info_sub_samples_icp + i; property_set.set_app_id(i % 2 == 0 ? app_id_empty : app_id_not_empty); - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); std::string key_id = a2bs_hex( "000000427073736800000000" // blob size and pssh @@ -3291,9 +3280,9 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest) { // TODO(rfrias): streaming_clip6 is a streaming license without a pst if (ch == '6') - VerifyKeyRequestResponse(g_license_server, g_client_auth, false); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), false); else - VerifyUsageKeyRequestResponse(g_license_server, g_client_auth); + VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -3426,7 +3415,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) { for (size_t i = 0; i < N_ELEM(usage_info_sub_samples_icp); ++i) { SubSampleInfo* data = usage_info_sub_samples_icp + i; property_set.set_app_id(i % 2 == 0 ? app_id_empty : app_id_not_empty); - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); std::string key_id = a2bs_hex( "000000427073736800000000" // blob size and pssh @@ -3441,9 +3430,9 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) { // TODO(rfrias): streaming_clip6 is a streaming license without a pst if (ch == '6') - VerifyKeyRequestResponse(g_license_server, g_client_auth, false); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(), false); else - VerifyUsageKeyRequestResponse(g_license_server, g_client_auth); + VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -3598,12 +3587,12 @@ TEST_F(WvCdmRequestLicenseTest, GetSecureStopIdsTest) { SubSampleInfo* data = kUsageLicenseTestVector1[i].sub_sample; property_set.set_app_id(app_id_empty); - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(kUsageLicenseTestVector1[i].pssh, kLicenseTypeStreaming, &property_set); - VerifyUsageKeyRequestResponse(g_license_server, g_client_auth); + VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -3652,7 +3641,7 @@ TEST_F(WvCdmRequestLicenseTest, GetSecureStopIdsTest) { property_set.set_app_id(kExampleIdentifier.app_package_name); EXPECT_EQ(NO_ERROR, - decryptor_.OpenSession(g_key_system, &property_set, + decryptor_.OpenSession(config_.key_system(), &property_set, kExampleIdentifier, NULL, &session_id_)); std::string init_data_type = "video/mp4"; @@ -3662,7 +3651,7 @@ TEST_F(WvCdmRequestLicenseTest, GetSecureStopIdsTest) { kLicenseTypeStreaming, kExampleIdentifier, &property_set); - VerifyUsageKeyRequestResponse(g_license_server, g_client_auth); + VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -3750,12 +3739,12 @@ TEST_F(WvCdmRequestLicenseTest, UsageRecoveryTest) { SubSampleInfo* data = kUsageLicenseTestVector1[0].sub_sample; property_set.set_app_id(app_id_empty); - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(kUsageLicenseTestVector1[0].pssh, kLicenseTypeStreaming, &property_set); - VerifyUsageKeyRequestResponse(g_license_server, g_client_auth); + VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -3799,24 +3788,24 @@ TEST_F(WvCdmRequestLicenseTest, UsageRecoveryTest) { // Fetch a second usage license, this should fail as the usage table is // corrupt - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(kUsageLicenseTestVector1[1].pssh, kLicenseTypeStreaming, &property_set); std::string response; - VerifyKeyRequestResponse(wvcdm::STORE_USAGE_INFO_ERROR, g_license_server, - g_client_auth, true, &response); + VerifyKeyRequestResponse(wvcdm::STORE_USAGE_INFO_ERROR, config_.license_server(), + config_.client_auth(), true, &response); decryptor_.CloseSession(session_id_); // Fetch the second usage license and verify that it is usable - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(kUsageLicenseTestVector1[1].pssh, kLicenseTypeStreaming, &property_set); - VerifyUsageKeyRequestResponse(g_license_server, g_client_auth); + VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); data = kUsageLicenseTestVector1[1].sub_sample; @@ -3860,12 +3849,12 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveSecureStopTest) { SubSampleInfo* data = kUsageLicenseTestVector1[i].sub_sample; property_set.set_app_id(app_id_empty); - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); GenerateKeyRequest(kUsageLicenseTestVector1[i].pssh, kLicenseTypeStreaming, &property_set); - VerifyUsageKeyRequestResponse(g_license_server, g_client_auth); + VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -3890,7 +3879,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveSecureStopTest) { property_set.set_app_id(kExampleIdentifier.app_package_name); EXPECT_EQ(NO_ERROR, - decryptor_.OpenSession(g_key_system, &property_set, + decryptor_.OpenSession(config_.key_system(), &property_set, kExampleIdentifier, NULL, &session_id_)); std::string init_data_type = "video/mp4"; @@ -3900,7 +3889,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveSecureStopTest) { kLicenseTypeStreaming, kExampleIdentifier, &property_set); - VerifyUsageKeyRequestResponse(g_license_server, g_client_auth); + VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth()); std::vector decrypt_buffer(data->encrypt_data.size()); CdmDecryptionParameters decryption_parameters( @@ -3988,10 +3977,10 @@ TEST_F(WvCdmRequestLicenseTest, QueryKeyStatus) { Unprovision(); Provision(kLevelDefault); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); CdmQueryMap query_info; CdmQueryMap::iterator itr; @@ -4228,10 +4217,10 @@ TEST_F(WvCdmRequestLicenseTest, QueryOemCryptoSessionId) { Unprovision(); Provision(kLevelDefault); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); CdmQueryMap query_info; CdmQueryMap::iterator itr; @@ -4250,10 +4239,10 @@ TEST_F(WvCdmRequestLicenseTest, QueryOemCryptoSessionId) { } TEST_F(WvCdmRequestLicenseTest, DISABLED_OfflineLicenseDecryptionTest) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); - GenerateKeyRequest(g_key_id, kLicenseTypeOffline); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + GenerateKeyRequest(binary_key_id(), kLicenseTypeOffline); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); /* // key 1, encrypted, 256b @@ -4304,16 +4293,16 @@ TEST_F(WvCdmRequestLicenseTest, DISABLED_OfflineLicenseDecryptionTest) { } TEST_F(WvCdmRequestLicenseTest, DISABLED_RestoreOfflineLicenseDecryptionTest) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); - GenerateKeyRequest(g_key_id, kLicenseTypeOffline); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + GenerateKeyRequest(binary_key_id(), kLicenseTypeOffline); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); CdmKeySetId key_set_id = key_set_id_; EXPECT_FALSE(key_set_id_.empty()); decryptor_.CloseSession(session_id_); session_id_.clear(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id)); /* @@ -4367,9 +4356,9 @@ TEST_F(WvCdmRequestLicenseTest, DISABLED_RestoreOfflineLicenseDecryptionTest) { // TODO(rfrias, edwinwong): pending L1 OEMCrypto due to key block handling /* TEST_F(WvCdmRequestLicenseTest, KeyControlBlockDecryptionTest) { - decryptor_.OpenSession(g_key_system, &session_id_); - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + decryptor_.OpenSession(config_.key_system(), &session_id_); + GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); DecryptionData data; @@ -4436,12 +4425,12 @@ TEST_P(WvCdmSessionSharingTest, SessionSharingTest) { property_set.set_session_sharing_mode( session_sharing_info->session_sharing_enabled); - ASSERT_EQ(NO_ERROR, decryptor_.OpenSession(g_key_system, &property_set, + ASSERT_EQ(NO_ERROR, decryptor_.OpenSession(config_.key_system(), &property_set, cdm_identifier, NULL, &session_id_)); CdmSessionId gp_session_id_1 = session_id_; - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming, cdm_identifier); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming, cdm_identifier); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); // TODO(rfrias): Move content information to ConfigTestEnv std::string gp_client_auth2 = @@ -4451,12 +4440,12 @@ TEST_P(WvCdmSessionSharingTest, SessionSharingTest) { "edef8ba979d64acea3c827dcd51d21ed00000014" // Widevine system id "08011210bdf1cb4fffc6506b8b7945b0bd2917fb"); // pssh data - ASSERT_EQ(NO_ERROR, decryptor_.OpenSession(g_key_system, &property_set, + ASSERT_EQ(NO_ERROR, decryptor_.OpenSession(config_.key_system(), &property_set, cdm_identifier, NULL, &session_id_)); CdmSessionId gp_session_id_2 = session_id_; GenerateKeyRequest(gp_key_id2, kLicenseTypeStreaming, cdm_identifier); - VerifyKeyRequestResponse(g_license_server, gp_client_auth2); + VerifyKeyRequestResponse(config_.license_server(), gp_client_auth2); SubSampleInfo* data = session_sharing_info->sub_sample; std::vector decrypt_buffer(data->encrypt_data.size()); @@ -4506,11 +4495,11 @@ TEST_F(WvCdmRequestLicenseTest, SessionSharingTest) { "EDEF8BA979D64ACEA3C827DCD51D21ED00000014" // Widevine system id "0801121030313233343536373839616263646566"); // pssh data - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); CdmSessionId session_id1 = session_id_; GenerateKeyRequest(init_data1, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); // TODO(rfrias): Move content information to ConfigTestEnv std::string gp_client_auth2 = @@ -4520,11 +4509,11 @@ TEST_F(WvCdmRequestLicenseTest, SessionSharingTest) { "edef8ba979d64acea3c827dcd51d21ed00000014" // Widevine system id "08011210bdf1cb4fffc6506b8b7945b0bd2917fb"); // pssh data - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); CdmSessionId session_id2 = session_id_; GenerateKeyRequest(init_data2, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, gp_client_auth2); + VerifyKeyRequestResponse(config_.license_server(), gp_client_auth2); SubSampleInfo* data = &single_encrypted_sub_sample_short_expiry; @@ -4542,11 +4531,11 @@ TEST_F(WvCdmRequestLicenseTest, SessionSharingTest) { sleep(kSingleEncryptedSubSampleIcpLicenseDurationExpiration - kSingleEncryptedSubSampleIcpLicenseExpirationWindow); - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); CdmSessionId session_id3 = session_id_; GenerateKeyRequest(init_data1, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); EXPECT_EQ(NO_ERROR, decryptor_.Decrypt(session_id1, data->validate_key_id, decryption_parameters)); @@ -4567,11 +4556,11 @@ TEST_F(WvCdmRequestLicenseTest, DecryptionKeyExpiredTest) { "EDEF8BA979D64ACEA3C827DCD51D21ED00000014" // Widevine system id "0801121030313233343536373839616263646566"); // pssh data SubSampleInfo* data = &single_encrypted_sub_sample_short_expiry; - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); if (data->retrieve_key) { GenerateKeyRequest(kCpKeyId, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); } std::vector decrypt_buffer(data->encrypt_data.size()); @@ -4595,7 +4584,7 @@ TEST_F(WvCdmRequestLicenseTest, SessionKeyChangeNotificationTest) { DecryptCallbackTester decrypt_callback( &decryptor_, &single_encrypted_sub_sample_short_expiry); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, &listener, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, &listener, &session_id_); EXPECT_CALL( listener, @@ -4612,7 +4601,7 @@ TEST_F(WvCdmRequestLicenseTest, SessionKeyChangeNotificationTest) { "0801121030313233343536373839616263646566"); // pssh data GenerateKeyRequest(kCpKeyId, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); decryptor_.CloseSession(session_id_); } @@ -4623,11 +4612,11 @@ class WvCdmDecryptionTest TEST_P(WvCdmDecryptionTest, DecryptionTest) { SubSampleInfo* data = GetParam(); - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); if (data->retrieve_key) { - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); } uint32_t decrypt_sample_buffer_size = 0; @@ -4680,10 +4669,10 @@ TEST_P(WvCdmSessionSharingNoKeyTest, DecryptionTest) { TestWvCdmClientPropertySet property_set; property_set.set_session_sharing_mode(true); - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); CdmSessionId gp_session_id_1 = session_id_; - GenerateKeyRequest(g_key_id, kLicenseTypeStreaming); + GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming); // TODO(rfrias): Move content information to ConfigTestEnv std::string gp_client_auth2 = @@ -4693,7 +4682,7 @@ TEST_P(WvCdmSessionSharingNoKeyTest, DecryptionTest) { "edef8ba979d64acea3c827dcd51d21ed00000014" // Widevine system id "08011210bdf1cb4fffc6506b8b7945b0bd2917fb"); // pssh data - decryptor_.OpenSession(g_key_system, &property_set, kDefaultCdmIdentifier, + decryptor_.OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_); CdmSessionId gp_session_id_2 = session_id_; GenerateKeyRequest(gp_key_id2, kLicenseTypeStreaming); @@ -4740,7 +4729,7 @@ TEST(VersionNumberTest, VersionNumberChangeCanary) { } TEST_F(WvCdmRequestLicenseTest, AddHlsStreamingKeyTest) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); CdmAppParameterMap app_parameters; GenerateKeyRequest(wvcdm::KEY_MESSAGE, HLS_INIT_DATA_FORMAT, @@ -4748,7 +4737,7 @@ TEST_F(WvCdmRequestLicenseTest, AddHlsStreamingKeyTest) { kLicenseTypeStreaming, NULL); //TODO(rfrias): Remove once we switch to git-on-borg std::string license_server = "https://proxy.uat.widevine.com/proxy"; - VerifyKeyRequestResponse(license_server, g_client_auth); + VerifyKeyRequestResponse(license_server, config_.client_auth()); decryptor_.CloseSession(session_id_); } @@ -4757,7 +4746,7 @@ class WvHlsInitDataTest public ::testing::WithParamInterface {}; TEST_P(WvHlsInitDataTest, InvalidHlsFormatTest) { - decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL, + decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_); CdmAppParameterMap app_parameters; std::string init_data = GetParam(); @@ -4784,7 +4773,7 @@ TEST_P(WvHlsDecryptionTest, HlsDecryptionTest) { HlsDecryptionInfo* info = GetParam(); TestWvCdmHlsEventListener listener; - decryptor_.OpenSession(g_key_system, &client_property_set, + decryptor_.OpenSession(config_.key_system(), &client_property_set, kDefaultCdmIdentifier, &listener, &session_id_); CdmAppParameterMap app_parameters; GenerateKeyRequest(wvcdm::KEY_MESSAGE, HLS_INIT_DATA_FORMAT, @@ -4792,7 +4781,7 @@ TEST_P(WvHlsDecryptionTest, HlsDecryptionTest) { kLicenseTypeStreaming, NULL); //TODO(rfrias): Remove once we switch to git-on-borg std::string license_server = "https://proxy.uat.widevine.com/proxy"; - VerifyKeyRequestResponse(license_server, g_client_auth); + VerifyKeyRequestResponse(license_server, config_.client_auth()); CdmKeyStatusMap key_status_map = listener.GetKeyStatusMap(); EXPECT_EQ(1u, key_status_map.size()); KeyId key_id = key_status_map.begin()->first; @@ -4838,7 +4827,7 @@ TEST_P(WvHlsFourCCBackwardCompatibilityTest, HlsDecryptionTest) { HlsDecryptionInfo* info = GetParam(); TestWvCdmHlsEventListener listener; - decryptor_.OpenSession(g_key_system, &client_property_set, + decryptor_.OpenSession(config_.key_system(), &client_property_set, kDefaultCdmIdentifier, &listener, &session_id_); CdmAppParameterMap app_parameters; GenerateKeyRequest(wvcdm::KEY_MESSAGE, ISO_BMFF_VIDEO_MIME_TYPE, @@ -4846,7 +4835,7 @@ TEST_P(WvHlsFourCCBackwardCompatibilityTest, HlsDecryptionTest) { kLicenseTypeStreaming, NULL); //TODO(rfrias): Remove once we switch to git-on-borg std::string license_server = "https://proxy.uat.widevine.com/proxy"; - VerifyKeyRequestResponse(license_server, g_client_auth); + VerifyKeyRequestResponse(license_server, config_.client_auth()); CdmKeyStatusMap key_status_map = listener.GetKeyStatusMap(); EXPECT_EQ(1u, key_status_map.size()); KeyId key_id = key_status_map.begin()->first; @@ -4909,12 +4898,12 @@ TEST_P(WvCenc30Test, DecryptionTest) { SingleSampleDecryptionInfo* info = GetParam(); TestWvCdmHlsEventListener listener; - decryptor_.OpenSession(g_key_system, &client_property_set, + decryptor_.OpenSession(config_.key_system(), &client_property_set, kDefaultCdmIdentifier, &listener, &session_id_); CdmAppParameterMap app_parameters; GenerateKeyRequest(info->pssh, app_parameters, kLicenseTypeStreaming, NULL); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); CdmKeyStatusMap key_status_map = listener.GetKeyStatusMap(); EXPECT_EQ(8u, key_status_map.size()); @@ -4974,12 +4963,12 @@ TEST_P(WvCenc30SwitchCipherModeTest, DecryptionTest) { FourSampleDecryptionInfo* info = GetParam(); TestWvCdmHlsEventListener listener; - decryptor_.OpenSession(g_key_system, &client_property_set, + decryptor_.OpenSession(config_.key_system(), &client_property_set, kDefaultCdmIdentifier, &listener, &session_id_); CdmAppParameterMap app_parameters; GenerateKeyRequest(info->pssh, app_parameters, kLicenseTypeStreaming, NULL); - VerifyKeyRequestResponse(g_license_server, g_client_auth); + VerifyKeyRequestResponse(config_.license_server(), config_.client_auth()); CdmKeyStatusMap key_status_map = listener.GetKeyStatusMap(); EXPECT_EQ(8u, key_status_map.size()); @@ -5015,135 +5004,3 @@ INSTANTIATE_TEST_CASE_P( &kCenc30SwitchCipherData[8])); } // namespace wvcdm - -void show_menu(char* prog_name) { - std::cout << std::endl; - std::cout << "usage: " << prog_name << " [options]" << std::endl << std::endl; - std::cout << " enclose multiple arguments in '' when using adb shell" - << std::endl; - std::cout << " e.g. adb shell '" << prog_name << " --server=\"url\"'" - << std::endl; - std::cout << " or adb shell '" << prog_name << " -u\"url\"'" << std::endl - << std::endl; - - std::cout << " -i/--license_server_id=" << std::endl; - std::cout << " specifies which default server settings to use: " - << std::endl; - std::cout << " gp for GooglePlay server" << std::endl; - std::cout << " cp for Content Protection UAT server" << std::endl; - std::cout << " st for Content Protection Staging server" << std::endl - << std::endl; - - std::cout << " -k/--keyid=" << std::endl; - std::cout << " configure the key id or pssh, in hex format" << std::endl - << std::endl; - - std::cout << " -s/--cert=" << std::endl; - std::cout << " configure the signed service certificate" << std::endl; - std::cout << " Specify the SignedDeviceCertificate (from " - << "device_certificate.proto) " << std::endl; - std::cout << " in hex format." << std::endl; - std::cout << " Due to the length of the argument use, " << std::endl; - std::cout << " echo \"/system/bin/request_license_test -s \\\"" - << "0ABF02...A29914\\\"\" \\" << std::endl; - std::cout << " > run_request_license_test.sh" << std::endl; - std::cout << " chmod +x run_request_license_test.sh" << std::endl; - std::cout << " adb push run_request_license_test.sh /system/bin" - << std::endl; - std::cout << " adb shell sh /system/bin/run_request_license_test.sh" - << std::endl - << std::endl; - - std::cout << " -u/--server=" << std::endl; - std::cout << " configure the license server url, please include http[s]" - << " in the url" << std::endl - << std::endl; -} - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - - bool show_usage = false; - static const struct option long_options[] = { - {"keyid", required_argument, NULL, 'k'}, - {"license_server_id", required_argument, NULL, 'i'}, - {"service_certificate", required_argument, NULL, 's'}, - {"license_server_url", required_argument, NULL, 'u'}, - {NULL, 0, NULL, '\0'}}; - - int option_index = 0; - int opt = 0; - while ((opt = getopt_long(argc, argv, "i:k:s:u:", long_options, - &option_index)) != -1) { - switch (opt) { - case 'i': { - std::string license_id(optarg); - if (!license_id.compare("gp")) { - g_server_configuration_id = wvcdm::kGooglePlayServer; - } else if (!license_id.compare("cp")) { - g_server_configuration_id = wvcdm::kContentProtectionUatServer; - } else if (!license_id.compare("st")) { - g_server_configuration_id = - wvcdm::kContentProtectionStagingServer; - } else { - std::cout << "Invalid license server id" << optarg << std::endl; - show_usage = true; - } - break; - } - case 'k': { - g_key_id.clear(); - g_key_id.assign(optarg); - break; - } - case 's': { - g_service_certificate.clear(); - g_service_certificate.assign(wvcdm::a2bs_hex(optarg)); - break; - } - case 'u': { - g_license_server.clear(); - g_license_server.assign(optarg); - break; - } - case '?': { - show_usage = true; - break; - } - } - } - - if (show_usage) { - show_menu(argv[0]); - return 0; - } - - g_config = new wvcdm::ConfigTestEnv(g_server_configuration_id); - g_client_auth.assign(g_config->client_auth()); - g_key_system.assign(g_config->key_system()); - - // The following variables are configurable through command line - // options. If the command line arguments are absent, use the settings - // in kLicenseServers[] pointed to by g_config. - if (g_key_id.empty()) { - g_key_id.assign(g_config->key_id()); - } - if (g_service_certificate.empty()) { - g_service_certificate.assign(g_config->license_service_certificate()); - } - if (g_license_server.empty()) { - g_license_server.assign(g_config->license_server()); - } - - // Displays server url, port and key Id being used - std::cout << std::endl; - std::cout << "Server: " << g_license_server << std::endl; - std::cout << "KeyID: " << g_key_id << std::endl << std::endl; - - g_key_id = wvcdm::a2bs_hex(g_key_id); - g_config->set_license_server(g_license_server); - - int status = RUN_ALL_TESTS(); - delete g_config; - return status; -}