BASELINE: Update Chromium to 69.0.3497.70

Change-Id: I2b7b56e4e7a8b26656930def0d4575dc32b900a0
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

20 files changed, 235 insertions, 182 deletions

diff --git a/chromium/media/cdm/BUILD.gn b/chromium/media/cdm/BUILD.gn
index f3dbef75fb6..deff5005c73 100644
--- a/chromium/media/cdm/BUILD.gn
+++ b/chromium/media/cdm/BUILD.gn
@@ -98,12 +98,6 @@ source_set("cdm") {
         "cdm_host_files.cc",
         "cdm_host_files.h",
       ]
-      deps += [
-        # Needed for finding CDM path from CDM adapter path.
-        # TODO(xhwang): Remove this dependency when CDM adapter is deprecated.
-        # See http://crbug.com/403462
-        "//third_party/widevine/cdm:headers",
-      ]
     }
   }
 }
diff --git a/chromium/media/cdm/aes_decryptor.cc b/chromium/media/cdm/aes_decryptor.cc
index b1a95211ef6..2a8c76b43c2 100644
--- a/chromium/media/cdm/aes_decryptor.cc
+++ b/chromium/media/cdm/aes_decryptor.cc
@@ -417,7 +417,7 @@ void AesDecryptor::RemoveSession(const std::string& session_id,
   //              Let message be a message containing or reflecting the record
   //              of license destruction.
   std::vector<uint8_t> message;
-  if (it->second != CdmSessionType::TEMPORARY_SESSION) {
+  if (it->second != CdmSessionType::kTemporary) {
     // The license release message is specified in the spec:
     // https://w3c.github.io/encrypted-media/#clear-key-release-format.
     KeyIdList key_ids;
@@ -486,6 +486,8 @@ void AesDecryptor::RegisterNewKeyCB(StreamType stream_type,
 void AesDecryptor::Decrypt(StreamType stream_type,
                            scoped_refptr<DecoderBuffer> encrypted,
                            const DecryptCB& decrypt_cb) {
+  DVLOG(3) << __func__ << ": " << encrypted->AsHumanReadableString();
+
   if (!encrypted->decrypt_config()) {
     // If there is no DecryptConfig, then the data is unencrypted so return it
     // immediately.
@@ -575,7 +577,7 @@ std::string AesDecryptor::GetSessionStateAsJWK(const std::string& session_id) {
       }
     }
   }
-  return GenerateJWKSet(keys, CdmSessionType::PERSISTENT_LICENSE_SESSION);
+  return GenerateJWKSet(keys, CdmSessionType::kPersistentLicense);
 }
 
 bool AesDecryptor::AddDecryptionKey(const std::string& session_id,
diff --git a/chromium/media/cdm/aes_decryptor.h b/chromium/media/cdm/aes_decryptor.h
index 943e76d87cc..3c6cfcb873d 100644
--- a/chromium/media/cdm/aes_decryptor.h
+++ b/chromium/media/cdm/aes_decryptor.h
@@ -85,7 +85,9 @@ class MEDIA_EXPORT AesDecryptor : public ContentDecryptionModule,
   void DeinitializeDecoder(StreamType stream_type) override;
 
  private:
+  // Testing classes that needs to manipulate internal states for testing.
   friend class ClearKeyPersistentSessionCdm;
+  friend class ClearKeyCdmProxy;
 
   // Internally this class supports persistent license type sessions so that
   // it can be used by ClearKeyPersistentSessionCdm. The following methods
diff --git a/chromium/media/cdm/aes_decryptor_unittest.cc b/chromium/media/cdm/aes_decryptor_unittest.cc
index cb06e066713..efeaee1f715 100644
--- a/chromium/media/cdm/aes_decryptor_unittest.cc
+++ b/chromium/media/cdm/aes_decryptor_unittest.cc
@@ -367,7 +367,7 @@ class AesDecryptorTest : public testing::TestWithParam<TestType> {
     DCHECK(!key_id.empty());
     EXPECT_CALL(cdm_client_,
                 OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
-    cdm_->CreateSessionAndGenerateRequest(CdmSessionType::TEMPORARY_SESSION,
+    cdm_->CreateSessionAndGenerateRequest(CdmSessionType::kTemporary,
                                           EmeInitDataType::WEBM, key_id,
                                           CreateSessionPromise(RESOLVED));
     // This expects the promise to be called synchronously, which is the case
@@ -519,13 +519,13 @@ class AesDecryptorTest : public testing::TestWithParam<TestType> {
 
 TEST_P(AesDecryptorTest, CreateSessionWithEmptyInitData) {
   cdm_->CreateSessionAndGenerateRequest(
-      CdmSessionType::TEMPORARY_SESSION, EmeInitDataType::WEBM,
-      std::vector<uint8_t>(), CreateSessionPromise(REJECTED));
+      CdmSessionType::kTemporary, EmeInitDataType::WEBM, std::vector<uint8_t>(),
+      CreateSessionPromise(REJECTED));
   cdm_->CreateSessionAndGenerateRequest(
-      CdmSessionType::TEMPORARY_SESSION, EmeInitDataType::CENC,
-      std::vector<uint8_t>(), CreateSessionPromise(REJECTED));
+      CdmSessionType::kTemporary, EmeInitDataType::CENC, std::vector<uint8_t>(),
+      CreateSessionPromise(REJECTED));
   cdm_->CreateSessionAndGenerateRequest(
-      CdmSessionType::TEMPORARY_SESSION, EmeInitDataType::KEYIDS,
+      CdmSessionType::kTemporary, EmeInitDataType::KEYIDS,
       std::vector<uint8_t>(), CreateSessionPromise(REJECTED));
 }
 
@@ -534,41 +534,41 @@ TEST_P(AesDecryptorTest, CreateSessionWithVariousLengthInitData_WebM) {
   init_data.resize(1);
   EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
-      CdmSessionType::TEMPORARY_SESSION, EmeInitDataType::WEBM,
+      CdmSessionType::kTemporary, EmeInitDataType::WEBM,
       std::vector<uint8_t>(init_data), CreateSessionPromise(RESOLVED));
 
   init_data.resize(16);  // The expected size.
   EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
-      CdmSessionType::TEMPORARY_SESSION, EmeInitDataType::WEBM,
+      CdmSessionType::kTemporary, EmeInitDataType::WEBM,
       std::vector<uint8_t>(init_data), CreateSessionPromise(RESOLVED));
 
   init_data.resize(512);
   EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
-      CdmSessionType::TEMPORARY_SESSION, EmeInitDataType::WEBM,
+      CdmSessionType::kTemporary, EmeInitDataType::WEBM,
       std::vector<uint8_t>(init_data), CreateSessionPromise(RESOLVED));
 
   init_data.resize(513);
   cdm_->CreateSessionAndGenerateRequest(
-      CdmSessionType::TEMPORARY_SESSION, EmeInitDataType::WEBM,
+      CdmSessionType::kTemporary, EmeInitDataType::WEBM,
       std::vector<uint8_t>(init_data), CreateSessionPromise(REJECTED));
 }
 
 TEST_P(AesDecryptorTest, MultipleCreateSession) {
   EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
-      CdmSessionType::TEMPORARY_SESSION, EmeInitDataType::WEBM,
+      CdmSessionType::kTemporary, EmeInitDataType::WEBM,
       std::vector<uint8_t>(1), CreateSessionPromise(RESOLVED));
 
   EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
-      CdmSessionType::TEMPORARY_SESSION, EmeInitDataType::WEBM,
+      CdmSessionType::kTemporary, EmeInitDataType::WEBM,
       std::vector<uint8_t>(1), CreateSessionPromise(RESOLVED));
 
   EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
-      CdmSessionType::TEMPORARY_SESSION, EmeInitDataType::WEBM,
+      CdmSessionType::kTemporary, EmeInitDataType::WEBM,
       std::vector<uint8_t>(1), CreateSessionPromise(RESOLVED));
 }
 
