Reland r262568 "Encrypted Media: Check container mime type in MediaDrmBridge".

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"
@@ skipping 156 matching lines @@
     case MediaDrmBridge::SECURITY_LEVEL_NONE:
       return "";
     case MediaDrmBridge::SECURITY_LEVEL_1:
       return "L1";
     case MediaDrmBridge::SECURITY_LEVEL_3:
       return "L3";
   }
   return "";
 }
 
+// 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.
+static bool IsKeySystemSupportedWithTypeImpl(
+    const std::string& key_system,
+    const std::string& container_mime_type) {
+  if (!MediaDrmBridge::IsAvailable())
+    return false;
+
+  std::vector<uint8> scheme_uuid = 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());
+}
+
 // static
 bool MediaDrmBridge::IsAvailable() {
   return base::android::BuildInfo::GetInstance()->sdk_int() >= 19;
 }
 
 // static
 bool MediaDrmBridge::IsSecureDecoderRequired(SecurityLevel security_level) {
   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);
   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) {
-  if (!IsAvailable())
-    return false;
-
-  std::vector<uint8> scheme_uuid = 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());
+  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)
@@ skipping 47 matching lines @@
   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) {
-  std::vector<uint8> pssh_data;
-  if (!GetPsshData(init_data, init_data_length, scheme_uuid_, &pssh_data))
-    return false;
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jbyteArray> j_init_data;
+  // Caller should always use "video/*" content types.
+  DCHECK_EQ(0u, content_type.find("video/"));
 
-  JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jbyteArray> j_pssh_data =
-      base::android::ToJavaByteArray(env, &pssh_data[0], pssh_data.size());
+  // 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;
+    if (!GetPsshData(init_data, init_data_length, scheme_uuid_, &pssh_data))
+      return false;
+    j_init_data =
+        base::android::ToJavaByteArray(env, &pssh_data[0], pssh_data.size());
+  } else {
+    j_init_data =
+        base::android::ToJavaByteArray(env, init_data, init_data_length);
+  }
+
   ScopedJavaLocalRef<jstring> j_mime =
       ConvertUTF8ToJavaString(env, content_type);
   Java_MediaDrmBridge_createSession(
-      env, j_media_drm_.obj(), session_id, j_pssh_data.obj(), j_mime.obj());
+      env, j_media_drm_.obj(), session_id, j_init_data.obj(), j_mime.obj());
   return true;
 }
 
 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,
@@ skipping 109 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