Prepare MediaDrmBridge to work with MediaCodecPlayer

media/base/android/media_drm_bridge.cc

Index: media/base/android/media_drm_bridge.cc
diff --git a/media/base/android/media_drm_bridge.cc b/media/base/android/media_drm_bridge.cc
index 14bdbda03f0ac81e2f32ea958d02103f3b91e3d1..5ff49ee017c02f024aa8c6aafd2b8f11490ff21c 100644
--- a/media/base/android/media_drm_bridge.cc
+++ b/media/base/android/media_drm_bridge.cc
@@ -9,6 +9,7 @@
 #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"
@@ -23,11 +24,23 @@
 #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 "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
+#define RUN_CB_ON_MEDIA_THREAD(cb, ...)                              \
+  do {                                                               \
+    if (run_on_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;
@@ -228,6 +241,31 @@ bool MediaDrmBridge::IsAvailable() {
   return true;
 }
 
+// static
+bool MediaDrmBridge::CanCreate(const std::string& key_system,
+                               SecurityLevel widevine_security_level) {
+  if (!IsAvailable()) {
+    DVLOG(1) << __FUNCTION__ << ": DRM is not available";
+    return false;
+  }
+
+  UUID scheme_uuid = g_key_system_manager.Get().GetUUID(key_system);
+  if (scheme_uuid.empty()) {
+    DVLOG(1) << __FUNCTION__ << ": key system " << key_system
+             << " not supported";
+    return false;
+  }
+
+  if (key_system == kWidevineKeySystem &&
+      widevine_security_level != SECURITY_LEVEL_NONE &&
+      !std::equal(scheme_uuid.begin(), scheme_uuid.end(), kWidevineUuid)) {
+    NOTREACHED() << "Widevine security level " << widevine_security_level
+                 << "used with another key system";
+    return false;
+  }
+  return true;
+}
+
 // TODO(ddorwin): This is specific to Widevine. http://crbug.com/459400
 // static
 bool MediaDrmBridge::IsSecureDecoderRequired(SecurityLevel security_level) {
@@ -254,6 +292,7 @@ bool MediaDrmBridge::IsKeySystemSupportedWithType(
   return IsKeySystemSupportedWithTypeImpl(key_system, container_mime_type);
 }
 
+// static
 bool MediaDrmBridge::RegisterMediaDrmBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
@@ -270,7 +309,29 @@ MediaDrmBridge::MediaDrmBridge(
       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),
+      run_on_media_thread_(false),
+      weak_factory_(this) {
+  DVLOG(1) << "MediaDrmBridge::MediaDrmBridge";
+
+  // When this flag is set we need to repost the notifications about
+  // crypto became ready and a key had been added to the Media thread.
+  run_on_media_thread_ = GetMediaTaskRunner()->BelongsToCurrentThread();
+
+  // Create internal callbacks to repost Java new key notification and
+  // promise related notifications to the media thread.
+
+  base::WeakPtr<MediaDrmBridge> weak_this = weak_factory_.GetWeakPtr();
+
+  internal_keys_added_cb_ =
+      base::Bind(&MediaDrmBridge::InternalKeysAdded, weak_this);
+  internal_promise_resolved_cb_ =
+      base::Bind(&MediaDrmBridge::InternalPromiseResolved, weak_this);
+  internal_promise_resolved_with_session_cb_ = base::Bind(
+      &MediaDrmBridge::InternalPromiseResolvedWithSession, weak_this);
+  internal_promise_rejected_cb_ =
+      base::Bind(&MediaDrmBridge::InternalPromiseRejected, weak_this);
+
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
 
@@ -288,14 +349,15 @@ MediaDrmBridge::~MediaDrmBridge() {
 }
 
 // static
-scoped_ptr<MediaDrmBridge> MediaDrmBridge::Create(
+scoped_ptr<MediaDrmBridge, BrowserCdmDeleter> MediaDrmBridge::Create(
     const std::string& key_system,
+    SecurityLevel widevine_security_level,
     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();
 
@@ -311,15 +373,24 @@ scoped_ptr<MediaDrmBridge> MediaDrmBridge::Create(
   if (media_drm_bridge->j_media_drm_.is_null())
     media_drm_bridge.reset();
 
+  if (key_system == kWidevineKeySystem &&

[ddorwin, 2015/09/16 20:42:21]

We shouldn't need the WV check here again.

+      widevine_security_level != SECURITY_LEVEL_NONE &&
+      !media_drm_bridge->SetSecurityLevel(widevine_security_level)) {
+    DVLOG(1) << __FUNCTION__ << ": failed to set security level "
+             << widevine_security_level;
+    media_drm_bridge.reset();
+  }
+
   return media_drm_bridge.Pass();
 }
 
 // static
-scoped_ptr<MediaDrmBridge> MediaDrmBridge::CreateWithoutSessionSupport(
-    const std::string& key_system) {
-  return MediaDrmBridge::Create(
-      key_system, SessionMessageCB(), SessionClosedCB(), LegacySessionErrorCB(),
-      SessionKeysChangeCB(), SessionExpirationUpdateCB());
+scoped_ptr<MediaDrmBridge, BrowserCdmDeleter>
+MediaDrmBridge::CreateWithoutSessionSupport(const std::string& key_system) {
+  return MediaDrmBridge::Create(key_system, SECURITY_LEVEL_NONE,
+                                SessionMessageCB(), SessionClosedCB(),
+                                LegacySessionErrorCB(), SessionKeysChangeCB(),
+                                SessionExpirationUpdateCB());
 }
 
 bool MediaDrmBridge::SetSecurityLevel(SecurityLevel security_level) {
@@ -425,7 +496,7 @@ void MediaDrmBridge::UpdateSession(
     const std::string& session_id,
     const std::vector<uint8_t>& response,
     scoped_ptr<media::SimpleCdmPromise> promise) {
-  DVLOG(1) << __FUNCTION__;
+  DVLOG(1) << __FUNCTION__ << " session_id:" << session_id;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_response = base::android::ToJavaByteArray(
@@ -441,6 +512,7 @@ void MediaDrmBridge::UpdateSession(
 void MediaDrmBridge::CloseSession(const std::string& session_id,
                                   scoped_ptr<media::SimpleCdmPromise> promise) {
   DVLOG(1) << __FUNCTION__;
+
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_session_id = base::android::ToJavaByteArray(
       env, reinterpret_cast<const uint8_t*>(session_id.data()),
@@ -472,6 +544,8 @@ void MediaDrmBridge::UnregisterPlayer(int registration_id) {
 }
 
 void MediaDrmBridge::SetMediaCryptoReadyCB(const base::Closure& closure) {
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__;
+
   if (closure.is_null()) {
     media_crypto_ready_cb_.Reset();
     return;
@@ -487,32 +561,62 @@ void MediaDrmBridge::SetMediaCryptoReadyCB(const base::Closure& closure) {
   media_crypto_ready_cb_ = closure;
 }
 
-void MediaDrmBridge::OnMediaCryptoReady(JNIEnv* env, jobject) {
+void MediaDrmBridge::OnMediaCryptoReady(JNIEnv* env, jobject j_media_drm) {
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__;
+
   DCHECK(!GetMediaCrypto().is_null());
-  if (!media_crypto_ready_cb_.is_null())
-    base::ResetAndReturn(&media_crypto_ready_cb_).Run();
+
+  if (media_crypto_ready_cb_.is_null())
+    return;
+
+  RUN_CB_ON_MEDIA_THREAD(base::ResetAndReturn(&media_crypto_ready_cb_));
 }
 
 void MediaDrmBridge::OnPromiseResolved(JNIEnv* env,
                                        jobject j_media_drm,
                                        jint j_promise_id) {
-  cdm_promise_adapter_.ResolvePromise(j_promise_id);
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__;
+  RUN_CB_ON_MEDIA_THREAD(internal_promise_resolved_cb_, j_promise_id);
+}
+
+void MediaDrmBridge::InternalPromiseResolved(uint32_t promise_id) {
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__
+           << ": promise_id:" << promise_id;
+  cdm_promise_adapter_.ResolvePromise(promise_id);
 }
 
 void MediaDrmBridge::OnPromiseResolvedWithSession(JNIEnv* env,
                                                   jobject j_media_drm,
                                                   jint j_promise_id,
                                                   jbyteArray j_session_id) {
-  cdm_promise_adapter_.ResolvePromise(j_promise_id,
-                                      GetSessionId(env, j_session_id));
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__;
+  RUN_CB_ON_MEDIA_THREAD(internal_promise_resolved_with_session_cb_,
+                         j_promise_id, GetSessionId(env, j_session_id));
+}
+
+void MediaDrmBridge::InternalPromiseResolvedWithSession(
+    uint32_t promise_id,
+    const std::string& session_id) {
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__
+           << ": promise_id:" << promise_id << " session_id:" << session_id;
+  cdm_promise_adapter_.ResolvePromise(promise_id, session_id);
 }
 
 void MediaDrmBridge::OnPromiseRejected(JNIEnv* env,
                                        jobject j_media_drm,
                                        jint j_promise_id,
                                        jstring j_error_message) {
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__;
   std::string error_message = ConvertJavaStringToUTF8(env, j_error_message);
-  cdm_promise_adapter_.RejectPromise(j_promise_id, MediaKeys::UNKNOWN_ERROR, 0,
+  RUN_CB_ON_MEDIA_THREAD(internal_promise_rejected_cb_, j_promise_id,
+                         error_message);
+}
+
+void MediaDrmBridge::InternalPromiseRejected(uint32_t promise_id,
+                                             const std::string& error_message) {
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__
+           << ": promise_id:" << promise_id << " error:" << error_message;
+  cdm_promise_adapter_.RejectPromise(promise_id, MediaKeys::UNKNOWN_ERROR, 0,
                                      error_message);
 }
 
@@ -529,14 +633,26 @@ void MediaDrmBridge::OnSessionMessage(JNIEnv* env,
   MediaKeys::MessageType message_type =
       GetMessageType(static_cast<RequestType>(j_message_type));
 
-  session_message_cb_.Run(GetSessionId(env, j_session_id), message_type,
-                          message, legacy_destination_url);
+  std::string session_id = GetSessionId(env, j_session_id);
+
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__
+           << " session_id:" << session_id;
+
+  // We need to preserve the order of messages. If the promise-related
+  // callbacks are posted to the Media thread, we have to do the same with
+  // all callbacks. See the comment in media_drm_proxy.h.
+  RUN_CB_ON_MEDIA_THREAD(session_message_cb_, session_id, message_type, message,
+                         legacy_destination_url);
 }
 
 void MediaDrmBridge::OnSessionClosed(JNIEnv* env,
                                      jobject j_media_drm,
                                      jbyteArray j_session_id) {
-  session_closed_cb_.Run(GetSessionId(env, j_session_id));
+  std::string session_id = GetSessionId(env, j_session_id);
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__
+           << " session_id:" << session_id;
+
+  RUN_CB_ON_MEDIA_THREAD(session_closed_cb_, session_id);

[ddorwin, 2015/09/16 20:42:21]

Should it be up to the caller to ensure this? At what layer is the contract
about threads? Unless it's being used to ensure synchronization (is it?), it
probably makes sense to move this up the stack. WDYT?

Would using something like
https://code.google.com/p/chromium/codesearch#chromium/src/media/blink/webmed...
when the CBs are created be better?

 }
 
 void MediaDrmBridge::OnSessionKeysChange(JNIEnv* env,
@@ -544,8 +660,7 @@ void MediaDrmBridge::OnSessionKeysChange(JNIEnv* env,
                                          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;
 
@@ -579,8 +694,24 @@ void MediaDrmBridge::OnSessionKeysChange(JNIEnv* env,
     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);
+
+  if (run_on_media_thread_ && !GetMediaTaskRunner()->BelongsToCurrentThread()) {
+    GetMediaTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(session_keys_change_cb_, session_id,
+                   has_additional_usable_key, base::Passed(&cdm_keys_info)));
+  } else {
+    session_keys_change_cb_.Run(session_id, has_additional_usable_key,
+                                cdm_keys_info.Pass());
+  }
+}
+
+void MediaDrmBridge::InternalKeysAdded(bool has_additional_usable_key) {
+  if (has_additional_usable_key)
+    player_tracker_.NotifyNewKey();
 }
 
 // According to MeidaDrm documentation [1], zero |expiry_time_ms| means the keys
@@ -597,19 +728,27 @@ void MediaDrmBridge::OnSessionExpirationUpdate(JNIEnv* env,
                                                jobject j_media_drm,
                                                jbyteArray j_session_id,
                                                jlong expiry_time_ms) {
-  DVLOG(2) << __FUNCTION__ << ": " << expiry_time_ms << " ms";
-  session_expiration_update_cb_.Run(
-      GetSessionId(env, j_session_id),
-      base::Time::FromDoubleT(expiry_time_ms / 1000.0));
+  std::string session_id = GetSessionId(env, j_session_id);
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__
+           << ": session_id:" << session_id << " expiration:" << expiry_time_ms
+           << " ms";
+
+  RUN_CB_ON_MEDIA_THREAD(session_expiration_update_cb_, session_id,
+                         base::Time::FromDoubleT(expiry_time_ms / 1000.0));
 }
 
 void MediaDrmBridge::OnLegacySessionError(JNIEnv* env,
                                           jobject j_media_drm,
                                           jbyteArray j_session_id,
                                           jstring j_error_message) {
+  std::string session_id = GetSessionId(env, j_session_id);
   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);
+
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__ << " session_id:" << session_id
+           << " error:" << error_message;
+
+  RUN_CB_ON_MEDIA_THREAD(legacy_session_error_cb_, session_id,
+                         MediaKeys::UNKNOWN_ERROR, 0, error_message);
 }
 
 ScopedJavaLocalRef<jobject> MediaDrmBridge::GetMediaCrypto() {
@@ -645,7 +784,9 @@ void MediaDrmBridge::ResetDeviceCredentials(
 
 void MediaDrmBridge::OnResetDeviceCredentialsCompleted(
     JNIEnv* env, jobject, bool success) {
-  base::ResetAndReturn(&reset_credentials_cb_).Run(success);
+  DVLOG(1) << "MediaDrmBridge::" << __FUNCTION__ << ": success:" << success;
+
+  RUN_CB_ON_MEDIA_THREAD(base::ResetAndReturn(&reset_credentials_cb_), success);
 }
 
 }  // namespace media