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/numerics/safe_conversions.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/android/media_client_android.h"
+#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.
 
 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 std::vector<uint8_t>& data,
-                 const UUID& uuid,
-                 std::vector<uint8>* pssh_data) {
-  int bytes_left = base::checked_cast<int>(data.size());
-  const uint8_t* cur = &data[0];
-  const uint8_t* data_end = cur + bytes_left;
-
-  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 {

[xhwang, 2015/04/28 05:25:11]

I wonder whether we still need this class, which looks very similar to
MediaClientAndroid. Can this be replaced by MediaClientAndroid? The only
difference I see is that we add kWidevineKeySystem here, but we can also add it
to the map of the MediaClientAndroid member map. 

[xhwang, 2015/04/28 17:06:10]

If not, maybe we can do something like:

MediaClientAndroid::AddKeySystemsUUIDMappings(KeySystemUuidMap*
key_system_uuid_map)

So that we don't copy the map here...

[gunsch, 2015/04/28 18:50:51]

Right now, I assume that MediaClientAndroid is optional, so it can't be the
single source of truth. Changing that assumption to make MediaClientAndroid hold
the source of truth for all the mappings would _require_ every embedder to
create a MediaClientAndroid, which seems to go against the concept of it being a
"client".

[xhwang, 2015/04/28 19:00:38]

Agreed. That makes sense and is good layering.

How about my second comment to avoid copying the map?

[gunsch, 2015/04/28 19:56:32]

I guess I'm unclear on the API you're asking for: is this to have
MediaClientAndroid populate key_system_uuid_map_ instead of asking it for a copy
of the map, just to avoid the transient copy? Or are you asking for a way to not
have MediaClientAndroid have a separate map from KeySystemManager? ISTM that the
first case is avoided by using a reference for GetKeySystemUUIDMappings (which I
forgot to do, fixed below). But the second one might need a slightly different
approach, such as querying MediaClientAndroid on the fly when calling GetUUID. 

  public:
-  KeySystemUuidManager();
+  KeySystemManager();
   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;
 
+  void AddMappingsFromMediaClient();
+
   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));
+  AddMappingsFromMediaClient();
 }
 
-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,
-                                      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())
+void KeySystemManager::AddMappingsFromMediaClient() {
+  MediaClientAndroid* client = GetMediaClientAndroid();
+  if (!client)
     return;
-  key_system_uuid_map_[key_system] = uuid;
+  base::hash_map<std::string, UUID> mappings =

[xhwang, 2015/04/28 17:06:10]

Use KeySystemUuidMap

[gunsch, 2015/04/28 18:50:51]

Done.

+      client->GetKeySystemUUIDMappings();
+  for (const auto& mapping : mappings) {
+    key_system_uuid_map_[mapping.first] = mapping.second;
+  }
 }
 
-std::vector<std::string> KeySystemUuidManager::GetPlatformKeySystemNames() {
+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 17 matching lines @@
     case MediaDrmBridge::SECURITY_LEVEL_1:
       return "L1";
     case MediaDrmBridge::SECURITY_LEVEL_3:
       return "L3";
   }
   return "";
 }
 
 }  // 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);
-}
-
 // 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(
@@ skipping 40 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();
 
   media_drm_bridge.reset(
       new MediaDrmBridge(scheme_uuid, session_message_cb, session_closed_cb,
                          legacy_session_error_cb, session_keys_change_cb));
 
   if (media_drm_bridge->j_media_drm_.is_null())
     media_drm_bridge.reset();
 
@@ skipping 43 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, scheme_uuid_, &pssh_data)) {
-      promise->reject(INVALID_ACCESS_ERROR, 0, "Invalid PSSH data.");
-      return;
+  MediaClientAndroid* client = GetMediaClientAndroid();
+  if (client) {
+    MediaDrmBridgeDelegate* delegate =
+        client->GetMediaDrmBridgeDelegate(scheme_uuid_);
+    if (delegate) {
+      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_from_delegate,
+                                     &optional_parameters_from_delegate)) {
+        promise->reject(INVALID_ACCESS_ERROR, 0, "Invalid init data.");
+      }
+      j_init_data = base::android::ToJavaByteArray(
+          env, vector_as_array(&init_data_from_delegate),
+          init_data_from_delegate.size());
+      if (!optional_parameters_from_delegate.empty()) {
+        j_optional_parameters = base::android::ToJavaArrayOfStrings(
+            env, optional_parameters_from_delegate);
+      }
     }
-    j_init_data = base::android::ToJavaByteArray(
-        env, vector_as_array(&pssh_data), pssh_data.size());
-  } else {
+  }
+
+  if (j_init_data.is_null()) {
     j_init_data = base::android::ToJavaByteArray(
         env, vector_as_array(&init_data), init_data.size());
   }
 
   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 173 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