@@ -590,7 +590,7 @@ TEST_P(AesDecryptorTest, CreateSessionWithCencInitData) {
 
   EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
-      CdmSessionType::TEMPORARY_SESSION, EmeInitDataType::CENC,
+      CdmSessionType::kTemporary, EmeInitDataType::CENC,
       std::vector<uint8_t>(init_data, init_data + arraysize(init_data)),
       CreateSessionPromise(RESOLVED));
 }
@@ -601,7 +601,7 @@ TEST_P(AesDecryptorTest, CreateSessionWithKeyIdsInitData) {
 
   EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
-      CdmSessionType::TEMPORARY_SESSION, EmeInitDataType::KEYIDS,
+      CdmSessionType::kTemporary, EmeInitDataType::KEYIDS,
       std::vector<uint8_t>(init_data, init_data + arraysize(init_data) - 1),
       CreateSessionPromise(RESOLVED));
 }
diff --git a/chromium/media/cdm/api/content_decryption_module.h b/chromium/media/cdm/api/content_decryption_module.h
index 0dde3ff4c91..85ffd01ac2e 100644
--- a/chromium/media/cdm/api/content_decryption_module.h
+++ b/chromium/media/cdm/api/content_decryption_module.h
@@ -420,7 +420,7 @@ CHECK_TYPE(InitDataType, 4, 4);
 enum SessionType : uint32_t {
   kTemporary = 0,
   kPersistentLicense = 1,
-  kPersistentKeyRelease = 2
+  kPersistentUsageRecord = 2
 };
 CHECK_TYPE(SessionType, 4, 4);
 
