Create an interface for KeySystems, migrate WebEncryptedMediaClientImpl.

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 122 matching lines @@
 // True is always returned for a |key_system| that begins with "x-".
 //
 // As with other web platform features, advertising support for a key system
 // implies that it adheres to a defined and interoperable specification.
 //
 // To ensure interoperability, implementations of a specific |key_system| string
 // must conform to a specification for that identifier that defines
 // key system-specific behaviors not fully defined by the EME specification.
 // That specification should be provided by the owner of the domain that is the
 // reverse of the |key_system| string.
-// This involves more than calling a library, SDK, or platform API. KeySystems
-// must be populated appropriately, and there will likely be glue code to adapt
-// to the API of the library, SDK, or platform API.
+// This involves more than calling a library, SDK, or platform API.
+// KeySystemsImpl must be populated appropriately, and there will likely be glue
+// code to adapt to the API of the library, SDK, or platform API.
 //
 // Chromium mainline contains this data and glue code for specific key systems,
 // which should help ensure interoperability with other implementations using
 // these key systems.
 //
 // If you need to add support for other key systems, ensure that you have
 // obtained the specification for how to integrate it with EME, implemented the
 // appropriate glue/adapter code, and added all the appropriate data to
-// KeySystems. Only then should you change this function.
+// KeySystemsImpl. Only then should you change this function.
 static bool IsPotentiallySupportedKeySystem(const std::string& key_system) {
   // Known and supported key systems.
   if (key_system == kWidevineKeySystem)
     return true;
   if (key_system == kClearKey)
     return true;
 
   // External Clear Key is known and supports suffixes for testing.
   if (IsExternalClearKey(key_system))
     return true;
 
   // Chromecast defines behaviors for Cast clients within its reverse domain.
   const char kChromecastRoot[] = "com.chromecast";
   if (IsParentKeySystemOf(kChromecastRoot, key_system))
     return true;
 
   // Implementations that do not have a specification or appropriate glue code
   // can use the "x-" prefix to avoid conflicting with and advertising support
   // for real key system names. Use is discouraged.
   const char kExcludedPrefix[] = "x-";
   if (key_system.find(kExcludedPrefix, 0, arraysize(kExcludedPrefix) - 1) == 0)
     return true;
 
   return false;
 }
 
-class KeySystems {
+class KeySystemsImpl : public KeySystems {
  public:
-  static KeySystems& GetInstance();
+  static KeySystemsImpl& GetInstance();
 
   void UpdateIfNeeded();
 
-  bool IsConcreteSupportedKeySystem(const std::string& key_system);
-
-  bool IsSupportedKeySystem(const std::string& key_system);
+  bool IsConcreteSupportedKeySystem(const std::string& key_system) const;
 
   bool IsSupportedKeySystemWithInitDataType(
       const std::string& key_system,
-      const std::string& init_data_type);
+      const std::string& init_data_type) const;
+
+  bool PrefixedIsSupportedKeySystemWithMediaMimeType(
+      const std::string& mime_type,
+      const std::vector<std::string>& codecs,
+      const std::string& key_system);
 
   bool IsSupportedKeySystemWithMediaMimeType(
       const std::string& mime_type,
       const std::vector<std::string>& codecs,
-      const std::string& key_system,
-      bool is_prefixed);
+      const std::string& key_system) const;
 
   std::string GetKeySystemNameForUMA(const std::string& key_system) const;
 
-  bool UseAesDecryptor(const std::string& concrete_key_system);
+  bool UseAesDecryptor(const std::string& concrete_key_system) const;
 
 #if defined(ENABLE_PEPPER_CDMS)
-  std::string GetPepperType(const std::string& concrete_key_system);
+  std::string GetPepperType(const std::string& concrete_key_system) const;
 #endif
 
