Address deferred comments from https://codereview.chromium.org/23464005/

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"
@@ skipping 40 matching lines @@
 
 #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:
   friend struct base::DefaultLazyInstanceTraits<KeySystems>;
 
-  typedef base::hash_set<std::string> CodecMappings;
-  typedef std::map<std::string, CodecMappings> MimeTypeMappings;
+  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
-    MimeTypeMappings types;
+    MimeTypeMap types;
   };
 
-  typedef std::map<std::string, KeySystemProperties> KeySystemMappings;
+  typedef std::map<std::string, KeySystemProperties> KeySystemPropertiesMap;
 
-  typedef std::map<std::string, std::string> ParentKeySystemMappings;
+  typedef std::map<std::string, std::string> ParentKeySystemMap;
 
   KeySystems() {}
 
   bool IsSupportedKeySystemWithContainerAndCodec(
       const std::string& mime_type,
       const std::string& codec,
       const std::string& key_system);
 
   // Map from key system string to capabilities.
-  KeySystemMappings key_system_map_;
+  KeySystemPropertiesMap concrete_key_system_map_;
 
   // Map from parent key system to the concrete key system that should be used
   // to represent its capabilities.
-  ParentKeySystemMappings parent_key_system_map_;
+  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();
   }
   return key_systems;
 }
 
-// TODO(ddorwin): Change first parameter to |concrete_key_system|.
 void KeySystems::AddConcreteSupportedKeySystem(
-    const std::string& key_system,
+    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],
 #endif
     const std::string& parent_key_system) {
-  DCHECK(!IsConcreteSupportedKeySystem(key_system))
-      << "Key system '" << key_system << "' already registered";
+  DCHECK(!IsConcreteSupportedKeySystem(concrete_key_system))
+      << "Key system '" << concrete_key_system << "' already registered";
 
   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);
 #endif
-  key_system_map_[key_system] = properties;
+  concrete_key_system_map_[concrete_key_system] = properties;
 
   if (!parent_key_system.empty()) {
     DCHECK(parent_key_system_map_.find(parent_key_system) ==
            parent_key_system_map_.end())
         << "Parent '" << parent_key_system.c_str() << "' already registered.";
-    parent_key_system_map_[parent_key_system] = key_system;
+    parent_key_system_map_[parent_key_system] = concrete_key_system;
   }
 }
 
