Prepare MediaDrmBridge to work with MediaCodecPlayer

media/base/android/media_drm_bridge.cc

 // Copyright (c) 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/base/android/media_drm_bridge.h"
 
 #include <algorithm>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
+#include "base/bind.h"
 #include "base/callback_helpers.h"
+#include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/sys_byteorder.h"
 #include "base/sys_info.h"
 #include "base/thread_task_runner_handle.h"
 #include "jni/MediaDrmBridge_jni.h"
 #include "media/base/android/media_client_android.h"
+#include "media/base/android/media_codec_player.h"  // for GetMediaTaskRunner()
 #include "media/base/android/media_drm_bridge_delegate.h"
 #include "media/base/cdm_key_information.h"
+#include "media/base/media_switches.h"
 
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
+#define RUN_CB_ON_MEDIA_THREAD(cb, ...)                              \
+  do {                                                               \
+    if (use_media_thread_ &&                                         \
+        !GetMediaTaskRunner()->BelongsToCurrentThread()) {           \
+      GetMediaTaskRunner()->PostTask(FROM_HERE,                      \
+                                     base::Bind(cb, ##__VA_ARGS__)); \
+    } else {                                                         \
+      cb.Run(__VA_ARGS__);                                           \
+    }                                                                \
+  } while (0)
+
 using base::android::AttachCurrentThread;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::JavaByteArrayToByteVector;
 using base::android::ScopedJavaLocalRef;
+using base::android::ScopedJavaGlobalRef;

[xhwang, 2015/09/29 17:28:23]

nit: order

[Tima Vaisburd, 2015/09/29 19:55:44]

Done.

 
 namespace media {
 
 namespace {
 
 // These must be in sync with Android MediaDrm REQUEST_TYPE_XXX constants!
 // https://developer.android.com/reference/android/media/MediaDrm.KeyRequest.html
 enum class RequestType {
   REQUEST_TYPE_INITIAL = 0,
   REQUEST_TYPE_RENEWAL = 1,
@@ skipping 201 matching lines @@
 }
 
 // static
 bool MediaDrmBridge::IsKeySystemSupportedWithType(
     const std::string& key_system,
     const std::string& container_mime_type) {
   DCHECK(!key_system.empty() && !container_mime_type.empty());
   return IsKeySystemSupportedWithTypeImpl(key_system, container_mime_type);
 }
 
+// static
 bool MediaDrmBridge::RegisterMediaDrmBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 MediaDrmBridge::MediaDrmBridge(
     const std::vector<uint8>& scheme_uuid,
     const SessionMessageCB& session_message_cb,
     const SessionClosedCB& session_closed_cb,
     const LegacySessionErrorCB& legacy_session_error_cb,
     const SessionKeysChangeCB& session_keys_change_cb,
     const SessionExpirationUpdateCB& session_expiration_update_cb)
     : scheme_uuid_(scheme_uuid),
       session_message_cb_(session_message_cb),
       session_closed_cb_(session_closed_cb),
       legacy_session_error_cb_(legacy_session_error_cb),
       session_keys_change_cb_(session_keys_change_cb),
-      session_expiration_update_cb_(session_expiration_update_cb) {
+      session_expiration_update_cb_(session_expiration_update_cb),
+      ui_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      use_media_thread_(false),
+      weak_factory_(this) {
+  DVLOG(1) << "MediaDrmBridge::MediaDrmBridge";
+
+  use_media_thread_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableMediaThreadForMediaPlayback);
+
+  base::WeakPtr<MediaDrmBridge> weak_this = weak_factory_.GetWeakPtr();
+
+  internal_keys_added_cb_ =
+      base::Bind(&MediaDrmBridge::InternalKeysAdded, weak_this);
+
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
 
   ScopedJavaLocalRef<jbyteArray> j_scheme_uuid =
       base::android::ToJavaByteArray(env, &scheme_uuid[0], scheme_uuid.size());
   j_media_drm_.Reset(Java_MediaDrmBridge_create(
       env, j_scheme_uuid.obj(), reinterpret_cast<intptr_t>(this)));
 }
 
-MediaDrmBridge::~MediaDrmBridge() {
+void MediaDrmBridge::DeleteOnCorrectThread() {
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__;
+
   JNIEnv* env = AttachCurrentThread();
-  player_tracker_.NotifyCdmUnset();
   if (!j_media_drm_.is_null())
     Java_MediaDrmBridge_destroy(env, j_media_drm_.obj());
+
+  // Post deletion onto Media thread if we use it.
+  if (use_media_thread_)
+    GetMediaTaskRunner()->DeleteSoon(FROM_HERE, this);
+  else
+    delete this;
+}
+
+MediaDrmBridge::~MediaDrmBridge() {
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__;

[xhwang, 2015/09/29 17:28:23]

nit: in media code (and the rest of this file) we don't usually include the
class name in the log. You'll see the file name in the logs anyway.

[Tima Vaisburd, 2015/09/29 19:55:43]

Class name removed.

+
+  DCHECK(!use_media_thread_ || GetMediaTaskRunner()->BelongsToCurrentThread());
+
+  player_tracker_.NotifyCdmUnset();
 }
 
 // static
-scoped_ptr<MediaDrmBridge> MediaDrmBridge::Create(
+scoped_ptr<MediaDrmBridge, BrowserCdmDeleter> MediaDrmBridge::Create(
     const std::string& key_system,
     const SessionMessageCB& session_message_cb,
     const SessionClosedCB& session_closed_cb,
     const LegacySessionErrorCB& legacy_session_error_cb,
     const SessionKeysChangeCB& session_keys_change_cb,
     const SessionExpirationUpdateCB& session_expiration_update_cb) {
-  scoped_ptr<MediaDrmBridge> media_drm_bridge;
+  scoped_ptr<MediaDrmBridge, BrowserCdmDeleter> media_drm_bridge;
   if (!IsAvailable())
     return media_drm_bridge.Pass();
 
   UUID scheme_uuid = g_key_system_manager.Get().GetUUID(key_system);
   if (scheme_uuid.empty())
     return media_drm_bridge.Pass();
 
   media_drm_bridge.reset(
       new MediaDrmBridge(scheme_uuid, session_message_cb, session_closed_cb,
                          legacy_session_error_cb, session_keys_change_cb,
                          session_expiration_update_cb));
 
   if (media_drm_bridge->j_media_drm_.is_null())
     media_drm_bridge.reset();
 
   return media_drm_bridge.Pass();
 }
 
 // static
-scoped_ptr<MediaDrmBridge> MediaDrmBridge::CreateWithoutSessionSupport(
-    const std::string& key_system) {
+scoped_ptr<MediaDrmBridge, BrowserCdmDeleter>
+MediaDrmBridge::CreateWithoutSessionSupport(const std::string& key_system) {
   return MediaDrmBridge::Create(
       key_system, SessionMessageCB(), SessionClosedCB(), LegacySessionErrorCB(),
       SessionKeysChangeCB(), SessionExpirationUpdateCB());
 }
 
 bool MediaDrmBridge::SetSecurityLevel(SecurityLevel security_level) {
   if (security_level != SECURITY_LEVEL_NONE &&
       !std::equal(scheme_uuid_.begin(), scheme_uuid_.end(), kWidevineUuid)) {
     NOTREACHED() << "Widevine security level " << security_level
                  << "used with another key system";
@@ skipping 127 matching lines @@
   promise->reject(NOT_SUPPORTED_ERROR, 0, "RemoveSession() is not supported.");
 }
 
 CdmContext* MediaDrmBridge::GetCdmContext() {
   NOTREACHED();
   return nullptr;
 }
 
 int MediaDrmBridge::RegisterPlayer(const base::Closure& new_key_cb,
                                    const base::Closure& cdm_unset_cb) {
+  DCHECK(!use_media_thread_ || GetMediaTaskRunner()->BelongsToCurrentThread());
   return player_tracker_.RegisterPlayer(new_key_cb, cdm_unset_cb);
 }
 
 void MediaDrmBridge::UnregisterPlayer(int registration_id) {
+  DCHECK(!use_media_thread_ || GetMediaTaskRunner()->BelongsToCurrentThread());
   player_tracker_.UnregisterPlayer(registration_id);
 }
 
-void MediaDrmBridge::SetMediaCryptoReadyCB(const base::Closure& closure) {
-  if (closure.is_null()) {
-    media_crypto_ready_cb_.Reset();
+void MediaDrmBridge::SetMediaCryptoReadyCB(const MediaCryptoReadyCB& closure) {
+  DCHECK(!use_media_thread_ || GetMediaTaskRunner()->BelongsToCurrentThread());
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__;
+
+  {
+    base::AutoLock lock(media_crypto_ready_lock_);
+
+    if (closure.is_null()) {
+      media_crypto_ready_cb_.Reset();
+      return;
+    }
+
+    DCHECK(media_crypto_ready_cb_.is_null());
+
+    media_crypto_ready_cb_ = closure;
+  }
+
+  ui_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&MediaDrmBridge::CheckMediaCryptoAndInvokeCB,
+                            base::Unretained(this)));
+}
+
+void MediaDrmBridge::CheckMediaCryptoAndInvokeCB() {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__;
+
+  ScopedJavaLocalRef<jobject> media_crypto = GetMediaCrypto();
+  if (media_crypto.is_null()) {
+    DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__ << ": no MediaCrypto";
     return;
   }
 
-  DCHECK(media_crypto_ready_cb_.is_null());
+  MediaCryptoReadyCB media_crypto_ready_cb;
+  {
+    base::AutoLock lock(media_crypto_ready_lock_);
 
-  if (!GetMediaCrypto().is_null()) {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, closure);
-    return;
+    if (media_crypto_ready_cb_.is_null()) {
+      DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__ << ": no callback";
+      return;
+    }
+
+    media_crypto_ready_cb = base::ResetAndReturn(&media_crypto_ready_cb_);
   }
 
-  media_crypto_ready_cb_ = closure;
+  scoped_ptr<ScopedJavaGlobalRef<jobject>> j_object_ptr(
+      new ScopedJavaGlobalRef<jobject>());
+  j_object_ptr->Reset(AttachCurrentThread(), media_crypto.obj());
+
+  if (use_media_thread_) {
+    GetMediaTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(media_crypto_ready_cb, base::Passed(&j_object_ptr)));
+  } else {
+    media_crypto_ready_cb.Run(j_object_ptr.Pass());
+  }
 }
 
-void MediaDrmBridge::OnMediaCryptoReady(JNIEnv* env, jobject) {
+void MediaDrmBridge::OnMediaCryptoReady(JNIEnv* env, jobject j_media_drm) {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__;
+
   DCHECK(!GetMediaCrypto().is_null());
-  if (!media_crypto_ready_cb_.is_null())
-    base::ResetAndReturn(&media_crypto_ready_cb_).Run();
+
+  CheckMediaCryptoAndInvokeCB();
 }
 
 void MediaDrmBridge::OnPromiseResolved(JNIEnv* env,
                                        jobject j_media_drm,
                                        jint j_promise_id) {
   cdm_promise_adapter_.ResolvePromise(j_promise_id);
 }
 
 void MediaDrmBridge::OnPromiseResolvedWithSession(JNIEnv* env,
                                                   jobject j_media_drm,
@@ skipping 33 matching lines @@
                                      jobject j_media_drm,
                                      jbyteArray j_session_id) {
   session_closed_cb_.Run(GetSessionId(env, j_session_id));
 }
 
 void MediaDrmBridge::OnSessionKeysChange(JNIEnv* env,
                                          jobject j_media_drm,
                                          jbyteArray j_session_id,
                                          jobjectArray j_keys_info,
                                          bool has_additional_usable_key) {
-  if (has_additional_usable_key)
-    player_tracker_.NotifyNewKey();
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__;
 
   CdmKeysInfo cdm_keys_info;
 
   size_t size = env->GetArrayLength(j_keys_info);
   DCHECK_GT(size, 0u);
 
   for (size_t i = 0; i < size; ++i) {
     ScopedJavaLocalRef<jobject> j_key_status(
         env, env->GetObjectArrayElement(j_keys_info, i));
 
@@ skipping 13 matching lines @@
              << key_status;
 
     // TODO(xhwang): Update CdmKeyInformation to take key_id and status in the
     // constructor.
     scoped_ptr<CdmKeyInformation> cdm_key_information(new CdmKeyInformation());
     cdm_key_information->key_id = key_id;
     cdm_key_information->status = key_status;
     cdm_keys_info.push_back(cdm_key_information.release());
   }
 
-  session_keys_change_cb_.Run(GetSessionId(env, j_session_id),
-                              has_additional_usable_key, cdm_keys_info.Pass());
+  RUN_CB_ON_MEDIA_THREAD(internal_keys_added_cb_, has_additional_usable_key);
+
+  std::string session_id = GetSessionId(env, j_session_id);
+
+  session_keys_change_cb_.Run(session_id, has_additional_usable_key,
+                              cdm_keys_info.Pass());
+}
+
+void MediaDrmBridge::InternalKeysAdded(bool has_additional_usable_key) {
+  DCHECK(!use_media_thread_ || GetMediaTaskRunner()->BelongsToCurrentThread());
+  if (has_additional_usable_key)
+    player_tracker_.NotifyNewKey();
 }
 
 // According to MeidaDrm documentation [1], zero |expiry_time_ms| means the keys
 // will never expire. This will be translated into a NULL base::Time() [2],
 // which will then be mapped to a zero Java time [3]. The zero Java time is
 // passed to Blink which will then be translated to NaN [4], which is what the
 // spec uses to indicate that the license will never expire [5].
 // [1] http://developer.android.com/reference/android/media/MediaDrm.OnExpirationUpdateListener.html
 // [2] See base::Time::FromDoubleT()
 // [3] See base::Time::ToJavaTime()
@@ skipping 12 matching lines @@
 void MediaDrmBridge::OnLegacySessionError(JNIEnv* env,
                                           jobject j_media_drm,
                                           jbyteArray j_session_id,
                                           jstring j_error_message) {
   std::string error_message = ConvertJavaStringToUTF8(env, j_error_message);
   legacy_session_error_cb_.Run(GetSessionId(env, j_session_id),
                                MediaKeys::UNKNOWN_ERROR, 0, error_message);
 }
 
 ScopedJavaLocalRef<jobject> MediaDrmBridge::GetMediaCrypto() {
+  DCHECK(ui_task_runner_->BelongsToCurrentThread());
+
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaDrmBridge_getMediaCrypto(env, j_media_drm_.obj());
 }
 
 MediaDrmBridge::SecurityLevel MediaDrmBridge::GetSecurityLevel() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_security_level =
       Java_MediaDrmBridge_getSecurityLevel(env, j_media_drm_.obj());
   std::string security_level_str =
       ConvertJavaStringToUTF8(env, j_security_level.obj());
@@ skipping 16 matching lines @@
   JNIEnv* env = AttachCurrentThread();
   Java_MediaDrmBridge_resetDeviceCredentials(env, j_media_drm_.obj());
 }
 
 void MediaDrmBridge::OnResetDeviceCredentialsCompleted(
     JNIEnv* env, jobject, bool success) {
   base::ResetAndReturn(&reset_credentials_cb_).Run(success);
 }
 
 }  // namespace media