Refactor KeySystems code to call a function to populate the info.

content/renderer/media/crypto/key_systems.cc

 // Copyright 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 "content/renderer/media/crypto/key_systems.h"
 
 #include <map>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
+#include "content/public/common/content_client.h"
+#include "content/public/common/key_system_info.h"
 #include "content/renderer/media/crypto/key_systems_info.h"
 #include "net/base/mime_util.h"
 #include "third_party/WebKit/public/platform/WebCString.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 namespace content {
 
 // Convert a WebString to ASCII, falling back on an empty string in the case
 // of a non-ASCII string.
 static std::string ToASCIIOrEmpty(const WebKit::WebString& string) {
   return IsStringASCII(string) ? UTF16ToASCII(string) : std::string();
 }
 
 class KeySystems {
  public:
-  static KeySystems* GetInstance();
-
-  void AddConcreteSupportedKeySystem(
-      const std::string& key_system,
-      bool use_aes_decryptor,
-#if defined(ENABLE_PEPPER_CDMS)
-      const std::string& pepper_type,
-#elif defined(OS_ANDROID)
-      const uint8 uuid[16],
-#endif
-      const std::string& parent_key_system);
-
-  void AddSupportedType(const std::string& key_system,
-                        const std::string& mime_type,
-                        const std::string& codecs_list);
+  static KeySystems& GetInstance();
 
   bool IsConcreteSupportedKeySystem(const std::string& key_system);
 
   bool IsSupportedKeySystemWithMediaMimeType(
       const std::string& mime_type,
       const std::vector<std::string>& codecs,
       const std::string& key_system);
 
   bool UseAesDecryptor(const std::string& concrete_key_system);
 
 #if defined(ENABLE_PEPPER_CDMS)
   std::string GetPepperType(const std::string& concrete_key_system);
 #elif defined(OS_ANDROID)
   std::vector<uint8> GetUUID(const std::string& concrete_key_system);
 #endif
 
  private:
+  void AddConcreteSupportedKeySystems(
+      const std::vector<KeySystemInfo>& concrete_key_systems);
+
+  void AddConcreteSupportedKeySystem(
+      const std::string& key_system,
+      bool use_aes_decryptor,
+#if defined(ENABLE_PEPPER_CDMS)
+      const std::string& pepper_type,
+#elif defined(OS_ANDROID)
+      const std::vector<uint8>& uuid,
+#endif
+      const std::vector<KeySystemInfo::ContainerCodecsPair>& supported_types,
+      const std::string& parent_key_system);
+
+
   friend struct base::DefaultLazyInstanceTraits<KeySystems>;
 
   typedef base::hash_set<std::string> CodecSet;
   typedef std::map<std::string, CodecSet> MimeTypeMap;
 
   struct KeySystemProperties {
     KeySystemProperties() : use_aes_decryptor(false) {}
 
     bool use_aes_decryptor;
 #if defined(ENABLE_PEPPER_CDMS)
     std::string pepper_type;
 #elif defined(OS_ANDROID)
     std::vector<uint8> uuid;
 #endif
     MimeTypeMap types;
   };
 
   typedef std::map<std::string, KeySystemProperties> KeySystemPropertiesMap;
 
   typedef std::map<std::string, std::string> ParentKeySystemMap;
 
-  KeySystems() {}
+  KeySystems();
+  ~KeySystems() {}
+
+  void AddSupportedType(const std::string& mime_type,
+                        const std::string& codecs_list,
+                        KeySystemProperties* properties);
 
   bool IsSupportedKeySystemWithContainerAndCodec(
       const std::string& mime_type,
       const std::string& codec,
       const std::string& key_system);
 
   // Map from key system string to capabilities.
   KeySystemPropertiesMap concrete_key_system_map_;
 
   // Map from parent key system to the concrete key system that should be used
   // to represent its capabilities.
   ParentKeySystemMap parent_key_system_map_;
 
   DISALLOW_COPY_AND_ASSIGN(KeySystems);
 };
 
 static base::LazyInstance<KeySystems> g_key_systems = LAZY_INSTANCE_INITIALIZER;
 