diff --git a/chromium/media/cdm/api/content_decryption_module_proxy.h b/chromium/media/cdm/api/content_decryption_module_proxy.h
index f41b9f73f98..78751066279 100644
--- a/chromium/media/cdm/api/content_decryption_module_proxy.h
+++ b/chromium/media/cdm/api/content_decryption_module_proxy.h
@@ -80,7 +80,7 @@ class CDM_CLASS_API CdmProxyClient {
 
   enum Protocol : uint32_t {
     kNone = 0,  // No protocol supported. Can be used in failure cases.
-    kIntelConvergedSecurityAndManageabilityEngine,  // Method using Intel CSME.
+    kIntel,  // Method using Intel CSME.
     // There will be more values in the future e.g. kD3D11RsaHardware,
     // kD3D11RsaSoftware to use the D3D11 RSA method.
   };
diff --git a/chromium/media/cdm/cdm_adapter.cc b/chromium/media/cdm/cdm_adapter.cc
index 6e9cdfb8c6a..c2bad3057e7 100644
--- a/chromium/media/cdm/cdm_adapter.cc
+++ b/chromium/media/cdm/cdm_adapter.cc
@@ -84,12 +84,12 @@ cdm::HdcpVersion ToCdmHdcpVersion(HdcpVersion hdcp_version) {
 
 cdm::SessionType ToCdmSessionType(CdmSessionType session_type) {
   switch (session_type) {
-    case CdmSessionType::TEMPORARY_SESSION:
+    case CdmSessionType::kTemporary:
       return cdm::kTemporary;
-    case CdmSessionType::PERSISTENT_LICENSE_SESSION:
+    case CdmSessionType::kPersistentLicense:
       return cdm::kPersistentLicense;
-    case CdmSessionType::PERSISTENT_RELEASE_MESSAGE_SESSION:
-      return cdm::kPersistentKeyRelease;
+    case CdmSessionType::kPersistentUsageRecord:
+      return cdm::kPersistentUsageRecord;
   }
 
   NOTREACHED() << "Unexpected session type: " << static_cast<int>(session_type);
@@ -318,11 +318,8 @@ cdm::EncryptionScheme ToCdmEncryptionScheme(const EncryptionScheme& scheme) {
     case EncryptionScheme::CIPHER_MODE_UNENCRYPTED:
       return cdm::EncryptionScheme::kUnencrypted;
     case EncryptionScheme::CIPHER_MODE_AES_CTR:
-      if (!scheme.pattern().IsInEffect())
-        return cdm::EncryptionScheme::kCenc;
-      break;
+      return cdm::EncryptionScheme::kCenc;
     case EncryptionScheme::CIPHER_MODE_AES_CBC:
-      // Pattern should be required for 'cbcs' but is currently optional.
       return cdm::EncryptionScheme::kCbcs;
   }
 
@@ -686,7 +683,10 @@ Decryptor* CdmAdapter::GetDecryptor() {
 
   // When using HW secure codecs, we cannot and should not use the CDM instance
   // to do decrypt and/or decode. Instead, we should use the CdmProxy.
-  if (cdm_config_.use_hw_secure_codecs)
+  // TODO(xhwang): Fix External Clear Key key system to be able to set
+  // |use_hw_secure_codecs| so that we don't have to check both.
+  // TODO(xhwang): Update this logic to support transcryption.
+  if (cdm_config_.use_hw_secure_codecs || cdm_proxy_created_)
     return nullptr;
 
   return this;
diff --git a/chromium/media/cdm/cdm_adapter_unittest.cc b/chromium/media/cdm/cdm_adapter_unittest.cc
index 8ca37d995f8..4ecc77cfec7 100644
--- a/chromium/media/cdm/cdm_adapter_unittest.cc
+++ b/chromium/media/cdm/cdm_adapter_unittest.cc
@@ -229,7 +229,7 @@ class CdmAdapterTestWithClearKeyCdm : public CdmAdapterTestBase {
     }
 
     cdm_->CreateSessionAndGenerateRequest(
-        CdmSessionType::TEMPORARY_SESSION, data_type, key_id,
+        CdmSessionType::kTemporary, data_type, key_id,
         CreateSessionPromise(expected_result));
     RunUntilIdle();
   }
@@ -241,7 +241,7 @@ class CdmAdapterTestWithClearKeyCdm : public CdmAdapterTestBase {
     DCHECK(!session_id.empty());
     ASSERT_EQ(expected_result, FAILURE) << "LoadSession not supported.";
 
-    cdm_->LoadSession(CdmSessionType::TEMPORARY_SESSION, session_id,
+    cdm_->LoadSession(CdmSessionType::kTemporary, session_id,
                       CreateSessionPromise(expected_result));
     RunUntilIdle();
   }
diff --git a/chromium/media/cdm/cdm_proxy.h b/chromium/media/cdm/cdm_proxy.h
index d735d20cf6f..822e1581f89 100644
--- a/chromium/media/cdm/cdm_proxy.h
+++ b/chromium/media/cdm/cdm_proxy.h
@@ -38,17 +38,17 @@ class MEDIA_EXPORT CdmProxy {
   enum class Status {
     kOk,
     kFail,
-    kMax = kFail,
+    kMaxValue = kFail,
   };
 
   enum class Protocol {
     // No supported protocol. Used in failure cases.
     kNone,
     // Method using Intel CSME.
-    kIntelConvergedSecurityAndManageabilityEngine,
+    kIntel,
     // There will be more values in the future e.g. kD3D11RsaHardware,
     // kD3D11RsaSoftware to use the D3D11 RSA method.
-    kMax = kIntelConvergedSecurityAndManageabilityEngine,
+    kMaxValue = kIntel,
   };
 
   enum class Function {
@@ -56,7 +56,7 @@ class MEDIA_EXPORT CdmProxy {
     // ID3D11VideoContext::NegotiateCryptoSessionKeyExchange.
     kIntelNegotiateCryptoSessionKeyExchange,
     // There will be more values in the future e.g. for D3D11 RSA method.
-    kMax = kIntelNegotiateCryptoSessionKeyExchange,
+    kMaxValue = kIntelNegotiateCryptoSessionKeyExchange,
   };
 
   CdmProxy();
diff --git a/chromium/media/cdm/cenc_decryptor_unittest.cc b/chromium/media/cdm/cenc_decryptor_unittest.cc
index 2fa6b6900e1..441c2c41b7a 100644
--- a/chromium/media/cdm/cenc_decryptor_unittest.cc
+++ b/chromium/media/cdm/cenc_decryptor_unittest.cc
@@ -129,7 +129,8 @@ TEST_F(CencDecryptorTest, OneBlock) {
   auto encrypted_block = Encrypt(one_block_, *key_, iv_);
 
   // Only 1 subsample, all encrypted data.
-  std::vector<SubsampleEntry> subsamples = {{0, encrypted_block.size()}};
+  std::vector<SubsampleEntry> subsamples = {
+      {0, static_cast<uint32_t>(encrypted_block.size())}};
 
   auto encrypted_buffer =
       CreateEncryptedBuffer(encrypted_block, iv_, subsamples);
@@ -140,7 +141,8 @@ TEST_F(CencDecryptorTest, ExtraData) {
   auto encrypted_block = Encrypt(one_block_, *key_, iv_);
 
   // Only 1 subsample, all encrypted data.
-  std::vector<SubsampleEntry> subsamples = {{0, encrypted_block.size()}};
+  std::vector<SubsampleEntry> subsamples = {
+      {0, static_cast<uint32_t>(encrypted_block.size())}};
 
   auto encrypted_buffer =
       CreateEncryptedBuffer(encrypted_block, iv_, subsamples);
@@ -179,7 +181,8 @@ TEST_F(CencDecryptorTest, BadSubsamples) {
   auto encrypted_block = Encrypt(one_block_, *key_, iv_);
 
   // Subsample size > data size.
-  std::vector<SubsampleEntry> subsamples = {{0, encrypted_block.size() + 1}};
+  std::vector<SubsampleEntry> subsamples = {
+      {0, static_cast<uint32_t>(encrypted_block.size() + 1)}};
 
   auto encrypted_buffer =
       CreateEncryptedBuffer(encrypted_block, iv_, subsamples);
@@ -189,7 +192,8 @@ TEST_F(CencDecryptorTest, BadSubsamples) {
 TEST_F(CencDecryptorTest, InvalidIv) {
   auto encrypted_block = Encrypt(one_block_, *key_, iv_);
 
-  std::vector<SubsampleEntry> subsamples = {{0, encrypted_block.size()}};
+  std::vector<SubsampleEntry> subsamples = {
+      {0, static_cast<uint32_t>(encrypted_block.size())}};
 
   // Use an invalid IV for decryption. Call should succeed, but return
   // something other than the original data.
@@ -204,7 +208,8 @@ TEST_F(CencDecryptorTest, InvalidKey) {
       crypto::SymmetricKey::AES, std::string(arraysize(kKey), 'b'));
   auto encrypted_block = Encrypt(one_block_, *key_, iv_);
 
-  std::vector<SubsampleEntry> subsamples = {{0, encrypted_block.size()}};
+  std::vector<SubsampleEntry> subsamples = {
+      {0, static_cast<uint32_t>(encrypted_block.size())}};
 
   // Use a different key for decryption. Call should succeed, but return
   // something other than the original data.
@@ -217,7 +222,8 @@ TEST_F(CencDecryptorTest, PartialBlock) {
   auto encrypted_block = Encrypt(partial_block_, *key_, iv_);
 
   // Only 1 subsample, all encrypted data.
-  std::vector<SubsampleEntry> subsamples = {{0, encrypted_block.size()}};
+  std::vector<SubsampleEntry> subsamples = {
+      {0, static_cast<uint32_t>(encrypted_block.size())}};
 
   auto encrypted_buffer =
       CreateEncryptedBuffer(encrypted_block, iv_, subsamples);
@@ -230,7 +236,9 @@ TEST_F(CencDecryptorTest, MultipleSubsamples) {
 
   // Treat as 3 subsamples.
   std::vector<SubsampleEntry> subsamples = {
-      {0, one_block_.size()}, {0, one_block_.size()}, {0, one_block_.size()}};
+      {0, static_cast<uint32_t>(one_block_.size())},
+      {0, static_cast<uint32_t>(one_block_.size())},
+      {0, static_cast<uint32_t>(one_block_.size())}};
 
   auto encrypted_buffer =
       CreateEncryptedBuffer(encrypted_block, iv_, subsamples);
@@ -258,9 +266,11 @@ TEST_F(CencDecryptorTest, MultipleSubsamplesWithClearBytes) {
   auto expected_result = Combine(
       {one_block_, partial_block_, partial_block_, one_block_, partial_block_});
   std::vector<SubsampleEntry> subsamples = {
-      {one_block_.size(), partial_block_.size()},
-      {partial_block_.size(), one_block_.size()},
-      {partial_block_.size(), 0}};
+      {static_cast<uint32_t>(one_block_.size()),
+       static_cast<uint32_t>(partial_block_.size())},
+      {static_cast<uint32_t>(partial_block_.size()),
+       static_cast<uint32_t>(one_block_.size())},
+      {static_cast<uint32_t>(partial_block_.size()), 0}};
 
   auto encrypted_buffer = CreateEncryptedBuffer(input_data, iv_, subsamples);
   EXPECT_EQ(expected_result, DecryptWithKey(encrypted_buffer, *key_));
diff --git a/chromium/media/cdm/json_web_key.cc b/chromium/media/cdm/json_web_key.cc
index d851ff30ef6..aec3796e3cb 100644
--- a/chromium/media/cdm/json_web_key.cc
+++ b/chromium/media/cdm/json_web_key.cc
@@ -32,7 +32,7 @@ const char kKeyIdsTag[] = "kids";
 const char kTypeTag[] = "type";
 const char kTemporarySession[] = "temporary";
 const char kPersistentLicenseSession[] = "persistent-license";
-const char kPersistentReleaseMessageSession[] = "persistent-release-message";
+const char kPersistentUsageRecordSession[] = "persistent-usage-record";
 
 static std::string ShortenTo64Characters(const std::string& input) {
   // Convert |input| into a string with escaped characters replacing any
@@ -100,14 +100,14 @@ std::string GenerateJWKSet(const KeyIdAndKeyPairs& keys,
   base::DictionaryValue jwk_set;
   jwk_set.Set(kKeysTag, std::move(list));
   switch (session_type) {
-    case CdmSessionType::TEMPORARY_SESSION:
+    case CdmSessionType::kTemporary:
       jwk_set.SetString(kTypeTag, kTemporarySession);
       break;
-    case CdmSessionType::PERSISTENT_LICENSE_SESSION:
+    case CdmSessionType::kPersistentLicense:
       jwk_set.SetString(kTypeTag, kPersistentLicenseSession);
       break;
-    case CdmSessionType::PERSISTENT_RELEASE_MESSAGE_SESSION:
-      jwk_set.SetString(kTypeTag, kPersistentReleaseMessageSession);
+    case CdmSessionType::kPersistentUsageRecord:
+      jwk_set.SetString(kTypeTag, kPersistentUsageRecordSession);
       break;
   }
 
@@ -212,16 +212,16 @@ bool ExtractKeysFromJWKSet(const std::string& jwk_set,
   std::string session_type_id;
   if (!dictionary->Get(kTypeTag, &value)) {
     // Not specified, so use the default type.
-    *session_type = CdmSessionType::TEMPORARY_SESSION;
+    *session_type = CdmSessionType::kTemporary;
   } else if (!value->GetAsString(&session_type_id)) {
     DVLOG(1) << "Invalid '" << kTypeTag << "' value";
     return false;
   } else if (session_type_id == kTemporarySession) {
-    *session_type = CdmSessionType::TEMPORARY_SESSION;
+    *session_type = CdmSessionType::kTemporary;
   } else if (session_type_id == kPersistentLicenseSession) {
-    *session_type = CdmSessionType::PERSISTENT_LICENSE_SESSION;
-  } else if (session_type_id == kPersistentReleaseMessageSession) {
-    *session_type = CdmSessionType::PERSISTENT_RELEASE_MESSAGE_SESSION;
+    *session_type = CdmSessionType::kPersistentLicense;
+  } else if (session_type_id == kPersistentUsageRecordSession) {
+    *session_type = CdmSessionType::kPersistentUsageRecord;
   } else {
     DVLOG(1) << "Invalid '" << kTypeTag << "' value: " << session_type_id;
     return false;
@@ -317,14 +317,14 @@ void CreateLicenseRequest(const KeyIdList& key_ids,
   request->Set(kKeyIdsTag, std::move(list));
 
   switch (session_type) {
-    case CdmSessionType::TEMPORARY_SESSION:
+    case CdmSessionType::kTemporary:
       request->SetString(kTypeTag, kTemporarySession);
       break;
-    case CdmSessionType::PERSISTENT_LICENSE_SESSION:
+    case CdmSessionType::kPersistentLicense:
       request->SetString(kTypeTag, kPersistentLicenseSession);
       break;
-    case CdmSessionType::PERSISTENT_RELEASE_MESSAGE_SESSION:
-      request->SetString(kTypeTag, kPersistentReleaseMessageSession);
+    case CdmSessionType::kPersistentUsageRecord:
+      request->SetString(kTypeTag, kPersistentUsageRecordSession);
       break;
   }
 
diff --git a/chromium/media/cdm/json_web_key_unittest.cc b/chromium/media/cdm/json_web_key_unittest.cc
index 689d781ade3..f0c4de25a29 100644
--- a/chromium/media/cdm/json_web_key_unittest.cc
+++ b/chromium/media/cdm/json_web_key_unittest.cc
@@ -112,22 +112,22 @@ TEST_F(JSONWebKeyTest, GenerateJWKSet) {
   EXPECT_EQ(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":"
       "\"temporary\"}",
-      GenerateJWKSet(keys, CdmSessionType::TEMPORARY_SESSION));
+      GenerateJWKSet(keys, CdmSessionType::kTemporary));
   keys.push_back(
       MakeKeyIdAndKeyPair(data2, arraysize(data2), data2, arraysize(data2)));
   EXPECT_EQ(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"},{\"k\":"
       "\"AQIDBA\",\"kid\":\"AQIDBA\",\"kty\":\"oct\"}],\"type\":\"persistent-"
       "license\"}",
-      GenerateJWKSet(keys, CdmSessionType::PERSISTENT_LICENSE_SESSION));
+      GenerateJWKSet(keys, CdmSessionType::kPersistentLicense));
   keys.push_back(
       MakeKeyIdAndKeyPair(data3, arraysize(data3), data3, arraysize(data3)));
   EXPECT_EQ(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"},{\"k\":"
       "\"AQIDBA\",\"kid\":\"AQIDBA\",\"kty\":\"oct\"},{\"k\":"
       "\"AQIDBAUGBwgJCgsMDQ4PEA\",\"kid\":\"AQIDBAUGBwgJCgsMDQ4PEA\",\"kty\":"
-      "\"oct\"}],\"type\":\"persistent-release-message\"}",
-      GenerateJWKSet(keys, CdmSessionType::PERSISTENT_RELEASE_MESSAGE_SESSION));
+      "\"oct\"}],\"type\":\"persistent-usage-record\"}",
+      GenerateJWKSet(keys, CdmSessionType::kPersistentUsageRecord));
 }
 
 TEST_F(JSONWebKeyTest, ExtractValidJWKKeys) {
@@ -398,26 +398,26 @@ TEST_F(JSONWebKeyTest, Alg) {
 TEST_F(JSONWebKeyTest, CdmSessionType) {
   ExtractSessionTypeAndExpect(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}]}", true,
-      CdmSessionType::TEMPORARY_SESSION);
+      CdmSessionType::kTemporary);
   ExtractSessionTypeAndExpect(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":"
       "\"temporary\"}",
-      true, CdmSessionType::TEMPORARY_SESSION);
+      true, CdmSessionType::kTemporary);
   ExtractSessionTypeAndExpect(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":"
       "\"persistent-license\"}",
-      true, CdmSessionType::PERSISTENT_LICENSE_SESSION);
+      true, CdmSessionType::kPersistentLicense);
   ExtractSessionTypeAndExpect(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":"
-      "\"persistent-release-message\"}",
-      true, CdmSessionType::PERSISTENT_RELEASE_MESSAGE_SESSION);
+      "\"persistent-usage-record\"}",
+      true, CdmSessionType::kPersistentUsageRecord);
   ExtractSessionTypeAndExpect(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":"
       "\"unknown\"}",
-      false, CdmSessionType::TEMPORARY_SESSION);
+      false, CdmSessionType::kTemporary);
   ExtractSessionTypeAndExpect(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":3}",
-      false, CdmSessionType::TEMPORARY_SESSION);
+      false, CdmSessionType::kTemporary);
 }
 
 TEST_F(JSONWebKeyTest, CreateLicense) {
@@ -426,21 +426,18 @@ TEST_F(JSONWebKeyTest, CreateLicense) {
   const uint8_t data3[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
                            0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
 
-  CreateLicenseAndExpect(data1, arraysize(data1),
-                         CdmSessionType::TEMPORARY_SESSION,
+  CreateLicenseAndExpect(data1, arraysize(data1), CdmSessionType::kTemporary,
                          "{\"kids\":[\"AQI\"],\"type\":\"temporary\"}");
   CreateLicenseAndExpect(
-      data1, arraysize(data1), CdmSessionType::PERSISTENT_LICENSE_SESSION,
+      data1, arraysize(data1), CdmSessionType::kPersistentLicense,
       "{\"kids\":[\"AQI\"],\"type\":\"persistent-license\"}");
   CreateLicenseAndExpect(
-      data1, arraysize(data1),
-      CdmSessionType::PERSISTENT_RELEASE_MESSAGE_SESSION,
-      "{\"kids\":[\"AQI\"],\"type\":\"persistent-release-message\"}");
-  CreateLicenseAndExpect(data2, arraysize(data2),
-                         CdmSessionType::TEMPORARY_SESSION,
+      data1, arraysize(data1), CdmSessionType::kPersistentUsageRecord,
+      "{\"kids\":[\"AQI\"],\"type\":\"persistent-usage-record\"}");
+  CreateLicenseAndExpect(data2, arraysize(data2), CdmSessionType::kTemporary,
                          "{\"kids\":[\"AQIDBA\"],\"type\":\"temporary\"}");
   CreateLicenseAndExpect(data3, arraysize(data3),
-                         CdmSessionType::PERSISTENT_LICENSE_SESSION,
+                         CdmSessionType::kPersistentLicense,
                          "{\"kids\":[\"AQIDBAUGBwgJCgsMDQ4PEA\"],\"type\":"
                          "\"persistent-license\"}");
 }
@@ -506,8 +503,7 @@ TEST_F(JSONWebKeyTest, Base64UrlEncoding) {
   EXPECT_EQ(encoded_text.find('-'), std::string::npos);
   EXPECT_EQ(encoded_text.find('_'), std::string::npos);
 
-  CreateLicenseAndExpect(data1, arraysize(data1),
-                         CdmSessionType::TEMPORARY_SESSION,
+  CreateLicenseAndExpect(data1, arraysize(data1), CdmSessionType::kTemporary,
                          "{\"kids\":[\"-_37_fv9-w\"],\"type\":\"temporary\"}");
 
   ExtractKeyFromLicenseAndExpect(
@@ -526,7 +522,7 @@ TEST_F(JSONWebKeyTest, MultipleKeys) {
   key_ids.push_back(std::vector<uint8_t>(data1, data1 + arraysize(data1)));
   key_ids.push_back(std::vector<uint8_t>(data2, data2 + arraysize(data2)));
   key_ids.push_back(std::vector<uint8_t>(data3, data3 + arraysize(data3)));
-  CreateLicenseRequest(key_ids, CdmSessionType::TEMPORARY_SESSION, &result);
+  CreateLicenseRequest(key_ids, CdmSessionType::kTemporary, &result);
   std::string s(result.begin(), result.end());
   EXPECT_EQ(
       "{\"kids\":[\"AQI\",\"AQIDBA\",\"AQIDBAUGBwgJCgsMDQ4PEA\"],\"type\":"
diff --git a/chromium/media/cdm/library_cdm/clear_key_cdm/BUILD.gn b/chromium/media/cdm/library_cdm/clear_key_cdm/BUILD.gn
index c6fe179fc73..932e2bd5a34 100644
--- a/chromium/media/cdm/library_cdm/clear_key_cdm/BUILD.gn
+++ b/chromium/media/cdm/library_cdm/clear_key_cdm/BUILD.gn
@@ -14,8 +14,8 @@ loadable_module("clear_key_cdm") {
     "cdm_file_adapter.h",
     "cdm_file_io_test.cc",
     "cdm_file_io_test.h",
-    "cdm_proxy_test.cc",
-    "cdm_proxy_test.h",
+    "cdm_proxy_handler.cc",
+    "cdm_proxy_handler.h",
     "cdm_video_decoder.cc",
     "cdm_video_decoder.h",
     "clear_key_cdm.cc",
@@ -32,7 +32,6 @@ loadable_module("clear_key_cdm") {
   deps = [
     ":cdm_proxy_common",
     "//base",
-    "//build/config:exe_and_shlib_deps",
     "//media",  # For media::AudioTimestampHelper
     "//media:shared_memory_support",  # For media::AudioBus.
     "//media/cdm:cdm_api",  # For content_decryption_module.h
diff --git a/chromium/media/cdm/library_cdm/clear_key_cdm/cdm_proxy_test.cc b/chromium/media/cdm/library_cdm/clear_key_cdm/cdm_proxy_handler.cc
index 152539f4bd6..ebcb163a7fa 100644
--- a/chromium/media/cdm/library_cdm/clear_key_cdm/cdm_proxy_test.cc
+++ b/chromium/media/cdm/library_cdm/clear_key_cdm/cdm_proxy_handler.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "media/cdm/library_cdm/clear_key_cdm/cdm_proxy_test.h"
+#include "media/cdm/library_cdm/clear_key_cdm/cdm_proxy_handler.h"
 
 #include <stdint.h>
 #include <algorithm>
@@ -14,43 +14,48 @@
 
 namespace media {
 
-CdmProxyTest::CdmProxyTest(CdmHostProxy* cdm_host_proxy)
+CdmProxyHandler::CdmProxyHandler(CdmHostProxy* cdm_host_proxy)
     : cdm_host_proxy_(cdm_host_proxy) {}
 
-CdmProxyTest::~CdmProxyTest() {}
+CdmProxyHandler::~CdmProxyHandler() {}
 
-void CdmProxyTest::Run(CompletionCB completion_cb) {
+void CdmProxyHandler::Initialize(InitCB init_cb) {
   DVLOG(1) << __func__;
-  completion_cb_ = std::move(completion_cb);
+  init_cb_ = std::move(init_cb);
 
   cdm_proxy_ = cdm_host_proxy_->RequestCdmProxy(this);
   if (!cdm_proxy_) {
-    OnTestComplete(false);
+    FinishInitialization(false);
     return;
   }
 
   cdm_proxy_->Initialize();
 }
 
-void CdmProxyTest::OnTestComplete(bool success) {
+void CdmProxyHandler::SetKey(const std::vector<uint8_t>& response) {
+  cdm_proxy_->SetKey(crypto_session_id_, nullptr, 0, response.data(),
+                     response.size());
+}
+
+void CdmProxyHandler::FinishInitialization(bool success) {
   DVLOG(1) << __func__ << ": success = " << success;
-  std::move(completion_cb_).Run(success);
+  std::move(init_cb_).Run(success);
 }
 
-void CdmProxyTest::OnInitialized(Status status,
-                                 Protocol protocol,
-                                 uint32_t crypto_session_id) {
+void CdmProxyHandler::OnInitialized(Status status,
+                                    Protocol protocol,
+                                    uint32_t crypto_session_id) {
   DVLOG(1) << __func__ << ": status = " << status;
 
   if (status != Status::kOk ||
       crypto_session_id != kClearKeyCdmProxyCryptoSessionId) {
-    OnTestComplete(false);
+    FinishInitialization(false);
     return;
   }
 
   // Only one CdmProxy can be created during the lifetime of the CDM instance.
   if (cdm_host_proxy_->RequestCdmProxy(this)) {
-    OnTestComplete(false);
+    FinishInitialization(false);
     return;
   }
 
@@ -59,15 +64,15 @@ void CdmProxyTest::OnInitialized(Status status,
                       kClearKeyCdmProxyInputData.size(), 0);
 }
 
-void CdmProxyTest::OnProcessed(Status status,
-                               const uint8_t* output_data,
-                               uint32_t output_data_size) {
+void CdmProxyHandler::OnProcessed(Status status,
+                                  const uint8_t* output_data,
+                                  uint32_t output_data_size) {
   DVLOG(1) << __func__ << ": status = " << status;
 
   if (status != Status::kOk ||
       !std::equal(output_data, output_data + output_data_size,
                   kClearKeyCdmProxyOutputData.begin())) {
-    OnTestComplete(false);
+    FinishInitialization(false);
     return;
   }
 
@@ -75,21 +80,21 @@ void CdmProxyTest::OnProcessed(Status status,
                                        kClearKeyCdmProxyInputData.size());
 }
 
-void CdmProxyTest::OnMediaCryptoSessionCreated(Status status,
-                                               uint32_t crypto_session_id,
-                                               uint64_t output_data) {
+void CdmProxyHandler::OnMediaCryptoSessionCreated(Status status,
+                                                  uint32_t crypto_session_id,
+                                                  uint64_t output_data) {
   DVLOG(1) << __func__ << ": status = " << status;
 
   if (status != Status::kOk ||
       crypto_session_id != kClearKeyCdmProxyMediaCryptoSessionId) {
-    OnTestComplete(false);
+    FinishInitialization(false);
     return;
   }
 
-  OnTestComplete(true);
+  FinishInitialization(true);
 }
 
-void CdmProxyTest::NotifyHardwareReset() {
+void CdmProxyHandler::NotifyHardwareReset() {
   DVLOG(1) << __func__;
   NOTREACHED();
 }
diff --git a/chromium/media/cdm/library_cdm/clear_key_cdm/cdm_proxy_test.h b/chromium/media/cdm/library_cdm/clear_key_cdm/cdm_proxy_handler.h
index 27237be66ec..dd5badb9952 100644
--- a/chromium/media/cdm/library_cdm/clear_key_cdm/cdm_proxy_test.h
+++ b/chromium/media/cdm/library_cdm/clear_key_cdm/cdm_proxy_handler.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef MEDIA_CDM_LIBRARY_CDM_CLEAR_KEY_CDM_CDM_PROXY_TEST_H_
-#define MEDIA_CDM_LIBRARY_CDM_CLEAR_KEY_CDM_CDM_PROXY_TEST_H_
+#ifndef MEDIA_CDM_LIBRARY_CDM_CLEAR_KEY_CDM_CDM_PROXY_HANDLER_H_
+#define MEDIA_CDM_LIBRARY_CDM_CLEAR_KEY_CDM_CDM_PROXY_HANDLER_H_
 
 #include "base/callback.h"
 #include "base/macros.h"
@@ -13,18 +13,23 @@ namespace media {
 
 class CdmHostProxy;
 
-class CdmProxyTest : public cdm::CdmProxyClient {
+class CdmProxyHandler : public cdm::CdmProxyClient {
  public:
-  using CompletionCB = base::OnceCallback<void(bool success)>;
+  using InitCB = base::OnceCallback<void(bool success)>;
 
-  explicit CdmProxyTest(CdmHostProxy* cdm_host_proxy);
-  ~CdmProxyTest() override;
+  explicit CdmProxyHandler(CdmHostProxy* cdm_host_proxy);
+  ~CdmProxyHandler() override;
 
-  // Runs the test and returns the test result through |completion_cb|.
-  void Run(CompletionCB completion_cb);
+  // Initializes the CdmProxyHandler and returns the result through |init_cb|.
+  // This will request and initialize the CdmProxy, create media crypto session
+  // and do some trivial procesing for better test coverage.
+  void Initialize(InitCB init_cb);
+
+  // Push a response that contains a license to the CdmProxy.
+  void SetKey(const std::vector<uint8_t>& response);
 
  private:
-  void OnTestComplete(bool success);
+  void FinishInitialization(bool success);
 
   // cdm::CdmProxyClient implementation.
   void OnInitialized(Status status,
@@ -39,12 +44,13 @@ class CdmProxyTest : public cdm::CdmProxyClient {
   void NotifyHardwareReset() final;
 
   CdmHostProxy* const cdm_host_proxy_ = nullptr;
-  CompletionCB completion_cb_;
+  InitCB init_cb_;
   cdm::CdmProxy* cdm_proxy_ = nullptr;
+  uint32_t crypto_session_id_ = 0u;
 
-  DISALLOW_COPY_AND_ASSIGN(CdmProxyTest);
+  DISALLOW_COPY_AND_ASSIGN(CdmProxyHandler);
 };
 
 }  // namespace media
 
-#endif  // MEDIA_CDM_LIBRARY_CDM_CLEAR_KEY_CDM_CDM_PROXY_TEST_H_
+#endif  // MEDIA_CDM_LIBRARY_CDM_CLEAR_KEY_CDM_CDM_PROXY_HANDLER_H_
diff --git a/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm.cc b/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm.cc
index 27c7940acc8..35f55902eff 100644
--- a/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm.cc
+++ b/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm.cc
@@ -27,7 +27,7 @@
 #include "media/cdm/library_cdm/cdm_host_proxy.h"
 #include "media/cdm/library_cdm/cdm_host_proxy_impl.h"
 #include "media/cdm/library_cdm/clear_key_cdm/cdm_file_io_test.h"
-#include "media/cdm/library_cdm/clear_key_cdm/cdm_proxy_test.h"
+#include "media/cdm/library_cdm/clear_key_cdm/cdm_proxy_handler.h"
 #include "media/cdm/library_cdm/clear_key_cdm/cdm_video_decoder.h"
 #include "media/media_buildflags.h"
 
@@ -65,8 +65,8 @@ const char kExternalClearKeyStorageIdTestKeySystem[] =
     "org.chromium.externalclearkey.storageidtest";
 const char kExternalClearKeyDifferentGuidTestKeySystem[] =
     "org.chromium.externalclearkey.differentguid";
-const char kExternalClearKeyCdmProxyTestKeySystem[] =
-    "org.chromium.externalclearkey.cdmproxytest";
+const char kExternalClearKeyCdmProxyKeySystem[] =
+    "org.chromium.externalclearkey.cdmproxy";
 
 const int64_t kSecondsPerMinute = 60;
 const int64_t kMsPerSecond = 1000;
@@ -151,14 +151,14 @@ static cdm::Exception ConvertException(
 static media::CdmSessionType ConvertSessionType(cdm::SessionType session_type) {
   switch (session_type) {
     case cdm::kTemporary:
-      return media::CdmSessionType::TEMPORARY_SESSION;
+      return media::CdmSessionType::kTemporary;
     case cdm::kPersistentLicense:
-      return media::CdmSessionType::PERSISTENT_LICENSE_SESSION;
-    case cdm::kPersistentKeyRelease:
-      return media::CdmSessionType::PERSISTENT_RELEASE_MESSAGE_SESSION;
+      return media::CdmSessionType::kPersistentLicense;
+    case cdm::kPersistentUsageRecord:
+      return media::CdmSessionType::kPersistentUsageRecord;
   }
   NOTREACHED();
-  return media::CdmSessionType::TEMPORARY_SESSION;
+  return media::CdmSessionType::kTemporary;
 }
 
 static media::EmeInitDataType ConvertInitDataType(
@@ -264,7 +264,7 @@ void* CreateCdmInstance(int cdm_interface_version,
       key_system_string != kExternalClearKeyVerifyCdmHostTestKeySystem &&
       key_system_string != kExternalClearKeyStorageIdTestKeySystem &&
       key_system_string != kExternalClearKeyDifferentGuidTestKeySystem &&
-      key_system_string != kExternalClearKeyCdmProxyTestKeySystem) {
+      key_system_string != kExternalClearKeyCdmProxyKeySystem) {
     DVLOG(1) << "Unsupported key system:" << key_system_string;
     return nullptr;
   }
@@ -416,9 +416,9 @@ void ClearKeyCdm::Initialize(bool allow_distinctive_identifier,
   allow_persistent_state_ = allow_persistent_state;
 
   // CdmProxy must be created during initialization time. OnInitialized() will
-  // be called in OnCdmProxyTestComplete().
-  if (key_system_ == kExternalClearKeyCdmProxyTestKeySystem) {
-    StartCdmProxyTest();
+  // be called in OnCdmProxyHandlerInitialized().
+  if (key_system_ == kExternalClearKeyCdmProxyKeySystem) {
+    InitializeCdmProxyHandler();
     return;
   }
 
@@ -483,8 +483,6 @@ void ClearKeyCdm::CreateSessionAndGenerateRequest(
     ReportVerifyCdmHostTestResult();
   } else if (key_system_ == kExternalClearKeyStorageIdTestKeySystem) {
     StartStorageIdTest();
-  } else if (key_system_ == kExternalClearKeyCdmProxyTestKeySystem) {
-    ReportCdmProxyTestResult();
   }
 }
 
@@ -514,6 +512,16 @@ void ClearKeyCdm::UpdateSession(uint32_t promise_id,
                                 uint32_t response_size) {
   DVLOG(1) << __func__;
   std::string web_session_str(session_id, session_id_length);
+  std::vector<uint8_t> response_vector(response, response + response_size);
+
+  // Push the license to CdmProxy.
+  // TODO(xhwang): There's a potential race condition here where key status
+  // update is dispatched in the render process first, which triggers the
+  // resume-decryption-after-no-key logic, and by the time we try to decrypt
+  // again in the ClearKeyCdmProxy (GPU process), SetKey() hasn't been
+  // dispatched yet. To solve this, handle no-key in ClearKeyCdmProxy.
+  if (cdm_proxy_handler_)
+    cdm_proxy_handler_->SetKey(response_vector);
 
   std::unique_ptr<media::SimpleCdmPromise> promise(
       new media::CdmCallbackPromise<>(
@@ -521,9 +529,7 @@ void ClearKeyCdm::UpdateSession(uint32_t promise_id,
                      promise_id, web_session_str),
           base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                      promise_id)));
-  cdm_->UpdateSession(web_session_str,
-                      std::vector<uint8_t>(response, response + response_size),
-                      std::move(promise));
+  cdm_->UpdateSession(web_session_str, response_vector, std::move(promise));
 }
 
 void ClearKeyCdm::OnUpdateSuccess(uint32_t promise_id,
@@ -649,6 +655,10 @@ cdm::Status ClearKeyCdm::Decrypt(const cdm::InputBuffer_2& encrypted_buffer,
   DVLOG(1) << __func__;
   DCHECK(encrypted_buffer.data);
 
+  // When CdmProxy is used, the CDM cannot do any decryption or decoding.
+  if (key_system_ == kExternalClearKeyCdmProxyKeySystem)
+    return cdm::kDecryptError;
+
   scoped_refptr<DecoderBuffer> buffer;
   cdm::Status status = DecryptToMediaDecoderBuffer(encrypted_buffer, &buffer);
 
@@ -683,8 +693,10 @@ cdm::Status ClearKeyCdm::InitializeAudioDecoder(
 
 cdm::Status ClearKeyCdm::InitializeAudioDecoder(
     const cdm::AudioDecoderConfig_2& audio_decoder_config) {
-  if (key_system_ == kExternalClearKeyDecryptOnlyKeySystem)
+  if (key_system_ == kExternalClearKeyDecryptOnlyKeySystem ||
+      key_system_ == kExternalClearKeyCdmProxyKeySystem) {
     return cdm::kInitializationError;
+  }
 
 #if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
   if (!audio_decoder_)
@@ -696,8 +708,7 @@ cdm::Status ClearKeyCdm::InitializeAudioDecoder(
 
   return cdm::kSuccess;
 #else
-  NOTIMPLEMENTED();
-  return cdm::kSessionError;
+  return cdm::kInitializationError;
 #endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 }
 
@@ -715,8 +726,10 @@ cdm::Status ClearKeyCdm::InitializeVideoDecoder(
 
 cdm::Status ClearKeyCdm::InitializeVideoDecoder(
     const cdm::VideoDecoderConfig_2& video_decoder_config) {
-  if (key_system_ == kExternalClearKeyDecryptOnlyKeySystem)
+  if (key_system_ == kExternalClearKeyDecryptOnlyKeySystem ||
+      key_system_ == kExternalClearKeyCdmProxyKeySystem) {
     return cdm::kInitializationError;
+  }
 
   if (video_decoder_ && video_decoder_->is_initialized()) {
     DCHECK(!video_decoder_->is_initialized());
@@ -1071,29 +1084,20 @@ void ClearKeyCdm::StartStorageIdTest() {
   cdm_host_proxy_->RequestStorageId(0);
 }
 
-void ClearKeyCdm::StartCdmProxyTest() {
+void ClearKeyCdm::InitializeCdmProxyHandler() {
   DVLOG(1) << __func__;
-  DCHECK(!cdm_proxy_test_);
+  DCHECK(!cdm_proxy_handler_);
 
-  cdm_proxy_test_.reset(new CdmProxyTest(cdm_host_proxy_.get()));
-  cdm_proxy_test_->Run(base::BindOnce(&ClearKeyCdm::OnCdmProxyTestComplete,
-                                      base::Unretained(this)));
+  cdm_proxy_handler_ = std::make_unique<CdmProxyHandler>(cdm_host_proxy_.get());
+  cdm_proxy_handler_->Initialize(base::BindOnce(
+      &ClearKeyCdm::OnCdmProxyHandlerInitialized, base::Unretained(this)));
 }
 
-void ClearKeyCdm::OnCdmProxyTestComplete(bool success) {
+void ClearKeyCdm::OnCdmProxyHandlerInitialized(bool success) {
   DVLOG(1) << __func__;
-  DCHECK(cdm_proxy_test_);
-
-  cdm_proxy_test_.reset();
-  has_cdm_proxy_test_passed_ = success;
-
-  // Ignore test result here. It will be reported in ReportCdmProxyTestResult().
-  cdm_host_proxy_->OnInitialized(true);
-}
+  DCHECK(cdm_proxy_handler_);
 
-void ClearKeyCdm::ReportCdmProxyTestResult() {
-  // StartCdmProxyTest() should have already been called and finished.
-  OnUnitTestComplete(has_cdm_proxy_test_passed_);
+  cdm_host_proxy_->OnInitialized(success);
 }
 
 }  // namespace media
diff --git a/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm.h b/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm.h
index b9c78fa9665..386f2b95d07 100644
--- a/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm.h
+++ b/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm.h
@@ -23,7 +23,7 @@
 namespace media {
 
 class CdmHostProxy;
-class CdmProxyTest;
+class CdmProxyHandler;
 class CdmVideoDecoder;
 class DecoderBuffer;
 class FFmpegCdmAudioDecoder;
@@ -159,9 +159,8 @@ class ClearKeyCdm : public cdm::ContentDecryptionModule_9,
   void ReportVerifyCdmHostTestResult();
   void StartStorageIdTest();
 
-  void StartCdmProxyTest();
-  void OnCdmProxyTestComplete(bool success);
-  void ReportCdmProxyTestResult();
+  void InitializeCdmProxyHandler();
+  void OnCdmProxyHandlerInitialized(bool success);
 
   int host_interface_version_ = 0;
 
@@ -189,12 +188,11 @@ class ClearKeyCdm : public cdm::ContentDecryptionModule_9,
 
   std::unique_ptr<CdmVideoDecoder> video_decoder_;
   std::unique_ptr<FileIOTestRunner> file_io_test_runner_;
-  std::unique_ptr<CdmProxyTest> cdm_proxy_test_;
+  std::unique_ptr<CdmProxyHandler> cdm_proxy_handler_;
 
   bool is_running_output_protection_test_ = false;
   bool is_running_platform_verification_test_ = false;
   bool is_running_storage_id_test_ = false;
-  bool has_cdm_proxy_test_passed_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(ClearKeyCdm);
 };
diff --git a/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm_proxy.cc b/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm_proxy.cc
index c251354b535..2a4b2c2e337 100644
--- a/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm_proxy.cc
+++ b/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm_proxy.cc
@@ -11,6 +11,26 @@
 
 namespace media {
 
+namespace {
+
+constexpr char kDummySessionId[] = "dummy session id";
+
+class IgnoreResponsePromise : public SimpleCdmPromise {
+ public:
+  IgnoreResponsePromise() = default;
+  ~IgnoreResponsePromise() override = default;
+
+  // SimpleCdmPromise implementation.
+  void resolve() final { MarkPromiseSettled(); }
+  void reject(CdmPromise::Exception exception_code,
+              uint32_t system_code,
+              const std::string& error_message) final {
+    MarkPromiseSettled();
+  }
+};
+
+}  // namespace
+
 ClearKeyCdmProxy::ClearKeyCdmProxy() : weak_factory_(this) {}
 
 ClearKeyCdmProxy::~ClearKeyCdmProxy() {}
@@ -23,9 +43,8 @@ base::WeakPtr<CdmContext> ClearKeyCdmProxy::GetCdmContext() {
 void ClearKeyCdmProxy::Initialize(Client* client, InitializeCB init_cb) {
   DVLOG(1) << __func__;
 
-  std::move(init_cb).Run(
-      Status::kOk, Protocol::kIntelConvergedSecurityAndManageabilityEngine,
-      kClearKeyCdmProxyCryptoSessionId);
+  std::move(init_cb).Run(Status::kOk, Protocol::kIntel,
+                         kClearKeyCdmProxyCryptoSessionId);
 }
 
 void ClearKeyCdmProxy::Process(Function function,
@@ -67,7 +86,15 @@ void ClearKeyCdmProxy::CreateMediaCryptoSession(
 
 void ClearKeyCdmProxy::SetKey(uint32_t crypto_session_id,
                               const std::vector<uint8_t>& key_id,
-                              const std::vector<uint8_t>& key_blob) {}
+                              const std::vector<uint8_t>& key_blob) {
+  DVLOG(1) << __func__;
+
+  if (!aes_decryptor_)
+    CreateDecryptor();
+
+  aes_decryptor_->UpdateSession(kDummySessionId, key_blob,
+                                std::make_unique<IgnoreResponsePromise>());
+}
 
 void ClearKeyCdmProxy::RemoveKey(uint32_t crypto_session_id,
                                  const std::vector<uint8_t>& key_id) {}
@@ -75,13 +102,22 @@ void ClearKeyCdmProxy::RemoveKey(uint32_t crypto_session_id,
 Decryptor* ClearKeyCdmProxy::GetDecryptor() {
   DVLOG(1) << __func__;
 
-  if (!aes_decryptor_) {
-    aes_decryptor_ = base::MakeRefCounted<AesDecryptor>(
-        base::DoNothing(), base::DoNothing(), base::DoNothing(),
-        base::DoNothing());
-  }
+  if (!aes_decryptor_)
+    CreateDecryptor();
 
   return aes_decryptor_.get();
 }
 
+void ClearKeyCdmProxy::CreateDecryptor() {
+  DVLOG(1) << __func__;
+  DCHECK(!aes_decryptor_);
+
+  aes_decryptor_ =
+      base::MakeRefCounted<AesDecryptor>(base::DoNothing(), base::DoNothing(),
+                                         base::DoNothing(), base::DoNothing());
+
+  // Also create a dummy session to be used for SetKey().
+  aes_decryptor_->CreateSession(kDummySessionId, CdmSessionType::kTemporary);
+}
+
 }  // namespace media
diff --git a/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm_proxy.h b/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm_proxy.h
index 20f3d99cb35..ac8dce769c9 100644
--- a/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm_proxy.h
+++ b/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_cdm_proxy.h
@@ -42,6 +42,8 @@ class ClearKeyCdmProxy : public CdmProxy, public CdmContext {
   Decryptor* GetDecryptor() final;
 
  private:
+  void CreateDecryptor();
+
   scoped_refptr<AesDecryptor> aes_decryptor_;
 
   base::WeakPtrFactory<ClearKeyCdmProxy> weak_factory_;
diff --git a/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_persistent_session_cdm.cc b/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_persistent_session_cdm.cc
index aade5d5d23e..f065633e075 100644
--- a/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_persistent_session_cdm.cc
+++ b/chromium/media/cdm/library_cdm/clear_key_cdm/clear_key_persistent_session_cdm.cc
@@ -117,7 +117,7 @@ void ClearKeyPersistentSessionCdm::CreateSessionAndGenerateRequest(
     const std::vector<uint8_t>& init_data,
     std::unique_ptr<NewSessionCdmPromise> promise) {
   std::unique_ptr<NewSessionCdmPromise> new_promise;
-  if (session_type != CdmSessionType::PERSISTENT_LICENSE_SESSION) {
+  if (session_type != CdmSessionType::kPersistentLicense) {
     new_promise = std::move(promise);
   } else {
     // Since it's a persistent session, we need to save the session ID after
@@ -135,7 +135,7 @@ void ClearKeyPersistentSessionCdm::LoadSession(
     CdmSessionType session_type,
     const std::string& session_id,
     std::unique_ptr<NewSessionCdmPromise> promise) {
-  DCHECK_EQ(CdmSessionType::PERSISTENT_LICENSE_SESSION, session_type);
+  DCHECK_EQ(CdmSessionType::kPersistentLicense, session_type);
 
   // Load the saved state for |session_id| and then create the session.
   std::unique_ptr<CdmFileAdapter> file(new CdmFileAdapter(cdm_host_proxy_));
@@ -180,8 +180,7 @@ void ClearKeyPersistentSessionCdm::OnFileReadForLoadSession(
   }
 
   // Add the session to the list of active sessions.
-  if (!cdm_->CreateSession(session_id,
-                           CdmSessionType::PERSISTENT_LICENSE_SESSION)) {
+  if (!cdm_->CreateSession(session_id, CdmSessionType::kPersistentLicense)) {
     // If the session can't be created it's due to an already existing session
     // with the same name.
     promise->reject(CdmPromise::Exception::QUOTA_EXCEEDED_ERROR, 0,