media: Make MediaKeys ref-counted.

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/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_drm_bridge_delegate.h"
-#include "media/base/android/media_task_runner.h"
 #include "media/base/cdm_key_information.h"
 
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::JavaByteArrayToByteVector;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
@@ skipping 168 matching lines @@
     case MediaDrmBridge::SECURITY_LEVEL_1:
       return "L1";
     case MediaDrmBridge::SECURITY_LEVEL_3:
       return "L3";
   }
   return "";
 }
 
 }  // namespace
 
-MediaDrmBridge::~MediaDrmBridge() {
-  DVLOG(1) << __FUNCTION__;
-
-  DCHECK(!use_media_thread_ || GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  player_tracker_.NotifyCdmUnset();
-}
-
-void MediaDrmBridge::DeleteOnCorrectThread() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  JNIEnv* env = AttachCurrentThread();
-  if (!j_media_drm_.is_null())
-    Java_MediaDrmBridge_destroy(env, j_media_drm_.obj());
-
-  // After the call to Java_MediaDrmBridge_destroy() Java won't call native
-  // methods anymore, this is ensured by MediaDrmBridge.java.
-
-  // CdmPromiseAdapter must be destroyed on the UI thread.
-  cdm_promise_adapter_.reset();
-
-  // Post deletion onto Media thread if we use it.
-  if (use_media_thread_) {
-    weak_factory_.InvalidateWeakPtrs();
-    GetMediaTaskRunner()->DeleteSoon(FROM_HERE, this);
-  } else {
-    delete this;
-  }
-}
-
 // static
 bool MediaDrmBridge::IsAvailable() {
   if (base::android::BuildInfo::GetInstance()->sdk_int() < 19)
     return false;
 
   int32 os_major_version = 0;
   int32 os_minor_version = 0;
   int32 os_bugfix_version = 0;
   base::SysInfo::OperatingSystemVersionNumbers(
       &os_major_version, &os_minor_version, &os_bugfix_version);
@@ skipping 21 matching lines @@
   DCHECK(!key_system.empty() && !container_mime_type.empty());
   return IsKeySystemSupportedWithTypeImpl(key_system, container_mime_type);
 }
 
 // static
 std::vector<std::string> MediaDrmBridge::GetPlatformKeySystemNames() {
   return g_key_system_manager.Get().GetPlatformKeySystemNames();
 }
 
 // static
