media: CdmFactory creates CDM (MediaKeys) asynchronously.

media/blink/encrypted_media_player_support.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/blink/encrypted_media_player_support.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 137 matching lines @@
 
 WebMediaPlayer::MediaKeyException
 EncryptedMediaPlayerSupport::GenerateKeyRequestInternal(
     blink::WebLocalFrame* frame,
     const std::string& key_system,
     const unsigned char* init_data,
     unsigned init_data_length) {
   if (!PrefixedIsSupportedConcreteKeySystem(key_system))
     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
 
-  // We do not support run-time switching between key systems for now.
-  if (current_key_system_.empty()) {
-    if (!proxy_decryptor_) {
-      proxy_decryptor_.reset(new ProxyDecryptor(
-          media_permission_,
-          BIND_TO_RENDER_LOOP(&EncryptedMediaPlayerSupport::OnKeyAdded),
-          BIND_TO_RENDER_LOOP(&EncryptedMediaPlayerSupport::OnKeyError),
-          BIND_TO_RENDER_LOOP(&EncryptedMediaPlayerSupport::OnKeyMessage)));
-    }
+  if (!proxy_decryptor_) {
+    DCHECK(current_key_system_.empty());
+    DCHECK(!set_cdm_context_cb_.is_null());
+    proxy_decryptor_.reset(new ProxyDecryptor(
+        media_permission_,
+        BIND_TO_RENDER_LOOP(&EncryptedMediaPlayerSupport::OnKeyAdded),
+        BIND_TO_RENDER_LOOP(&EncryptedMediaPlayerSupport::OnKeyError),
+        BIND_TO_RENDER_LOOP(&EncryptedMediaPlayerSupport::OnKeyMessage)));
 
     GURL security_origin(frame->document().securityOrigin().toString());
+    proxy_decryptor_->CreateCdm(cdm_factory_, key_system, security_origin,
+                                set_cdm_context_cb_);
+    current_key_system_ = key_system;
+  }
 
-    if (!proxy_decryptor_->InitializeCDM(cdm_factory_, key_system,
-                                         security_origin)) {
-      return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
-    }
-
-    if (proxy_decryptor_ && !set_cdm_context_cb_.is_null()) {
-      base::ResetAndReturn(&set_cdm_context_cb_)
-          .Run(proxy_decryptor_->GetCdmContext(),
-               base::Bind(&IgnoreCdmAttached));
-    }
-
-    current_key_system_ = key_system;
-  } else if (key_system != current_key_system_) {
+  // We do not support run-time switching between key systems for now.

[ddorwin, 2015/04/10 00:59:43]

Be sure this passes layout tests. I think there was some test that triggered a
corner case in wGKR() calls.

[xhwang, 2015/04/10 17:41:17]

This has always been the case and just confirmed that all layout tests are still
passing.

The only behavior change is:

- Previously when CDM initialization failed, we reset |current_key_system_| (but
we don't reset |proxy_decryptor_|), so that if GKR is called again after the
failure, we'll call InitializeCDM() again on the same |proxy_decryptor_| which
might succeed in theory.

- Now since CDM creation is async, if we want to do the same, we have to reset
the |current_key_system_| in a callback. But it becomes more complex if a second
GKR is called immediately after the first one, before the callback returns. And
we have to have this case in both EMPS and WMPA... Since this is only about a
corner case for a to-be-deprecated feature, I chose a simper solution: if CDM
instance creation failed, all following GKR calls will fail.

WDYT?

+  DCHECK(!current_key_system_.empty());
+  if (key_system != current_key_system_)
     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
-  }
 
   EmeInitDataType init_data_type = init_data_type_;
   if (init_data_type == EmeInitDataType::UNKNOWN)
     init_data_type = GuessInitDataType(init_data, init_data_length);
 
-  if (!proxy_decryptor_->GenerateKeyRequest(init_data_type, init_data,
-                                            init_data_length)) {
-    current_key_system_.clear();
-    return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
-  }
+  proxy_decryptor_->GenerateKeyRequest(init_data_type, init_data,

[ddorwin, 2015/04/10 00:59:43]

Can this no longer fail? Is everything in an Initialize() call now (all the way
into the CdmAdapter)?

[xhwang, 2015/04/10 17:41:17]

Since we added RequestPermission, this path is already async. So it cannot fail
synchronously.

+                                       init_data_length);
 
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 WebMediaPlayer::MediaKeyException EncryptedMediaPlayerSupport::AddKey(
     const WebString& key_system,
     const unsigned char* key,
     unsigned key_length,
     const unsigned char* init_data,
     unsigned init_data_length,
@@ skipping 122 matching lines @@
 
   client_->keyMessage(
       WebString::fromUTF8(GetPrefixedKeySystemName(current_key_system_)),
       WebString::fromUTF8(session_id),
       message.empty() ? NULL : &message[0],
       base::saturated_cast<unsigned int>(message.size()),
       destination_url);
 }
 
 }  // namespace media