media: CdmFactory creates CDM (MediaKeys) asynchronously.

media/cdm/proxy_decryptor.cc

 // Copyright 2013 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/cdm/proxy_decryptor.h"
 
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "media/base/cdm_callback_promise.h"
 #include "media/base/cdm_factory.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/key_systems.h"
 #include "media/base/media_permission.h"
 #include "media/cdm/json_web_key.h"
 #include "media/cdm/key_system_names.h"
 
 namespace media {
 
 // Special system code to signal a closed persistent session in a SessionError()
 // call. This is needed because there is no SessionClosed() call in the prefixed
 // EME API.
 const int kSessionClosedSystemCode = 29127;
 
+ProxyDecryptor::PendingGenerateKeyRequestData::PendingGenerateKeyRequestData(
+    EmeInitDataType init_data_type,
+    const std::vector<uint8>& init_data)
+    : init_data_type(init_data_type), init_data(init_data) {
+}
+
+ProxyDecryptor::PendingGenerateKeyRequestData::
+    ~PendingGenerateKeyRequestData() {
+}
+
 ProxyDecryptor::ProxyDecryptor(MediaPermission* media_permission,
                                const KeyAddedCB& key_added_cb,
                                const KeyErrorCB& key_error_cb,
                                const KeyMessageCB& key_message_cb)
-    : media_permission_(media_permission),
+    : is_creating_cdm_(false),
+      media_permission_(media_permission),
       key_added_cb_(key_added_cb),
       key_error_cb_(key_error_cb),
       key_message_cb_(key_message_cb),
       is_clear_key_(false),
       weak_ptr_factory_(this) {
   DCHECK(media_permission);
   DCHECK(!key_added_cb_.is_null());
   DCHECK(!key_error_cb_.is_null());
   DCHECK(!key_message_cb_.is_null());
 }
 
 ProxyDecryptor::~ProxyDecryptor() {
   // Destroy the decryptor explicitly before destroying the plugin.
   media_keys_.reset();
 }
 
-CdmContext* ProxyDecryptor::GetCdmContext() {
-  return media_keys_ ? media_keys_->GetCdmContext() : nullptr;
+void ProxyDecryptor::CreateCdm(CdmFactory* cdm_factory,
+                               const std::string& key_system,
+                               const GURL& security_origin,
+                               const CdmContextReadyCB& cdm_context_ready_cb) {
+  DVLOG(1) << __FUNCTION__ << ": key_system = " << key_system;
+  DCHECK(!is_creating_cdm_);
+  DCHECK(!media_keys_);
+
+  // TODO(sandersd): Trigger permissions check here and use it to determine
+  // distinctive identifier support, instead of always requiring the
+  // permission. http://crbug.com/455271
+  bool allow_distinctive_identifier = true;
+  bool allow_persistent_state = true;
+
+  is_creating_cdm_ = true;
+
+  base::WeakPtr<ProxyDecryptor> weak_this = weak_ptr_factory_.GetWeakPtr();
+  cdm_factory->Create(
+      key_system, allow_distinctive_identifier, allow_persistent_state,
+      security_origin, base::Bind(&ProxyDecryptor::OnSessionMessage, weak_this),
+      base::Bind(&ProxyDecryptor::OnSessionClosed, weak_this),
+      base::Bind(&ProxyDecryptor::OnLegacySessionError, weak_this),
+      base::Bind(&ProxyDecryptor::OnSessionKeysChange, weak_this),
+      base::Bind(&ProxyDecryptor::OnSessionExpirationUpdate, weak_this),
+      base::Bind(&ProxyDecryptor::OnCdmCreated, weak_this, key_system,
+                 security_origin, cdm_context_ready_cb));
 }
 
-bool ProxyDecryptor::InitializeCDM(CdmFactory* cdm_factory,
-                                   const std::string& key_system,
-                                   const GURL& security_origin) {
-  DVLOG(1) << "InitializeCDM: key_system = " << key_system;
+void ProxyDecryptor::OnCdmCreated(const std::string& key_system,
+                                  const GURL& security_origin,
+                                  const CdmContextReadyCB& cdm_context_ready_cb,
+                                  scoped_ptr<MediaKeys> cdm) {
+  is_creating_cdm_ = false;
 
-  DCHECK(!media_keys_);
-  media_keys_ = CreateMediaKeys(cdm_factory, key_system, security_origin);
-  if (!media_keys_)
-    return false;
+  if (!cdm) {
+    cdm_context_ready_cb.Run(nullptr);
+    return;
+  }
 
   key_system_ = key_system;
   security_origin_ = security_origin;
+  is_clear_key_ = IsClearKey(key_system) || IsExternalClearKey(key_system);
+  media_keys_ = cdm.Pass();
 
-  is_clear_key_ =
-      IsClearKey(key_system) || IsExternalClearKey(key_system);
-  return true;
+  cdm_context_ready_cb.Run(media_keys_->GetCdmContext());
+
+  for (const auto& request : pending_requests_)
+    GenerateKeyRequestInternal(request->init_data_type, request->init_data);
+
+  pending_requests_.clear();
+}
+
+void ProxyDecryptor::GenerateKeyRequest(EmeInitDataType init_data_type,
+                                        const uint8* init_data,
+                                        int init_data_length) {
+  std::vector<uint8> init_data_vector(init_data, init_data + init_data_length);
+
+  if (is_creating_cdm_) {
+    pending_requests_.push_back(
+        new PendingGenerateKeyRequestData(init_data_type, init_data_vector));
+    return;
+  }
+
+  GenerateKeyRequestInternal(init_data_type, init_data_vector);
 }
 
 // Returns true if |data| is prefixed with |header| and has data after the
 // |header|.
-bool HasHeader(const uint8* data, int data_length, const std::string& header) {
-  return static_cast<size_t>(data_length) > header.size() &&
-         std::equal(data, data + header.size(), header.begin());
+bool HasHeader(const std::vector<uint8>& data, const std::string& header) {
+  return data.size() > header.size() &&
+         std::equal(header.begin(), header.end(), data.begin());
 }
 
 // Removes the first |length| items from |data|.
 void StripHeader(std::vector<uint8>& data, size_t length) {
   data.erase(data.begin(), data.begin() + length);
 }
 
-bool ProxyDecryptor::GenerateKeyRequest(EmeInitDataType init_data_type,
-                                        const uint8* init_data,
-                                        int init_data_length) {
-  DVLOG(1) << "GenerateKeyRequest()";
+void ProxyDecryptor::GenerateKeyRequestInternal(
+    EmeInitDataType init_data_type,
+    const std::vector<uint8>& init_data) {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(!is_creating_cdm_);
+
+  if (!media_keys_) {
+    OnLegacySessionError(std::string(), MediaKeys::NOT_SUPPORTED_ERROR, 0,
+                         "CDM creation failed.");
+    return;
+  }
+
   const char kPrefixedApiPersistentSessionHeader[] = "PERSISTENT|";
   const char kPrefixedApiLoadSessionHeader[] = "LOAD_SESSION|";
 
   SessionCreationType session_creation_type = TemporarySession;
-  std::vector<uint8> init_data_vector(init_data, init_data + init_data_length);
-  if (HasHeader(init_data, init_data_length, kPrefixedApiLoadSessionHeader)) {
+  std::vector<uint8> stripped_init_data = init_data;
+  if (HasHeader(init_data, kPrefixedApiLoadSessionHeader)) {
     session_creation_type = LoadSession;
-    StripHeader(init_data_vector, strlen(kPrefixedApiLoadSessionHeader));
-  } else if (HasHeader(init_data,
-                       init_data_length,
-                       kPrefixedApiPersistentSessionHeader)) {
+    StripHeader(stripped_init_data, strlen(kPrefixedApiLoadSessionHeader));
+  } else if (HasHeader(init_data, kPrefixedApiPersistentSessionHeader)) {
     session_creation_type = PersistentSession;
-    StripHeader(init_data_vector, strlen(kPrefixedApiPersistentSessionHeader));
+    StripHeader(stripped_init_data,
+                strlen(kPrefixedApiPersistentSessionHeader));
   }
 
   scoped_ptr<NewSessionCdmPromise> promise(new CdmCallbackPromise<std::string>(
       base::Bind(&ProxyDecryptor::SetSessionId, weak_ptr_factory_.GetWeakPtr(),
                  session_creation_type),
       base::Bind(&ProxyDecryptor::OnLegacySessionError,
                  weak_ptr_factory_.GetWeakPtr(),
                  std::string())));  // No session id until created.
 
   if (session_creation_type == LoadSession) {
     media_keys_->LoadSession(
         MediaKeys::PERSISTENT_LICENSE_SESSION,
         std::string(
-            reinterpret_cast<const char*>(vector_as_array(&init_data_vector)),
-            init_data_vector.size()),
+            reinterpret_cast<const char*>(vector_as_array(&stripped_init_data)),
+            stripped_init_data.size()),
         promise.Pass());
-    return true;
+    return;
   }
 
   MediaKeys::SessionType session_type =
       session_creation_type == PersistentSession
           ? MediaKeys::PERSISTENT_LICENSE_SESSION
           : MediaKeys::TEMPORARY_SESSION;
 
   // No permission required when AesDecryptor is used or when the key system is
   // external clear key.
   DCHECK(!key_system_.empty());
   if (CanUseAesDecryptor(key_system_) || IsExternalClearKey(key_system_)) {
-    OnPermissionStatus(session_type, init_data_type, init_data_vector,
+    OnPermissionStatus(session_type, init_data_type, stripped_init_data,
                        promise.Pass(), true /* granted */);
-    return true;
+    return;
   }
 
 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
   media_permission_->RequestPermission(
       MediaPermission::PROTECTED_MEDIA_IDENTIFIER, security_origin_,
       base::Bind(&ProxyDecryptor::OnPermissionStatus,
                  weak_ptr_factory_.GetWeakPtr(), session_type, init_data_type,
-                 init_data_vector, base::Passed(&promise)));
+                 stripped_init_data, base::Passed(&promise)));
 #else
-  OnPermissionStatus(session_type, init_data_type, init_data_vector,
+  OnPermissionStatus(session_type, init_data_type, stripped_init_data,
                      promise.Pass(), true /* granted */);
 #endif
-
-  return true;
 }
 
 void ProxyDecryptor::OnPermissionStatus(
     MediaKeys::SessionType session_type,
     EmeInitDataType init_data_type,
     const std::vector<uint8>& init_data,
     scoped_ptr<NewSessionCdmPromise> promise,
     bool granted) {
   // ProxyDecryptor is only used by Prefixed EME, where RequestPermission() is
   // only for triggering the permission UI. Later CheckPermission() will be
   // called (e.g. in PlatformVerificationFlow on ChromeOS; in BrowserCdmManager
   // on Android) and the permission status will be evaluated then.
   DVLOG_IF(1, !granted) << "Permission request rejected.";
 
   media_keys_->CreateSessionAndGenerateRequest(
       session_type, init_data_type, vector_as_array(&init_data),
       init_data.size(), promise.Pass());
 }
 
 void ProxyDecryptor::AddKey(const uint8* key,
                             int key_length,
                             const uint8* init_data,
                             int init_data_length,
                             const std::string& session_id) {
   DVLOG(1) << "AddKey()";
 
+  if (!media_keys_) {
+    OnLegacySessionError(std::string(), MediaKeys::INVALID_STATE_ERROR, 0,
+                         "CDM is not available.");
+    return;
+  }
+
   // In the prefixed API, the session parameter provided to addKey() is
   // optional, so use the single existing session if it exists.
   std::string new_session_id(session_id);
   if (new_session_id.empty()) {
     if (active_sessions_.size() == 1) {
       base::hash_map<std::string, bool>::iterator it = active_sessions_.begin();
       new_session_id = it->first;
     } else {
       OnLegacySessionError(std::string(), MediaKeys::NOT_SUPPORTED_ERROR, 0,
                            "SessionId not specified.");
@@ skipping 28 matching lines @@
                                jwk.size(), promise.Pass());
     return;
   }
 
   media_keys_->UpdateSession(new_session_id, key, key_length, promise.Pass());
 }
 
 void ProxyDecryptor::CancelKeyRequest(const std::string& session_id) {
   DVLOG(1) << "CancelKeyRequest()";
 
+  if (!media_keys_) {
+    OnLegacySessionError(std::string(), MediaKeys::INVALID_STATE_ERROR, 0,
+                         "CDM is not available.");
+    return;
+  }
+
   scoped_ptr<SimpleCdmPromise> promise(new CdmCallbackPromise<>(
       base::Bind(&ProxyDecryptor::OnSessionClosed,
                  weak_ptr_factory_.GetWeakPtr(), session_id),
       base::Bind(&ProxyDecryptor::OnLegacySessionError,
                  weak_ptr_factory_.GetWeakPtr(), session_id)));
   media_keys_->RemoveSession(session_id, promise.Pass());
 }
 
-scoped_ptr<MediaKeys> ProxyDecryptor::CreateMediaKeys(
-    CdmFactory* cdm_factory,
-    const std::string& key_system,
-    const GURL& security_origin) {
-  // TODO(sandersd): Trigger permissions check here and use it to determine
-  // distinctive identifier support, instead of always requiring the
-  // permission. http://crbug.com/455271
-  bool allow_distinctive_identifier = true;
-  bool allow_persistent_state = true;
-  base::WeakPtr<ProxyDecryptor> weak_this = weak_ptr_factory_.GetWeakPtr();
-  return cdm_factory->Create(
-      key_system, allow_distinctive_identifier, allow_persistent_state,
-      security_origin, base::Bind(&ProxyDecryptor::OnSessionMessage, weak_this),
-      base::Bind(&ProxyDecryptor::OnSessionClosed, weak_this),
-      base::Bind(&ProxyDecryptor::OnLegacySessionError, weak_this),
-      base::Bind(&ProxyDecryptor::OnSessionKeysChange, weak_this),
-      base::Bind(&ProxyDecryptor::OnSessionExpirationUpdate, weak_this));
-}
-
 void ProxyDecryptor::OnSessionMessage(const std::string& session_id,
                                       MediaKeys::MessageType message_type,
                                       const std::vector<uint8>& message,
                                       const GURL& legacy_destination_url) {
   // Assumes that OnSessionCreated() has been called before this.
 
   // For ClearKey, convert the message from JSON into just passing the key
   // as the message. If unable to extract the key, return the message unchanged.
   if (is_clear_key_) {
     std::vector<uint8> key;
@@ skipping 77 matching lines @@
   bool is_persistent =
       session_type == PersistentSession || session_type == LoadSession;
   active_sessions_.insert(std::make_pair(session_id, is_persistent));
 
   // For LoadSession(), generate the KeyAdded event.
   if (session_type == LoadSession)
     GenerateKeyAdded(session_id);
 }
 
 }  // namespace media