-// TODO(ddorwin): Change first parameter to |concrete_key_system|.
-void KeySystems::AddSupportedType(const std::string& key_system,
+void KeySystems::AddSupportedType(const std::string& concrete_key_system,
                                   const std::string& mime_type,
                                   const std::string& codecs_list) {
   std::vector<std::string> mime_type_codecs;
   net::ParseCodecString(codecs_list, &mime_type_codecs, false);
 
-  CodecMappings codecs(mime_type_codecs.begin(), mime_type_codecs.end());
+  CodecSet codecs(mime_type_codecs.begin(), mime_type_codecs.end());
   // Support the MIME type string alone, without codec(s) specified.
   codecs.insert(std::string());
 
-  KeySystemMappings::iterator key_system_iter =
-      key_system_map_.find(key_system);
-  DCHECK(key_system_iter != key_system_map_.end());
-  MimeTypeMappings& mime_types_map = key_system_iter->second.types;
+  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;
   // 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 key_system_map_.find(key_system) != key_system_map_.end();
+  return concrete_key_system_map_.find(key_system) !=
+      concrete_key_system_map_.end();
 }
 
 bool KeySystems::IsSupportedKeySystemWithContainerAndCodec(
     const std::string& mime_type,
     const std::string& codec,
     const std::string& key_system) {
-  KeySystemMappings::const_iterator key_system_iter =
-      key_system_map_.find(key_system);
-  if (key_system_iter == key_system_map_.end())
+  KeySystemPropertiesMap::const_iterator key_system_iter =
+      concrete_key_system_map_.find(key_system);
+  if (key_system_iter == concrete_key_system_map_.end())
     return false;
 
-  const MimeTypeMappings& mime_types_map = key_system_iter->second.types;
-  MimeTypeMappings::const_iterator mime_iter = mime_types_map.find(mime_type);
+  const MimeTypeMap& mime_types_map = key_system_iter->second.types;
+  MimeTypeMap::const_iterator mime_iter = mime_types_map.find(mime_type);
   if (mime_iter == mime_types_map.end())
     return false;
 
-  const CodecMappings& codecs = mime_iter->second;
+  const CodecSet& codecs = mime_iter->second;
   return (codecs.find(codec) != codecs.end());
 }
 
 bool KeySystems::IsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system) {
   // If |key_system| is a parent key_system, use its concrete child.
   // Otherwise, use |key_system|.
   std::string concrete_key_system;
-  ParentKeySystemMappings::iterator parent_key_system_iter =
+  ParentKeySystemMap::iterator parent_key_system_iter =
       parent_key_system_map_.find(key_system);
   if (parent_key_system_iter != parent_key_system_map_.end())
     concrete_key_system = parent_key_system_iter->second;
   else
     concrete_key_system = key_system;
 
   // This method is only used by the canPlaytType() path (not the EME methods),
   // so we check for suppressed key_systems here.
   if(IsCanPlayTypeSuppressed(concrete_key_system))
     return false;
 
   if (codecs.empty()) {
     return IsSupportedKeySystemWithContainerAndCodec(
         mime_type, std::string(), concrete_key_system);
   }
 
   for (size_t i = 0; i < codecs.size(); ++i) {
     if (!IsSupportedKeySystemWithContainerAndCodec(
             mime_type, codecs[i], concrete_key_system)) {
       return false;
     }
   }
 
   return true;
 }
 
 bool KeySystems::UseAesDecryptor(const std::string& concrete_key_system) {
-  KeySystemMappings::iterator key_system_iter =
-      key_system_map_.find(concrete_key_system);
-  if (key_system_iter == key_system_map_.end()) {
+  KeySystemPropertiesMap::iterator key_system_iter =
+      concrete_key_system_map_.find(concrete_key_system);
+  if (key_system_iter == concrete_key_system_map_.end()) {
       DLOG(FATAL) << concrete_key_system << " is not a known concrete system";
       return false;
   }
 
   return key_system_iter->second.use_aes_decryptor;
 }
 
 #if defined(ENABLE_PEPPER_CDMS)
 std::string KeySystems::GetPepperType(const std::string& concrete_key_system) {
-  KeySystemMappings::iterator key_system_iter =
-      key_system_map_.find(concrete_key_system);
-  if (key_system_iter == key_system_map_.end()) {
+  KeySystemPropertiesMap::iterator key_system_iter =
+      concrete_key_system_map_.find(concrete_key_system);
+  if (key_system_iter == concrete_key_system_map_.end()) {
       DLOG(FATAL) << concrete_key_system << " is not a known concrete system";
       return std::string();
   }
 
   const std::string& type = key_system_iter->second.pepper_type;
   DLOG_IF(FATAL, type.empty()) << concrete_key_system << " is not Pepper-based";
   return type;
 }
 #elif defined(OS_ANDROID)
 std::vector<uint8> KeySystems::GetUUID(const std::string& concrete_key_system) {
-  KeySystemMappings::iterator key_system_iter =
-      key_system_map_.find(concrete_key_system);
-  if (key_system_iter == key_system_map_.end()) {
+  KeySystemPropertiesMap::iterator key_system_iter =
+      concrete_key_system_map_.find(concrete_key_system);
+  if (key_system_iter == concrete_key_system_map_.end()) {
       DLOG(FATAL) << concrete_key_system << " is not a known concrete system";
       return std::vector<uint8>();
   }
 
   return key_system_iter->second.uuid;
 }
 #endif
 
 //------------------------------------------------------------------------------
 
@@ skipping 48 matching lines @@
 std::string GetPepperType(const std::string& 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);
 }
 #endif
 
 }  // namespace content