Source release v3.3.0

2017-05-04 14:01:27 -07:00
parent baa7b133d3
commit 8082775924
678 changed files with 51264 additions and 14200 deletions
--- a/core/test/cdm_engine_test.cpp
+++ b/core/test/cdm_engine_test.cpp
@@ -11,12 +11,12 @@

 #include "cdm_engine.h"
 #include "config_test_env.h"
-#include "default_service_certificate.h"
 #include "initialization_data.h"
 #include "license_request.h"
 #include "log.h"
 #include "OEMCryptoCENC.h"
 #include "properties.h"
+#include "properties_ce.h"
 #include "scoped_ptr.h"
 #include "string_conversions.h"
 #include "test_printers.h"
@@ -27,6 +27,7 @@
 namespace wvcdm {

 namespace {
+
 // Http OK response code.
 const int kHttpOk = 200;

@@ -37,27 +38,313 @@ KeyId g_key_id_pssh;
 KeyId g_key_id_unwrapped;
 CdmKeySystem g_key_system;
 std::string g_license_server;
+std::string g_provisioning_server;
+std::string g_provisioning_service_certificate;
+std::string g_license_service_certificate;
 KeyId g_wrong_key_id;

 const std::string kCencMimeType = "video/mp4";
 const std::string kWebmMimeType = "video/webm";
+
+static void CommonSetup(ServerConfigurationId which,
+                        bool bin_prov = false) {
+
+  widevine::PropertiesCE::SetProvisioningMessagesAreBinary(bin_prov);
+  Properties::Init();
+
+  // NOTE: Select configuration
+  ConfigTestEnv config(which);
+
+  g_client_auth.assign(config.client_auth());
+  g_key_system.assign(config.key_system());
+  g_wrong_key_id.assign(config.wrong_key_id());
+  g_license_server.assign(config.license_server());
+  g_key_id_pssh.assign(a2bs_hex(config.key_id()));
+  g_provisioning_service_certificate.assign(
+      config.provisioning_service_certificate());
+  g_license_service_certificate.assign(config.license_service_certificate());
+  g_provisioning_server.assign(config.provisioning_server());
+
+  // Extract the key ID from the PSSH box.
+  InitializationData extractor(CENC_INIT_DATA_FORMAT, g_key_id_pssh);
+  g_key_id_unwrapped = extractor.data();
+}
+
+/*
+ * Locate the portion of the server's response message that is between
+ * the strings jason_start_substr and json_end_substr. Returns the string
+ * through *result. If the start substring match fails, assume the entire
+ * string represents a serialized protobuf mesaage and return true with
+ * the entire string. If the end_substring match fails, return false with
+ * an empty *result.
+ */
+bool ExtractSignedMessage(const std::string& response,
+                          const std::string& json_start_substr,
+                          const std::string& json_end_substr,
+                          std::string* result) {
+  std::string response_string;
+  size_t start = response.find(json_start_substr);
+
+  if (start == response.npos) {
+    // Assume serialized protobuf message.
+    result->assign(response);
+  } else {
+    // Assume JSON-wrapped protobuf.
+    size_t end = response.find(json_end_substr,
+                               start + json_start_substr.length());
+    if (end == response.npos) {
+      LOGE("ExtractSignedMessage cannot locate end substring");
+      result->clear();
+      return false;
+    }
+    size_t result_string_size = end - start - json_start_substr.length();
+    result->assign(response, start + json_start_substr.length(),
+                   result_string_size);
+  }
+
+  if (result->empty()) {
+    LOGE("ExtractSignedMessage: Response message is empty");
+    return false;
+  }
+  return true;
+}
+
 }  // namespace

-class WvCdmEngineTest : public testing::Test {
+class WvCdmEnginePreProvTest : public testing::Test {
 public:
-  WvCdmEngineTest() : cdm_engine_(&file_system_) {}
+  WvCdmEnginePreProvTest() : cdm_engine_(&file_system_),
+                             session_opened_(false) {}
+
+  virtual ~WvCdmEnginePreProvTest() {}
+
+  virtual void SetUp() {
+    CdmResponseType status =
+        cdm_engine_.OpenSession(g_key_system, NULL, NULL, &session_id_);
+    ASSERT_EQ(status, NO_ERROR);
+    session_opened_ = true;
+  }
+
+  virtual void TearDown() {
+    if (session_opened_) {
+      cdm_engine_.CloseSession(session_id_);
+      session_opened_ = false;
+    }
+  }
+
+ protected:
+
+  // Trade request for response via the license server.
+  virtual bool LicenseServerRequestResponse(const std::string& request,
+                                            std::string* response) {
+    LOGV("LicenseServerRequestResponse: server url: %s",
+         g_license_server.c_str());
+    UrlRequest url_request(g_license_server + g_client_auth);
+    url_request.PostRequest(request);
+
+    std::string http_response;
+    if (!url_request.GetResponse(&http_response)) {
+      return false;
+    }
+
+    LOGV("http_response:\n%s\n", http_response.c_str());
+
+    // Separate message from HTTP headers.
+    LicenseRequest license_request;
+    license_request.GetDrmMessage(http_response, *response);
+
+    LOGV("response: size=%u, string:\n%s\n", response->size(),
+         Base64SafeEncode(std::vector<uint8_t>(response->begin(),
+                                               response->end())).c_str());
+    return true;
+  }
+
+  virtual void Provision() {
+    LOGV("WvCdmEnginePreProvTest::Provision: url=%s",
+         g_provisioning_server.c_str());
+    CdmProvisioningRequest prov_request;
+    std::string provisioning_server_url;
+    CdmCertificateType cert_type = kCertificateWidevine;
+    std::string cert_authority;
+    std::string cert, wrapped_key;
+    ASSERT_EQ(NO_ERROR, cdm_engine_.SetServiceCertificate(
+        g_provisioning_service_certificate));
+    ASSERT_EQ(NO_ERROR, cdm_engine_.GetProvisioningRequest(
+        cert_type, cert_authority, &prov_request,
+        &provisioning_server_url));
+
+    LOGV("WvCdmEnginePreProvTest::Provision: req=%s", prov_request.c_str());
+
+    // Ignore URL provided by CdmEngine.  Use ours, as configured
+    // for test vs. production server.
+    provisioning_server_url.assign(g_provisioning_server);
+    UrlRequest url_request(provisioning_server_url);
+    EXPECT_TRUE(url_request.is_connected());
+    url_request.PostCertRequestInQueryString(prov_request);
+    std::string http_message;
+    bool ok = url_request.GetResponse(&http_message);
+    EXPECT_TRUE(ok);
+
+    LOGV("WvCdmEnginePreProvTest::Provision: http_message: \n%s\n",
+         http_message.c_str());
+
+    ASSERT_EQ(NO_ERROR,
+              cdm_engine_.HandleProvisioningResponse(http_message,
+                                                     &cert, &wrapped_key));
+
+    ASSERT_EQ(NO_ERROR,
+              cdm_engine_.SetServiceCertificate(g_license_service_certificate));
+  }
+
+  FileSystem file_system_;
+  CdmEngine cdm_engine_;
+  bool session_opened_;
+  std::string key_msg_;
+  std::string session_id_;
+};
+
+class WvCdmEnginePreProvTestStaging : public WvCdmEnginePreProvTest {
+ public:
+  WvCdmEnginePreProvTestStaging() {}
+
+  virtual ~WvCdmEnginePreProvTestStaging() {}

  static void SetUpTestCase() {
-    ConfigTestEnv config(kContentProtectionUatServer);
-    g_client_auth.assign(config.client_auth());
-    g_key_system.assign(config.key_system());
-    g_wrong_key_id.assign(config.wrong_key_id());
-    g_license_server.assign(config.license_server());
-    g_key_id_pssh.assign(a2bs_hex(config.key_id()));
+    // NOTE: Select server configuration
+    CommonSetup(kContentProtectionStagingLicense);
+  }
+};

-    // Extract the key ID from the PSSH box.
-    InitializationData extractor(CENC_INIT_DATA_FORMAT, g_key_id_pssh);
-    g_key_id_unwrapped = extractor.data();
+class WvCdmEnginePreProvTestProd : public WvCdmEnginePreProvTest {
+ public:
+  WvCdmEnginePreProvTestProd() {}
+
+  virtual ~WvCdmEnginePreProvTestProd() {}
+
+  static void SetUpTestCase() {
+    // NOTE: Select server configuration
+    CommonSetup(kContentProtectionProdLicense);
+  }
+};
+
+class WvCdmEnginePreProvTestUat : public WvCdmEnginePreProvTest {
+ public:
+  WvCdmEnginePreProvTestUat() {}
+
+  virtual ~WvCdmEnginePreProvTestUat() {}
+
+  static void SetUpTestCase() {
+    // NOTE: Select server configuration
+    CommonSetup(kContentProtectionUatLicense);
+  }
+};
+
+class WvCdmEnginePreProvTestStagingProv30 : public WvCdmEnginePreProvTest {
+ public:
+  WvCdmEnginePreProvTestStagingProv30() {}
+
+  virtual ~WvCdmEnginePreProvTestStagingProv30() {}
+
+  static void SetUpTestCase() {
+    // NOTE: Select server configuration
+    CommonSetup(kContentProtectionStagingPlusProv30);
+  }
+};
+
+class WvCdmEnginePreProvTestStagingProv30Binary : public WvCdmEnginePreProvTest {
+ public:
+  WvCdmEnginePreProvTestStagingProv30Binary() {}
+
+  virtual ~WvCdmEnginePreProvTestStagingProv30Binary() {}
+
+  static void SetUpTestCase() {
+    // NOTE: Select server configuration
+    // Override default setting of provisioning_messages_are_binary property
+    CommonSetup(kContentProtectionUatPlusProv30, true);
+  }
+
+ protected:
+
+  virtual void Provision() {
+    LOGV("WvCdmEnginePreProvTestProv30Binary::Provision: url=%s",
+         g_provisioning_server.c_str());
+    CdmProvisioningRequest binary_prov_request;
+    std::string provisioning_server_url;
+    CdmCertificateType cert_type = kCertificateWidevine;
+    std::string cert_authority;
+    std::string cert, wrapped_key;
+    ASSERT_EQ(NO_ERROR, cdm_engine_.SetServiceCertificate(
+        g_provisioning_service_certificate));
+    ASSERT_EQ(NO_ERROR, cdm_engine_.GetProvisioningRequest(
+        cert_type, cert_authority, &binary_prov_request,
+        &provisioning_server_url));
+
+    // prov_request is binary - base64 encode it
+    std::string prov_request(Base64SafeEncodeNoPad(
+        std::vector<uint8_t>(binary_prov_request.begin(),
+                             binary_prov_request.end())));
+
+    LOGV("WvCdmEnginePreProvTest::Provision: req=%s", prov_request.c_str());
+
+    // Ignore URL provided by CdmEngine.  Use ours, as configured
+    // for test vs. production server.
+    provisioning_server_url.assign(g_provisioning_server);
+    UrlRequest url_request(provisioning_server_url);
+    EXPECT_TRUE(url_request.is_connected());
+    url_request.PostCertRequestInQueryString(prov_request);
+    std::string http_message;
+    bool ok = url_request.GetResponse(&http_message);
+    EXPECT_TRUE(ok);
+
+    LOGV("WvCdmEnginePreProvTest::Provision: http_message: \n%s\n",
+         http_message.c_str());
+
+    // extract provisioning response from received message
+    // Extracts signed response from JSON string, result is serialized protobuf.
+    const std::string kMessageStart = "\"signedResponse\": \"";
+    const std::string kMessageEnd = "\"";
+    std::string protobuf_response;
+    EXPECT_TRUE (ExtractSignedMessage(http_message, kMessageStart, kMessageEnd,
+                                      &protobuf_response)) <<
+        "Failed to extract signed serialized response from JSON response";
+
+    LOGV("WvCdmEnginePreProvTest::Provision: extracted response "
+         "message: \n%s\n", protobuf_response.c_str());
+
+    // base64 decode response to yield binary protobuf
+    std::vector<uint8_t> response_vec(Base64SafeDecode(
+        std::string(protobuf_response.begin(), protobuf_response.end())));
+    std::string binary_protobuf_response(response_vec.begin(),
+                                         response_vec.end());
+    ASSERT_EQ(NO_ERROR,
+              cdm_engine_.HandleProvisioningResponse(binary_protobuf_response,
+                                                     &cert, &wrapped_key));
+
+    ASSERT_EQ(NO_ERROR,
+              cdm_engine_.SetServiceCertificate(g_license_service_certificate));
+  }
+
+};
+
+class WvCdmEnginePreProvTestUatProv30 : public WvCdmEnginePreProvTest {
+ public:
+  WvCdmEnginePreProvTestUatProv30() {}
+
+  virtual ~WvCdmEnginePreProvTestUatProv30() {}
+
+  static void SetUpTestCase() {
+    // NOTE: Select server configuration
+    CommonSetup(kContentProtectionStagingPlusProv30);
+  }
+};
+
+class WvCdmEngineTest : public WvCdmEnginePreProvTest {
+ public:
+  WvCdmEngineTest() {}
+
+  static void SetUpTestCase() {
+    // NOTE: Select server configuration
+    CommonSetup(kContentProtectionStagingLicense);
  }

  virtual void SetUp() {
@@ -72,29 +359,7 @@ class WvCdmEngineTest : public testing::Test {
    ASSERT_TRUE(cdm_engine_.IsOpenSession(session_id_));
  }

-  virtual void TearDown() { cdm_engine_.CloseSession(session_id_); }
-
 protected:
-  void Provision() {
-    CdmProvisioningRequest prov_request;
-    std::string provisioning_server_url;
-    CdmCertificateType cert_type = kCertificateWidevine;
-    std::string cert_authority;
-    std::string cert, wrapped_key;
-    ASSERT_EQ(NO_ERROR, cdm_engine_.SetServiceCertificate(
-        kDefaultServiceCertificate));
-    ASSERT_EQ(NO_ERROR, cdm_engine_.GetProvisioningRequest(
-        cert_type, cert_authority, &prov_request,
-        &provisioning_server_url));
-    UrlRequest url_request(provisioning_server_url);
-    EXPECT_TRUE(url_request.is_connected());
-    url_request.PostCertRequestInQueryString(prov_request);
-    std::string message;
-    bool ok = url_request.GetResponse(&message);
-    EXPECT_TRUE(ok);
-    ASSERT_EQ(NO_ERROR, cdm_engine_.HandleProvisioningResponse(message, &cert,
-                                                               &wrapped_key));
-  }

  void GenerateKeyRequest(const std::string& key_id,
                          const std::string& init_data_type_string) {
@@ -138,6 +403,9 @@ class WvCdmEngineTest : public testing::Test {
                                    const std::string& client_auth,
                                    bool expect_success) {
    // Use secure connection and chunk transfer coding.
+
+    LOGV("GetKeyRequestResponse: server_url: %s", server_url.c_str());
+
    UrlRequest url_request(server_url + client_auth);
    if (!url_request.is_connected()) {
      return "";
@@ -146,7 +414,7 @@ class WvCdmEngineTest : public testing::Test {
    url_request.PostRequest(key_msg_);
    std::string response;
    bool ok = url_request.GetResponse(&response);
-    LOGD("response: %s\n", response.c_str());
+    LOGV("response: %s\n", response.c_str());
    EXPECT_TRUE(ok);

    int status_code = url_request.GetStatusCode(response);
@@ -180,37 +448,147 @@ class WvCdmEngineTest : public testing::Test {
    EXPECT_EQ(KEY_ADDED, cdm_engine_.RenewKey(session_id_, resp));
  }

-  FileSystem file_system_;
-  CdmEngine cdm_engine_;
-  std::string key_msg_;
-  std::string session_id_;
  std::string server_url_;
 };

-// Test that provisioning works, even if device is already provisioned.
-TEST_F(WvCdmEngineTest, ProvisioningTest) {
+// Test that service certificate is initially absent.
+TEST_F(WvCdmEnginePreProvTestStaging, ServiceCertificateInitialNoneTest) {
+  ASSERT_FALSE(cdm_engine_.HasServiceCertificate());
+};
+
+// Test that service certificate can be properly installed.
+TEST_F(WvCdmEnginePreProvTestStaging, ServiceCertificateGoodTest) {
+  ASSERT_EQ(cdm_engine_.SetServiceCertificate(g_license_service_certificate),
+            NO_ERROR);
+  ASSERT_TRUE(cdm_engine_.HasServiceCertificate());
+};
+
+// Test that service certificate can be retrieved from the license server.
+TEST_F(WvCdmEnginePreProvTestStaging, ServiceCertificateRequestResponse) {
+  CdmKeyMessage request;
+  std::string certificate;
+
+  // Initial condition - no service certificate.
+  ASSERT_FALSE(cdm_engine_.HasServiceCertificate());
+
+  // Generate request.
+  // The request will be a serialized protobuf message.
+  ASSERT_TRUE(cdm_engine_.GetServiceCertificateRequest(&request));
+
+  std::string response;
+  ASSERT_TRUE(LicenseServerRequestResponse(request, &response));
+
+  // Extract the service certificate
+  ASSERT_EQ(cdm_engine_.ParseServiceCertificateResponse(response, &certificate),
+            NO_ERROR);
+
+  ASSERT_TRUE(cdm_engine_.HasServiceCertificate());
+  LOGV("ret'd service certificate:\n%s\n", b2a_hex(certificate).c_str());
+};
+
+// Test that service certificate can be retrieved from the license server.
+TEST_F(WvCdmEnginePreProvTestUat, ServiceCertificateRequestResponse) {
+  CdmKeyMessage request;
+  std::string certificate;
+
+  // Initial condition - no service certificate.
+  ASSERT_FALSE(cdm_engine_.HasServiceCertificate());
+
+  // Generate request.
+  // The request will be a serialized protobuf message.
+  ASSERT_TRUE(cdm_engine_.GetServiceCertificateRequest(&request));
+
+  std::string response;
+  ASSERT_TRUE(LicenseServerRequestResponse(request, &response));
+
+  // Extract the service certificate
+  ASSERT_EQ(cdm_engine_.ParseServiceCertificateResponse(response, &certificate),
+            NO_ERROR);
+
+  ASSERT_TRUE(cdm_engine_.HasServiceCertificate());
+  LOGV("ret'd service certificate:\n%s\n", b2a_hex(certificate).c_str());
+};
+
+// Test that service certificate can be retrieved from the license server.
+TEST_F(WvCdmEnginePreProvTestProd, ServiceCertificateRequestResponse) {
+  CdmKeyMessage request;
+  std::string certificate;
+
+  // Initial condition - no service certificate.
+  ASSERT_FALSE(cdm_engine_.HasServiceCertificate());
+
+  // Generate request.
+  // The request will be a serialized protobuf message.
+  ASSERT_TRUE(cdm_engine_.GetServiceCertificateRequest(&request));
+
+  std::string response;
+  ASSERT_TRUE(LicenseServerRequestResponse(request, &response));
+
+  // Extract the service certificate
+  ASSERT_EQ(cdm_engine_.ParseServiceCertificateResponse(response, &certificate),
+            NO_ERROR);
+
+  ASSERT_TRUE(cdm_engine_.HasServiceCertificate());
+  LOGV("ret'd service certificate:\n%s\n", b2a_hex(certificate).c_str());
+};
+
+// Test that empty service certificate fails.
+TEST_F(WvCdmEnginePreProvTestStaging, ServiceCertificateEmptyFailTest) {
+  std::string empty_cert;
+  ASSERT_EQ(cdm_engine_.SetServiceCertificate(g_license_service_certificate),
+            NO_ERROR);
+  ASSERT_TRUE(cdm_engine_.HasServiceCertificate());
+};
+
+TEST_F(WvCdmEnginePreProvTestStaging, ProvisioningTest) {
  uint32_t nonce = 0;
  uint8_t buffer[1];
  size_t size = 0;
+
  int result = OEMCrypto_RewrapDeviceRSAKey(
      0, buffer, 0, buffer, 0, &nonce, buffer, 0, buffer, buffer, &size);
-  if (result == OEMCrypto_ERROR_NOT_IMPLEMENTED) {
+  int result30 = OEMCrypto_RewrapDeviceRSAKey30(
+      0, &nonce, buffer, 0, buffer, 0, buffer, buffer, &size);
+  int method = OEMCrypto_GetProvisioningMethod(kLevelDefault);
+
+  if (result == OEMCrypto_ERROR_NOT_IMPLEMENTED &&
+      result30 == OEMCrypto_ERROR_NOT_IMPLEMENTED) {
    LOGW("WARNING: Skipping ProvisioningTest because the device does not "
-         "support provisioning. If you are using a baked-in certificate, this "
-         "is expected. Otherwise, something is wrong.");
-    return;
+         "support provisioning. If you are using a baked-in certificate, "
+         "this is expected. Otherwise, something is wrong.");
+    ASSERT_EQ(method, OEMCrypto_DrmCertificate);
+  } else {
+    if (result == OEMCrypto_ERROR_NOT_IMPLEMENTED) {
+      ASSERT_EQ(method, OEMCrypto_OEMCertificate);
+    } else {
+      ASSERT_EQ(method, OEMCrypto_Keybox);
+    }
  }

  Provision();
 }

+TEST_F(WvCdmEnginePreProvTestStagingProv30, ProvisioningTest) {
+  Provision();
+}
+
+TEST_F(WvCdmEnginePreProvTestStagingProv30Binary, ProvisioningTest) {
+  Provision();
+}
+
+// Test that provisioning works, even if device is already provisioned.
+TEST_F(WvCdmEngineTest, ProvisioningTest) {
+
+  Provision();
+}
+
 TEST_F(WvCdmEngineTest, BaseIsoBmffMessageTest) {
  GenerateKeyRequest(g_key_id_pssh, kCencMimeType);
  GetKeyRequestResponse(g_license_server, g_client_auth);
 }

 // TODO(juce): Set up with correct test data.
-TEST_F(WvCdmEngineTest, BaseWebmMessageTest) {
+TEST_F(WvCdmEngineTest, DISABLED_BaseWebmMessageTest) {
  GenerateKeyRequest(g_key_id_unwrapped, kWebmMimeType);
  GetKeyRequestResponse(g_license_server, g_client_auth);
 }
@@ -230,7 +608,7 @@ TEST_F(WvCdmEngineTest, NormalDecryptionIsoBmff) {
 }

 // TODO(juce): Set up with correct test data.
-TEST_F(WvCdmEngineTest, NormalDecryptionWebm) {
+TEST_F(WvCdmEngineTest, DISABLED_NormalDecryptionWebm) {
  GenerateKeyRequest(g_key_id_unwrapped, kWebmMimeType);
  VerifyNewKeyResponse(g_license_server, g_client_auth);
 }
--- a/core/test/cdm_session_unittest.cpp
+++ b/core/test/cdm_session_unittest.cpp
@@ -1,3 +1,4 @@
+
 // Copyright 2014 Google Inc. All Rights Reserved.

 #include <gmock/gmock.h>
@@ -176,7 +177,7 @@ TEST_F(CdmSessionTest, InitWithBuiltInCertificate) {
  EXPECT_CALL(*crypto_session_, GetPreProvisionTokenType())
      .WillOnce(Return(kClientTokenDrmCert));
  EXPECT_CALL(*file_handle_, RetrieveCertificate(NotNull(), NotNull(),
-                                                 NotNull(), NotNull()))
+                                                 NotNull(), _))
      .WillOnce(DoAll(SetArgPointee<0>(kToken), SetArgPointee<1>(kWrappedKey),
                      Return(true)));
  EXPECT_CALL(*crypto_session_, LoadCertificatePrivateKey(StrEq(kWrappedKey)))
@@ -206,7 +207,7 @@ TEST_F(CdmSessionTest, InitWithCertificate) {
      .WillOnce(Return(kClientTokenKeybox));
  EXPECT_CALL(*file_handle_, Init(Eq(level))).WillOnce(Return(true));
  EXPECT_CALL(*file_handle_, RetrieveCertificate(NotNull(), NotNull(),
-                                                 NotNull(), NotNull()))
+                                                 NotNull(), _))
      .WillOnce(DoAll(SetArgPointee<0>(kToken), SetArgPointee<1>(kWrappedKey),
                      Return(true)));
  EXPECT_CALL(*crypto_session_, LoadCertificatePrivateKey(StrEq(kWrappedKey)))
@@ -260,7 +261,7 @@ TEST_F(CdmSessionTest, ReInitFail) {
      .WillOnce(Return(kClientTokenKeybox));
  EXPECT_CALL(*file_handle_, Init(Eq(level))).WillOnce(Return(true));
  EXPECT_CALL(*file_handle_, RetrieveCertificate(NotNull(), NotNull(),
-                                                 NotNull(), NotNull()))
+                                                 NotNull(), _))
      .WillOnce(DoAll(SetArgPointee<0>(kToken), SetArgPointee<1>(kWrappedKey),
                      Return(true)));
  EXPECT_CALL(*crypto_session_, LoadCertificatePrivateKey(StrEq(kWrappedKey)))
@@ -299,7 +300,7 @@ TEST_F(CdmSessionTest, InitNeedsProvisioning) {
      .WillOnce(Return(kClientTokenKeybox));
  EXPECT_CALL(*file_handle_, Init(Eq(level))).WillOnce(Return(true));
  EXPECT_CALL(*file_handle_, RetrieveCertificate(NotNull(), NotNull(),
-                                                 NotNull(), NotNull()))
+                                                 NotNull(), _))
      .WillOnce(Return(false));

  Properties::set_use_certificates_as_identification(true);
--- a/core/test/config_test_env.cpp
+++ b/core/test/config_test_env.cpp
@@ -1,6 +1,13 @@
 // Copyright 2013 Google Inc. All Rights Reserved.

 #include "config_test_env.h"
+#include "string_conversions.h"
+
+// Holds the data needed to talk to the various provisioning and
+// license servers.
+//
+// Define a series of configurations, and specify the specific
+// data items needed for that configuration.

 namespace wvcdm {

@@ -8,9 +15,100 @@ namespace {

 const std::string kWidevineKeySystem = "com.widevine.alpha";

+// For staging servers
+// NOTE: This matches the service cert returned by the staging
+// server. This is the one that the staging provisioning server uses.
+// NOTE: Provider ID = license.widevine.com
+const std::string kStagingServiceCertificate =
+    "0ac102080312101705b917cc1204868b06333a2f772a8c1882b482920522"
+    "8e023082010a028201010099ed5b3b327dab5e24efc3b62a95b598520ad5"
+    "bccb37503e0645b814d876b8df40510441ad8ce3adb11bb88c4e725a5e4a"
+    "9e0795291d58584023a7e1af0e38a91279393008610b6f158c878c7e21bf"
+    "fbfeea77e1019e1e5781e8a45f46263d14e60e8058a8607adce04fac8457"
+    "b137a8d67ccdeb33705d983a21fb4eecbd4a10ca47490ca47eaa5d438218"
+    "ddbaf1cade3392f13d6ffb6442fd31e1bf40b0c604d1c4ba4c9520a4bf97"
+    "eebd60929afceef55bbaf564e2d0e76cd7c55c73a082b996120b8359edce"
+    "24707082680d6f67c6d82c4ac5f3134490a74eec37af4b2f010c59e82843"
+    "e2582f0b6b9f5db0fc5e6edf64fbd308b4711bcf1250019c9f5a09020301"
+    "00013a146c6963656e73652e7769646576696e652e636f6d128003ae3473"
+    "14b5a835297f271388fb7bb8cb5277d249823cddd1da30b93339511eb3cc"
+    "bdea04b944b927c121346efdbdeac9d413917e6ec176a10438460a503bc1"
+    "952b9ba4e4ce0fc4bfc20a9808aaaf4bfcd19c1dcfcdf574ccac28d1b410"
+    "416cf9de8804301cbdb334cafcd0d40978423a642e54613df0afcf96ca4a"
+    "9249d855e42b3a703ef1767f6a9bd36d6bf82be76bbf0cba4fde59d2abcc"
+    "76feb64247b85c431fbca52266b619fc36979543fca9cbbdbbfafa0e1a55"
+    "e755a3c7bce655f9646f582ab9cf70aa08b979f867f63a0b2b7fdb362c5b"
+    "c4ecd555d85bcaa9c593c383c857d49daab77e40b7851ddfd24998808e35"
+    "b258e75d78eac0ca16f7047304c20d93ede4e8ff1c6f17e6243e3f3da8fc"
+    "1709870ec45fba823a263f0cefa1f7093b1909928326333705043a29bda6"
+    "f9b4342cc8df543cb1a1182f7c5fff33f10490faca5b25360b76015e9c5a"
+    "06ab8ee02f00d2e8d5986104aacc4dd475fd96ee9ce4e326f21b83c70585"
+    "77b38732cddabc6a6bed13fb0d49d38a45eb87a5f4";
+
+// NOTE: Provider ID = staging.google.com
+const std::string kProdServiceCertificate =
+    "0ABF020803121028703454C008F63618ADE7443DB6C4C8188BE7F9900522"
+    "8E023082010A0282010100B52112B8D05D023FCC5D95E2C251C1C649B417"
+    "7CD8D2BEEF355BB06743DE661E3D2ABC3182B79946D55FDC08DFE9540781"
+    "5E9A6274B322A2C7F5E067BB5F0AC07A89D45AEA94B2516F075B66EF811D"
+    "0D26E1B9A6B894F2B9857962AA171C4F66630D3E4C602718897F5E1EF9B6"
+    "AAF5AD4DBA2A7E14176DF134A1D3185B5A218AC05A4C41F081EFFF80A3A0"
+    "40C50B09BBC740EEDCD8F14D675A91980F92CA7DDC646A06ADAD5101F74A"
+    "0E498CC01F00532BAC217850BD905E90923656B7DFEFEF42486767F33EF6"
+    "283D4F4254AB72589390BEE55808F1D668080D45D893C2BCA2F74D60A0C0"
+    "D0A0993CEF01604703334C3638139486BC9DAF24FD67A07F9AD943020301"
+    "00013A1273746167696E672E676F6F676C652E636F6D128003983E303526"
+    "75F40BA715FC249BDAE5D4AC7249A2666521E43655739529721FF880E0AA"
+    "EFC5E27BC980DAEADABF3FC386D084A02C82537848CC753FF497B011A7DA"
+    "97788A00E2AA6B84CD7D71C07A48EBF61602CCA5A3F32030A7295C30DA91"
+    "5B91DC18B9BC9593B8DE8BB50F0DEDC12938B8E9E039CDDE18FA82E81BB0"
+    "32630FE955D85A566CE154300BF6D4C1BD126966356B287D657B18CE63D0"
+    "EFD45FC5269E97EAB11CB563E55643B26FF49F109C2101AFCAF35B832F28"
+    "8F0D9D45960E259E85FB5D24DBD2CF82764C5DD9BF727EFBE9C861F86932"
+    "1F6ADE18905F4D92F9A6DA6536DB8475871D168E870BB2303CF70C6E9784"
+    "C93D2DE845AD8262BE7E0D4E2E4A0759CEF82D109D2592C72429F8C01742"
+    "BAE2B3DECADBC33C3E5F4BAF5E16ECB74EADBAFCB7C6705F7A9E3B6F3940"
+    "383F9C5116D202A20C9229EE969C2519718303B50D0130C3352E06B014D8"
+    "38540F8A0C227C0011E0F5B38E4E298ED2CB301EB4564965F55C5D79757A"
+    "250A4EB9C84AB3E6539F6B6FDF56899EA29914";
+
+// For UAT License servers
+// NOTE: This matches the service cert returned by the UAT server.
+// NOTE: Provider ID = staging.google.com
+const std::string kUatServiceCertificate =
+    "0ABF020803121028703454C008F63618ADE7443DB6C4C8188BE7F9900522"
+    "8E023082010A0282010100B52112B8D05D023FCC5D95E2C251C1C649B417"
+    "7CD8D2BEEF355BB06743DE661E3D2ABC3182B79946D55FDC08DFE9540781"
+    "5E9A6274B322A2C7F5E067BB5F0AC07A89D45AEA94B2516F075B66EF811D"
+    "0D26E1B9A6B894F2B9857962AA171C4F66630D3E4C602718897F5E1EF9B6"
+    "AAF5AD4DBA2A7E14176DF134A1D3185B5A218AC05A4C41F081EFFF80A3A0"
+    "40C50B09BBC740EEDCD8F14D675A91980F92CA7DDC646A06ADAD5101F74A"
+    "0E498CC01F00532BAC217850BD905E90923656B7DFEFEF42486767F33EF6"
+    "283D4F4254AB72589390BEE55808F1D668080D45D893C2BCA2F74D60A0C0"
+    "D0A0993CEF01604703334C3638139486BC9DAF24FD67A07F9AD943020301"
+    "00013A1273746167696E672E676F6F676C652E636F6D128003983E303526"
+    "75F40BA715FC249BDAE5D4AC7249A2666521E43655739529721FF880E0AA"
+    "EFC5E27BC980DAEADABF3FC386D084A02C82537848CC753FF497B011A7DA"
+    "97788A00E2AA6B84CD7D71C07A48EBF61602CCA5A3F32030A7295C30DA91"
+    "5B91DC18B9BC9593B8DE8BB50F0DEDC12938B8E9E039CDDE18FA82E81BB0"
+    "32630FE955D85A566CE154300BF6D4C1BD126966356B287D657B18CE63D0"
+    "EFD45FC5269E97EAB11CB563E55643B26FF49F109C2101AFCAF35B832F28"
+    "8F0D9D45960E259E85FB5D24DBD2CF82764C5DD9BF727EFBE9C861F86932"
+    "1F6ADE18905F4D92F9A6DA6536DB8475871D168E870BB2303CF70C6E9784"
+    "C93D2DE845AD8262BE7E0D4E2E4A0759CEF82D109D2592C72429F8C01742"
+    "BAE2B3DECADBC33C3E5F4BAF5E16ECB74EADBAFCB7C6705F7A9E3B6F3940"
+    "383F9C5116D202A20C9229EE969C2519718303B50D0130C3352E06B014D8"
+    "38540F8A0C227C0011E0F5B38E4E298ED2CB301EB4564965F55C5D79757A"
+    "250A4EB9C84AB3E6539F6B6FDF56899EA29914";
+
+// Content Protection license server (Production) data
+const std::string kCpProdLicenseServer =
+    "https://widevine-proxy.appspot.com/proxy";
+
 // Content Protection license server (UAT) data
 const std::string kCpUatLicenseServer =
-    "http://widevine-proxy.appspot.com/proxy";
+    "https://proxy.uat.widevine.com/proxy";
+
 const std::string kCpClientAuth = "";
 const std::string kCpKeyId =
    "00000042"                          // blob size
@@ -31,52 +129,10 @@ const std::string kCpOfflineKeyId =
    // pssh data:
    "08011a0d7769646576696e655f746573"
    "74220d6f66666c696e655f636c697032";
-const std::string kCpUatServiceCertificate =
-    "0ABF020803121028703454C008F63618ADE7443DB6C4C8188BE7F99005228E023082010A02"
-    "82010100B52112B8D05D023FCC5D95E2C251C1C649B4177CD8D2BEEF355BB06743DE661E3D"
-    "2ABC3182B79946D55FDC08DFE95407815E9A6274B322A2C7F5E067BB5F0AC07A89D45AEA94"
-    "B2516F075B66EF811D0D26E1B9A6B894F2B9857962AA171C4F66630D3E4C602718897F5E1E"
-    "F9B6AAF5AD4DBA2A7E14176DF134A1D3185B5A218AC05A4C41F081EFFF80A3A040C50B09BB"
-    "C740EEDCD8F14D675A91980F92CA7DDC646A06ADAD5101F74A0E498CC01F00532BAC217850"
-    "BD905E90923656B7DFEFEF42486767F33EF6283D4F4254AB72589390BEE55808F1D668080D"
-    "45D893C2BCA2F74D60A0C0D0A0993CEF01604703334C3638139486BC9DAF24FD67A07F9AD9"
-    "4302030100013A1273746167696E672E676F6F676C652E636F6D128003983E30352675F40B"
-    "A715FC249BDAE5D4AC7249A2666521E43655739529721FF880E0AAEFC5E27BC980DAEADABF"
-    "3FC386D084A02C82537848CC753FF497B011A7DA97788A00E2AA6B84CD7D71C07A48EBF616"
-    "02CCA5A3F32030A7295C30DA915B91DC18B9BC9593B8DE8BB50F0DEDC12938B8E9E039CDDE"
-    "18FA82E81BB032630FE955D85A566CE154300BF6D4C1BD126966356B287D657B18CE63D0EF"
-    "D45FC5269E97EAB11CB563E55643B26FF49F109C2101AFCAF35B832F288F0D9D45960E259E"
-    "85FB5D24DBD2CF82764C5DD9BF727EFBE9C861F869321F6ADE18905F4D92F9A6DA6536DB84"
-    "75871D168E870BB2303CF70C6E9784C93D2DE845AD8262BE7E0D4E2E4A0759CEF82D109D25"
-    "92C72429F8C01742BAE2B3DECADBC33C3E5F4BAF5E16ECB74EADBAFCB7C6705F7A9E3B6F39"
-    "40383F9C5116D202A20C9229EE969C2519718303B50D0130C3352E06B014D838540F8A0C22"
-    "7C0011E0F5B38E4E298ED2CB301EB4564965F55C5D79757A250A4EB9C84AB3E6539F6B6FDF"
-    "56899EA29914";

 // Content Protection license server (staging) data
 const std::string kCpStagingLicenseServer =
-    "http://wv-staging-proxy.appspot.com/proxy";
-const std::string kCpStagingServiceCertificate =
-    "0AC102080312101705B917CC1204868B06333A2F772A8C1882B4829205228E023082010A02"
-    "8201010099ED5B3B327DAB5E24EFC3B62A95B598520AD5BCCB37503E0645B814D876B8DF40"
-    "510441AD8CE3ADB11BB88C4E725A5E4A9E0795291D58584023A7E1AF0E38A9127939300861"
-    "0B6F158C878C7E21BFFBFEEA77E1019E1E5781E8A45F46263D14E60E8058A8607ADCE04FAC"
-    "8457B137A8D67CCDEB33705D983A21FB4EECBD4A10CA47490CA47EAA5D438218DDBAF1CADE"
-    "3392F13D6FFB6442FD31E1BF40B0C604D1C4BA4C9520A4BF97EEBD60929AFCEEF55BBAF564"
-    "E2D0E76CD7C55C73A082B996120B8359EDCE24707082680D6F67C6D82C4AC5F3134490A74E"
-    "EC37AF4B2F010C59E82843E2582F0B6B9F5DB0FC5E6EDF64FBD308B4711BCF1250019C9F5A"
-    "0902030100013A146C6963656E73652E7769646576696E652E636F6D128003AE347314B5A8"
-    "35297F271388FB7BB8CB5277D249823CDDD1DA30B93339511EB3CCBDEA04B944B927C12134"
-    "6EFDBDEAC9D413917E6EC176A10438460A503BC1952B9BA4E4CE0FC4BFC20A9808AAAF4BFC"
-    "D19C1DCFCDF574CCAC28D1B410416CF9DE8804301CBDB334CAFCD0D40978423A642E54613D"
-    "F0AFCF96CA4A9249D855E42B3A703EF1767F6A9BD36D6BF82BE76BBF0CBA4FDE59D2ABCC76"
-    "FEB64247B85C431FBCA52266B619FC36979543FCA9CBBDBBFAFA0E1A55E755A3C7BCE655F9"
-    "646F582AB9CF70AA08B979F867F63A0B2B7FDB362C5BC4ECD555D85BCAA9C593C383C857D4"
-    "9DAAB77E40B7851DDFD24998808E35B258E75D78EAC0CA16F7047304C20D93EDE4E8FF1C6F"
-    "17E6243E3F3DA8FC1709870EC45FBA823A263F0CEFA1F7093B1909928326333705043A29BD"
-    "A6F9B4342CC8DF543CB1A1182F7C5FFF33F10490FACA5B25360B76015E9C5A06AB8EE02F00"
-    "D2E8D5986104AACC4DD475FD96EE9CE4E326F21B83C7058577B38732CDDABC6A6BED13FB0D"
-    "49D38A45EB87A5F4";
+    "https://proxy.staging.widevine.com/proxy";

 // Google Play license server data
 const std::string kGpLicenseServer =
@@ -116,31 +172,58 @@ const std::string kWrongKeyId =
    "0901121094889920e8d6520098577df8"
    "f2dd5546";

-// URL of provisioning server (returned by GetProvisioningRequest())
+// URL of provisioning server (overrides value from GetProvisioningRequest())
 const std::string kProductionProvisioningServerUrl =
    "https://www.googleapis.com/"
    "certificateprovisioning/v1/devicecertificates/create"
    "?key=AIzaSyB-5OLKTx2iU5mko18DfdwK5611JIjbUhE";

+const std::string kStagingProvisioningServerUrl =
+    "https://staging-www.sandbox.googleapis.com/"
+    "certificateprovisioning/v1/devicecertificates/create"
+    "?key=AIzaSyB-5OLKTx2iU5mko18DfdwK5611JIjbUhE";
+
 const ConfigTestEnv::LicenseServerConfiguration license_servers[] = {
-    {kGooglePlayServer, kGpLicenseServer, kGpClientAuth, kGpKeyId,
-     kGpOfflineKeyId, ""},
-    {kContentProtectionUatServer, kCpUatLicenseServer, kCpClientAuth,
-     kCpKeyId, kCpOfflineKeyId, kCpUatServiceCertificate},
-    {kContentProtectionStagingServer, kCpStagingLicenseServer,
-     kCpClientAuth, kCpKeyId, kCpOfflineKeyId, kCpStagingServiceCertificate},
+  {kGooglePlayServer, kGpLicenseServer, "", kGpClientAuth, kGpKeyId,
+     kGpOfflineKeyId, kStagingProvisioningServerUrl, ""},
+
+    {kContentProtectionProdLicense, kCpProdLicenseServer,
+     kProdServiceCertificate, kCpClientAuth, kCpKeyId, kCpOfflineKeyId,
+     kProductionProvisioningServerUrl, kProdServiceCertificate},
+
+    {kContentProtectionUatLicense, kCpUatLicenseServer,
+     kProdServiceCertificate, kCpClientAuth, kCpKeyId, kCpOfflineKeyId,
+     kProductionProvisioningServerUrl, kProdServiceCertificate},
+
+    {kContentProtectionStagingLicense, kCpStagingLicenseServer,
+     kProdServiceCertificate, kCpClientAuth, kCpKeyId, kCpOfflineKeyId,
+     kStagingProvisioningServerUrl, kStagingServiceCertificate},
+
+    {kContentProtectionProdPlusProv30, kCpProdLicenseServer,
+     kProdServiceCertificate, kCpClientAuth, kCpKeyId, kCpOfflineKeyId,
+     kStagingProvisioningServerUrl, kStagingServiceCertificate},
+
+    {kContentProtectionUatPlusProv30, kCpUatLicenseServer,
+     kProdServiceCertificate, kCpClientAuth, kCpKeyId, kCpOfflineKeyId,
+     kStagingProvisioningServerUrl, kStagingServiceCertificate},
+
+    {kContentProtectionStagingPlusProv30, kCpStagingLicenseServer,
+     kStagingServiceCertificate, kCpClientAuth, kCpKeyId, kCpOfflineKeyId,
+     kStagingProvisioningServerUrl, kStagingServiceCertificate},
 };

 }  // namespace

-ConfigTestEnv::ConfigTestEnv(LicenseServerId server_id) { Init(server_id); }
+ConfigTestEnv::ConfigTestEnv(ServerConfigurationId server_id) {
+  Init(server_id);
+}

-ConfigTestEnv::ConfigTestEnv(LicenseServerId server_id, bool streaming) {
+ConfigTestEnv::ConfigTestEnv(ServerConfigurationId server_id, bool streaming) {
  Init(server_id);
  if (!streaming) key_id_ = license_servers[server_id].offline_key_id;
 }

-ConfigTestEnv::ConfigTestEnv(LicenseServerId server_id, bool streaming,
+ConfigTestEnv::ConfigTestEnv(ServerConfigurationId server_id, bool streaming,
                             bool renew, bool release) {
  Init(server_id);
  if (!streaming) {
@@ -158,13 +241,16 @@ ConfigTestEnv::ConfigTestEnv(LicenseServerId server_id, bool streaming,
  }
 }

-void ConfigTestEnv::Init(LicenseServerId server_id) {
+void ConfigTestEnv::Init(ServerConfigurationId server_id) {
  client_auth_ = license_servers[server_id].client_tag;
  key_id_ = license_servers[server_id].key_id;
  key_system_ = kWidevineKeySystem;
-  license_server_ = license_servers[server_id].url;
-  provisioning_server_url_ = kProductionProvisioningServerUrl;
-  service_certificate_ = license_servers[server_id].service_certificate;
+  license_server_ = license_servers[server_id].license_server_url;
+  provisioning_server_ = license_servers[server_id].provisioning_server_url;
+  license_service_certificate_ =
+      a2bs_hex(license_servers[server_id].license_service_certificate);
+  provisioning_service_certificate_ =
+      a2bs_hex(license_servers[server_id].provisioning_service_certificate);
  wrong_key_id_ = kWrongKeyId;
 }

--- a/core/test/config_test_env.h
+++ b/core/test/config_test_env.h
@@ -6,28 +6,50 @@
 #include <string>
 #include "wv_cdm_types.h"

+// Declare class ConfigTestEnv - holds the configuration settings needed
+// to talk to the various provisioning and license servers.
+//
+// License Servers
+//   QA  - early test server (corporate access only, not generally usable).
+//   UAT  - test server with non-production data.
+//   Staging  - test server with access to production data.
+//   Production  - live, production server.
+//   Google Play  - Allows testing on Google Play servers (very stale).
+//
+// Provisioning Servers
+//   UAT  - early access provisioning server.
+//   Staging  - early access to features.
+//   Production  - live production server.
+
+// Useful configurations
 namespace wvcdm {
 typedef enum {
-  kGooglePlayServer,
-  kContentProtectionUatServer,
-  kContentProtectionStagingServer,
-} LicenseServerId;
+  kGooglePlayServer,   // not tested recently
+  kContentProtectionProdLicense,
+  kContentProtectionUatLicense,
+  kContentProtectionStagingLicense,
+  kContentProtectionProdPlusProv30,
+  kContentProtectionUatPlusProv30,
+  kContentProtectionStagingPlusProv30,
+} ServerConfigurationId;

 // Configures default test environment.
 class ConfigTestEnv {
 public:
  typedef struct {
-    LicenseServerId id;
-    std::string url;
+    ServerConfigurationId id;
+    std::string license_server_url;
+    std::string license_service_certificate;
    std::string client_tag;
    std::string key_id;
    std::string offline_key_id;
-    std::string service_certificate;
+    std::string provisioning_server_url;
+    std::string provisioning_service_certificate;
  } LicenseServerConfiguration;

-  explicit ConfigTestEnv(LicenseServerId server_id);
-  ConfigTestEnv(LicenseServerId server_id, bool streaming);
-  ConfigTestEnv(LicenseServerId server_id, bool streaming, bool renew,
+  explicit ConfigTestEnv(ServerConfigurationId server_id);
+  ConfigTestEnv(ServerConfigurationId server_id, bool streaming);
+  ConfigTestEnv(ServerConfigurationId server_id, bool streaming, bool renew,
                bool release);
  ~ConfigTestEnv() {};

@@ -35,11 +57,14 @@ class ConfigTestEnv {
  const KeyId& key_id() const { return key_id_; }
  const CdmKeySystem& key_system() const { return key_system_; }
  const std::string& license_server() const { return license_server_; }
-  const std::string& provisioning_server_url() const {
-    return provisioning_server_url_;
+  const std::string& provisioning_server() const {
+    return provisioning_server_;
  }
-  const std::string& service_certificate() const {
-    return service_certificate_;
+  const std::string& license_service_certificate() const {
+    return license_service_certificate_;
+  }
+  const std::string& provisioning_service_certificate() const {
+    return provisioning_service_certificate_;
  }
  const KeyId& wrong_key_id() const { return wrong_key_id_; }

@@ -52,14 +77,15 @@ class ConfigTestEnv {
  }

 private:
-  void Init(LicenseServerId server_id);
+  void Init(ServerConfigurationId server_id);

  std::string client_auth_;
  KeyId key_id_;
  CdmKeySystem key_system_;
  std::string license_server_;
-  std::string provisioning_server_url_;
-  std::string service_certificate_;
+  std::string provisioning_server_;
+  std::string license_service_certificate_;
+  std::string provisioning_service_certificate_;
  KeyId wrong_key_id_;

  CORE_DISALLOW_COPY_AND_ASSIGN(ConfigTestEnv);
--- a/core/test/default_service_certificate.h
+++ b/core/test/default_service_certificate.h
@@ -1,36 +0,0 @@
-// Copyright 2017 Google Inc. All Rights Reserved.
-
-#ifndef CDM_TEST_DEFAULT_SERVICE_CERTIFICATE_H_
-#define CDM_TEST_DEFAULT_SERVICE_CERTIFICATE_H_
-
-#include <string>
-
-#include "string_conversions.h"
-
-namespace {
-
-const std::string kDefaultServiceCertificate = wvcdm::a2bs_hex(
-    "0ABF020803121028703454C008F63618ADE7443DB6C4C8188BE7F99005228E023082010A02"
-    "82010100B52112B8D05D023FCC5D95E2C251C1C649B4177CD8D2BEEF355BB06743DE661E3D"
-    "2ABC3182B79946D55FDC08DFE95407815E9A6274B322A2C7F5E067BB5F0AC07A89D45AEA94"
-    "B2516F075B66EF811D0D26E1B9A6B894F2B9857962AA171C4F66630D3E4C602718897F5E1E"
-    "F9B6AAF5AD4DBA2A7E14176DF134A1D3185B5A218AC05A4C41F081EFFF80A3A040C50B09BB"
-    "C740EEDCD8F14D675A91980F92CA7DDC646A06ADAD5101F74A0E498CC01F00532BAC217850"
-    "BD905E90923656B7DFEFEF42486767F33EF6283D4F4254AB72589390BEE55808F1D668080D"
-    "45D893C2BCA2F74D60A0C0D0A0993CEF01604703334C3638139486BC9DAF24FD67A07F9AD9"
-    "4302030100013A1273746167696E672E676F6F676C652E636F6D128003983E30352675F40B"
-    "A715FC249BDAE5D4AC7249A2666521E43655739529721FF880E0AAEFC5E27BC980DAEADABF"
-    "3FC386D084A02C82537848CC753FF497B011A7DA97788A00E2AA6B84CD7D71C07A48EBF616"
-    "02CCA5A3F32030A7295C30DA915B91DC18B9BC9593B8DE8BB50F0DEDC12938B8E9E039CDDE"
-    "18FA82E81BB032630FE955D85A566CE154300BF6D4C1BD126966356B287D657B18CE63D0EF"
-    "D45FC5269E97EAB11CB563E55643B26FF49F109C2101AFCAF35B832F288F0D9D45960E259E"
-    "85FB5D24DBD2CF82764C5DD9BF727EFBE9C861F869321F6ADE18905F4D92F9A6DA6536DB84"
-    "75871D168E870BB2303CF70C6E9784C93D2DE845AD8262BE7E0D4E2E4A0759CEF82D109D25"
-    "92C72429F8C01742BAE2B3DECADBC33C3E5F4BAF5E16ECB74EADBAFCB7C6705F7A9E3B6F39"
-    "40383F9C5116D202A20C9229EE969C2519718303B50D0130C3352E06B014D838540F8A0C22"
-    "7C0011E0F5B38E4E298ED2CB301EB4564965F55C5D79757A250A4EB9C84AB3E6539F6B6FDF"
-    "56899EA29914");
-
-}  // namespace
-
-#endif  // CDM_TEST_DEFAULT_SERVICE_CERTIFICATE_H_
--- a/core/test/device_files_unittest.cpp
+++ b/core/test/device_files_unittest.cpp
@@ -1634,7 +1634,8 @@ TEST_F(DeviceCertificateStoreTest, StoreCertificate) {
  EXPECT_TRUE(device_files.StoreCertificate(certificate, wrapped_private_key));
 }

-TEST_F(DeviceCertificateTest, ReadCertificate) {
+// TODO(tinskip): Fix. kTestCertificateFileData appears to be incorect.
+TEST_F(DeviceCertificateTest, DISABLED_ReadCertificate) {
  MockFileSystem file_system;
  std::string device_certificate_path =
      device_base_path_ + DeviceFiles::GetCertificateFileName();
@@ -1664,7 +1665,7 @@ TEST_F(DeviceCertificateTest, ReadCertificate) {
                                       &serial_number, &system_id));
  EXPECT_EQ(kTestCertificate, b2a_hex(certificate));
  EXPECT_EQ(kTestWrappedPrivateKey, b2a_hex(wrapped_private_key));
-  EXPECT_EQ(0, system_id);
+  EXPECT_EQ(0u, system_id);
  EXPECT_EQ("", b2a_hex(serial_number));
 }

@@ -2328,5 +2329,4 @@ TEST_P(DeviceFilesHlsAttributesTest, Delete) {
 INSTANTIATE_TEST_CASE_P(HlsAttributes, DeviceFilesHlsAttributesTest,
                        ::testing::Range(&kHlsAttributesTestData[0],
                                         &kHlsAttributesTestData[2]));
-
 }  // namespace wvcdm
--- a/core/test/file_store_unittest.cpp
+++ b/core/test/file_store_unittest.cpp
@@ -171,7 +171,7 @@ TEST_F(FileTest, ListFiles) {
  EXPECT_TRUE(file_system.List(path_dir, &names));

  // Should find three files. Order not important.
-  EXPECT_EQ(3, names.size());
+  EXPECT_EQ(3u, names.size());
  EXPECT_THAT(names, ::testing::UnorderedElementsAre(kTestFileName,
                                                     kTestFileName2,
                                                     kTestFileName3));
@@ -180,14 +180,14 @@ TEST_F(FileTest, ListFiles) {
  EXPECT_TRUE(file_system.Remove(wild_card_path));
  EXPECT_TRUE(file_system.List(path_dir, &names));

-  EXPECT_EQ(1, names.size());
+  EXPECT_EQ(1u, names.size());
  EXPECT_TRUE(names[0].compare(kTestFileName3) == 0);

  std::string wild_card_path2 = path_dir + kWildcard + kTestFileNameExt3;
  EXPECT_TRUE(file_system.Remove(wild_card_path2));
  EXPECT_TRUE(file_system.List(path_dir, &names));

-  EXPECT_EQ(0, names.size());
+  EXPECT_EQ(0u, names.size());
 }

 }  // namespace wvcdm
--- a/core/test/generic_crypto_unittest.cpp
+++ b/core/test/generic_crypto_unittest.cpp
@@ -10,8 +10,7 @@
 #include <string>

 #include "cdm_engine.h"
-
-#include "default_service_certificate.h"
+#include "config_test_env.h"
 #include "license_request.h"
 #include "log.h"
 #include "oec_session_util.h"
@@ -25,6 +24,52 @@ namespace {

 const std::string kKeySystem = "com.widevine.alpha";

+std::string g_provisioning_server;
+std::string g_license_service_certificate;
+std::string g_provisioning_service_certificate;
+
+/*
+ * Locate the portion of the server's response message that is between
+ * the strings jason_start_substr and json_end_substr. Returns the string
+ * through *result. If the start substring match fails, assume the entire
+ * string represents a serialized protobuf mesaage and return true with
+ * the entire string. If the end_substring match fails, return false with
+ * an empty *result.
+ */
+bool ExtractSignedMessage(const std::string& response,
+                          const std::string& json_start_substr,
+                          const std::string& json_end_substr,
+                          std::string* result) {
+  std::string b64_string;
+  size_t start = response.find(json_start_substr);
+
+  if (start == response.npos) {
+    // Assume web safe protobuf
+    b64_string.assign(response);
+  } else {
+    // Assume JSON-wrapped protobuf
+    size_t end = response.find(json_end_substr,
+                               start + json_start_substr.length());
+    if (end == response.npos) {
+      LOGE("ExtractSignedMessage cannot locate end substring");
+      result->clear();
+      return false;
+    }
+    size_t b64_string_size = end - start - json_start_substr.length();
+    b64_string.assign(response, start + json_start_substr.length(),
+                      b64_string_size);
+  }
+
+  if (b64_string.empty()) {
+    LOGE("Response message is empty");
+    result->clear();
+    return false;
+  }
+
+  result->swap(b64_string);
+  return true;
+}
+
 }  // namespace

 namespace wvcdm {
@@ -34,6 +79,15 @@ class WvGenericOperationsTest : public testing::Test {
  virtual void SetUp() {
    ::testing::Test::SetUp();

+    ConfigTestEnv config(kContentProtectionStagingPlusProv30);
+
+    g_provisioning_service_certificate.assign(
+        config.provisioning_service_certificate());
+    g_license_service_certificate.assign(config.license_service_certificate());
+    g_provisioning_server.assign(config.provisioning_server());
+
+    cdm_engine_ = NULL;
+
    // TODO(fredgc or gmorgan): This should be updated for provisioning 3.0
    // Load test keybox. This keybox will be used by any CryptoSession
    // created by the CDM under test.
@@ -42,6 +96,8 @@ class WvGenericOperationsTest : public testing::Test {
    // Perform CdmEngine setup
    cdm_engine_ = new CdmEngine(&file_system_);

+    Provision();
+
    CdmResponseType status =
        cdm_engine_->OpenSession(kKeySystem, NULL, NULL, &session_id_);
    if (status == NEED_PROVISIONING) {
@@ -66,7 +122,9 @@ class WvGenericOperationsTest : public testing::Test {

  virtual void TearDown() {
    oec_util_session_.close();
-    cdm_engine_->CloseSession(session_id_);
+    if (cdm_engine_ != NULL) {
+      cdm_engine_->CloseSession(session_id_);
+    }
    // OEMCrypto_Terminate() will be performed during the test class's
    // destruction (specifically by the CryptoSession destructor)
  }
@@ -156,26 +214,55 @@ class WvGenericOperationsTest : public testing::Test {
  }

 protected:
-  void Provision() {
+
+  virtual void Provision() {
+    LOGE("WvCdmEnginePreProvTest::Provision: url=%s",
+         g_provisioning_server.c_str());
    CdmProvisioningRequest prov_request;
    std::string provisioning_server_url;
    CdmCertificateType cert_type = kCertificateWidevine;
    std::string cert_authority;
    std::string cert, wrapped_key;
-    cdm_engine_->SetServiceCertificate(kDefaultServiceCertificate);
-    ASSERT_EQ(NO_ERROR,
-              cdm_engine_->GetProvisioningRequest(
-                  cert_type, cert_authority, &prov_request,
-                  &provisioning_server_url));
+    ASSERT_EQ(NO_ERROR, cdm_engine_->SetServiceCertificate(
+        g_provisioning_service_certificate));
+    ASSERT_EQ(NO_ERROR, cdm_engine_->GetProvisioningRequest(
+        cert_type, cert_authority, &prov_request,
+        &provisioning_server_url));
+
+    LOGV("WvCdmEnginePreProvTest::Provision: req=%s", prov_request.c_str());
+
+    // Ignore URL provided by CdmEngine.  Use ours, as configured
+    // for test vs. production server.
+    provisioning_server_url.assign(g_provisioning_server);
    UrlRequest url_request(provisioning_server_url);
    EXPECT_TRUE(url_request.is_connected());
    url_request.PostCertRequestInQueryString(prov_request);
-    std::string message;
-    bool ok = url_request.GetResponse(&message);
+    std::string http_message;
+    bool ok = url_request.GetResponse(&http_message);
    EXPECT_TRUE(ok);
+
+    LOGV("WvCdmEnginePreProvTest::Provision: http_message: \n%s\n",
+         http_message.c_str());
+
+    // extract provisioning response from received message
+    // Extracts signed response from JSON string, decodes base64 signed response
+    const std::string kMessageStart = "\"signedResponse\": \"";
+    const std::string kMessageEnd = "\"";
+    std::string base64_response;
+    EXPECT_TRUE (ExtractSignedMessage(http_message, kMessageStart, kMessageEnd,
+                                      &base64_response)) <<
+        "Failed to extract signed serialized response from JSON response";
+
+    LOGV("WvCdmEnginePreProvTest::Provision: extracted response "
+         "message: \n%s\n", base64_response.c_str());
+
    ASSERT_EQ(NO_ERROR,
-              cdm_engine_->HandleProvisioningResponse(message, &cert,
-                                                      &wrapped_key));
+              cdm_engine_->HandleProvisioningResponse(base64_response,
+                                                     &cert, &wrapped_key));
+
+    ASSERT_EQ(NO_ERROR,
+              cdm_engine_->SetServiceCertificate(
+                  g_license_service_certificate));
  }

  // This CryptoSession object handles Initialization and Termination
--- a/core/test/license_keys_unittest.cpp
+++ b/core/test/license_keys_unittest.cpp
@@ -317,7 +317,7 @@ class LicenseKeysTest : public ::testing::Test {
  }


-  int content_key_count_;
+  size_t content_key_count_;
  LicenseKeys license_keys_;
  License license_;
 };
@@ -495,7 +495,7 @@ TEST_F(LicenseKeysTest, ExtractKeyStatuses) {
  CdmKeyStatusMap key_status_map;
  StageOperatorSessionKeys();
  license_keys_.ExtractKeyStatuses(&key_status_map);
-  EXPECT_EQ(0, key_status_map.size());
+  EXPECT_EQ(0u, key_status_map.size());
  StageContentKeys();
  license_keys_.ExtractKeyStatuses(&key_status_map);
  EXPECT_EQ(content_key_count_, key_status_map.size());
--- a/core/test/license_unittest.cpp
+++ b/core/test/license_unittest.cpp
@@ -5,7 +5,6 @@

 #include "clock.h"
 #include "crypto_session.h"
-#include "default_service_certificate.h"
 #include "initialization_data.h"
 #include "license.h"
 #include "policy_engine.h"
@@ -220,7 +219,8 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidation) {
          DoAll(SetArgPointee<2>(kLicenseRequestSignature), Return(true)));

  CreateCdmLicense();
-  service_cert_.Init(kDefaultServiceCertificate);
+  // TODO(gmorgan) fix below - no default service certificate
+  //service_cert_.Init(kDefaultServiceCertificate);
  EXPECT_TRUE(cdm_license_->Init(
      &service_cert_, kToken, kClientTokenDrmCert, kEmptyString,
      crypto_session_, policy_engine_));
--- a/core/test/policy_engine_constraints_unittest.cpp
+++ b/core/test/policy_engine_constraints_unittest.cpp
@@ -2,6 +2,7 @@

 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
+
 #include "crypto_session.h"
 #include "license.h"
 #include "policy_engine.h"
@@ -212,15 +213,27 @@ class PolicyEngineConstraintsTest : public Test {
 TEST_F(PolicyEngineConstraintsTest, IsPermissiveWithoutAResolution) {
  EXPECT_CALL(*mock_clock_, GetCurrentTime()).Times(2);
  EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(kSessionId, _));
-  ExpectSessionKeysChange(kKeyStatusUsable, true);
+
+  {
+    Sequence key_change;
+    ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable,
+                             kKeyId2, kKeyStatusOutputNotAllowed,
+                             kKeyId3, kKeyStatusUsable,
+                             kKeyId4, kKeyStatusOutputNotAllowed, true);
+  }
+
+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));

  policy_engine_->SetLicense(license_);
  policy_engine_->OnTimerEvent();

  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId1));
-  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId2));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId2));
  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId3));
-  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId4));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId4));
  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId5));
  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId6));
 }
@@ -247,7 +260,6 @@ TEST_F(PolicyEngineConstraintsTest, HandlesResolutionsBasedOnConstraints) {
          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                Return(true)));

-
  policy_engine_->SetLicense(license_);
  policy_engine_->NotifyResolution(1, kTargetRes1);
  policy_engine_->OnTimerEvent();
@@ -285,17 +297,34 @@ TEST_F(PolicyEngineConstraintsTest,
  EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(kSessionId, _));
  ExpectSessionKeysChange(kKeyStatusUsable, true);

+  {
+    Sequence key_change;
+    ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable,
+                             kKeyId2, kKeyStatusOutputNotAllowed,
+                             kKeyId3, kKeyStatusUsable,
+                             kKeyId4, kKeyStatusOutputNotAllowed, true);
+    EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+        .WillOnce(
+            DoAll(SetArgPointee<0>(HDCP_V2_2),
+                  Return(false)))
+        .WillOnce(
+            DoAll(SetArgPointee<0>(HDCP_V2_2),
+                  Return(false)));
+  }
  int64_t start_time = current_time_ + 5;
  {
    InSequence calls;
    EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
        .WillOnce(
            DoAll(SetArgPointee<0>(HDCP_V2_2),
-                  Return(true)));
+                  Return(false)));
    EXPECT_CALL(*mock_clock_, GetCurrentTime())
        .WillOnce(Return(start_time + kHdcpInterval / 2))
        .WillOnce(Return(start_time + kHdcpInterval));
    EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+        .WillOnce(
+            DoAll(SetArgPointee<0>(HDCP_V2_2),
+                  Return(false)))
        .WillOnce(
            DoAll(SetArgPointee<0>(HDCP_V2_2),
                  Return(true)));
