Adds MediaClientAndroid to support embedder/MediaDrmBridge interaction.

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/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/sys_byteorder.h"
 #include "base/sys_info.h"
 #include "jni/MediaDrmBridge_jni.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::ScopedJavaLocalRef;
 
 namespace media {
 
 namespace {
 
 // DrmBridge supports session expiration event but doesn't provide detailed
 // status for each key ID, which is required by the EME spec. Use a dummy key ID
 // here to report session expiration info.
 const char kDummyKeyId[] = "Dummy Key Id";
 
+/*
 uint32 ReadUint32(const uint8_t* data) {
   uint32 value = 0;
   for (int i = 0; i < 4; ++i)
     value = (value << 8) | data[i];
   return value;
 }
 
 uint64 ReadUint64(const uint8_t* data) {
   uint64 value = 0;
   for (int i = 0; i < 8; ++i)
     value = (value << 8) | data[i];
   return value;
 }
+*/
 
 // Returns string session ID from jbyteArray (byte[] in Java).
 std::string GetSessionId(JNIEnv* env, jbyteArray j_session_id) {
   std::vector<uint8> session_id_vector;
   JavaByteArrayToByteVector(env, j_session_id, &session_id_vector);
   return std::string(session_id_vector.begin(), session_id_vector.end());
 }
 
+/*
 // The structure of an ISO CENC Protection System Specific Header (PSSH) box is
 // as follows. (See ISO/IEC FDIS 23001-7:2011(E).)
 // Note: ISO boxes use big-endian values.
 //
 // PSSH {
 //   uint32 Size
 //   uint32 Type
 //   uint64 LargeSize  # Field is only present if value(Size) == 1.
 //   uint32 VersionAndFlags
 //   uint8[16] SystemId
 //   uint32 DataSize
 //   uint8[DataSize] Data
 // }
 const int kBoxHeaderSize = 8;  // Box's header contains Size and Type.
 const int kBoxLargeSizeSize = 8;
 const int kPsshVersionFlagSize = 4;
 const int kPsshSystemIdSize = 16;
 const int kPsshDataSizeSize = 4;
 const uint32 kTencType = 0x74656e63;
 const uint32 kPsshType = 0x70737368;
+*/
 const uint8 kWidevineUuid[16] = {
     0xED, 0xEF, 0x8B, 0xA9, 0x79, 0xD6, 0x4A, 0xCE,
     0xA3, 0xC8, 0x27, 0xDC, 0xD5, 0x1D, 0x21, 0xED };
 
 typedef std::vector<uint8> UUID;
 
+/*
 // Tries to find a PSSH box whose "SystemId" is |uuid| in |data|, parses the
 // "Data" of the box and put it in |pssh_data|. Returns true if such a box is
 // found and successfully parsed. Returns false otherwise.
 // Notes:
 // 1, If multiple PSSH boxes are found,the "Data" of the first matching PSSH box
 // will be set in |pssh_data|.
 // 2, Only PSSH and TENC boxes are allowed in |data|. TENC boxes are skipped.
 bool GetPsshData(const uint8* data,
                  int data_size,
                  const UUID& uuid,
@@ skipping 64 matching lines @@
 
     if (box_end < cur + data_size)
       return false;
 
     pssh_data->assign(cur, cur + data_size);
     return true;
   }
 
   return false;
 }
+*/
 
 class KeySystemUuidManager {
  public:
   KeySystemUuidManager();
   UUID GetUUID(const std::string& key_system);
   void AddMapping(const std::string& key_system, const UUID& uuid);
   std::vector<std::string> GetPlatformKeySystemNames();
 
  private:
   typedef base::hash_map<std::string, UUID> KeySystemUuidMap;
@@ skipping 79 matching lines @@
     case MediaDrmBridge::SECURITY_LEVEL_NONE:
       return "";
     case MediaDrmBridge::SECURITY_LEVEL_1:
       return "L1";
     case MediaDrmBridge::SECURITY_LEVEL_3:
       return "L3";
   }
   return "";
 }
 
+class DelegateList {
+ public:
+  DelegateList();
+
+  void RegisterDelegate(const std::string& key_system,
+                        MediaDrmBridge::Delegate* delegate);
+  MediaDrmBridge::Delegate* GetDelegate(const std::string& key_system);
+
+ private:
+  std::hash_map<std::string, MediaDrmBridge::Delegate*> delegates_;
+  DISALLOW_COPY_AND_ASSIGN(DelegateList);
+};
+
+base::LazyInstance<DelegateList>::Leaky g_delegates =
+    LAZY_INSTANCE_INITIALIZER;
+
+DelegateList::DelegateList() {
+}
+
+void DelegateList::RegisterDelegate(
+    const std::string& key_system, MediaDrmBridge::Delegate* delegate) {
+  DCHECK(!ContainsKey(delegates_, key_system));
+  delegates_[key_system] = delegate;
+}
+
+MediaDrmBridge::Delegate* DelegateList::GetDelegate(
+    const std::string& key_system) {
+  if (!ContainsKey(delegates_, key_system))
+    return nullptr;
+  return delegates_[key_system];
+}
+
 }  // namespace
 
 // Called by Java.
 static void AddKeySystemUuidMapping(JNIEnv* env,
                                     jclass clazz,
                                     jstring j_key_system,
                                     jobject j_buffer) {
   std::string key_system = ConvertJavaStringToUTF8(env, j_key_system);
   uint8* buffer = static_cast<uint8*>(env->GetDirectBufferAddress(j_buffer));
   UUID uuid(buffer, buffer + 16);
   g_key_system_uuid_manager.Get().AddMapping(key_system, uuid);

[xhwang, 2015/03/23 04:59:47]

Can we merge g_delegates and g_key_system_uuid_manager?

[gunsch, 2015/04/09 01:36:39]

Done.

 }
 
 // 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;