-ScopedMediaDrmBridgePtr MediaDrmBridge::Create(
+scoped_refptr<MediaDrmBridge> 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) {
   DVLOG(1) << __FUNCTION__;
 
-  scoped_ptr<MediaDrmBridge, BrowserCdmDeleter> media_drm_bridge;
   if (!IsAvailable())
-    return media_drm_bridge.Pass();
+    return nullptr;
 
   UUID scheme_uuid = g_key_system_manager.Get().GetUUID(key_system);
   if (scheme_uuid.empty())
-    return media_drm_bridge.Pass();
+    return nullptr;
 
-  media_drm_bridge.reset(
+  scoped_refptr<MediaDrmBridge> media_drm_bridge(
       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();
+    media_drm_bridge = nullptr;
 
-  return media_drm_bridge.Pass();
+  return media_drm_bridge;
 }
 
 // static
-ScopedMediaDrmBridgePtr MediaDrmBridge::CreateWithoutSessionSupport(
+scoped_refptr<MediaDrmBridge> MediaDrmBridge::CreateWithoutSessionSupport(
     const std::string& key_system) {
   return MediaDrmBridge::Create(
       key_system, SessionMessageCB(), SessionClosedCB(), LegacySessionErrorCB(),
       SessionKeysChangeCB(), SessionExpirationUpdateCB());
 }
 
-base::WeakPtr<MediaDrmBridge> MediaDrmBridge::WeakPtr() {
-  return weak_factory_.GetWeakPtr();
-}
-
 void MediaDrmBridge::SetServerCertificate(
     const std::vector<uint8_t>& certificate,
     scoped_ptr<media::SimpleCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
 
   DCHECK(!certificate.empty());
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_certificate;
   if (Java_MediaDrmBridge_setServerCertificate(env, j_media_drm_.obj(),
@@ skipping 106 matching lines @@
 
   NOTIMPLEMENTED() << "EME persistent sessions not yet supported on Android.";
   promise->reject(NOT_SUPPORTED_ERROR, 0, "RemoveSession() is not supported.");
 }
 
 CdmContext* MediaDrmBridge::GetCdmContext() {
   NOTREACHED();
   return nullptr;
 }
 
+void MediaDrmBridge::DeleteOnCorrectThread() const {
+  DVLOG(1) << __FUNCTION__;
+
+  if (!task_runner_->BelongsToCurrentThread()) {
+    // When DeleteSoon returns false, |this| will be leaked, which is okay.
+    task_runner_->DeleteSoon(FROM_HERE, this);
+  } else {
+    delete this;
+  }
+}
+
 int MediaDrmBridge::RegisterPlayer(const base::Closure& new_key_cb,
                                    const base::Closure& cdm_unset_cb) {
-  DCHECK(!use_media_thread_ || GetMediaTaskRunner()->BelongsToCurrentThread());
+  // |player_tracker_| can be accessed from any thread.
   return player_tracker_.RegisterPlayer(new_key_cb, cdm_unset_cb);
 }
 
 void MediaDrmBridge::UnregisterPlayer(int registration_id) {
-  DCHECK(!use_media_thread_ || GetMediaTaskRunner()->BelongsToCurrentThread());
+  // |player_tracker_| can be accessed from any thread.
   player_tracker_.UnregisterPlayer(registration_id);
 }
 
 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";
     return false;
   }
@@ skipping 47 matching lines @@
 
 ScopedJavaLocalRef<jobject> MediaDrmBridge::GetMediaCrypto() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaDrmBridge_getMediaCrypto(env, j_media_drm_.obj());
 }
 
 void MediaDrmBridge::SetMediaCryptoReadyCB(
     const MediaCryptoReadyCB& media_crypto_ready_cb) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  if (!task_runner_->BelongsToCurrentThread()) {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&MediaDrmBridge::SetMediaCryptoReadyCB,
+                   weak_factory_.GetWeakPtr(), media_crypto_ready_cb));
+    return;
+  }
+
   DVLOG(1) << __FUNCTION__;
 
   if (media_crypto_ready_cb.is_null()) {
     media_crypto_ready_cb_.Reset();
     return;
   }
 
   DCHECK(media_crypto_ready_cb_.is_null());
 
   // |media_crypto_ready_cb| is already bound to the correct thread
@@ skipping 10 matching lines @@
 // only do minimal work and then post tasks to avoid reentrancy issues.
 
 void MediaDrmBridge::OnMediaCryptoReady(JNIEnv* env, jobject j_media_drm) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   if (media_crypto_ready_cb_.is_null())
     return;
 
   task_runner_->PostTask(
-      FROM_HERE, base::Bind(&MediaDrmBridge::NotifyMediaCryptoReady, WeakPtr(),
+      FROM_HERE, base::Bind(&MediaDrmBridge::NotifyMediaCryptoReady,
+                            weak_factory_.GetWeakPtr(),
                             base::ResetAndReturn(&media_crypto_ready_cb_)));
 }
 
 void MediaDrmBridge::OnPromiseResolved(JNIEnv* env,
                                        jobject j_media_drm,
                                        jint j_promise_id) {
-  task_runner_->PostTask(FROM_HERE, base::Bind(&MediaDrmBridge::ResolvePromise,
-                                               WeakPtr(), j_promise_id));
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&MediaDrmBridge::ResolvePromise,
+                                    weak_factory_.GetWeakPtr(), j_promise_id));
 }
 
 void MediaDrmBridge::OnPromiseResolvedWithSession(JNIEnv* env,
                                                   jobject j_media_drm,
                                                   jint j_promise_id,
                                                   jbyteArray j_session_id) {
-  task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&MediaDrmBridge::ResolvePromiseWithSession, WeakPtr(),
-                 j_promise_id, GetSessionId(env, j_session_id)));
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&MediaDrmBridge::ResolvePromiseWithSession,
+                                    weak_factory_.GetWeakPtr(), j_promise_id,
+                                    GetSessionId(env, j_session_id)));
 }
 
 void MediaDrmBridge::OnPromiseRejected(JNIEnv* env,
                                        jobject j_media_drm,
                                        jint j_promise_id,
                                        jstring j_error_message) {
   task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&MediaDrmBridge::RejectPromise, WeakPtr(), j_promise_id,
-                 ConvertJavaStringToUTF8(env, j_error_message)));
+      base::Bind(&MediaDrmBridge::RejectPromise, weak_factory_.GetWeakPtr(),
+                 j_promise_id, ConvertJavaStringToUTF8(env, j_error_message)));
 }
 
 void MediaDrmBridge::OnSessionMessage(JNIEnv* env,
                                       jobject j_media_drm,
                                       jbyteArray j_session_id,
                                       jint j_message_type,
                                       jbyteArray j_message,
                                       jstring j_legacy_destination_url) {
   DVLOG(2) << __FUNCTION__;
 
@@ skipping 19 matching lines @@
 }
 
 void MediaDrmBridge::OnSessionKeysChange(JNIEnv* env,
                                          jobject j_media_drm,
                                          jbyteArray j_session_id,
                                          jobjectArray j_keys_info,
                                          bool has_additional_usable_key) {
   DVLOG(2) << __FUNCTION__;
 
   if (has_additional_usable_key)
-    NotifyNewKeyOnCorrectThread();
+    player_tracker_.NotifyNewKey();
 
   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 80 matching lines @@
     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),
       cdm_promise_adapter_(new CdmPromiseAdapter()),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      use_media_thread_(UseMediaThreadForMediaPlayback()),