@@ -371,14 +400,13 @@ TEST_F(PolicyEngineConstraintsTest, HandlesNoHdcp) {
    ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable,
                             kKeyId2, kKeyStatusOutputNotAllowed,
                             kKeyId3, kKeyStatusUsable,
-                             kKeyId4, kKeyStatusOutputNotAllowed, false);
+                             kKeyId4, kKeyStatusOutputNotAllowed, true);
    ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable,
                             kKeyId2, kKeyStatusOutputNotAllowed,
                             kKeyId3, kKeyStatusOutputNotAllowed,
                             kKeyId4, kKeyStatusOutputNotAllowed, false);
  }
  EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(kSessionId, _));
-  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
      .WillRepeatedly(
          DoAll(SetArgPointee<0>(HDCP_NONE),
@@ -405,7 +433,7 @@ TEST_F(PolicyEngineConstraintsTest, HandlesNoHdcp) {
  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId6));
 }

-TEST_F(PolicyEngineConstraintsTest, IgnoresHdcpWithoutAResolution) {
+TEST_F(PolicyEngineConstraintsTest, UsesDefaultHdcpWhenResolutionNotSet) {
  {
    Sequence time;
    for (int i=0; i<2; ++i) {
@@ -413,16 +441,28 @@ TEST_F(PolicyEngineConstraintsTest, IgnoresHdcpWithoutAResolution) {
          .WillOnce(Return(i * 10));
    }
  }
-  ExpectSessionKeysChange(kKeyStatusUsable, true);
+
+  {
+    Sequence key_change;
+    ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable,
+                             kKeyId2, kKeyStatusOutputNotAllowed,
+                             kKeyId3, kKeyStatusUsable,
+                             kKeyId4, kKeyStatusOutputNotAllowed, true);
+  }
+
  EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(kSessionId, _));
-  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)).Times(0);
+
+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));

  policy_engine_->SetLicense(license_);
  policy_engine_->OnTimerEvent();
  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId1));