+  void AddContainerMask(const std::string& container, uint32 mask);
+  void AddCodecMask(const std::string& codec, uint32 mask);
+
+  // Implementation of KeySystems interface.
+  bool IsSupportedKeySystem(const std::string& key_system) const override;
+
+  bool IsSupportedCodecCombination(
+      const std::string& key_system,
+      EmeMediaType media_type,
+      const std::string& container_mime_type,
+      const std::vector<std::string>& codecs) const override;
+
   EmeConfigRule GetRobustnessConfigRule(
       const std::string& key_system,
       EmeMediaType media_type,
-      EmeRobustness robustness);
+      EmeRobustness robustness) const override;
 
   EmeConfigRule GetPersistentLicenseSessionConfigRule(
-      const std::string& key_system);
+      const std::string& key_system) const override;
 
   EmeConfigRule GetPersistentReleaseMessageSessionConfigRule(
-      const std::string& key_system);
+      const std::string& key_system) const override;
 
   EmeConfigRule GetPersistentStateConfigRule(
       const std::string& key_system,
-      EmeFeatureRequirement requirement);
+      EmeFeatureRequirement requirement) const override;
 
   EmeConfigRule GetDistinctiveIdentifierConfigRule(
       const std::string& key_system,
-      EmeFeatureRequirement requirement);
-
-  void AddContainerMask(const std::string& container, uint32 mask);
-  void AddCodecMask(const std::string& codec, uint32 mask);
+      EmeFeatureRequirement requirement) const override;
 
  private:
   void InitializeUMAInfo();
 
   void UpdateSupportedKeySystems();
 
   void AddConcreteSupportedKeySystems(
       const std::vector<KeySystemInfo>& concrete_key_systems);
 
-  friend struct base::DefaultLazyInstanceTraits<KeySystems>;
+  friend struct base::DefaultLazyInstanceTraits<KeySystemsImpl>;
 
   typedef base::hash_map<std::string, KeySystemInfo> KeySystemInfoMap;
   typedef base::hash_map<std::string, std::string> ParentKeySystemMap;
   typedef base::hash_map<std::string, SupportedCodecs> ContainerCodecsMap;
   typedef base::hash_map<std::string, EmeCodec> CodecsMap;
   typedef base::hash_map<std::string, EmeInitDataType> InitDataTypesMap;
   typedef base::hash_map<std::string, std::string> KeySystemNameForUMAMap;
 
-  KeySystems();
-  ~KeySystems() {}
+  KeySystemsImpl();
+  ~KeySystemsImpl() {}
 
   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& PrefixedGetConcreteKeySystemNameFor(
@@ skipping 22 matching lines @@
   KeySystemsSupportUMA key_systems_support_uma_;
 
   InitDataTypesMap init_data_type_name_map_;
   ContainerCodecsMap container_to_codec_mask_map_;
   CodecsMap codec_string_map_;
   KeySystemNameForUMAMap key_system_name_for_uma_map_;
 
   // Makes sure all methods are called from the same thread.
   base::ThreadChecker thread_checker_;
 
-  DISALLOW_COPY_AND_ASSIGN(KeySystems);
+  DISALLOW_COPY_AND_ASSIGN(KeySystemsImpl);
 };
 
-static base::LazyInstance<KeySystems> g_key_systems = LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<KeySystemsImpl> g_key_systems =
+    LAZY_INSTANCE_INITIALIZER;
 
