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 75b08ee8adfd50dc2b84c69c52953b42b33447c1..c828da0cc79b4e1bcfae965a846daca00a1858f8 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;
@@ -130,55 +129,55 @@ void KeySystems::AddConcreteSupportedKeySystem(
   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());
 }
 
@@ -189,7 +188,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;
@@ -217,9 +216,9 @@ bool KeySystems::IsSupportedKeySystemWithMediaMimeType(
 }
 
 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;
   }
@@ -229,9 +228,9 @@ bool KeySystems::UseAesDecryptor(const std::string& concrete_key_system) {
 
 #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();
   }
@@ -242,9 +241,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);
-  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>();
   }