media: Pass KeyType in CdmProxy::SetKey()

Bug: 854943
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel
Change-Id: I6c53ae4eac8526117cf2485f481302020f9bf0d7
Reviewed-on: https://chromium-review.googlesource.com/1225296Reviewed-by: Rintaro Kuroiwa <rkuroiwa@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Commit-Queue: Xiaohan Wang <xhwang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#591452}

DEPS

@@ -363,7 +363,7 @@ deps = {
   },
 
   'src/media/cdm/api':
-    Var('chromium_git') + '/chromium/cdm.git' + '@' + '50431fd832bbf389ee839e3f8cb68e82606f0513',
+    Var('chromium_git') + '/chromium/cdm.git' + '@' + '38948025e7e8ef4cf9a061ea5bc5b1a83d7735bb',
 
   'src/native_client': {
       'url': Var('chromium_git') + '/native_client/src/native_client.git' + '@' + Var('nacl_revision'),

media/base/ipc/media_param_traits_macros.h

@@ -64,6 +64,9 @@ IPC_ENUM_TRAITS_MAX_VALUE(media::CdmPromise::Exception,
 IPC_ENUM_TRAITS_MAX_VALUE(media::CdmProxy::Function,
                           media::CdmProxy::Function::kMaxValue)
 
+IPC_ENUM_TRAITS_MAX_VALUE(media::CdmProxy::KeyType,
+                          media::CdmProxy::KeyType::kMaxValue)
+
 IPC_ENUM_TRAITS_MAX_VALUE(media::CdmProxy::Protocol,
                           media::CdmProxy::Protocol::kMaxValue)
 

media/cdm/cdm_proxy.h

@@ -59,6 +59,12 @@ class MEDIA_EXPORT CdmProxy {
     kMaxValue = kIntelNegotiateCryptoSessionKeyExchange,
   };
 
+  enum class KeyType {
+    kDecryptOnly,
+    kDecryptAndDecode,
+    kMaxValue = kDecryptAndDecode,
+  };
+
   CdmProxy();
   virtual ~CdmProxy();
 
@@ -109,9 +115,11 @@ class MEDIA_EXPORT CdmProxy {
   // Sets a key in the proxy.
   // |crypto_session_id| is the crypto session for decryption.
   // |key_id| is the ID of the key.
+  // |key_type| is the type of the key.
   // |key_blob| is the opaque key blob for decrypting or decoding.
   virtual void SetKey(uint32_t crypto_session_id,
                       const std::vector<uint8_t>& key_id,
+                      KeyType key_type,
                       const std::vector<uint8_t>& key_blob) = 0;
 
   // Removes a key from the proxy.

media/cdm/library_cdm/clear_key_cdm/cdm_proxy_handler.cc

@@ -33,7 +33,8 @@ void CdmProxyHandler::Initialize(InitCB init_cb) {
 }
 
 void CdmProxyHandler::SetKey(const std::vector<uint8_t>& response) {
-  cdm_proxy_->SetKey(crypto_session_id_, nullptr, 0, response.data(),
+  cdm_proxy_->SetKey(crypto_session_id_, nullptr, 0,
+                     cdm::CdmProxy::kDecryptAndDecode, response.data(),
                      response.size());
 }
 

media/cdm/library_cdm/clear_key_cdm/clear_key_cdm_proxy.cc

@@ -86,6 +86,7 @@ void ClearKeyCdmProxy::CreateMediaCryptoSession(
 
 void ClearKeyCdmProxy::SetKey(uint32_t crypto_session_id,
                               const std::vector<uint8_t>& key_id,
+                              KeyType /* key_type */,
                               const std::vector<uint8_t>& key_blob) {
   DVLOG(1) << __func__;
 

media/cdm/library_cdm/clear_key_cdm/clear_key_cdm_proxy.h

@@ -34,6 +34,7 @@ class ClearKeyCdmProxy : public CdmProxy, public CdmContext {
       CreateMediaCryptoSessionCB create_media_crypto_session_cb) final;
   void SetKey(uint32_t crypto_session_id,
               const std::vector<uint8_t>& key_id,
+              KeyType key_type,
               const std::vector<uint8_t>& key_blob) final;
   void RemoveKey(uint32_t crypto_session_id,
                  const std::vector<uint8_t>& key_id) final;

media/gpu/windows/d3d11_cdm_proxy.cc

@@ -62,8 +62,10 @@ class D3D11CdmProxyContext : public CdmProxyContext {
   ~D3D11CdmProxyContext() override = default;
 
   // The pointers are owned by the caller.
+  // TODO(rkuroiwa): Handle |key_type|.
   void SetKey(ID3D11CryptoSession* crypto_session,
               const std::vector<uint8_t>& key_id,
+              CdmProxy::KeyType /* key_type */,
               const std::vector<uint8_t>& key_blob) {
     std::string key_id_str(key_id.begin(), key_id.end());
     KeyInfo key_info(crypto_session, key_blob);
@@ -106,6 +108,7 @@ class D3D11CdmProxyContext : public CdmProxyContext {
         : crypto_session(crypto_session), key_blob(std::move(key_blob)) {}
     KeyInfo(const KeyInfo&) = default;
     ~KeyInfo() = default;
+
     ID3D11CryptoSession* crypto_session;
     std::vector<uint8_t> key_blob;
   };
@@ -190,8 +193,9 @@ class D3D11CdmContext : public CdmContext {
   // The pointers are owned by the caller.
   void SetKey(ID3D11CryptoSession* crypto_session,
               const std::vector<uint8_t>& key_id,
+              CdmProxy::KeyType key_type,
               const std::vector<uint8_t>& key_blob) {
-    cdm_proxy_context_.SetKey(crypto_session, key_id, key_blob);
+    cdm_proxy_context_.SetKey(crypto_session, key_id, key_type, key_blob);
     new_key_callbacks_.Notify();
   }
   void RemoveKey(ID3D11CryptoSession* crypto_session,
@@ -486,6 +490,7 @@ void D3D11CdmProxy::CreateMediaCryptoSession(
 
 void D3D11CdmProxy::SetKey(uint32_t crypto_session_id,
                            const std::vector<uint8_t>& key_id,
+                           KeyType key_type,
                            const std::vector<uint8_t>& key_blob) {
   auto crypto_session_it = crypto_session_map_.find(crypto_session_id);
   if (crypto_session_it == crypto_session_map_.end()) {
@@ -493,7 +498,8 @@ void D3D11CdmProxy::SetKey(uint32_t crypto_session_id,
                   << " did not map to a crypto session instance.";
     return;
   }
-  cdm_context_->SetKey(crypto_session_it->second.Get(), key_id, key_blob);
+  cdm_context_->SetKey(crypto_session_it->second.Get(), key_id, key_type,
+                       key_blob);
 }
 
 void D3D11CdmProxy::RemoveKey(uint32_t crypto_session_id,

media/gpu/windows/d3d11_cdm_proxy.h

@@ -58,6 +58,7 @@ class MEDIA_GPU_EXPORT D3D11CdmProxy : public CdmProxy {
       CreateMediaCryptoSessionCB create_media_crypto_session_cb) override;
   void SetKey(uint32_t crypto_session_id,
               const std::vector<uint8_t>& key_id,
+              KeyType key_type,
               const std::vector<uint8_t>& key_blob) override;
   void RemoveKey(uint32_t crypto_session_id,
                  const std::vector<uint8_t>& key_id) override;

media/gpu/windows/d3d11_cdm_proxy_unittest.cc

@@ -56,6 +56,8 @@ class MockPowerMonitorSource : public base::PowerMonitorSource {
 const CdmProxy::Protocol kTestProtocol = CdmProxy::Protocol::kIntel;
 const CdmProxy::Function kTestFunction =
     CdmProxy::Function::kIntelNegotiateCryptoSessionKeyExchange;
+// TODO(rkuroiwa): Add test cases for KeyType.
+const CdmProxy::KeyType kTestKeyType = CdmProxy::KeyType::kDecryptOnly;
 const uint32_t kTestFunctionId = 123;
 // clang-format off
 DEFINE_GUID(CRYPTO_TYPE_GUID,
@@ -708,7 +710,8 @@ TEST_F(D3D11CdmProxyTest, SetKeyAndGetDecryptContext) {
       0xab, 0x01, 0x20, 0xd3, 0xee, 0x05, 0x99, 0x87,
       0xff, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x7F,
   };
-  proxy_->SetKey(crypto_session_id_from_initialize, kKeyId, kKeyBlob);
+  proxy_->SetKey(crypto_session_id_from_initialize, kKeyId, kTestKeyType,
+                 kKeyBlob);
 
   std::string key_id_str(kKeyId.begin(), kKeyId.end());
   auto decrypt_context = proxy_context->GetD3D11DecryptContext(key_id_str);
@@ -753,7 +756,8 @@ TEST_F(D3D11CdmProxyTest, ClearKeysAfterHardwareContentProtectionTeardown) {
       0xab, 0x01, 0x20, 0xd3, 0xee, 0x05, 0x99, 0x87,
       0xff, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x7F,
   };
-  proxy_->SetKey(crypto_session_id_from_initialize, kKeyId, kKeyBlob);
+  proxy_->SetKey(crypto_session_id_from_initialize, kKeyId, kTestKeyType,
+                 kKeyBlob);
 
   SetEvent(teardown_event_);
   run_loop.Run();
@@ -786,7 +790,8 @@ TEST_F(D3D11CdmProxyTest, RemoveKey) {
       0xab, 0x01, 0x20, 0xd3, 0xee, 0x05, 0x99, 0x87,
       0xff, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x7F,
   };
-  proxy_->SetKey(crypto_session_id_from_initialize, kKeyId, kKeyBlob);
+  proxy_->SetKey(crypto_session_id_from_initialize, kKeyId, kTestKeyType,
+                 kKeyBlob);
   proxy_->RemoveKey(crypto_session_id_from_initialize, kKeyId);
 
   std::string keyblob_str(kKeyId.begin(), kKeyId.end());
@@ -800,7 +805,7 @@ TEST_F(D3D11CdmProxyTest, SetRemoveKeyWrongCryptoSessionId) {
   const uint32_t kAnyCryptoSessionId = 0x9238;
   const std::vector<uint8_t> kEmpty;
   proxy_->RemoveKey(kAnyCryptoSessionId, kEmpty);
-  proxy_->SetKey(kAnyCryptoSessionId, kEmpty, kEmpty);
+  proxy_->SetKey(kAnyCryptoSessionId, kEmpty, kTestKeyType, kEmpty);
 }
 
 TEST_F(D3D11CdmProxyTest, ProxyInvalidationInvalidatesCdmContext) {

media/mojo/interfaces/cdm_proxy.mojom

@@ -10,18 +10,19 @@ module media.mojom;
 // protocol dependent.
 // CdmProxy implementation is hosted in the GPU process.
 interface CdmProxy {
-  // See media/cdm/cdm_proxy.h.
+  // See media/cdm/cdm_proxy.h for the following native enums.
   [Native]
   enum Status;
 
-  // See media/cdm/cdm_proxy.h.
   [Native]
   enum Protocol;
 
-  // See media/cdm/cdm_proxy.h.
   [Native]
   enum Function;
 
+  [Native]
+  enum KeyType;
+
   // Initializes the proxy.
   // If the proxy created a crypto session, then the ID for the crypto session
   // is |crypto_session_id|.
@@ -58,7 +59,8 @@ interface CdmProxy {
   // |crypto_session_id| is the crypto session for decryption.
   // |key_id| is the ID of the key.
   // |key_blob| is the opaque key blob for decrypting or decoding.
-  SetKey(uint32 crypto_session_id, array<uint8> key_id, array<uint8> key_blob);
+  SetKey(uint32 crypto_session_id, array<uint8> key_id, KeyType key_type,
+         array<uint8> key_blob);
 
   // Removes a key from the proxy.
   // |crypto_session_id| is the crypto session for decryption.

media/mojo/interfaces/cdm_proxy.typemap

@@ -15,6 +15,7 @@ deps = [
 
 type_mappings = [
   "media.mojom.CdmProxy.Function=media::CdmProxy::Function",
+  "media.mojom.CdmProxy.KeyType=media::CdmProxy::KeyType",
   "media.mojom.CdmProxy.Protocol=media::CdmProxy::Protocol",
   "media.mojom.CdmProxy.Status=media::CdmProxy::Status",
 ]

media/mojo/services/mojo_cdm_proxy.cc

@@ -62,6 +62,18 @@ CdmProxy::Function ToMediaFunction(cdm::CdmProxy::Function function) {
   return CdmProxy::Function::kIntelNegotiateCryptoSessionKeyExchange;
 }
 
+CdmProxy::KeyType ToMediaKeyType(cdm::CdmProxy::KeyType key_type) {
+  switch (key_type) {
+    case cdm::CdmProxy::KeyType::kDecryptOnly:
+      return CdmProxy::KeyType::kDecryptOnly;
+    case cdm::CdmProxy::KeyType::kDecryptAndDecode:
+      return CdmProxy::KeyType::kDecryptAndDecode;
+  }
+
+  NOTREACHED() << "Unexpected key type: " << static_cast<int32_t>(key_type);
+  return CdmProxy::KeyType::kDecryptOnly;
+}
+
 }  // namespace
 
 MojoCdmProxy::MojoCdmProxy(mojom::CdmProxyPtr cdm_proxy_ptr,
@@ -127,6 +139,7 @@ void MojoCdmProxy::CreateMediaCryptoSession(const uint8_t* input_data,
 void MojoCdmProxy::SetKey(uint32_t crypto_session_id,
                           const uint8_t* key_id,
                           uint32_t key_id_size,
+                          KeyType key_type,
                           const uint8_t* key_blob,
                           uint32_t key_blob_size) {
   DVLOG(3) << __func__;
@@ -134,6 +147,7 @@ void MojoCdmProxy::SetKey(uint32_t crypto_session_id,
 
   cdm_proxy_ptr_->SetKey(
       crypto_session_id, std::vector<uint8_t>(key_id, key_id + key_id_size),
+      ToMediaKeyType(key_type),
       std::vector<uint8_t>(key_blob, key_blob + key_blob_size));
 }
 

media/mojo/services/mojo_cdm_proxy.h

@@ -38,6 +38,7 @@ class MEDIA_MOJO_EXPORT MojoCdmProxy : public cdm::CdmProxy,
   void SetKey(uint32_t crypto_session_id,
               const uint8_t* key_id,
               uint32_t key_id_size,
+              KeyType key_type,
               const uint8_t* key_blob,
               uint32_t key_blob_size) final;
   void RemoveKey(uint32_t crypto_session_id,

media/mojo/services/mojo_cdm_proxy_service.cc

@@ -56,9 +56,10 @@ void MojoCdmProxyService::CreateMediaCryptoSession(
 
 void MojoCdmProxyService::SetKey(uint32_t crypto_session_id,
                                  const std::vector<uint8_t>& key_id,
+                                 media::CdmProxy::KeyType key_type,
                                  const std::vector<uint8_t>& key_blob) {
   DVLOG(3) << __func__;
-  cdm_proxy_->SetKey(crypto_session_id, key_id, key_blob);
+  cdm_proxy_->SetKey(crypto_session_id, key_id, key_type, key_blob);
 }
 
 void MojoCdmProxyService::RemoveKey(uint32_t crypto_session_id,

media/mojo/services/mojo_cdm_proxy_service.h

@@ -43,6 +43,7 @@ class MEDIA_MOJO_EXPORT MojoCdmProxyService : public mojom::CdmProxy,
       CreateMediaCryptoSessionCallback callback) final;
   void SetKey(uint32_t crypto_session_id,
               const std::vector<uint8_t>& key_id,
+              media::CdmProxy::KeyType key_type,
               const std::vector<uint8_t>& key_blob) final;
   void RemoveKey(uint32_t crypto_session_id,
                  const std::vector<uint8_t>& key_id) final;

media/mojo/services/mojo_cdm_proxy_unittest.cc

@@ -66,9 +66,10 @@ class MockCdmProxy : public media::CdmProxy, public media::CdmContext {
                void(const std::vector<uint8_t>& input_data,
                     CreateMediaCryptoSessionCB create_media_crypto_session_cb));
 
-  MOCK_METHOD3(SetKey,
+  MOCK_METHOD4(SetKey,
                void(uint32_t crypto_session_id,
                     const std::vector<uint8_t>& key_id,
+                    KeyType key_type,
                     const std::vector<uint8_t>& key_blob));
   MOCK_METHOD2(RemoveKey,
                void(uint32_t crypto_session_id,
@@ -212,9 +213,11 @@ class MojoCdmProxyTest : public ::testing::Test {
   void SetKey() {
     const std::vector<uint8_t> key_id = {8, 9};
     const std::vector<uint8_t> key_blob = {10, 11, 12};
-    EXPECT_CALL(*mock_cdm_proxy_, SetKey(crypto_session_id_, key_id, key_blob));
+    EXPECT_CALL(*mock_cdm_proxy_,
+                SetKey(crypto_session_id_, key_id, _, key_blob));
     cdm_proxy_->SetKey(crypto_session_id_, key_id.data(), key_id.size(),
-                       key_blob.data(), key_blob.size());
+                       cdm::CdmProxy::KeyType::kDecryptOnly, key_blob.data(),
+                       key_blob.size());
     base::RunLoop().RunUntilIdle();
   }