-  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId2));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId2));
  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId3));
-  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId4));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId4));
  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId5));
  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId6));
 }
--- a/core/test/policy_engine_unittest.cpp
+++ b/core/test/policy_engine_unittest.cpp
@@ -18,6 +18,8 @@

 namespace wvcdm {

+using namespace testing;
+
 namespace {
 const int64_t kDurationUnlimited = 0;
 const int64_t kLicenseStartTime = 1413517500;   // ~ 01/01/2013
@@ -52,6 +54,11 @@ int64_t ParseInt(const std::string& str) {
  return ret;
 }

+class HdcpOnlyMockCryptoSession : public CryptoSession {
+ public:
+  MOCK_METHOD2(GetHdcpCapabilities, bool(HdcpCapability*, HdcpCapability*));
+};
+
 class MockCdmEventListener : public WvCdmEventListener {
 public:
  MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId& session_id));
@@ -85,7 +92,8 @@ class PolicyEngineTest : public ::testing::Test {
 protected:
  virtual void SetUp() {
    policy_engine_.reset(
-        new PolicyEngine(kSessionId, &mock_event_listener_, NULL));
+        new PolicyEngine(kSessionId, &mock_event_listener_,
+                         &crypto_session_));
    InjectMockClock();

    license_.set_license_start_time(kLicenseStartTime);
@@ -141,6 +149,7 @@ class PolicyEngineTest : public ::testing::Test {
                    expected_has_new_usable_key));
  }

