Add MediaDrmBridge::AddKeySystemUuidMapping().

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/lazy_instance.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;
@@ skipping 35 matching lines @@
 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) {
-  // For security reasons, we only do exact string comparisons here - we don't
-  // try to parse the |key_system| in any way.
-  if (key_system == kWidevineKeySystem) {
-    return std::vector<uint8>(kWidevineUuid,
-                              kWidevineUuid + arraysize(kWidevineUuid));
-  }
-  return std::vector<uint8>();
+typedef std::vector<uint8> UUID;

[xhwang, 2014/05/21 17:11:08]

nit: Add an empty line after this.

[ycheo (away), 2014/05/21 23:35:11]

Done.

+class KeySystemUuidManager {
+ public:
+  KeySystemUuidManager();
+  UUID GetUUID(const std::string& key_system);
+  void AddMapping(const std::string& key_system, const UUID& uuid);
+
+ private:
+  typedef base::hash_map<std::string, UUID> KeySystemUuidMap;

[xhwang, 2014/05/21 17:11:08]

add include for hash_map

[ycheo (away), 2014/05/21 23:35:11]

Done.

+
+  KeySystemUuidMap key_system_uuid_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(KeySystemUuidManager);
+};
+
+KeySystemUuidManager::KeySystemUuidManager() {
+  key_system_uuid_map_[kWidevineKeySystem] =

[xhwang, 2014/05/21 17:11:08]

Add a comment that Widevine is always supported.

[ycheo (away), 2014/05/21 23:35:11]

Done.

+      UUID(kWidevineUuid, kWidevineUuid + arraysize(kWidevineUuid));
 }
 
+UUID KeySystemUuidManager::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 the existing keysystem";

[xhwang, 2014/05/21 17:11:08]

nit: s/the/an/
nit: s/keysystem/key system/
nit: add period at the end

[ycheo (away), 2014/05/21 23:35:11]

Done.

+  if (it != key_system_uuid_map_.end())
+    return;
+  key_system_uuid_map_[key_system] = uuid;
+}
+
+base::LazyInstance<KeySystemUuidManager>::Leaky g_key_system_uuid_manager =
+    LAZY_INSTANCE_INITIALIZER;
+
 // 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,
+                        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;
@@ skipping 89 matching lines @@
 // 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);
+  UUID scheme_uuid = g_key_system_uuid_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 19 matching lines @@
   // 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
+void MediaDrmBridge::AddKeySystemUuidMapping(const std::string& key_system,

[xhwang, 2014/05/21 17:11:08]

Add a comment that this gives other platforms a chance to register their own
UUID mappings. Otherwise people may wonder how/when this is used.

[ycheo (away), 2014/05/21 23:35:11]

Applied this on the header.

+                                             const std::vector<uint8>& uuid) {
+  g_key_system_uuid_manager.Get().AddMapping(key_system, uuid);
+}
+
 // 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) {
@@ skipping 30 matching lines @@
 
 // static
 scoped_ptr<MediaDrmBridge> MediaDrmBridge::Create(int cdm_id,
                                                   const std::string& key_system,
                                                   const GURL& security_origin,
                                                   MediaPlayerManager* manager) {
   scoped_ptr<MediaDrmBridge> media_drm_bridge;
   if (!IsAvailable())
     return media_drm_bridge.Pass();
 
-  std::vector<uint8> scheme_uuid = GetUUID(key_system);
+  UUID scheme_uuid = g_key_system_uuid_manager.Get().GetUUID(key_system);
   if (scheme_uuid.empty())
     return media_drm_bridge.Pass();
 
   media_drm_bridge.reset(
       new MediaDrmBridge(cdm_id, scheme_uuid, security_origin, manager));
   if (media_drm_bridge->j_media_drm_.is_null())
     media_drm_bridge.reset();
 
   return media_drm_bridge.Pass();
 }
@@ skipping 160 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