Encrypted Media: Confine UUID code to 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 "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"
 
+#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 {
 
 static uint32 ReadUint32(const uint8_t* data) {
   uint32 value = 0;
@@ skipping 15 matching lines @@
 //
 // 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
 // }
-static const int kBoxHeaderSize = 8;  // Box's header contains Size and Type.
-static const int kBoxLargeSizeSize = 8;
-static const int kPsshVersionFlagSize = 4;
-static const int kPsshSystemIdSize = 16;
-static const int kPsshDataSizeSize = 4;
-static const uint32 kTencType = 0x74656e63;
-static const uint32 kPsshType = 0x70737368;
+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 };
+
+static std::vector<uint8> GetUUID(const std::string& key_system) {
+  if (key_system == kWidevineKeySystem) {

[ddorwin, 2014/03/04 20:00:56]

We should probably state that for security reasons, we only do exact string
comparisons here - we don't try to parse the |key_system| in any way.

Preferably, we would do this on the browser side of the IPC. Maybe we should
check IsSupportedKeySystem() there. There's no reason to continue to here if
it's not.

[xhwang, 2014/03/05 21:52:33]

IsSupportedKeySystem() will actually call into this file in various ways. For
example, the handler of ChromeViewHostMsg_GetSupportedKeySystems will call
MediaDrmBridge::IsKeySystemSupported().

+    return std::vector<uint8>(kWidevineUuid,
+                              kWidevineUuid + arraysize(kWidevineUuid));
+  }
+  return std::vector<uint8>();
+}
 
 // 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.
 static bool GetPsshData(const uint8* data, int data_size,
                         const std::vector<uint8>& uuid,
@@ skipping 98 matching lines @@
 // static
 bool MediaDrmBridge::IsAvailable() {
   return base::android::BuildInfo::GetInstance()->sdk_int() >= 19;
 }
 
 // static
 bool MediaDrmBridge::IsSecureDecoderRequired(SecurityLevel security_level) {
   return SECURITY_LEVEL_1 == security_level;
 }
 
-bool MediaDrmBridge::IsSecurityLevelSupported(
-    const std::vector<uint8>& scheme_uuid,
-    SecurityLevel security_level) {
+bool MediaDrmBridge::IsSecurityLevelSupported(const std::string& key_system,
+                                              SecurityLevel security_level) {
   // 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, scheme_uuid, GURL(), NULL);
+      MediaDrmBridge::Create(0, key_system, GURL(), NULL);
   if (!media_drm_bridge)
     return false;
 
   return media_drm_bridge->SetSecurityLevel(security_level);
 }
 
 bool MediaDrmBridge::IsCryptoSchemeSupported(
-    const std::vector<uint8>& scheme_uuid,
+    const std::string& key_system,
     const std::string& container_mime_type) {
+  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());
 }
 
 bool MediaDrmBridge::RegisterMediaDrmBridge(JNIEnv* env) {
@@ skipping 17 matching lines @@
       env, j_scheme_uuid.obj(), reinterpret_cast<intptr_t>(this)));
 }
 
 MediaDrmBridge::~MediaDrmBridge() {
   JNIEnv* env = AttachCurrentThread();
   if (!j_media_drm_.is_null())
     Java_MediaDrmBridge_release(env, j_media_drm_.obj());
 }
 
 // static
-scoped_ptr<MediaDrmBridge> MediaDrmBridge::Create(
-    int cdm_id,
-    const std::vector<uint8>& scheme_uuid,
-    const GURL& frame_url,
-    MediaPlayerManager* manager) {
+scoped_ptr<MediaDrmBridge> MediaDrmBridge::Create(int cdm_id,
+                                                  const std::string& key_system,
+                                                  const GURL& frame_url,
+                                                  MediaPlayerManager* manager) {
   scoped_ptr<MediaDrmBridge> media_drm_bridge;
+  if (!IsAvailable())
+    return media_drm_bridge.Pass();
 
-  if (IsAvailable() && !scheme_uuid.empty()) {
-    // TODO(qinmin): check whether the uuid is valid.
-    media_drm_bridge.reset(
-        new MediaDrmBridge(cdm_id, scheme_uuid, frame_url, manager));
-    if (media_drm_bridge->j_media_drm_.is_null())
-      media_drm_bridge.reset();
-  }
+  std::vector<uint8> scheme_uuid = GetUUID(key_system);
+  if (scheme_uuid.empty())
+    return media_drm_bridge.Pass();
+
+  media_drm_bridge.reset(
+      new MediaDrmBridge(cdm_id, scheme_uuid, frame_url, manager));
+  if (media_drm_bridge->j_media_drm_.is_null())
+    media_drm_bridge.reset();
 
   return media_drm_bridge.Pass();
 }
 
 bool MediaDrmBridge::SetSecurityLevel(SecurityLevel security_level) {
   JNIEnv* env = AttachCurrentThread();
 
   std::string security_level_str = GetSecurityLevelString(security_level);
   if (security_level_str.empty())
     return false;
@@ skipping 141 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