BrowserMediaPlayerManager manages MediaKeys objects.

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/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_util.h"
 #include "jni/MediaDrmBridge_jni.h"
-#include "media/base/android/media_player_manager.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::ScopedJavaLocalRef;
 
 namespace media {
@@ skipping 187 matching lines @@
   DCHECK(IsAvailable());
   return SECURITY_LEVEL_1 == security_level;
 }
 
 // static
 bool MediaDrmBridge::IsSecurityLevelSupported(const std::string& key_system,
                                               SecurityLevel security_level) {
   if (!IsAvailable())
     return false;
 
-  // Pass 0 as |cdm_id| and NULL as |manager| as they are not used in
-  // creation time of MediaDrmBridge.
   scoped_ptr<MediaDrmBridge> media_drm_bridge =
-      MediaDrmBridge::Create(0, key_system, GURL(), NULL);
+      MediaDrmBridge::CreateSessionless(key_system);
   if (!media_drm_bridge)
     return false;
 
   return media_drm_bridge->SetSecurityLevel(security_level);
 }
 
 // static
 bool MediaDrmBridge::IsKeySystemSupported(const std::string& key_system) {
   DCHECK(!key_system.empty());
   return IsKeySystemSupportedWithTypeImpl(key_system, "");
 }
 
 // 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);
 }
 
 bool MediaDrmBridge::RegisterMediaDrmBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
