Create an interface for KeySystems, migrate WebEncryptedMediaClientImpl.

media/base/key_systems.h

 // 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.
 
 #ifndef MEDIA_BASE_KEY_SYSTEMS_H_
 #define MEDIA_BASE_KEY_SYSTEMS_H_
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "media/base/eme_constants.h"
 #include "media/base/media_export.h"
 
 namespace media {
 
+class MEDIA_EXPORT KeySystems {
+ public:
+  static KeySystems& GetInstance();

[ddorwin, 2015/03/20 00:55:03]

const ref?

[sandersd (OOO until July 31), 2015/03/20 22:53:19]

No, we may need to provide access to methods that are not const. (In particular:
key system registration, UMAs, and test-related methods.) We can design around
it for unprefixed but it may not be worth the effort.

+
+  // Returns whether the list of codecs are supported together by |key_system|.
+  // TODO(sandersd): Return a rule instead of a bool so that codec selection can
+  // affect other configuration options (namely robustness).
+  virtual bool IsSupportedCodecCombination(
+      const std::string& key_system,
+      EmeMediaType media_type,
+      const std::string& container_mime_type,
+      const std::vector<std::string>& codecs) const = 0;
+
+  // Returns the configuration rule for supporting a robustness requirement.
+  virtual EmeConfigRule GetRobustnessConfigRule(
+      const std::string& key_system,
+      EmeMediaType media_type,
+      EmeRobustness robustness) const = 0;
+
+  // Returns the configuration rule for supporting persistent-license sessions.
+  virtual EmeConfigRule GetPersistentLicenseSessionConfigRule(
+      const std::string& key_system) const = 0;
+
+  // Returns the configuration rule for supporting persistent-release-message
+  // sessions.
+  virtual EmeConfigRule GetPersistentReleaseMessageSessionConfigRule(
+      const std::string& key_system) const = 0;
+
+  // Returns the configuration rule for supporting a persistent state
+  // requirement.
+  virtual EmeConfigRule GetPersistentStateConfigRule(
+      const std::string& key_system,
+      EmeFeatureRequirement requirement) const = 0;
+
+  // Returns the configuration rule for supporting a distinctive identifier
+  // requirement.
+  virtual EmeConfigRule GetDistinctiveIdentifierConfigRule(
+      const std::string& key_system,
+      EmeFeatureRequirement requirement) const = 0;
+};
+
 // Prefixed EME API only supports prefixed (webkit-) key system name for
 // certain key systems. But internally only unprefixed key systems are
 // supported. The following two functions help convert between prefixed and
 // unprefixed key system names.
 
 // Gets the unprefixed key system name for |key_system|.
 MEDIA_EXPORT std::string GetUnprefixedKeySystemName(
     const std::string& key_system);
 
 // Gets the prefixed key system name for |key_system|.
 MEDIA_EXPORT std::string GetPrefixedKeySystemName(
     const std::string& key_system);
 
 // Returns false if a container-specific |init_data_type| is specified with an
 // inappropriate container.
 // TODO(sandersd): Remove this essentially internal detail if the spec is
 // updated to not convolve the two in a single method call.
 // TODO(sandersd): Use enum values instead of strings. http://crbug.com/417440
 MEDIA_EXPORT bool IsSaneInitDataTypeWithContainer(
     const std::string& init_data_type,
     const std::string& container);
 
 // Use for unprefixed EME only!
 // Returns whether |key_system| is a supported key system.
 // Note: Shouldn't be used for prefixed API as the original
 // IsSupportedKeySystemWithMediaMimeType() path reports UMAs, but this path does
 // not.
 MEDIA_EXPORT bool IsSupportedKeySystem(const std::string& key_system);

[ddorwin, 2015/03/20 00:55:03]

re: The description: It would be good to at least move all the unprefixed
methods into the interface. That provides additional differentiation between
which to use.

[sandersd (OOO until July 31), 2015/03/20 22:53:19]

Agreed, I scoped this CL to avoid having to change too many files, but that's
the direction I am imagining.

 
 MEDIA_EXPORT bool IsSupportedKeySystemWithInitDataType(
     const std::string& key_system,
     const std::string& init_data_type);
 
 // Use for prefixed EME only!
 // Returns whether |key_system| is a real supported key system that can be
 // instantiated.
 // Abstract parent |key_system| strings will return false.
 // Call IsSupportedKeySystemWithMediaMimeType() to determine whether a
@@ skipping 23 matching lines @@
 // Returns whether AesDecryptor can be used for the given |concrete_key_system|.
 MEDIA_EXPORT bool CanUseAesDecryptor(const std::string& concrete_key_system);
 
 #if defined(ENABLE_PEPPER_CDMS)
 // Returns the Pepper MIME type for |concrete_key_system|.
 // Returns empty string if |concrete_key_system| is unknown or not Pepper-based.
 MEDIA_EXPORT std::string GetPepperType(
     const std::string& concrete_key_system);
 #endif
 
-// Returns the configuration rule for supporting a robustness requirement.
-// TODO(sandersd): Also take a list of codecs, as they may affect the result.
-MEDIA_EXPORT EmeConfigRule GetRobustnessConfigRule(
-    const std::string& key_system,
-    EmeMediaType media_type,
-    EmeRobustness robustness);
-
-// Returns the configuration rule for supporting persistent-license sessions.
-MEDIA_EXPORT EmeConfigRule GetPersistentLicenseSessionConfigRule(
-    const std::string& key_system);
-
-// Returns the configuration rule for supporting persistent-release-message
-// sessions.
-MEDIA_EXPORT EmeConfigRule GetPersistentReleaseMessageSessionConfigRule(
-    const std::string& key_system);
-
-// Returns the configuration rule for supporting a persistent state requirement.
-MEDIA_EXPORT EmeConfigRule GetPersistentStateConfigRule(
-    const std::string& key_system,
-    EmeFeatureRequirement requirement);
-
-// Returns the configuration rule for supporting a distinctive identifier
-// requirement.
-MEDIA_EXPORT EmeConfigRule GetDistinctiveIdentifierConfigRule(
-    const std::string& key_system,
-    EmeFeatureRequirement requirement);
-
 #if defined(UNIT_TEST)
 // Helper functions to add container/codec types for testing purposes.
 MEDIA_EXPORT void AddContainerMask(const std::string& container, uint32 mask);
 MEDIA_EXPORT void AddCodecMask(const std::string& codec, uint32 mask);
 #endif  // defined(UNIT_TEST)
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_KEY_SYSTEMS_H_