Prepare MediaDrmBridge to work with MediaCodecPlayer

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/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/browser_cdm.h"
 #include "media/base/browser_cdm_factory.h"
 #include "media/base/cdm_promise.h"
 #include "media/base/limits.h"
 
 #if defined(OS_ANDROID)
 #include "content/public/common/renderer_preferences.h"
+
+#define POST_ON_UI_THREAD(method, ...)                                      \

[qinmin, 2015/09/16 18:09:40]

nit: maybe RUN_ON_UI_THREAD is more appropriate since if the task is already
running on UI thread, no post will happen

+  do {                                                                      \
+    if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {                    \
+      if (manager_)                                                         \
+        manager_->method(__VA_ARGS__);                                      \
+    } else {                                                                \
+      BrowserThread::PostTask(                                              \
+          BrowserThread::UI, FROM_HERE,                                     \
+          base::Bind(&BrowserCdmManager::method, manager_, ##__VA_ARGS__)); \
+    }                                                                       \
+  } while (0)
 #endif
 
 namespace content {
 
 using media::BrowserCdm;
+using media::BrowserCdmPtr;
 using media::MediaKeys;
 
 namespace {
 
 #if defined(OS_ANDROID)
 // Android only supports 128-bit key IDs.
 const size_t kAndroidKeyIdBytes = 128 / 8;
 #endif
 
 // The ID used in this class is a concatenation of |render_frame_id| and
@@ skipping 25 matching lines @@
 
   ~CdmPromiseInternal() final {}
 
   // CdmPromiseTemplate<> implementation.
   void resolve(const T&... result) final;
 
   void reject(MediaKeys::Exception exception,
               uint32_t system_code,
               const std::string& error_message) final {
     MarkPromiseSettled();
+#if defined(OS_ANDROID)
+    POST_ON_UI_THREAD(RejectPromise, render_frame_id_, cdm_id_, promise_id_,
+                      exception, system_code, error_message);
+#else
     if (manager_) {
       manager_->RejectPromise(render_frame_id_, cdm_id_, promise_id_, exception,
                               system_code, error_message);
     }
+#endif
   }
 
  private:
   using media::CdmPromiseTemplate<T...>::MarkPromiseSettled;
 
   base::WeakPtr<BrowserCdmManager> const manager_;
   const int render_frame_id_;
   const int cdm_id_;
   const uint32_t promise_id_;
 };
 
 template <>
 void CdmPromiseInternal<>::resolve() {
   MarkPromiseSettled();
+#if defined(OS_ANDROID)
+  POST_ON_UI_THREAD(ResolvePromise, render_frame_id_, cdm_id_, promise_id_);
+#else
   if (manager_)
     manager_->ResolvePromise(render_frame_id_, cdm_id_, promise_id_);
+#endif
 }
 
 template <>
 void CdmPromiseInternal<std::string>::resolve(const std::string& session_id) {
   MarkPromiseSettled();
+#if defined(OS_ANDROID)
+  POST_ON_UI_THREAD(ResolvePromiseWithSession, render_frame_id_, cdm_id_,
+                    promise_id_, session_id);
+#else
   if (manager_) {
     manager_->ResolvePromiseWithSession(render_frame_id_, cdm_id_, promise_id_,
                                         session_id);
   }
+#endif
 }
 
 typedef CdmPromiseInternal<> SimplePromise;
 typedef CdmPromiseInternal<std::string> NewSessionPromise;
 
 // Render process ID to BrowserCdmManager map.
 typedef std::map<int, BrowserCdmManager*> BrowserCdmManagerMap;
 base::LazyInstance<BrowserCdmManagerMap>::Leaky g_browser_cdm_manager_map =
     LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 416 matching lines @@
                                uint32_t promise_id,
                                const std::string& key_system,
                                const GURL& security_origin,
                                bool use_hw_secure_codecs) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!GetCdm(render_frame_id, cdm_id));
 
   scoped_ptr<SimplePromise> promise(new SimplePromise(
       weak_ptr_factory_.GetWeakPtr(), render_frame_id, cdm_id, promise_id));
 
-  scoped_ptr<BrowserCdm> cdm(media::CreateBrowserCdm(
+  BrowserCdmPtr cdm(media::CreateBrowserCdm(
       key_system, use_hw_secure_codecs,
       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)));
 
   if (!cdm) {
     DVLOG(1) << "failed to create CDM.";
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "Failed to create CDM.");
@@ skipping 125 matching lines @@
   BrowserCdm* 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