MediaSourcePlayer implements IsTypeSupported().

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 "base/android/build_info.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/logging.h"
@@ skipping 120 matching lines @@
     if (box_end < cur + data_size)
       return false;
 
     pssh_data->assign(cur, cur + data_size);
     return true;
   }
 
   return false;
 }
 
+static MediaDrmBridge::SecurityLevel GetSecurityLevelFromString(

[qinmin, 2013/08/27 21:41:12]

this doesn't needs to be a class member function, make it a helper function

[xhwang, 2013/08/28 01:21:24]

This is already a helper function and not a class member function.

+    const std::string& security_level_str) {
+  if (0 == security_level_str.compare("L1"))
+    return MediaDrmBridge::SECURITY_LEVEL_1;
+  if (0 == security_level_str.compare("L3"))
+    return MediaDrmBridge::SECURITY_LEVEL_3;
+  DCHECK(security_level_str.empty());
+  return MediaDrmBridge::SECURITY_LEVEL_NONE;
+}
+
 // static
 MediaDrmBridge* MediaDrmBridge::Create(int media_keys_id,
                                        const std::vector<uint8>& scheme_uuid,
                                        MediaPlayerManager* manager) {
   if (!IsAvailable() || scheme_uuid.empty())
     return NULL;
 
   // TODO(qinmin): check whether the uuid is valid.
   return new MediaDrmBridge(media_keys_id, scheme_uuid, manager);
 }
 
+// static
 bool MediaDrmBridge::IsAvailable() {
   return base::android::BuildInfo::GetInstance()->sdk_int() >= 18;
 }
 
+// static
+bool MediaDrmBridge::IsSecureDecoderRequired(
+    const std::string& security_level_str) {
+  return IsSecureDecoderRequired(
+      GetSecurityLevelFromString(security_level_str));
+}
+
+bool MediaDrmBridge::IsCryptoSchemeSupported(
+    const std::vector<uint8>& scheme_uuid,
+    const std::string& container_mime_type) {
+  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());
+}
+
 bool MediaDrmBridge::RegisterMediaDrmBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 MediaDrmBridge::MediaDrmBridge(int media_keys_id,
                                const std::vector<uint8>& scheme_uuid,
                                MediaPlayerManager* manager)
     : media_keys_id_(media_keys_id),
       scheme_uuid_(scheme_uuid),
       manager_(manager) {
@@ skipping 68 matching lines @@
 void MediaDrmBridge::OnKeyAdded(JNIEnv* env, jobject, jstring j_session_id) {
   std::string session_id = ConvertJavaStringToUTF8(env, j_session_id);
   manager_->OnKeyAdded(media_keys_id_, session_id);
 }
 
 void MediaDrmBridge::OnKeyError(JNIEnv* env, jobject, jstring j_session_id) {
   std::string session_id = ConvertJavaStringToUTF8(env, j_session_id);
   manager_->OnKeyError(media_keys_id_, session_id, MediaKeys::kUnknownError, 0);
 }
 
+// static
+bool MediaDrmBridge::IsSecureDecoderRequired(SecurityLevel security_level) {
+  return MediaDrmBridge::SECURITY_LEVEL_1 == security_level;
+}
+
 MediaDrmBridge::SecurityLevel MediaDrmBridge::GetSecurityLevel() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_security_level =
       Java_MediaDrmBridge_getSecurityLevel(env, j_media_drm_.obj());
-  std::string security_level =
+  std::string security_level_str =
       ConvertJavaStringToUTF8(env, j_security_level.obj());
-  if (0 == security_level.compare("L1"))
-    return SECURITY_LEVEL_1;
-  if (0 == security_level.compare("L3"))
-    return SECURITY_LEVEL_3;
-  DCHECK(security_level.empty());
-  return SECURITY_LEVEL_NONE;
+  return GetSecurityLevelFromString(security_level_str);
 }
 
 bool MediaDrmBridge::IsProtectedSurfaceRequired() {
-  return MediaDrmBridge::SECURITY_LEVEL_1 == GetSecurityLevel();
+  return IsSecureDecoderRequired(GetSecurityLevel());
 }
 
 }  // namespace media