Extract requestMediaKeySystemAccess() algorithm.

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 169 matching lines @@
   // 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 KeySystemsImpl : public KeySystems {
  public:
-  static KeySystemsImpl& GetInstance();
+  static KeySystemsImpl* GetInstance();
 
   void UpdateIfNeeded();
 
   bool IsConcreteSupportedKeySystem(const std::string& key_system) const;
 
   bool PrefixedIsSupportedKeySystemWithMediaMimeType(
       const std::string& mime_type,
       const std::vector<std::string>& codecs,
       const std::string& key_system);
 
@@ skipping 102 matching lines @@
 
   // Makes sure all methods are called from the same thread.
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(KeySystemsImpl);
 };
 
 static base::LazyInstance<KeySystemsImpl> g_key_systems =
     LAZY_INSTANCE_INITIALIZER;
 
-KeySystemsImpl& KeySystemsImpl::GetInstance() {
-  KeySystemsImpl& key_systems = g_key_systems.Get();
-  key_systems.UpdateIfNeeded();
+KeySystemsImpl* KeySystemsImpl::GetInstance() {
+  KeySystemsImpl* key_systems = g_key_systems.Pointer();
+  key_systems->UpdateIfNeeded();
   return key_systems;
 }
 
 // Because we use a LazyInstance, the key systems info must be populated when
 // the instance is lazily initiated.
 KeySystemsImpl::KeySystemsImpl() :
     audio_codec_mask_(EME_CODEC_AUDIO_ALL),
     video_codec_mask_(EME_CODEC_VIDEO_ALL) {
   for (size_t i = 0; i < arraysize(kContainerToCodecMasks); ++i) {
     const std::string& name = kContainerToCodecMasks[i].name;
@@ skipping 573 matching lines @@
              requirement == EME_FEATURE_OPTIONAL) {
     return EmeConfigRule::SUPPORTED;
   }
   if (support == EME_FEATURE_NOT_SUPPORTED ||
              requirement == EME_FEATURE_NOT_ALLOWED) {
     return EmeConfigRule::IDENTIFIER_NOT_ALLOWED;
   }
   return EmeConfigRule::IDENTIFIER_REQUIRED;
 }
 
-KeySystems& KeySystems::GetInstance() {
+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;
 
   return key_system;
 }
 
 std::string GetPrefixedKeySystemName(const std::string& key_system) {
   DCHECK_NE(key_system, kPrefixedClearKeyKeySystem);
 
   if (key_system == kClearKeyKeySystem)
     return kPrefixedClearKeyKeySystem;
 
   return key_system;
 }
 
 bool PrefixedIsSupportedConcreteKeySystem(const std::string& key_system) {
-  return KeySystemsImpl::GetInstance().IsConcreteSupportedKeySystem(key_system);
+  return KeySystemsImpl::GetInstance()->IsConcreteSupportedKeySystem(
+      key_system);
 }
 
 bool IsSupportedKeySystem(const std::string& key_system) {
-  if (!KeySystemsImpl::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,
                                           EmeInitDataType init_data_type) {
-  return KeySystemsImpl::GetInstance().IsSupportedInitDataType(key_system,
-                                                               init_data_type);
+  return KeySystemsImpl::GetInstance()->IsSupportedInitDataType(key_system,
+                                                                init_data_type);
 }
 
 bool PrefixedIsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system) {
   return KeySystemsImpl::GetInstance()
-      .PrefixedIsSupportedKeySystemWithMediaMimeType(mime_type, codecs,
-                                                     key_system);
+      ->PrefixedIsSupportedKeySystemWithMediaMimeType(mime_type, codecs,
+                                                      key_system);
 }
 
 std::string GetKeySystemNameForUMA(const std::string& key_system) {
-  return KeySystemsImpl::GetInstance().GetKeySystemNameForUMA(key_system);
+  return KeySystemsImpl::GetInstance()->GetKeySystemNameForUMA(key_system);
 }
 
 bool CanUseAesDecryptor(const std::string& concrete_key_system) {
-  return KeySystemsImpl::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 KeySystemsImpl::GetInstance().GetPepperType(concrete_key_system);
+  return KeySystemsImpl::GetInstance()->GetPepperType(concrete_key_system);
 }
 #endif
 
 // 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) {
-  KeySystemsImpl::GetInstance().AddContainerMask(container, mask);
+  KeySystemsImpl::GetInstance()->AddContainerMask(container, mask);
 }
 
 MEDIA_EXPORT void AddCodecMask(
     EmeMediaType media_type,
     const std::string& codec,
     uint32 mask) {
-  KeySystemsImpl::GetInstance().AddCodecMask(media_type, codec, mask);
+  KeySystemsImpl::GetInstance()->AddCodecMask(media_type, codec, mask);
 }
 
 }  // namespace media