+  StrictMock<HdcpOnlyMockCryptoSession> crypto_session_;
  StrictMock<MockCdmEventListener> mock_event_listener_;
  MockClock* mock_clock_;
  scoped_ptr<PolicyEngine> policy_engine_;
@@ -164,6 +173,11 @@ TEST_F(PolicyEngineTest, PlaybackSuccess_OfflineLicense) {
  EXPECT_CALL(mock_event_listener_,
              OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(true)));
+
  policy_engine_->SetLicense(license_);
  policy_engine_->BeginDecryption();
  policy_engine_->OnTimerEvent();
@@ -185,6 +199,11 @@ TEST_F(PolicyEngineTest, PlaybackSuccess_StreamingLicense) {
  EXPECT_CALL(mock_event_listener_,
              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);
  policy_engine_->BeginDecryption();
  policy_engine_->OnTimerEvent();
@@ -203,6 +222,11 @@ TEST_F(PolicyEngineTest, PlaybackFailed_CanPlayFalse) {

  ExpectSessionKeysChange(kKeyStatusExpired, false);

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);
  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));

@@ -223,6 +247,11 @@ TEST_F(PolicyEngineTest, LicenseExpired_RentalDurationExpiredWithoutPlayback) {
      .WillOnce(Return(kLicenseStartTime + kLowDuration - 1))
      .WillOnce(Return(kLicenseStartTime + kLowDuration));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -253,6 +282,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_RentalDurationPassedWithPlayback) {
      .WillOnce(Return(kLicenseStartTime + kLowDuration - 1))
      .WillOnce(Return(kLicenseStartTime + kLowDuration + 1));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -283,6 +317,11 @@ TEST_F(PolicyEngineTest, PlaybackFails_PlaybackDurationExpired) {
      .WillOnce(Return(playback_start_time + kPlaybackDuration - 2))
      .WillOnce(Return(playback_start_time + kPlaybackDuration + 2));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -315,6 +354,11 @@ TEST_F(PolicyEngineTest, LicenseExpired_LicenseDurationExpiredWithoutPlayback) {
      .WillOnce(Return(kLicenseStartTime + kLowDuration - 1))
      .WillOnce(Return(kLicenseStartTime + kLowDuration));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -346,6 +390,11 @@ TEST_F(PolicyEngineTest, PlaybackFails_ExpiryBeforeRenewalDelay_Offline) {
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 1))
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 1));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -381,6 +430,11 @@ TEST_F(PolicyEngineTest, PlaybackFails_ExpiryBeforeRenewalDelay_Streaming) {
      .WillOnce(Return(kLicenseStartTime + kLicenseDuration - 1))
      .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 1));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -411,6 +465,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_RentalDuration0) {
      .WillOnce(Return(kLicenseStartTime + kRentalDuration + 10))
      .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 1));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -443,6 +502,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_PlaybackDuration0) {
      .WillOnce(Return(kLicenseStartTime + kLicenseDuration - 2))
      .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 2));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -477,6 +541,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_LicenseDuration0) {
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 1))
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 1));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -514,6 +583,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_PlaybackAndRental0) {
  EXPECT_CALL(mock_event_listener_,
              OnExpirationUpdate(_, kLicenseStartTime + kLicenseDuration));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);
  policy_engine_->BeginDecryption();
  policy_engine_->OnTimerEvent();
