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,
-                 std::vector<uint8>* pssh_data) {
-  const uint8* cur = data;
-  const uint8* data_end = data + data_size;
-  int bytes_left = data_size;
-
-  while (bytes_left > 0) {
-    const uint8* box_head = cur;
-
-    if (bytes_left < kBoxHeaderSize)
-      return false;
-
-    uint64_t box_size = ReadUint32(cur);
-    uint32 type = ReadUint32(cur + 4);
-    cur += kBoxHeaderSize;
-    bytes_left -= kBoxHeaderSize;
-
-    if (box_size == 1) {  // LargeSize is present.
-      if (bytes_left < kBoxLargeSizeSize)
-        return false;
-
-      box_size = ReadUint64(cur);
-      cur += kBoxLargeSizeSize;
-      bytes_left -= kBoxLargeSizeSize;
-    } else if (box_size == 0) {
-      box_size = bytes_left + kBoxHeaderSize;
-    }
-
-    const uint8* box_end = box_head + box_size;
-    if (data_end < box_end)
-      return false;
-
-    if (type == kTencType) {
-      // Skip 'tenc' box.
-      cur = box_end;
-      bytes_left = data_end - cur;
-      continue;
-    } else if (type != kPsshType) {
-      return false;
-    }
-
-    const int kPsshBoxMinimumSize =
-        kPsshVersionFlagSize + kPsshSystemIdSize + kPsshDataSizeSize;
-    if (box_end < cur + kPsshBoxMinimumSize)
-      return false;
-
-    uint32 version_and_flags = ReadUint32(cur);
-    cur += kPsshVersionFlagSize;
-    bytes_left -= kPsshVersionFlagSize;
-    if (version_and_flags != 0)
-      return false;
-
-    DCHECK_GE(bytes_left, kPsshSystemIdSize);
-    if (!std::equal(uuid.begin(), uuid.end(), cur)) {
-      cur = box_end;
-      bytes_left = data_end - cur;
-      continue;
-    }
-
-    cur += kPsshSystemIdSize;
-    bytes_left -= kPsshSystemIdSize;
-
-    uint32 data_size = ReadUint32(cur);
-    cur += kPsshDataSizeSize;
-    bytes_left -= kPsshDataSizeSize;
-
-    if (box_end < cur + data_size)
-      return false;
-
-    pssh_data->assign(cur, cur + data_size);
-    return true;
-  }
-
-  return false;
-}
-
 // Convert |init_data_type| to a string supported by MediaDRM.
 // "audio"/"video" does not matter, so use "video".
 std::string ConvertInitDataType(media::EmeInitDataType init_data_type) {
   // TODO(jrummell): API level >=20 supports "webm" and "cenc", so switch
   // to those strings.
   switch (init_data_type) {
     case media::EmeInitDataType::WEBM:
       return "video/webm";
     case media::EmeInitDataType::CENC:
       return "video/mp4";
     default:
       NOTREACHED();
       return "video/unknown";
   }
 }
 