@@ skipping 25 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
+void MediaDrmBridge::RegisterDelegate(const std::string& key_system,
+                                      Delegate* delegate) {
+  g_delegates.Get().RegisterDelegate(key_system, delegate);
+}
+
 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 SessionErrorCB& session_error_cb,
-    const SessionKeysChangeCB& session_keys_change_cb)
+    const SessionKeysChangeCB& session_keys_change_cb,
+    Delegate* delegate)
     : scheme_uuid_(scheme_uuid),
+      delegate_(delegate),
       session_message_cb_(session_message_cb),
       session_closed_cb_(session_closed_cb),
       session_error_cb_(session_error_cb),
       session_keys_change_cb_(session_keys_change_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(
@@ skipping 17 matching lines @@
     const SessionKeysChangeCB& session_keys_change_cb,
     const SessionExpirationUpdateCB& /* session_expiration_update_cb */) {
   scoped_ptr<MediaDrmBridge> media_drm_bridge;
   if (!IsAvailable())
     return media_drm_bridge.Pass();
 
   UUID scheme_uuid = g_key_system_uuid_manager.Get().GetUUID(key_system);
   if (scheme_uuid.empty())
     return media_drm_bridge.Pass();
 
+  Delegate* delegate = g_delegates.Get().GetDelegate(key_system);
   media_drm_bridge.reset(new MediaDrmBridge(scheme_uuid, session_message_cb,
                                             session_closed_cb, session_error_cb,
-                                            session_keys_change_cb));
+                                            session_keys_change_cb, delegate));
 
   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) {
@@ skipping 39 matching lines @@
   DVLOG(1) << __FUNCTION__;
 
   if (session_type != media::MediaKeys::TEMPORARY_SESSION) {
     promise->reject(NOT_SUPPORTED_ERROR, 0,
                     "Only the temporary session type is supported.");
     return;
   }
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_init_data;
+  ScopedJavaLocalRef<jobjectArray> j_additional_data;
   // Caller should always use "video/*" content types.
   DCHECK_EQ(0u, init_data_type.find("video/"));
 
+/*
+  TODO: find an appropriate place for this to live.
   // 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) &&
       init_data_type == "video/mp4") {
     std::vector<uint8> pssh_data;
     if (!GetPsshData(init_data, init_data_length, scheme_uuid_, &pssh_data)) {
       promise->reject(INVALID_ACCESS_ERROR, 0, "Invalid PSSH data.");
       return;
     }
     j_init_data =
         base::android::ToJavaByteArray(env, &pssh_data[0], pssh_data.size());
-  } else {
+  }
+*/
+
+  if (delegate_) {
+    std::vector<uint8> init_data_from_delegate;
+    std::vector<std::string> additional_data_from_delegate;
+    delegate_->OnCreateSession(init_data_type, init_data, init_data_length,
+                               init_data_from_delegate,
+                               additional_data_from_delegate);
+    if (!init_data_from_delegate.empty()) {
+      j_init_data = base::android::ToJavaByteArray(
+          env, &init_data_from_delegate[0], init_data_from_delegate.size());
+    }
+    if (!additional_data_from_delegate.empty()) {
+      j_additional_data = base::android::ToJavaArrayOfStrings(
+          env, additional_data_from_delegate);
+    }
+  }
+
+  if (j_init_data.is_null()) {
     j_init_data =
         base::android::ToJavaByteArray(env, init_data, init_data_length);
   }
 
   ScopedJavaLocalRef<jstring> j_mime =
       ConvertUTF8ToJavaString(env, init_data_type);
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
   Java_MediaDrmBridge_createSession(env, j_media_drm_.obj(), j_init_data.obj(),
-                                    j_mime.obj(), promise_id);
+                                    j_mime.obj(), j_additional_data.obj(),
+                                    promise_id);
 }
 
 void MediaDrmBridge::LoadSession(
     SessionType session_type,
     const std::string& session_id,
     scoped_ptr<media::NewSessionCdmPromise> promise) {
   promise->reject(NOT_SUPPORTED_ERROR, 0, "LoadSession() is not supported.");
 }
 
 void MediaDrmBridge::UpdateSession(
@@ skipping 174 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