@@ -537,6 +611,16 @@ TEST_F(PolicyEngineTest, PlaybackOk_Durations0) {
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, NEVER_EXPIRES));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);

  policy_engine_->BeginDecryption();
@@ -555,6 +639,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_LicenseWithFutureStartTime) {
      .WillOnce(Return(kLicenseStartTime))
      .WillOnce(Return(kPlaybackStartTime));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusPending, false);
  EXPECT_CALL(mock_event_listener_,
@@ -589,6 +678,11 @@ TEST_F(PolicyEngineTest, PlaybackFailed_CanRenewFalse) {
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 10))
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 1));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -630,6 +724,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess) {
      .WillOnce(Return(kLicenseStartTime + license_renewal_delay +
                       kLicenseRenewalRetryInterval + 10));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -682,6 +781,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess_WithFutureStartTime) {
      .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 30))
      .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 60));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -734,6 +838,11 @@ TEST_F(PolicyEngineTest, LicenseExpired_RenewFailedVersionNotUpdated) {
      .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 40))
      .WillOnce(Return(kLicenseStartTime + kLowDuration + 10));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -792,6 +901,11 @@ TEST_F(PolicyEngineTest, PlaybackFailed_RepeatedRenewFailures) {
      .WillOnce(Return(kLicenseStartTime + kLicenseDuration - 15))
      .WillOnce(Return(kLicenseStartTime + kLicenseDuration));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -848,6 +962,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterExpiry) {
      .WillOnce(Return(new_license_start_time))
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 20));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -918,6 +1037,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterFailures) {
      .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 67))
      .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 200));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -972,6 +1096,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewedWithUsage) {
      .WillOnce(Return(kLicenseStartTime + 20))
      .WillOnce(Return(kLicenseStartTime + 40));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence s;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -1030,6 +1159,11 @@ TEST_F(PolicyEngineTest, MultipleKeysInLicense) {
  EXPECT_CALL(*mock_clock_, GetCurrentTime())
      .WillOnce(Return(kLicenseStartTime + 1));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  ExpectSessionKeysChange(kKeyStatusUsable, kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, _));

@@ -1052,6 +1186,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_SoftEnforcePlaybackDuration) {
      .WillOnce(Return(kLicenseStartTime + kLicenseDuration - 5))
      .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 5));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence seq;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -1085,6 +1224,11 @@ TEST_F(PolicyEngineTest, LicenseExpired_SoftEnforceLoadBeforeExpire) {
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 5))
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 10));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence seq;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -1109,6 +1253,11 @@ TEST_F(PolicyEngineTest, LicenseExpired_SoftEnforceLoadAfterExpire) {
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 5))
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 10));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence seq;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -1138,6 +1287,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_GracePeriod) {
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 5))
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 5));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence seq;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -1177,6 +1331,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_GracePeriodWithLoad) {
      .WillOnce(Return(kNewPlaybackStartTime + kPlaybackDuration - 5))
      .WillOnce(Return(kNewPlaybackStartTime + kPlaybackDuration + 5));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence seq;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -1215,6 +1374,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_GracePeriodWithExpiredLoad) {
      .WillOnce(Return(kNewPlaybackStartTime))
      .WillOnce(Return(kNewPlaybackStartTime));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence seq;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -1242,6 +1406,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_CanStoreGracePeriod) {
      .WillOnce(Return(kPlaybackStartTime + 50))
      .WillOnce(Return(kPlaybackStartTime + kGracePeriod + 2));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  InSequence seq;
  ExpectSessionKeysChange(kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_,
@@ -1383,6 +1552,11 @@ TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageBasic) {
  EXPECT_CALL(*mock_clock_, GetCurrentTime())
      .WillOnce(Return(kLicenseStartTime + 1));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  ExpectSessionKeysChange(kKeyStatusUsable, kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, _));

@@ -1438,6 +1612,11 @@ TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageGeneric) {
  EXPECT_CALL(*mock_clock_, GetCurrentTime())
      .WillOnce(Return(kLicenseStartTime + 1));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  ExpectSessionKeysChange(kKeyStatusUsable, kKeyStatusUsable, true);
  EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, _));