-class KeySystemUuidManager {
+class KeySystemManager {
  public:
-  KeySystemUuidManager();
+  KeySystemManager();
   UUID GetUUID(const std::string& key_system);
   void AddMapping(const std::string& key_system, const UUID& uuid);
+  void RegisterDelegate(const std::string& key_system,
+                        MediaDrmBridge::Delegate* delegate);
+  MediaDrmBridge::Delegate* GetDelegate(const std::string& key_system);
   std::vector<std::string> GetPlatformKeySystemNames();
 
  private:
   typedef base::hash_map<std::string, UUID> KeySystemUuidMap;
+  typedef base::hash_map<std::string, MediaDrmBridge::Delegate*>
+      KeySystemDelegateMap;
 
+  KeySystemDelegateMap key_system_delegates_;
   KeySystemUuidMap key_system_uuid_map_;
 
-  DISALLOW_COPY_AND_ASSIGN(KeySystemUuidManager);
+  DISALLOW_COPY_AND_ASSIGN(KeySystemManager);
 };
 
-KeySystemUuidManager::KeySystemUuidManager() {
+KeySystemManager::KeySystemManager() {
   // Widevine is always supported in Android.
   key_system_uuid_map_[kWidevineKeySystem] =
       UUID(kWidevineUuid, kWidevineUuid + arraysize(kWidevineUuid));
 }
 
-UUID KeySystemUuidManager::GetUUID(const std::string& key_system) {
+UUID KeySystemManager::GetUUID(const std::string& key_system) {
   KeySystemUuidMap::iterator it = key_system_uuid_map_.find(key_system);
   if (it == key_system_uuid_map_.end())
     return UUID();
   return it->second;
 }
 
-void KeySystemUuidManager::AddMapping(const std::string& key_system,
+void KeySystemManager::AddMapping(const std::string& key_system,
                                       const UUID& uuid) {
   KeySystemUuidMap::iterator it = key_system_uuid_map_.find(key_system);
   DCHECK(it == key_system_uuid_map_.end())
       << "Shouldn't overwrite an existing key system.";
   if (it != key_system_uuid_map_.end())
     return;
   key_system_uuid_map_[key_system] = uuid;
 }
 
-std::vector<std::string> KeySystemUuidManager::GetPlatformKeySystemNames() {
+void KeySystemManager::RegisterDelegate(
+    const std::string& key_system, MediaDrmBridge::Delegate* delegate) {
+  DCHECK(!ContainsKey(key_system_delegates_, key_system))
+      << "Shouldn't overwrite an existing delegate.";
+  key_system_delegates_[key_system] = delegate;
+}
+
+MediaDrmBridge::Delegate* KeySystemManager::GetDelegate(
+    const std::string& key_system) {
+  KeySystemDelegateMap::iterator it = key_system_delegates_.find(key_system);
+  if (it == key_system_delegates_.end())
+    return nullptr;
+  return it->second;
+}
+
+std::vector<std::string> KeySystemManager::GetPlatformKeySystemNames() {
   std::vector<std::string> key_systems;
   for (KeySystemUuidMap::iterator it = key_system_uuid_map_.begin();
        it != key_system_uuid_map_.end(); ++it) {
     // Rule out the key system handled by Chrome explicitly.
     if (it->first != kWidevineKeySystem)
       key_systems.push_back(it->first);
   }
   return key_systems;
 }
 
-base::LazyInstance<KeySystemUuidManager>::Leaky g_key_system_uuid_manager =
+base::LazyInstance<KeySystemManager>::Leaky g_key_system_manager =
     LAZY_INSTANCE_INITIALIZER;
 
 // Checks whether |key_system| is supported with |container_mime_type|. Only
 // checks |key_system| support if |container_mime_type| is empty.
 // TODO(xhwang): The |container_mime_type| is not the same as contentType in
 // the EME spec. Revisit this once the spec issue with initData type is
 // resolved.
 bool IsKeySystemSupportedWithTypeImpl(const std::string& key_system,
                                       const std::string& container_mime_type) {
   if (!MediaDrmBridge::IsAvailable())
     return false;
 
-  UUID scheme_uuid = g_key_system_uuid_manager.Get().GetUUID(key_system);
+  UUID scheme_uuid = g_key_system_manager.Get().GetUUID(key_system);
   if (scheme_uuid.empty())
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_scheme_uuid =
       base::android::ToJavaByteArray(env, &scheme_uuid[0], scheme_uuid.size());
   ScopedJavaLocalRef<jstring> j_container_mime_type =
       ConvertUTF8ToJavaString(env, container_mime_type);
   return Java_MediaDrmBridge_isCryptoSchemeSupported(
       env, j_scheme_uuid.obj(), j_container_mime_type.obj());
@@ skipping 25 matching lines @@
 }  // 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);
+  g_key_system_manager.Get().AddMapping(key_system, uuid);
+}
+
+MediaDrmBridge::Delegate::Delegate() {
+}
+
+MediaDrmBridge::Delegate::~Delegate() {
+}
+
+bool MediaDrmBridge::Delegate::OnCreateSession(
+    const EmeInitDataType init_data_type,
+    const uint8* init_data,
+    int init_data_length,
+    std::vector<uint8>& init_data_out,
+    std::vector<std::string>& optional_parameters_out) {
+  return true;
 }
 
 // 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);
   if (os_major_version == 4 && os_minor_version == 4 && os_bugfix_version == 0)
     return false;
 
   return true;
 }
 
 // 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;
 }
 
 // static
 std::vector<std::string> MediaDrmBridge::GetPlatformKeySystemNames() {
-  return g_key_system_uuid_manager.Get().GetPlatformKeySystemNames();
+  return g_key_system_manager.Get().GetPlatformKeySystemNames();
 }
 
 // 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);
 }
 
+// static
+void MediaDrmBridge::RegisterDelegate(const std::string& key_system,
+                                      Delegate* delegate) {
+  g_key_system_manager.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 LegacySessionErrorCB& legacy_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),
       legacy_session_error_cb_(legacy_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 13 matching lines @@
     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;
   if (!IsAvailable())
     return media_drm_bridge.Pass();
 
-  UUID scheme_uuid = g_key_system_uuid_manager.Get().GetUUID(key_system);
+  UUID scheme_uuid = g_key_system_manager.Get().GetUUID(key_system);
   if (scheme_uuid.empty())
     return media_drm_bridge.Pass();
 
+  Delegate* delegate = g_key_system_manager.Get().GetDelegate(key_system);
   media_drm_bridge.reset(
       new MediaDrmBridge(scheme_uuid, session_message_cb, session_closed_cb,
-                         legacy_session_error_cb, session_keys_change_cb));
+                         legacy_session_error_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_optional_parameters;
 
-  // 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 == media::EmeInitDataType::CENC) {
-    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;
+  if (delegate_) {

[xhwang, 2015/04/09 22:37:10]

Just call g_key_system_manager.Get().GetDelegate(key_system) here instead of
having a local variable?

[gunsch, 2015/04/10 00:20:53]

Can't right now: MediaDrmBridge doesn't actually track the key system string as
a member variable (feels intentional). MediaDrmBridge::Create maps the key
system string to a UUID, then passes the UUID into MediaDrmBridge instead. So I
see the following options:

1) Member variable for the delegate, mapped from key system string in
MediaDrmBridge::Create and passed into MediaDrmBridge instance (current
solution)

2) Extra member variable to also track the key system string in MediaDrmBridge
instance, then looking up the delegate using that

3) Registering delegates by UUID instead of by key system string.

I'm open to all three, and don't have any strong thoughts on the relative
pros/cons. What do you think?

[xhwang, 2015/04/10 16:41:13]

(3) makes sense to me. MediaDrmBridge only talks UUID and have no idea what a
key system is.

[gunsch, 2015/04/11 00:18:16]

Done.

+    std::vector<uint8> init_data_from_delegate;
+    std::vector<std::string> optional_parameters_from_delegate;
+    if (!delegate_->OnCreateSession(init_data_type, init_data, init_data_length,
+                                    init_data_from_delegate,
+                                    optional_parameters_from_delegate)) {
+      promise->reject(INVALID_ACCESS_ERROR, 0, "Invalid data.");
     }
-    j_init_data =
-        base::android::ToJavaByteArray(env, &pssh_data[0], pssh_data.size());
-  } else {
+    if (!init_data_from_delegate.empty()) {
+      j_init_data = base::android::ToJavaByteArray(
+          env, &init_data_from_delegate[0], init_data_from_delegate.size());
+    }
+    if (!optional_parameters_from_delegate.empty()) {
+      j_optional_parameters = base::android::ToJavaArrayOfStrings(
+          env, optional_parameters_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, ConvertInitDataType(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_optional_parameters.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