-MediaDrmBridge::MediaDrmBridge(int cdm_id,
-                               const std::vector<uint8>& scheme_uuid,
-                               const GURL& security_origin,
-                               MediaPlayerManager* manager)
-    : cdm_id_(cdm_id),
-      scheme_uuid_(scheme_uuid),
-      security_origin_(security_origin),
-      manager_(manager) {
+MediaDrmBridge::MediaDrmBridge(const std::vector<uint8>& scheme_uuid,
+                               const SessionCreatedCB& session_created_cb,
+                               const SessionMessageCB& session_message_cb,
+                               const SessionReadyCB& session_ready_cb,
+                               const SessionClosedCB& session_closed_cb,
+                               const SessionErrorCB& session_error_cb)
+    : scheme_uuid_(scheme_uuid),
+      session_created_cb_(session_created_cb),
+      session_message_cb_(session_message_cb),
+      session_ready_cb_(session_ready_cb),
+      session_closed_cb_(session_closed_cb),
+      session_error_cb_(session_error_cb) {
   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() {
   JNIEnv* env = AttachCurrentThread();
   if (!j_media_drm_.is_null())
     Java_MediaDrmBridge_release(env, j_media_drm_.obj());
 }
 
 // static
-scoped_ptr<MediaDrmBridge> MediaDrmBridge::Create(int cdm_id,
-                                                  const std::string& key_system,
-                                                  const GURL& security_origin,
-                                                  MediaPlayerManager* manager) {
+scoped_ptr<MediaDrmBridge> MediaDrmBridge::Create(
+    const std::string& key_system,
+    const SessionCreatedCB& session_created_cb,
+    const SessionMessageCB& session_message_cb,
+    const SessionReadyCB& session_ready_cb,
+    const SessionClosedCB& session_closed_cb,
+    const SessionErrorCB& session_error_cb) {
   scoped_ptr<MediaDrmBridge> media_drm_bridge;
   if (!IsAvailable())
     return media_drm_bridge.Pass();
 
   std::vector<uint8> scheme_uuid = GetUUID(key_system);
   if (scheme_uuid.empty())
     return media_drm_bridge.Pass();
 
-  media_drm_bridge.reset(
-      new MediaDrmBridge(cdm_id, scheme_uuid, security_origin, manager));
+  media_drm_bridge.reset(new MediaDrmBridge(scheme_uuid,
+                                            session_created_cb,
+                                            session_message_cb,
+                                            session_ready_cb,
+                                            session_closed_cb,
+                                            session_error_cb));
+
   if (media_drm_bridge->j_media_drm_.is_null())
     media_drm_bridge.reset();
 
   return media_drm_bridge.Pass();
 }
 
+// static
+scoped_ptr<MediaDrmBridge> MediaDrmBridge::CreateSessionless(
+    const std::string& key_system) {
+  return MediaDrmBridge::Create(key_system,
+                                SessionCreatedCB(),
+                                SessionMessageCB(),
+                                SessionReadyCB(),
+                                SessionClosedCB(),
+                                SessionErrorCB());
+}
+
 bool MediaDrmBridge::SetSecurityLevel(SecurityLevel security_level) {
   JNIEnv* env = AttachCurrentThread();
 
   std::string security_level_str = GetSecurityLevelString(security_level);
   if (security_level_str.empty())
     return false;
 
   ScopedJavaLocalRef<jstring> j_security_level =
       ConvertUTF8ToJavaString(env, security_level_str);
   return Java_MediaDrmBridge_setSecurityLevel(
       env, j_media_drm_.obj(), j_security_level.obj());
 }
 
 bool MediaDrmBridge::CreateSession(uint32 session_id,
                                    const std::string& content_type,
                                    const uint8* init_data,
                                    int init_data_length) {
+  DVLOG(1) << __FUNCTION__;
+
+  DCHECK(!session_created_cb_.is_null())
+      << "CreateSession called on a sessionless MediaDrmBridge object.";
+
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_init_data;
   // Caller should always use "video/*" content types.
   DCHECK_EQ(0u, content_type.find("video/"));
 
   // Widevine MediaDrm plugin only accepts the "data" part of the PSSH box as
   // the init data when using MP4 container.
   if (std::equal(scheme_uuid_.begin(), scheme_uuid_.end(), kWidevineUuid) &&
       content_type == "video/mp4") {
     std::vector<uint8> pssh_data;
@@ skipping 16 matching lines @@
 void MediaDrmBridge::LoadSession(uint32 session_id,
                                  const std::string& web_session_id) {
   // MediaDrmBridge doesn't support loading sessions.
   NOTREACHED();
 }
 
 void MediaDrmBridge::UpdateSession(uint32 session_id,
                                    const uint8* response,
                                    int response_length) {
   DVLOG(1) << __FUNCTION__;
+
+  DCHECK(!session_ready_cb_.is_null())
+      << __FUNCTION__ << " called on a sessionless MediaDrmBridge object.";
+
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_response =
       base::android::ToJavaByteArray(env, response, response_length);
   Java_MediaDrmBridge_updateSession(
       env, j_media_drm_.obj(), session_id, j_response.obj());
 }
 
 void MediaDrmBridge::ReleaseSession(uint32 session_id) {
   DVLOG(1) << __FUNCTION__;
+
+  DCHECK(!session_closed_cb_.is_null())
+      << __FUNCTION__ << " called on a sessionless MediaDrmBridge object.";
+
   JNIEnv* env = AttachCurrentThread();
   Java_MediaDrmBridge_releaseSession(env, j_media_drm_.obj(), session_id);
 }
 
 void MediaDrmBridge::SetMediaCryptoReadyCB(const base::Closure& closure) {
   if (closure.is_null()) {
     media_crypto_ready_cb_.Reset();
     return;
   }
 
@@ skipping 12 matching lines @@
   if (!media_crypto_ready_cb_.is_null())
     base::ResetAndReturn(&media_crypto_ready_cb_).Run();
 }
 
 void MediaDrmBridge::OnSessionCreated(JNIEnv* env,
                                       jobject j_media_drm,
                                       jint j_session_id,
                                       jstring j_web_session_id) {
   uint32 session_id = j_session_id;
   std::string web_session_id = ConvertJavaStringToUTF8(env, j_web_session_id);
-  manager_->OnSessionCreated(cdm_id_, session_id, web_session_id);
+  session_created_cb_.Run(session_id, web_session_id);
 }
 
 void MediaDrmBridge::OnSessionMessage(JNIEnv* env,
                                       jobject j_media_drm,
                                       jint j_session_id,
                                       jbyteArray j_message,
                                       jstring j_destination_url) {
   uint32 session_id = j_session_id;
   std::vector<uint8> message;
   JavaByteArrayToByteVector(env, j_message, &message);
   std::string destination_url = ConvertJavaStringToUTF8(env, j_destination_url);
-  GURL destination_gurl(destination_url);
-  if (!destination_gurl.is_valid() && !destination_gurl.is_empty()) {
-    DLOG(WARNING) << "SessionMessage destination_url is invalid : "
-                  << destination_gurl.possibly_invalid_spec();
-    destination_gurl = GURL::EmptyGURL();  // Replace invalid destination_url.
-  }
-
-  manager_->OnSessionMessage(cdm_id_, session_id, message, destination_gurl);
+  session_message_cb_.Run(session_id, message, destination_url);
 }
 
 void MediaDrmBridge::OnSessionReady(JNIEnv* env,
                                     jobject j_media_drm,
                                     jint j_session_id) {
   uint32 session_id = j_session_id;
-  manager_->OnSessionReady(cdm_id_, session_id);
+  session_ready_cb_.Run(session_id);
 }
 
 void MediaDrmBridge::OnSessionClosed(JNIEnv* env,
                                      jobject j_media_drm,
                                      jint j_session_id) {
   uint32 session_id = j_session_id;
-  manager_->OnSessionClosed(cdm_id_, session_id);
+  session_closed_cb_.Run(session_id);
 }
 
 void MediaDrmBridge::OnSessionError(JNIEnv* env,
                                     jobject j_media_drm,
                                     jint j_session_id) {
   uint32 session_id = j_session_id;
-  manager_->OnSessionError(cdm_id_, session_id, MediaKeys::kUnknownError, 0);
+  session_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0);
 }
 
 ScopedJavaLocalRef<jobject> MediaDrmBridge::GetMediaCrypto() {
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaDrmBridge_getMediaCrypto(env, j_media_drm_.obj());
 }
 
 MediaDrmBridge::SecurityLevel MediaDrmBridge::GetSecurityLevel() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_security_level =
@@ skipping 14 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