@@ -1463,7 +1642,7 @@ class PolicyEngineQueryTest : public PolicyEngineTest {
 protected:
  virtual void SetUp() {
    PolicyEngineTest::SetUp();
-    policy_engine_.reset(new PolicyEngine(kSessionId, NULL, NULL));
+    policy_engine_.reset(new PolicyEngine(kSessionId, NULL, &crypto_session_));
    InjectMockClock();

    // Use a STREAMING license policy.
@@ -1501,6 +1680,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess) {
      .WillOnce(Return(kLicenseStartTime + 1))
      .WillOnce(Return(kLicenseStartTime + 100));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);

  CdmQueryMap query_info;
@@ -1523,6 +1707,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackNotBegun) {
      .WillOnce(Return(kLicenseStartTime + 100))
      .WillOnce(Return(kLicenseStartTime + 200));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);

  CdmQueryMap query_info;
@@ -1559,6 +1748,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackBegun) {
      .WillOnce(Return(kLicenseStartTime + 150))
      .WillOnce(Return(kLicenseStartTime + 200));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(true)));
+
  policy_engine_->SetLicense(license_);

  CdmQueryMap query_info;
@@ -1608,6 +1802,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_Offline) {
      .WillOnce(Return(kLicenseStartTime + 200))
      .WillOnce(Return(kLicenseStartTime + 300));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);

  policy_engine_->OnTimerEvent();
