Move MediaDrmBridge provision communication to native side.

content/browser/media/cdm/browser_cdm_manager.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 "content/browser/media/cdm/browser_cdm_manager.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/task_runner.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/permission_manager.h"
 #include "content/public/browser/permission_type.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "content/public/browser/web_contents.h"
 #include "media/base/cdm_config.h"
 #include "media/base/cdm_factory.h"
 #include "media/base/cdm_promise.h"
 #include "media/base/limits.h"
 
 #if defined(OS_ANDROID)
+#include "content/browser/media/android/url_provision_fetcher.h"
 #include "content/public/common/renderer_preferences.h"
 #include "media/base/android/android_cdm_factory.h"
 #endif
 
 namespace content {
 
 using media::MediaKeys;
 
 namespace {
 
@@ skipping 229 matching lines @@
                                       MediaKeys::Exception exception,
                                       uint32_t system_code,
                                       const std::string& error_message) {
   Send(new CdmMsg_RejectPromise(render_frame_id, cdm_id, promise_id, exception,
                                 system_code, error_message));
 }
 
 media::CdmFactory* BrowserCdmManager::GetCdmFactory() {
   if (!cdm_factory_) {
     // Create a new CdmFactory.
+#if defined(OS_ANDROID)
+    cdm_factory_.reset(new media::AndroidCdmFactory());
+#else

[xhwang, 2015/11/11 09:53:21]

Why making this change? Different embedders could implement CreateCdmFactory in
the browser_content_client to inject it's own CdmFactory...

[Tima Vaisburd, 2015/11/11 23:26:35]

Restored your original code and passed ProvisionFetcherFactory object (see
below) into AndroidCdmFactory constructor. 

     cdm_factory_ = GetContentClient()->browser()->CreateCdmFactory();
-
-#if defined(OS_ANDROID)
-    if (!cdm_factory_)
-      cdm_factory_.reset(new media::AndroidCdmFactory());
 #endif
   }
 
   return cdm_factory_.get();
 }
 
 void BrowserCdmManager::OnSessionMessage(int render_frame_id,
                                          int cdm_id,
                                          const std::string& session_id,
                                          MediaKeys::MessageType message_type,
@@ skipping 72 matching lines @@
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0, "Invalid key system.");
     return;
   }
 
   if (!GetCdmFactory()) {
     NOTREACHED() << "CDM not supported.";
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0, "CDM not supported.");
     return;
   }
 
+  media::CdmFactory* cdm_factory = GetCdmFactory();
+  DCHECK(cdm_factory);
+
+#if defined(OS_ANDROID)
+  // Create ProvisionFetcher based on render process context.
+  net::URLRequestContextGetter* context =
+      RenderProcessHost::FromID(render_process_id_)
+          ->GetBrowserContext()
+          ->GetRequestContext();
+  DCHECK(context);
+  scoped_ptr<media::ProvisionFetcher> provision_fetcher(
+      new URLProvisionFetcher(context));
+
+  // Attach |provision_fetcher| to Android CDM factory.
+  media::AndroidCdmFactory* android_cdm_factory =
+      static_cast<media::AndroidCdmFactory*>(cdm_factory);
+  android_cdm_factory->SetProvisionFetcher(provision_fetcher.Pass());
+#endif  // OS_ANDROID
+
   // The render process makes sure |allow_distinctive_identifier| and
   // |allow_persistent_state| are true. See RenderCdmFactory::Create().
   // TODO(xhwang): Pass |allow_distinctive_identifier| and
   // |allow_persistent_state| from the render process.
   media::CdmConfig cdm_config;
   cdm_config.allow_distinctive_identifier = true;
   cdm_config.allow_persistent_state = true;
   cdm_config.use_hw_secure_codecs = params.use_hw_secure_codecs;
 
-  GetCdmFactory()->Create(
+  cdm_factory->Create(
       params.key_system, params.security_origin, cdm_config,
       BROWSER_CDM_MANAGER_CB(OnSessionMessage),
       BROWSER_CDM_MANAGER_CB(OnSessionClosed),
       BROWSER_CDM_MANAGER_CB(OnLegacySessionError),
       BROWSER_CDM_MANAGER_CB(OnSessionKeysChange),
       BROWSER_CDM_MANAGER_CB(OnSessionExpirationUpdate),
       BROWSER_CDM_MANAGER_CB(OnCdmCreated, params.security_origin,
                              base::Passed(&promise)));
 }
 
@@ skipping 314 matching lines @@
   scoped_refptr<MediaKeys> cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
   cdm->LoadSession(session_type, session_id, promise.Pass());
 }
 
 }  // namespace content