-KeySystems* KeySystems::GetInstance() {
-  KeySystems* key_systems = &g_key_systems.Get();
-  // TODO(ddorwin): Call out to ContentClient to register key systems.
-  static bool is_registered = false;
-  if (!is_registered) {
-    is_registered = true;  // Prevent reentrancy when Add*() is called.
-    RegisterKeySystems();
+KeySystems& KeySystems::GetInstance() {
+  return g_key_systems.Get();
+}
+
+// Because we use a LazyInstance, the key systems info must be populated when
+// the instance is lazily initiated.
+KeySystems::KeySystems() {
+  std::vector<KeySystemInfo> key_systems_info;
+  GetContentClient()->AddKeySystems(&key_systems_info);
+  // TODO(ddorwin): Remove in next CL after moving info to ChromeContentClient.
+  AddKeySystems(&key_systems_info);
+  AddConcreteSupportedKeySystems(key_systems_info);
+}
+
+void KeySystems::AddConcreteSupportedKeySystems(
+    const std::vector<KeySystemInfo>& concrete_key_systems) {
+  for (size_t i = 0; i < concrete_key_systems.size(); ++i) {
+    const KeySystemInfo& key_system_info = concrete_key_systems[i];
+    AddConcreteSupportedKeySystem(key_system_info.key_system,
+                                  key_system_info.use_aes_decryptor,
+#if defined(ENABLE_PEPPER_CDMS)
+                                  key_system_info.pepper_type,
+#elif defined(OS_ANDROID)
+                                  key_system_info.uuid,
+#endif
+                                  key_system_info.supported_types,
+                                  key_system_info.parent_key_system);
   }
-  return key_systems;
 }
 
 void KeySystems::AddConcreteSupportedKeySystem(
     const std::string& concrete_key_system,
     bool use_aes_decryptor,
 #if defined(ENABLE_PEPPER_CDMS)
     const std::string& pepper_type,
 #elif defined(OS_ANDROID)
-    const uint8 uuid[16],
+    const std::vector<uint8>& uuid,
 #endif
+    const std::vector<KeySystemInfo::ContainerCodecsPair>& supported_types,
     const std::string& parent_key_system) {
   DCHECK(!IsConcreteSupportedKeySystem(concrete_key_system))
       << "Key system '" << concrete_key_system << "' already registered";
+  DCHECK(parent_key_system_map_.find(concrete_key_system) ==
+         parent_key_system_map_.end())
+      <<  "'" << concrete_key_system << " is already registered as a parent";
 
   KeySystemProperties properties;
   properties.use_aes_decryptor = use_aes_decryptor;
 #if defined(ENABLE_PEPPER_CDMS)
   DCHECK_EQ(use_aes_decryptor, pepper_type.empty());
   properties.pepper_type = pepper_type;
 #elif defined(OS_ANDROID)
-  // Since |uuid| can't be empty, use |use_aes_decryptor|.
-  if (!use_aes_decryptor)
-    properties.uuid.assign(uuid, uuid + 16);
+  DCHECK_EQ(use_aes_decryptor, uuid.empty());
+  DCHECK(use_aes_decryptor || uuid.size() == 16);
+  properties.uuid = uuid;
 #endif
+
+  for (size_t i = 0; i < supported_types.size(); ++i) {
+    const KeySystemInfo::ContainerCodecsPair& pair = supported_types[i];
+    const std::string& mime_type = pair.first;
+    const std::string& codecs_list = pair.second;
+    AddSupportedType(mime_type, codecs_list, &properties);
+  }
+
   concrete_key_system_map_[concrete_key_system] = properties;
 
   if (!parent_key_system.empty()) {
+    DCHECK(!IsConcreteSupportedKeySystem(parent_key_system))
+        << "Parent '" << parent_key_system << "' already registered concrete";
     DCHECK(parent_key_system_map_.find(parent_key_system) ==
            parent_key_system_map_.end())
-        << "Parent '" << parent_key_system.c_str() << "' already registered.";
+        << "Parent '" << parent_key_system << "' already registered";
     parent_key_system_map_[parent_key_system] = concrete_key_system;
   }
 }
 
-void KeySystems::AddSupportedType(const std::string& concrete_key_system,
-                                  const std::string& mime_type,
-                                  const std::string& codecs_list) {
+void KeySystems::AddSupportedType(const std::string& mime_type,
+                                  const std::string& codecs_list,
+                                  KeySystemProperties* properties) {
   std::vector<std::string> mime_type_codecs;
   net::ParseCodecString(codecs_list, &mime_type_codecs, false);
 
   CodecSet codecs(mime_type_codecs.begin(), mime_type_codecs.end());
   // Support the MIME type string alone, without codec(s) specified.
   codecs.insert(std::string());
 
-  KeySystemPropertiesMap::iterator key_system_iter =
-      concrete_key_system_map_.find(concrete_key_system);
-  DCHECK(key_system_iter != concrete_key_system_map_.end());
-  MimeTypeMap& mime_types_map = key_system_iter->second.types;
+  MimeTypeMap& mime_types_map = properties->types;
   // mime_types_map must not be repeated for a given key system.
   DCHECK(mime_types_map.find(mime_type) == mime_types_map.end());
   mime_types_map[mime_type] = codecs;
 }
 
 bool KeySystems::IsConcreteSupportedKeySystem(const std::string& key_system) {
   return concrete_key_system_map_.find(key_system) !=
       concrete_key_system_map_.end();
 }
 
@@ skipping 81 matching lines @@
       DLOG(FATAL) << concrete_key_system << " is not a known concrete system";
       return std::vector<uint8>();
   }
 
   return key_system_iter->second.uuid;
 }
 #endif
 
 //------------------------------------------------------------------------------
 
-void AddConcreteSupportedKeySystem(
-    const std::string& key_system,
-    bool use_aes_decryptor,
-#if defined(ENABLE_PEPPER_CDMS)
-    const std::string& pepper_type,
-#elif defined(OS_ANDROID)
-    const uint8 uuid[16],
-#endif
-    const std::string& parent_key_system) {
-  KeySystems::GetInstance()->AddConcreteSupportedKeySystem(key_system,
-                                                           use_aes_decryptor,
-#if defined(ENABLE_PEPPER_CDMS)
-                                                           pepper_type,
-#elif defined(OS_ANDROID)
-                                                           uuid,
-#endif
-                                                           parent_key_system);
-}
-
-void AddSupportedType(const std::string& key_system,
-                      const std::string& mime_type,
-                      const std::string& codecs_list) {
-  KeySystems::GetInstance()->AddSupportedType(key_system,
-                                              mime_type, codecs_list);
-}
-
 bool IsConcreteSupportedKeySystem(const WebKit::WebString& key_system) {
-  return KeySystems::GetInstance()->IsConcreteSupportedKeySystem(
+  return KeySystems::GetInstance().IsConcreteSupportedKeySystem(
       ToASCIIOrEmpty(key_system));
 }
 
 bool IsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system) {
-  return KeySystems::GetInstance()->IsSupportedKeySystemWithMediaMimeType(
+  return KeySystems::GetInstance().IsSupportedKeySystemWithMediaMimeType(
       mime_type, codecs, key_system);
 }
 
 std::string KeySystemNameForUMA(const WebKit::WebString& key_system) {
   return KeySystemNameForUMAInternal(key_system);
 }
 
 bool CanUseAesDecryptor(const std::string& concrete_key_system) {
-  return KeySystems::GetInstance()->UseAesDecryptor(concrete_key_system);
+  return KeySystems::GetInstance().UseAesDecryptor(concrete_key_system);
 }
 
 #if defined(ENABLE_PEPPER_CDMS)
 std::string GetPepperType(const std::string& concrete_key_system) {
-  return KeySystems::GetInstance()->GetPepperType(concrete_key_system);
+  return KeySystems::GetInstance().GetPepperType(concrete_key_system);
 }
 #elif defined(OS_ANDROID)
 std::vector<uint8> GetUUID(const std::string& concrete_key_system) {
-  return KeySystems::GetInstance()->GetUUID(concrete_key_system);
+  return KeySystems::GetInstance().GetUUID(concrete_key_system);
 }
 #endif
 
 }  // namespace content