@@ -1690,6 +1889,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_CanPlayFalse) {
      .WillOnce(Return(kLicenseStartTime + 5))
      .WillOnce(Return(kLicenseStartTime + 100));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);
  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));

@@ -1725,6 +1929,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDurationExpired) {
      .WillOnce(Return(kLicenseStartTime + kLowDuration))
      .WillOnce(Return(kLicenseStartTime + kLowDuration + 5));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);

  policy_engine_->BeginDecryption();
@@ -1763,6 +1972,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDurationExpired) {
      .WillOnce(Return(playback_start_time + 2 + kLowDuration))
      .WillOnce(Return(playback_start_time + 5 + kLowDuration));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);

  policy_engine_->BeginDecryption();
@@ -1797,6 +2011,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDurationExpired) {
      .WillOnce(Return(kLicenseStartTime + kLowDuration))
      .WillOnce(Return(kLicenseStartTime + kLowDuration + 5));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);

  policy_engine_->BeginDecryption();
@@ -1835,6 +2054,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDuration0) {
      .WillOnce(Return(kLicenseStartTime + kLowDuration))
      .WillOnce(Return(kLicenseStartTime + kLowDuration + 5));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);

  policy_engine_->BeginDecryption();
@@ -1876,6 +2100,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDuration0) {
      .WillOnce(Return(kLicenseStartTime + kHighDuration + 2))
      .WillOnce(Return(kLicenseStartTime + kHighDuration + 5));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);

  policy_engine_->BeginDecryption();
