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

content/renderer/media/crypto/key_systems.cc

Index: content/renderer/media/crypto/key_systems.cc
diff --git a/content/renderer/media/crypto/key_systems.cc b/content/renderer/media/crypto/key_systems.cc
index c11d19e3fc3179ed1464f328a539b6a7e256e823..0b882c482b439e7a5a939aed7accbbc2bb31b485 100644
--- a/content/renderer/media/crypto/key_systems.cc
+++ b/content/renderer/media/crypto/key_systems.cc
@@ -58,8 +58,8 @@ class KeySystems {
  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) {}
@@ -70,12 +70,12 @@ class KeySystems {
 #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() {}
 
@@ -85,11 +85,11 @@ class KeySystems {
       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);
 };
@@ -107,9 +107,8 @@ KeySystems* KeySystems::GetInstance() {
   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,
@@ -117,8 +116,8 @@ void KeySystems::AddConcreteSupportedKeySystem(
     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;
@@ -128,55 +127,55 @@ void KeySystems::AddConcreteSupportedKeySystem(
 #elif defined(OS_ANDROID)
   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());

[xhwang, 2013/08/29 23:16:19]

indent

[ddorwin, 2013/08/30 21:47:43]

Done.

   // 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());
 }
 
@@ -187,7 +186,7 @@ bool KeySystems::IsSupportedKeySystemWithMediaMimeType(
   // 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;
@@ -215,18 +214,18 @@ bool KeySystems::IsSupportedKeySystemWithMediaMimeType(
 }
 
 bool KeySystems::UseAesDecryptor(const std::string& concrete_key_system) {
-  KeySystemMappings::iterator key_system_iter =
-      key_system_map_.find(concrete_key_system);
-  DCHECK(key_system_iter != key_system_map_.end())
+  KeySystemPropertiesMap::iterator key_system_iter =
+      concrete_key_system_map_.find(concrete_key_system);
+  DCHECK(key_system_iter != concrete_key_system_map_.end())
       << concrete_key_system << " is not a known concrete system";
   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);
-  DCHECK(key_system_iter != key_system_map_.end())
+  KeySystemPropertiesMap::iterator key_system_iter =
+      concrete_key_system_map_.find(concrete_key_system);
+  DCHECK(key_system_iter != concrete_key_system_map_.end())
       << concrete_key_system << " is not a known concrete system";
   const std::string& type = key_system_iter->second.pepper_type;
   DCHECK(!type.empty()) << concrete_key_system << " is not Pepper-based";
@@ -234,9 +233,9 @@ std::string KeySystems::GetPepperType(const std::string& concrete_key_system) {
 }
 #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);
-  DCHECK(key_system_iter != key_system_map_.end())
+  KeySystemPropertiesMap::iterator key_system_iter =
+      concrete_key_system_map_.find(concrete_key_system);
+  DCHECK(key_system_iter != concrete_key_system_map_.end())
       << concrete_key_system << " is not a known concrete system";
   return key_system_iter->second.uuid;
 }