Explicitly differentiate key system support functions by EME version.

media/base/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 "media/base/key_systems.h"
 
 #include <string>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
@@ skipping 103 matching lines @@
   bool IsSupportedKeySystem(const std::string& key_system);
 
   bool IsSupportedKeySystemWithInitDataType(
       const std::string& key_system,
       const std::string& init_data_type);
 
   bool IsSupportedKeySystemWithMediaMimeType(
       const std::string& mime_type,
       const std::vector<std::string>& codecs,
       const std::string& key_system,
-      bool reportToUma);
+      bool is_prefixed);
 
   std::string GetKeySystemNameForUMA(const std::string& key_system) const;
 
   bool UseAesDecryptor(const std::string& concrete_key_system);
 
 #if defined(ENABLE_PEPPER_CDMS)
   std::string GetPepperType(const std::string& concrete_key_system);
 #endif
 
   void AddContainerMask(const std::string& container, uint32 mask);
@@ skipping 43 matching lines @@
   ~KeySystems() {}
 
   EmeInitDataType GetInitDataTypeForName(
       const std::string& init_data_type) const;
   // TODO(sandersd): Separate container enum from codec mask value.
   // http://crbug.com/417440
   SupportedCodecs GetCodecMaskForContainer(
       const std::string& container) const;
   EmeCodec GetCodecForString(const std::string& codec) const;
 
-  const std::string& GetConcreteKeySystemName(
+  const std::string& PrefixedGetConcreteKeySystemNameFor(
       const std::string& key_system) const;
 
   // Returns whether a |container| type is supported by checking
   // |key_system_supported_codecs|.
   // TODO(xhwang): Update this to actually check initDataType support.
   bool IsSupportedContainer(const std::string& container,
                             SupportedCodecs key_system_supported_codecs) const;
 
   // Returns true if all |codecs| are supported in |container| by checking
   // |key_system_supported_codecs|.
@@ skipping 73 matching lines @@
   return EME_CODEC_NONE;
 }
 
 EmeCodec KeySystems::GetCodecForString(const std::string& codec) const {
   CodecsMap::const_iterator iter = codec_string_map_.find(codec);
   if (iter != codec_string_map_.end())
     return iter->second;
   return EME_CODEC_NONE;
 }
 
-const std::string& KeySystems::GetConcreteKeySystemName(
+const std::string& KeySystems::PrefixedGetConcreteKeySystemNameFor(
     const std::string& key_system) const {
   ParentKeySystemMap::const_iterator iter =
       parent_key_system_map_.find(key_system);
   if (iter != parent_key_system_map_.end())
     return iter->second;
   return key_system;
 }
 
 void KeySystems::InitializeUMAInfo() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 146 matching lines @@
     // Unsupported codec/container combination, e.g. "video/webm" and "avc1".
     if (!(codec & container_supported_codecs))
       return false;
   }
 
   return true;
 }
 
 bool KeySystems::IsSupportedKeySystem(const std::string& key_system) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return (concrete_key_system_map_.count(key_system) ||
-          parent_key_system_map_.count(key_system));
+  // Unprefixed EME only supports concrete key systems.
+  return concrete_key_system_map_.count(key_system) != 0;
 }
 
 bool KeySystems::IsSupportedKeySystemWithInitDataType(
     const std::string& key_system,
     const std::string& init_data_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // If |key_system| is a parent key system, use its concrete child.
-  const std::string& concrete_key_system = GetConcreteKeySystemName(key_system);
-
-  // Locate |concrete_key_system|.
+  // Locate |key_system|. Only concrete key systems are supported in unprefixed.
   KeySystemPropertiesMap::const_iterator key_system_iter =
-      concrete_key_system_map_.find(concrete_key_system);
+      concrete_key_system_map_.find(key_system);
   if (key_system_iter == concrete_key_system_map_.end())
     return false;
 
   // Check |init_data_type| and |key_system| x |init_data_type|.
   const KeySystemProperties& properties = key_system_iter->second;
   EmeInitDataType eme_init_data_type = GetInitDataTypeForName(init_data_type);
   return (properties.supported_init_data_types & eme_init_data_type) != 0;
 }
 
 // TODO(sandersd): Reorganize to be more similar to
 // IsKeySystemSupportedWithInitDataType(). Note that a fork may still be
 // required; http://crbug.com/417461.
 bool KeySystems::IsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system,
-    bool reportToUma) {
+    bool is_prefixed) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  const bool report_to_uma = is_prefixed;
 
-  // If |key_system| is a parent key system, use its concrete child.
-  const std::string& concrete_key_system = GetConcreteKeySystemName(key_system);
+  // If |is_prefixed| and |key_system| is a parent key system, use its concrete
+  // child.
+  const std::string& concrete_key_system = is_prefixed ?
+      PrefixedGetConcreteKeySystemNameFor(key_system) :
+      key_system;
 
   bool has_type = !mime_type.empty();
 
-  if (reportToUma)
+  if (report_to_uma)
     key_systems_support_uma_.ReportKeySystemQuery(key_system, has_type);
 
   // Check key system support.
   KeySystemPropertiesMap::const_iterator key_system_iter =
       concrete_key_system_map_.find(concrete_key_system);
   if (key_system_iter == concrete_key_system_map_.end())
     return false;
 
-  if (reportToUma)
+  if (report_to_uma)
     key_systems_support_uma_.ReportKeySystemSupport(key_system, false);
 
   if (!has_type) {
     DCHECK(codecs.empty());
     return true;
   }
 
   SupportedCodecs key_system_supported_codecs =
       key_system_iter->second.supported_codecs;
 
   if (!IsSupportedContainer(mime_type, key_system_supported_codecs))
     return false;
 
   if (!codecs.empty() &&
       !IsSupportedContainerAndCodecs(
           mime_type, codecs, key_system_supported_codecs)) {
     return false;
   }
 
-  if (reportToUma)
+  if (report_to_uma)
     key_systems_support_uma_.ReportKeySystemSupport(key_system, true);
   return true;
 }
 
 std::string KeySystems::GetKeySystemNameForUMA(
     const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemNameForUMAMap::const_iterator iter =
       key_system_name_for_uma_map_.find(key_system);
@@ skipping 71 matching lines @@
     const std::string& container) {
   if (init_data_type == "cenc") {
     return container == "audio/mp4" || container == "video/mp4";
   } else if (init_data_type == "webm") {
     return  container == "audio/webm" || container == "video/webm";
   } else {
     return true;
   }
 }
 
-bool IsConcreteSupportedKeySystem(const std::string& key_system) {
+bool PrefixedIsSupportedConcreteKeySystem(const std::string& key_system) {
   return KeySystems::GetInstance().IsConcreteSupportedKeySystem(key_system);
 }
 
 bool IsSupportedKeySystem(const std::string& key_system) {
   return KeySystems::GetInstance().IsSupportedKeySystem(key_system);
 }
 
 bool IsSupportedKeySystemWithInitDataType(
     const std::string& key_system,
     const std::string& init_data_type) {
@@ skipping 40 matching lines @@
 MEDIA_EXPORT void AddContainerMask(const std::string& container,
                                      uint32 mask) {
   KeySystems::GetInstance().AddContainerMask(container, mask);
 }
 
 MEDIA_EXPORT void AddCodecMask(const std::string& codec, uint32 mask) {
   KeySystems::GetInstance().AddCodecMask(codec, mask);
 }
 
 }  // namespace media