-KeySystems& KeySystems::GetInstance() {
-  KeySystems& key_systems = g_key_systems.Get();
+KeySystemsImpl& KeySystemsImpl::GetInstance() {
+  KeySystemsImpl& key_systems = g_key_systems.Get();
   key_systems.UpdateIfNeeded();
   return key_systems;
 }
 
 // Because we use a LazyInstance, the key systems info must be populated when
 // the instance is lazily initiated.
-KeySystems::KeySystems() {
+KeySystemsImpl::KeySystemsImpl() {
   for (size_t i = 0; i < arraysize(kInitDataTypeNames); ++i) {
     const std::string& name = kInitDataTypeNames[i].name;
     DCHECK(!init_data_type_name_map_.count(name));
     init_data_type_name_map_[name] = kInitDataTypeNames[i].type;
   }
   for (size_t i = 0; i < arraysize(kContainerToCodecMasks); ++i) {
     const std::string& name = kContainerToCodecMasks[i].name;
     DCHECK(!container_to_codec_mask_map_.count(name));
     container_to_codec_mask_map_[name] = kContainerToCodecMasks[i].type;
   }
   for (size_t i = 0; i < arraysize(kCodecStrings); ++i) {
     const std::string& name = kCodecStrings[i].name;
     DCHECK(!codec_string_map_.count(name));
     codec_string_map_[name] = kCodecStrings[i].type;
   }
 
   InitializeUMAInfo();
 
   // Always update supported key systems during construction.
   UpdateSupportedKeySystems();
 }
 
-EmeInitDataType KeySystems::GetInitDataTypeForName(
+EmeInitDataType KeySystemsImpl::GetInitDataTypeForName(
     const std::string& init_data_type) const {
   InitDataTypesMap::const_iterator iter =
       init_data_type_name_map_.find(init_data_type);
   if (iter != init_data_type_name_map_.end())
     return iter->second;
   return EME_INIT_DATA_TYPE_NONE;
 }
 
-SupportedCodecs KeySystems::GetCodecMaskForContainer(
+SupportedCodecs KeySystemsImpl::GetCodecMaskForContainer(
     const std::string& container) const {
   ContainerCodecsMap::const_iterator iter =
       container_to_codec_mask_map_.find(container);
   if (iter != container_to_codec_mask_map_.end())
     return iter->second;
   return EME_CODEC_NONE;
 }
 
-EmeCodec KeySystems::GetCodecForString(const std::string& codec) const {
+EmeCodec KeySystemsImpl::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::PrefixedGetConcreteKeySystemNameFor(
+const std::string& KeySystemsImpl::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() {
+void KeySystemsImpl::InitializeUMAInfo() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(key_system_name_for_uma_map_.empty());
 
   std::vector<KeySystemInfoForUMA> key_systems_info_for_uma;
   if (GetMediaClient())
     GetMediaClient()->AddKeySystemsInfoForUMA(&key_systems_info_for_uma);
 
   for (const KeySystemInfoForUMA& info : key_systems_info_for_uma) {
     key_system_name_for_uma_map_[info.key_system] =
         info.key_system_name_for_uma;
     if (info.reports_key_system_support_to_uma)
       key_systems_support_uma_.AddKeySystemToReport(info.key_system);
   }
 
   // Clear Key is always supported.
   key_system_name_for_uma_map_[kClearKeyKeySystem] =
       kClearKeyKeySystemNameForUMA;
 }
 
-void KeySystems::UpdateIfNeeded() {
+void KeySystemsImpl::UpdateIfNeeded() {
   if (GetMediaClient() && GetMediaClient()->IsKeySystemsUpdateNeeded())
     UpdateSupportedKeySystems();
 }
 
-void KeySystems::UpdateSupportedKeySystems() {
+void KeySystemsImpl::UpdateSupportedKeySystems() {
   DCHECK(thread_checker_.CalledOnValidThread());
   concrete_key_system_map_.clear();
   parent_key_system_map_.clear();
 
   // Build KeySystemInfo.
   std::vector<KeySystemInfo> key_systems_info;
 
   // Add key systems supported by the MediaClient implementation.
   if (GetMediaClient())
     GetMediaClient()->AddSupportedKeySystems(&key_systems_info);
 
   // Clear Key is always supported.
   AddClearKey(&key_systems_info);
 
   AddConcreteSupportedKeySystems(key_systems_info);
 }
 
-void KeySystems::AddConcreteSupportedKeySystems(
+void KeySystemsImpl::AddConcreteSupportedKeySystems(
     const std::vector<KeySystemInfo>& concrete_key_systems) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(concrete_key_system_map_.empty());
   DCHECK(parent_key_system_map_.empty());
 
   for (const KeySystemInfo& info : concrete_key_systems) {
     DCHECK(!info.key_system.empty());
     DCHECK(info.max_audio_robustness != EmeRobustness::INVALID);
     DCHECK(info.max_video_robustness != EmeRobustness::INVALID);
     DCHECK(info.persistent_license_support != EME_SESSION_TYPE_INVALID);
@@ skipping 63 matching lines @@
       DCHECK(!IsConcreteSupportedKeySystem(info.parent_key_system))
           << "Parent '" << info.parent_key_system << "' "
           << "already registered concrete";
       DCHECK(!parent_key_system_map_.count(info.parent_key_system))
           << "Parent '" << info.parent_key_system << "' already registered";
       parent_key_system_map_[info.parent_key_system] = info.key_system;
     }
   }
 }
 
-bool KeySystems::IsConcreteSupportedKeySystem(const std::string& key_system) {
+bool KeySystemsImpl::IsConcreteSupportedKeySystem(
+    const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return concrete_key_system_map_.count(key_system) != 0;
 }
 
-bool KeySystems::IsSupportedContainer(
+bool KeySystemsImpl::IsSupportedContainer(
     const std::string& container,
     SupportedCodecs key_system_supported_codecs) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!container.empty());
 
   // When checking container support for EME, "audio/foo" should be treated the
   // same as "video/foo". Convert the |container| to achieve this.
   // TODO(xhwang): Replace this with real checks against supported initDataTypes
   // combined with supported demuxers.
   std::string canonical_container = container;
   if (container.find("audio/") == 0)
     canonical_container.replace(0, 6, "video/");
 
   // A container is supported iif at least one codec in that container is
   // supported.
   SupportedCodecs supported_codecs =
       GetCodecMaskForContainer(canonical_container);
   return (supported_codecs & key_system_supported_codecs) != 0;
 }
 
-bool KeySystems::IsSupportedContainerAndCodecs(
+bool KeySystemsImpl::IsSupportedContainerAndCodecs(
     const std::string& container,
     const std::vector<std::string>& codecs,
     SupportedCodecs key_system_supported_codecs) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!container.empty());
   DCHECK(!codecs.empty());
   DCHECK(IsSupportedContainer(container, key_system_supported_codecs));
 
   SupportedCodecs container_supported_codecs =
       GetCodecMaskForContainer(container);
@@ skipping 11 matching lines @@
       return false;
 
     // 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());
-  // Unprefixed EME only supports concrete key systems.
-  return concrete_key_system_map_.count(key_system) != 0;
-}
-
-bool KeySystems::IsSupportedKeySystemWithInitDataType(
+bool KeySystemsImpl::IsSupportedKeySystemWithInitDataType(
     const std::string& key_system,
-    const std::string& init_data_type) {
+    const std::string& init_data_type) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Locate |key_system|. Only concrete key systems are supported in unprefixed.
   KeySystemInfoMap::const_iterator key_system_iter =
       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 KeySystemInfo& info = key_system_iter->second;
   EmeInitDataType eme_init_data_type = GetInitDataTypeForName(init_data_type);
   return (info.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(
+bool KeySystemsImpl::PrefixedIsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
-    const std::string& key_system,
-    bool is_prefixed) {
+    const std::string& key_system) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  const bool report_to_uma = is_prefixed;
 
-  // 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;
+  const std::string& concrete_key_system =
+      PrefixedGetConcreteKeySystemNameFor(key_system);
 
   bool has_type = !mime_type.empty();
 
-  if (report_to_uma)
-    key_systems_support_uma_.ReportKeySystemQuery(key_system, has_type);
+  key_systems_support_uma_.ReportKeySystemQuery(key_system, has_type);
 
   // Check key system support.
   KeySystemInfoMap::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 (report_to_uma)
-    key_systems_support_uma_.ReportKeySystemSupport(key_system, false);
+  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 (report_to_uma)
-    key_systems_support_uma_.ReportKeySystemSupport(key_system, true);
+  key_systems_support_uma_.ReportKeySystemSupport(key_system, true);
+
   return true;
 }
 
-std::string KeySystems::GetKeySystemNameForUMA(
+bool KeySystemsImpl::IsSupportedKeySystemWithMediaMimeType(
+    const std::string& mime_type,
+    const std::vector<std::string>& codecs,
     const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  KeySystemInfoMap::const_iterator key_system_iter =
+      concrete_key_system_map_.find(key_system);
+  if (key_system_iter == concrete_key_system_map_.end())
+    return false;
+
+  if (mime_type.empty()) {
+    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;
+  }
+
+  return true;
+}
+
+std::string KeySystemsImpl::GetKeySystemNameForUMA(
+    const std::string& key_system) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   KeySystemNameForUMAMap::const_iterator iter =
       key_system_name_for_uma_map_.find(key_system);
   if (iter == key_system_name_for_uma_map_.end())
     return kUnknownKeySystemNameForUMA;
 
   return iter->second;
 }
 
-bool KeySystems::UseAesDecryptor(const std::string& concrete_key_system) {
+bool KeySystemsImpl::UseAesDecryptor(
+    const std::string& concrete_key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemInfoMap::const_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) {
+std::string KeySystemsImpl::GetPepperType(
+    const std::string& concrete_key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemInfoMap::const_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;
 }
 #endif
 
-EmeConfigRule KeySystems::GetRobustnessConfigRule(
+void KeySystemsImpl::AddContainerMask(const std::string& container,
+                                      uint32 mask) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!container_to_codec_mask_map_.count(container));
+  container_to_codec_mask_map_[container] = static_cast<EmeCodec>(mask);
+}
+
+void KeySystemsImpl::AddCodecMask(const std::string& codec, uint32 mask) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!codec_string_map_.count(codec));
+  codec_string_map_[codec] = static_cast<EmeCodec>(mask);
+}
+
+bool KeySystemsImpl::IsSupportedKeySystem(const std::string& key_system) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return concrete_key_system_map_.count(key_system) != 0;
+}
+
+// TODO(sandersd): Make sure that the codecs also match the |media_type|.

[ddorwin, 2015/03/23 17:22:14]

Addressed now?

[sandersd (OOO until July 31), 2015/03/23 22:27:59]

No, this only covers the container, not the codecs yet.

+// http://crbug.com/457386
+bool KeySystemsImpl::IsSupportedCodecCombination(
     const std::string& key_system,
     EmeMediaType media_type,
-    EmeRobustness robustness) {
+    const std::string& container_mime_type,
+    const std::vector<std::string>& codecs) const {
+  // Make sure the container matches |media_type|.
+  switch (media_type) {
+    case EmeMediaType::AUDIO:
+      if (!StartsWithASCII(container_mime_type, "audio/", true))
+        return false;
+      break;
+    case EmeMediaType::VIDEO:
+      if (!StartsWithASCII(container_mime_type, "video/", true))
+        return false;
+      break;
+  }
+  return IsSupportedKeySystemWithMediaMimeType(
+      container_mime_type, codecs, key_system);
+}
+
+EmeConfigRule KeySystemsImpl::GetRobustnessConfigRule(
+    const std::string& key_system,
+    EmeMediaType media_type,
+    EmeRobustness robustness) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (robustness == EmeRobustness::INVALID)
     return EmeConfigRule::NOT_SUPPORTED;
   if (robustness == EmeRobustness::EMPTY)
     return EmeConfigRule::SUPPORTED;
 
   KeySystemInfoMap::const_iterator key_system_iter =
       concrete_key_system_map_.find(key_system);
   if (key_system_iter == concrete_key_system_map_.end()) {
@@ skipping 35 matching lines @@
     if (media_type == EmeMediaType::VIDEO &&
         max_robustness == EmeRobustness::HW_SECURE_ALL) {
       return EmeConfigRule::IDENTIFIER_RECOMMENDED;
     }
   }
 #endif  // defined(OS_CHROMEOS)
 
   return EmeConfigRule::SUPPORTED;
 }
 
-EmeConfigRule KeySystems::GetPersistentLicenseSessionConfigRule(
-    const std::string& key_system) {
+EmeConfigRule KeySystemsImpl::GetPersistentLicenseSessionConfigRule(
+    const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemInfoMap::const_iterator key_system_iter =
       concrete_key_system_map_.find(key_system);
   if (key_system_iter == concrete_key_system_map_.end()) {
     NOTREACHED();
     return EmeConfigRule::NOT_SUPPORTED;
   }
   return ConvertSessionTypeSupport(
       key_system_iter->second.persistent_license_support);
 }
 
-EmeConfigRule KeySystems::GetPersistentReleaseMessageSessionConfigRule(
-    const std::string& key_system) {
+EmeConfigRule KeySystemsImpl::GetPersistentReleaseMessageSessionConfigRule(
+    const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemInfoMap::const_iterator key_system_iter =
       concrete_key_system_map_.find(key_system);
   if (key_system_iter == concrete_key_system_map_.end()) {
     NOTREACHED();
     return EmeConfigRule::NOT_SUPPORTED;
   }
   return ConvertSessionTypeSupport(
       key_system_iter->second.persistent_release_message_support);
 }
 
-EmeConfigRule KeySystems::GetPersistentStateConfigRule(
+EmeConfigRule KeySystemsImpl::GetPersistentStateConfigRule(
     const std::string& key_system,
-    EmeFeatureRequirement requirement) {
+    EmeFeatureRequirement requirement) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemInfoMap::const_iterator key_system_iter =
       concrete_key_system_map_.find(key_system);
   if (key_system_iter == concrete_key_system_map_.end()) {
     NOTREACHED();
     return EmeConfigRule::NOT_SUPPORTED;
   }
 
   // For NOT_ALLOWED and REQUIRED, the result is as expected. For OPTIONAL, we
@@ skipping 19 matching lines @@
       requirement == EME_FEATURE_NOT_ALLOWED) {
     return EmeConfigRule::NOT_SUPPORTED;
   }
   if (support == EME_FEATURE_REQUESTABLE_WITH_IDENTIFIER &&
       requirement == EME_FEATURE_REQUIRED) {
     return EmeConfigRule::IDENTIFIER_REQUIRED;
   }
   return EmeConfigRule::SUPPORTED;
 }
 
-EmeConfigRule KeySystems::GetDistinctiveIdentifierConfigRule(
+EmeConfigRule KeySystemsImpl::GetDistinctiveIdentifierConfigRule(
     const std::string& key_system,
-    EmeFeatureRequirement requirement) {
+    EmeFeatureRequirement requirement) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemInfoMap::const_iterator key_system_iter =
       concrete_key_system_map_.find(key_system);
   if (key_system_iter == concrete_key_system_map_.end()) {
     NOTREACHED();
     return EmeConfigRule::NOT_SUPPORTED;
   }
 
   // Permission is required for REQUIRED, but not for NOT_ALLOWED. For OPTIONAL,
@@ skipping 15 matching lines @@
       requirement == EME_FEATURE_NOT_ALLOWED) {
     return EmeConfigRule::NOT_SUPPORTED;
   }
   if (support == EME_FEATURE_ALWAYS_ENABLED ||
       requirement == EME_FEATURE_REQUIRED) {
     return EmeConfigRule::IDENTIFIER_REQUIRED;
   }
   return EmeConfigRule::SUPPORTED;
 }
 
-void KeySystems::AddContainerMask(const std::string& container, uint32 mask) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!container_to_codec_mask_map_.count(container));
-  container_to_codec_mask_map_[container] = static_cast<EmeCodec>(mask);
-}
-
-void KeySystems::AddCodecMask(const std::string& codec, uint32 mask) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!codec_string_map_.count(codec));
-  codec_string_map_[codec] = static_cast<EmeCodec>(mask);
+KeySystems& KeySystems::GetInstance() {
+  return KeySystemsImpl::GetInstance();
 }
 
 //------------------------------------------------------------------------------
 
 std::string GetUnprefixedKeySystemName(const std::string& key_system) {
   if (key_system == kClearKeyKeySystem)
     return kUnsupportedClearKeyKeySystem;
 
   if (key_system == kPrefixedClearKeyKeySystem)
     return kClearKeyKeySystem;
@@ skipping 16 matching lines @@
   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 PrefixedIsSupportedConcreteKeySystem(const std::string& key_system) {
-  return KeySystems::GetInstance().IsConcreteSupportedKeySystem(key_system);
+  return KeySystemsImpl::GetInstance().IsConcreteSupportedKeySystem(key_system);
 }
 
 bool IsSupportedKeySystem(const std::string& key_system) {
-  if (!KeySystems::GetInstance().IsSupportedKeySystem(key_system))
+  if (!KeySystemsImpl::GetInstance().IsSupportedKeySystem(key_system))
     return false;
 
   // TODO(ddorwin): Move this to where we add key systems when prefixed EME is
   // removed (crbug.com/249976).
   if (!IsPotentiallySupportedKeySystem(key_system)) {
     // If you encounter this path, see the comments for the above function.
     NOTREACHED() << "Unrecognized key system " << key_system
                  << ". See code comments.";
     return false;
   }
 
   return true;
 }
 
 bool IsSupportedKeySystemWithInitDataType(
     const std::string& key_system,
     const std::string& init_data_type) {
-  return KeySystems::GetInstance().IsSupportedKeySystemWithInitDataType(
+  return KeySystemsImpl::GetInstance().IsSupportedKeySystemWithInitDataType(
       key_system, init_data_type);
 }
 
 bool IsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system) {
-  return KeySystems::GetInstance().IsSupportedKeySystemWithMediaMimeType(
-      mime_type, codecs, key_system, false);
+  return KeySystemsImpl::GetInstance().IsSupportedKeySystemWithMediaMimeType(
+      mime_type, codecs, key_system);
 }
 
 bool PrefixedIsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system) {
-  return KeySystems::GetInstance().IsSupportedKeySystemWithMediaMimeType(
-      mime_type, codecs, key_system, true);
+  return KeySystemsImpl::GetInstance()
+      .PrefixedIsSupportedKeySystemWithMediaMimeType(mime_type, codecs,
+                                                     key_system);
 }
 
 std::string GetKeySystemNameForUMA(const std::string& key_system) {
-  return KeySystems::GetInstance().GetKeySystemNameForUMA(key_system);
+  return KeySystemsImpl::GetInstance().GetKeySystemNameForUMA(key_system);
 }
 
 bool CanUseAesDecryptor(const std::string& concrete_key_system) {
-  return KeySystems::GetInstance().UseAesDecryptor(concrete_key_system);
+  return KeySystemsImpl::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 KeySystemsImpl::GetInstance().GetPepperType(concrete_key_system);
 }
 #endif
 
-EmeConfigRule GetRobustnessConfigRule(
-    const std::string& key_system,
-    EmeMediaType media_type,
-    EmeRobustness robustness) {
-  return KeySystems::GetInstance().GetRobustnessConfigRule(
-      key_system, media_type, robustness);
-}
-
-EmeConfigRule GetPersistentLicenseSessionConfigRule(
-    const std::string& key_system) {
-  return KeySystems::GetInstance().GetPersistentLicenseSessionConfigRule(
-      key_system);
-}
-
-EmeConfigRule GetPersistentReleaseMessageSessionConfigRule(
-    const std::string& key_system) {
-  return KeySystems::GetInstance().GetPersistentReleaseMessageSessionConfigRule(
-      key_system);
-}
-
-EmeConfigRule GetPersistentStateConfigRule(
-    const std::string& key_system,
-    EmeFeatureRequirement requirement) {
-  return KeySystems::GetInstance().GetPersistentStateConfigRule(
-      key_system, requirement);
-}
-
-EmeConfigRule GetDistinctiveIdentifierConfigRule(
-    const std::string& key_system,
-    EmeFeatureRequirement requirement) {
-  return KeySystems::GetInstance().GetDistinctiveIdentifierConfigRule(
-      key_system, requirement);
-}
-
 // These two functions are for testing purpose only. The declaration in the
 // header file is guarded by "#if defined(UNIT_TEST)" so that they can be used
 // by tests but not non-test code. However, this .cc file is compiled as part of
 // "media" where "UNIT_TEST" is not defined. So we need to specify
 // "MEDIA_EXPORT" here again so that they are visible to tests.
 
 MEDIA_EXPORT void AddContainerMask(const std::string& container, uint32 mask) {
-  KeySystems::GetInstance().AddContainerMask(container, mask);
+  KeySystemsImpl::GetInstance().AddContainerMask(container, mask);
 }
 
 MEDIA_EXPORT void AddCodecMask(const std::string& codec, uint32 mask) {
-  KeySystems::GetInstance().AddCodecMask(codec, mask);
+  KeySystemsImpl::GetInstance().AddCodecMask(codec, mask);
 }
 
 }  // namespace media