@@ -1928,6 +2157,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDuration0) {
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration))
      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 5));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);

  policy_engine_->BeginDecryption();
@@ -1965,6 +2199,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_Durations0) {
      .WillOnce(Return(kLicenseStartTime + kHighDuration + 9))
      .WillOnce(Return(kLicenseStartTime + kHighDuration + 15));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);

  policy_engine_->BeginDecryption();
@@ -1998,6 +2237,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseWithFutureStartTime) {
      .WillOnce(Return(kLicenseStartTime + 10))
      .WillOnce(Return(kLicenseStartTime + 25));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);

  policy_engine_->OnTimerEvent();
@@ -2049,6 +2293,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_Renew) {
      .WillOnce(Return(kLicenseStartTime + license_renewal_delay +
                       kLicenseRenewalRetryInterval + 15));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);

  policy_engine_->BeginDecryption();
@@ -2102,6 +2351,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RenewWithFutureStartTime) {
      .WillOnce(Return(kLicenseStartTime + license_renewal_delay +
                       kLicenseRenewalRetryInterval + 40));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);

  policy_engine_->BeginDecryption();
@@ -2177,6 +2431,11 @@ TEST_F(PolicyEngineTest, SetLicenseForReleaseAfterSetLicense) {
  EXPECT_CALL(mock_event_listener_,
              OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration));

+  EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillRepeatedly(
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+                Return(false)));
+
  policy_engine_->SetLicense(license_);
  policy_engine_->BeginDecryption();
  policy_engine_->OnTimerEvent();
--- a/core/test/service_certificate_unittest.cpp
+++ b/core/test/service_certificate_unittest.cpp
@@ -136,9 +136,11 @@ TEST_F(ServiceCertificateTest, InitServiceCertificatePresent) {
  Properties::AddSessionPropertySet(kTestSessionId1, &property_set);

  CreateServiceCertificate();
+  std::string service_certificate;
+  EXPECT_TRUE(Properties::GetServiceCertificate(kTestSessionId1,
+                                                &service_certificate));
  EXPECT_EQ(NO_ERROR,
-            service_certificate_->Init(
-                Properties::service_certificate(kTestSessionId1));
+            service_certificate_->Init(service_certificate));
  EXPECT_TRUE(service_certificate_->HasCertificate());
 }

@@ -151,7 +153,7 @@ TEST_F(ServiceCertificateTest, SetServiceCertificate) {
  Properties::AddSessionPropertySet(kTestSessionId1, &property_set);

  CreateServiceCertificate();
-  EXPECT_EQ(NO_ERROR, service_certificate_->Init(kTestSignedCertificate);
+  EXPECT_EQ(NO_ERROR, service_certificate_->Init(kTestSignedCertificate));
  EXPECT_TRUE(service_certificate_->HasCertificate());
 }

--- a/core/test/test_printers.cpp
+++ b/core/test/test_printers.cpp
@@ -249,6 +249,12 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
    case RELEASE_ALL_USAGE_INFO_ERROR_2:
      *os << "RELEASE_ALL_USAGE_INFO_ERROR_2";
      break;
+    case RELEASE_ALL_USAGE_INFO_ERROR_3:
+      *os << "RELEASE_ALL_USAGE_INFO_ERROR_3";
+      break;
+    case RELEASE_ALL_USAGE_INFO_ERROR_4:
+      *os << "RELEASE_ALL_USAGE_INFO_ERROR_4";
+      break;
    case RELEASE_KEY_ERROR: *os                    << "RELEASE_KEY_ERROR";
      break;
    case RELEASE_KEY_REQUEST_ERROR: *os          << "RELEASE_KEY_REQUEST_ERROR";
@@ -302,8 +308,6 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
      break;
    case STORE_LICENSE_ERROR_2: *os                << "STORE_LICENSE_ERROR_2";
      break;
-    case STORE_LICENSE_ERROR_3: *os                << "STORE_LICENSE_ERROR_3";
-      break;
    case STORE_USAGE_INFO_ERROR: *os               << "STORE_USAGE_INFO_ERROR";
      break;
    case UNPROVISION_ERROR_1: *os                  << "UNPROVISION_ERROR_1";
@@ -318,18 +322,12 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
      break;
    case USAGE_INFO_NOT_FOUND: *os                 << "USAGE_INFO_NOT_FOUND";
      break;
-    case LICENSE_RENEWAL_SERVICE_CERTIFICATE_GENERATION_ERROR:
-      *os << "LICENSE_RENEWAL_SERVICE_CERTIFICATE_GENERATION_ERROR";
-      break;
    case EMPTY_PROVISIONING_CERTIFICATE_2:
      *os << "EMPTY_PROVISIONING_CERTIFICATE_2";
      break;
    case PARSE_SERVICE_CERTIFICATE_ERROR:
      *os << "PARSE_SERVICE_CERTIFICATE_ERROR";
      break;
-    case SERVICE_CERTIFICATE_TYPE_ERROR:
-      *os << "SERVICE_CERTIFICATE_TYPE_ERROR";
-      break;
    case CLIENT_ID_GENERATE_RANDOM_ERROR:
      *os << "CLIENT_ID_GENERATE_RANDOM_ERROR";
      break;
@@ -354,9 +352,6 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
      break;
    case INVALID_PARAMETERS_LIC_7: *os            << "INVALID_PARAMETERS_LIC_7";
      break;
-    case LICENSE_REQUEST_SERVICE_CERTIFICATE_GENERATION_ERROR:
-      *os << "LICENSE_REQUEST_SERVICE_CERTIFICATE_GENERATION_ERROR";
-      break;
    case CENC_INIT_DATA_UNAVAILABLE: *os        << "CENC_INIT_DATA_UNAVAILABLE";
      break;
    case PREPARE_CENC_CONTENT_ID_FAILED:
@@ -449,6 +444,10 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
      break;
    case INVALID_PARAMETERS_ENG_17: *os          << "INVALID_PARAMETERS_ENG_17";
      break;
+    case INVALID_PARAMETERS_ENG_18: *os          << "INVALID_PARAMETERS_ENG_18";
+      break;
+    case INVALID_PARAMETERS_ENG_19: *os          << "INVALID_PARAMETERS_ENG_19";
+      break;
    case CERT_PROVISIONING_CLIENT_TOKEN_ERROR_1:
      *os << "CERT_PROVISIONING_CLIENT_TOKEN_ERROR_1";
      break;
@@ -458,6 +457,36 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
    case LICENSING_CLIENT_TOKEN_ERROR_1:
      *os << "LICENSING_CLIENT_TOKEN_ERROR_1";
      break;
+    case LIST_LICENSE_ERROR_1: *os               << "LIST_LICENSE_ERROR_1";
+      break;
+    case LIST_LICENSE_ERROR_2: *os               << "LIST_LICENSE_ERROR_2";
+      break;
+    case LIST_USAGE_ERROR_1: *os                 << "LIST_USAGE_ERROR_1";
+      break;
+    case LIST_USAGE_ERROR_2: *os                 << "LIST_USAGE_ERROR_2";
+      break;
+    case DELETE_USAGE_ERROR_1: *os               << "DELETE_USAGE_ERROR_1";
+      break;
+    case DELETE_USAGE_ERROR_2: *os               << "DELETE_USAGE_ERROR_2";
+      break;
+    case DELETE_USAGE_ERROR_3: *os               << "DELETE_USAGE_ERROR_3";
+      break;
+    case PRIVACY_MODE_ERROR_1: *os               << "PRIVACY_MODE_ERROR_1";
+      break;
+    case PRIVACY_MODE_ERROR_2: *os               << "PRIVACY_MODE_ERROR_2";
+      break;
+    case PRIVACY_MODE_ERROR_3: *os               << "PRIVACY_MODE_ERROR_3";
+      break;
+    case EMPTY_RESPONSE_ERROR_1: *os             << "EMPTY_RESPONSE_ERROR_1";
+      break;
+    case PARSE_RESPONSE_ERROR_1: *os             << "PARSE_RESPONSE_ERROR_1";
+      break;
+    case PARSE_RESPONSE_ERROR_2: *os             << "PARSE_RESPONSE_ERROR_2";
+      break;
+    case PARSE_RESPONSE_ERROR_3: *os             << "PARSE_RESPONSE_ERROR_3";
+      break;
+    case PARSE_RESPONSE_ERROR_4: *os             << "PARSE_RESPONSE_ERROR_4";
+      break;
    default:
      *os                                        << "Unknown CdmResponseType";
      break;
@@ -472,8 +501,6 @@ void PrintTo(const enum CdmLicenseType& value, ::std::ostream* os) {
      break;
    case kLicenseTypeRelease: *os                  << "kLicenseTypeRelease";
      break;
-    case kLicenseTypeDeferred: *os                 << "kLicenseTypeDeferred";
-      break;
    default:
      *os                                          << "Unknown  CdmLicenseType";
      break;
--- a/core/test/url_request.cpp
+++ b/core/test/url_request.cpp
@@ -167,10 +167,11 @@ bool UrlRequest::PostRequest(const std::string& data) {

 bool UrlRequest::PostCertRequestInQueryString(const std::string& data) {
  std::string path = socket_.resource_path();
-  path.append("&signedRequest=");
+  path.append((path.find('?') == std::string::npos) ? "?" : "&");
+  path.append("signedRequest=");
  path.append(data);
-
  return PostRequestWithPath(path, "");
+  return true;
 }

 }  // namespace wvcdm