-      media_weak_factory_(this),
       weak_factory_(this) {
   DVLOG(1) << __FUNCTION__;
 
   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() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DVLOG(1) << __FUNCTION__;
+
+  JNIEnv* env = AttachCurrentThread();
+
+  // After the call to Java_MediaDrmBridge_destroy() Java won't call native
+  // methods anymore, this is ensured by MediaDrmBridge.java.
+  if (!j_media_drm_.is_null())
+    Java_MediaDrmBridge_destroy(env, j_media_drm_.obj());
+
+  player_tracker_.NotifyCdmUnset();

[Tima Vaisburd, 2015/10/29 01:17:53]

There seem to be no players to notify, right? If you prefer to keep it here for
consistency, please explain it in the comment.

On the other hand, would it be possible to do the similar change in Cast and get
rid of NotifyCdmUnset() altogether?

[xhwang, 2015/10/29 03:12:31]

The fact that the callback won't fire is an implementation detail of the
MediaSourcePlayer and MediaCodecPlayer, who hold a scoped_refptr to the CDM and
know that these callbacks won't fire. However, it's possible that some other
player could hold a raw pointer to the CDM and will rely on this callback to
work properly. We don't have such a player now, but I'd like to keep
MediaDrmBridge self-contained.
We should. But I don't plan to dive too deep into ChromeCast code. ChromeCast
people can choose what to do next. If they do similar changes, we can drop
NotifyCdmUnset() altogther later.

+}
+
 // TODO(ddorwin): This is specific to Widevine. http://crbug.com/459400
 // static
 bool MediaDrmBridge::IsSecureDecoderRequired(SecurityLevel security_level) {
   DCHECK(IsAvailable());
   return SECURITY_LEVEL_1 == security_level;
 }
 
 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());
   return GetSecurityLevelFromString(security_level_str);
 }
 
-void MediaDrmBridge::NotifyNewKeyOnCorrectThread() {
-  // Repost this method onto the Media thread if |use_media_thread_| is true.
-  if (use_media_thread_ && !GetMediaTaskRunner()->BelongsToCurrentThread()) {
-    GetMediaTaskRunner()->PostTask(
-        FROM_HERE, base::Bind(&MediaDrmBridge::NotifyNewKeyOnCorrectThread,
-                              media_weak_factory_.GetWeakPtr()));
-    return;
-  }
-
-  DCHECK(!use_media_thread_ || GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  player_tracker_.NotifyNewKey();
-}
-
 void MediaDrmBridge::NotifyMediaCryptoReady(const MediaCryptoReadyCB& cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   DCHECK(!cb.is_null());
   DCHECK(!GetMediaCrypto().is_null());
 
   // We can use scoped_ptr to pass ScopedJavaGlobalRef with a callback.
   scoped_ptr<ScopedJavaGlobalRef<jobject>> j_object_ptr(
       new ScopedJavaGlobalRef<jobject>());
   j_object_ptr->Reset(AttachCurrentThread(), GetMediaCrypto().obj());
 
   cb.Run(j_object_ptr.Pass(), IsProtectedSurfaceRequired());
 }
 
 }  // namespace media