Create an interface for KeySystems, migrate WebEncryptedMediaClientImpl.

media/blink/webencryptedmediaclient_impl.cc

 // Copyright 2014 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 "webencryptedmediaclient_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
@@ skipping 124 matching lines @@
     return EmeRobustness::SW_SECURE_DECODE;
   if (robustness == "HW_SECURE_CRYPTO")
     return EmeRobustness::HW_SECURE_CRYPTO;
   if (robustness == "HW_SECURE_DECODE")
     return EmeRobustness::HW_SECURE_DECODE;
   if (robustness == "HW_SECURE_ALL")
     return EmeRobustness::HW_SECURE_ALL;
   return EmeRobustness::INVALID;
 }
 
-static bool IsSupportedContentType(const std::string& key_system,
-                                   const std::string& mime_type,
-                                   const std::string& codecs) {
+static bool IsSupportedContentType(
+    const KeySystems& key_systems,
+    const std::string& key_system,
+    EmeMediaType media_type,
+    const std::string& container_mime_type,
+    const std::string& codecs) {
   // TODO(sandersd): Move contentType parsing from Blink to here so that invalid
   // parameters can be rejected. http://crbug.com/417561
-  // TODO(sandersd): Pass in the media type (audio or video) and check that the
-  // container type matches. http://crbug.com/457384
-  std::string container = base::StringToLowerASCII(mime_type);
+  std::string container_lower = base::StringToLowerASCII(container_mime_type);
 
   // Check that |codecs| are supported by the CDM. This check does not handle
   // extended codecs, so extended codec information is stripped.
-  // TODO(sandersd): Reject codecs that do not match the media type.
-  // http://crbug.com/457386
   std::vector<std::string> codec_vector;
   net::ParseCodecString(codecs, &codec_vector, true);
-  if (!IsSupportedKeySystemWithMediaMimeType(container, codec_vector,
-                                             key_system)) {
+  if (!key_systems.IsSupportedCodecCombination(
+           key_system, media_type, container_lower, codec_vector)) {
     return false;
   }
 
   // Check that |codecs| are supported by Chrome. This is done primarily to
   // validate extended codecs, but it also ensures that the CDM cannot support
   // codecs that Chrome does not (which would be bad because it would require
   // considering the accumulated configuration, and could affect whether secure
   // decode is required).
   // TODO(sandersd): Reject ambiguous codecs. http://crbug.com/374751
   codec_vector.clear();
   net::ParseCodecString(codecs, &codec_vector, false);
   return net::AreSupportedMediaCodecs(codec_vector);
 }
 
 static bool GetSupportedCapabilities(
+    const KeySystems& key_systems,
     const std::string& key_system,
+    EmeMediaType media_type,
     const blink::WebVector<blink::WebMediaKeySystemMediaCapability>&
         capabilities,
-    EmeMediaType media_type,
+    ConfigState* config_state,
     std::vector<blink::WebMediaKeySystemMediaCapability>*
-        media_type_capabilities,
-    ConfigState* config_state) {
+        media_type_capabilities) {
   // From
   // https://w3c.github.io/encrypted-media/#get-supported-capabilities-for-media-type
   // 1. Let accumulated capabilities be partial configuration.
   //    (Skipped as there are no configuration-based codec restrictions.)
   // 2. Let media type capabilities be empty.
   DCHECK_EQ(media_type_capabilities->size(), 0ul);
   // 3. For each value in capabilities:
   for (size_t i = 0; i < capabilities.size(); i++) {
     // 3.1. Let contentType be the value's contentType member.
     // 3.2. Let robustness be the value's robustness member.
     const blink::WebMediaKeySystemMediaCapability& capability = capabilities[i];
     // 3.3. If contentType is the empty string, return null.
     if (capability.mimeType.isEmpty()) {
       DVLOG(2) << "Rejecting requested configuration because "
                << "a capability contentType was empty.";
       return false;
     }
     // 3.4-3.11. (Implemented by IsSupportedContentType().)
     if (!base::IsStringASCII(capability.mimeType) ||
         !base::IsStringASCII(capability.codecs) ||
-        !IsSupportedContentType(key_system,
+        !IsSupportedContentType(key_systems, key_system, media_type,
                                 base::UTF16ToASCII(capability.mimeType),
                                 base::UTF16ToASCII(capability.codecs))) {
       continue;
     }
     // 3.12. If robustness is not the empty string, run the following steps:
     if (!capability.robustness.isEmpty()) {
       // 3.12.1. If robustness is an unrecognized value or not supported by
       //         implementation, continue to the next iteration. String
       //         comparison is case-sensitive.
-      EmeConfigRule robustness_rule = GetRobustnessConfigRule(
+      EmeConfigRule robustness_rule = key_systems.GetRobustnessConfigRule(
           key_system, media_type, ConvertRobustness(capability.robustness));
       if (!config_state->IsRuleSupported(robustness_rule))
         continue;
       config_state->AddRule(robustness_rule);
       // 3.12.2. Add robustness to configuration.
       //         (It's already added, we use capability as the configuration.)
     }
     // 3.13. If the user agent and implementation do not support playback of
     //       encrypted media data as specified by configuration, including all
     //       media types, in combination with accumulated capabilities,
@@ skipping 27 matching lines @@
       return EME_FEATURE_OPTIONAL;
     case blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed:
       return EME_FEATURE_NOT_ALLOWED;
   }
 
   NOTREACHED();
   return EME_FEATURE_NOT_ALLOWED;
 }
 
 static ConfigurationSupport GetSupportedConfiguration(
+    const KeySystems& key_systems,
     const std::string& key_system,
     const blink::WebMediaKeySystemConfiguration& candidate,
     bool was_permission_requested,
     bool is_permission_granted,
     blink::WebMediaKeySystemConfiguration* accumulated_configuration) {
   ConfigState config_state(was_permission_requested, is_permission_granted);
 
   // From https://w3c.github.io/encrypted-media/#get-supported-configuration
   // 1. Let accumulated configuration be empty. (Done by caller.)
   // 2. If candidate configuration's initDataTypes attribute is not empty, run
@@ skipping 51 matching lines @@
   //    distinctiveIdentifier attribute from the following list:
   //     - "required": If the implementation does not support a persistent
   //       Distinctive Identifier in combination with accumulated configuration,
   //       return null.
   //     - "optional": Continue.
   //     - "not-allowed": If the implementation requires a Distinctive
   //       Identifier in combination with accumulated configuration, return
   //       null.
   // We also reject OPTIONAL when distinctive identifiers are ALWAYS_ENABLED and
   // permission has already been denied. This would happen anyway at step 11.
-  EmeConfigRule di_rule = GetDistinctiveIdentifierConfigRule(
+  EmeConfigRule di_rule = key_systems.GetDistinctiveIdentifierConfigRule(
       key_system, ConvertRequirement(candidate.distinctiveIdentifier));
   if (!config_state.IsRuleSupported(di_rule)) {
     DVLOG(2) << "Rejecting requested configuration because "
              << "the distinctiveIdentifier requirement was not supported.";
     return CONFIGURATION_NOT_SUPPORTED;
   }
   config_state.AddRule(di_rule);
 
   // 4. Add the value of the candidate configuration's distinctiveIdentifier
   //    attribute to accumulated configuration.
   accumulated_configuration->distinctiveIdentifier =
       candidate.distinctiveIdentifier;
 
   // 5. Follow the steps for the value of candidate configuration's
   //    persistentState attribute from the following list:
   //     - "required": If the implementation does not support persisting state
   //       in combination with accumulated configuration, return null.
   //     - "optional": Continue.
   //     - "not-allowed": If the implementation requires persisting state in
   //       combination with accumulated configuration, return null.
-  EmeConfigRule ps_rule = GetPersistentStateConfigRule(
+  EmeConfigRule ps_rule = key_systems.GetPersistentStateConfigRule(
       key_system, ConvertRequirement(candidate.persistentState));
   if (!config_state.IsRuleSupported(ps_rule)) {
     DVLOG(2) << "Rejecting requested configuration because "
              << "the persistentState requirement was not supported.";
     return CONFIGURATION_NOT_SUPPORTED;
   }
   config_state.AddRule(ps_rule);
 
   // 6. Add the value of the candidate configuration's persistentState
   //    attribute to accumulated configuration.
   accumulated_configuration->persistentState = candidate.persistentState;
 
   // 7. If candidate configuration's videoCapabilities attribute is not empty,
   //    run the following steps:
   if (!candidate.videoCapabilities.isEmpty()) {
     // 7.1. Let video capabilities be the result of executing the Get Supported
     //      Capabilities for Media Type algorithm on Video, candidate
     //      configuration's videoCapabilities attribute, and accumulated
     //      configuration.
     // 7.2. If video capabilities is null, return null.
     std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities;
-    if (!GetSupportedCapabilities(key_system, candidate.videoCapabilities,
-                                  EmeMediaType::VIDEO, &video_capabilities,
-                                  &config_state)) {
+    if (!GetSupportedCapabilities(key_systems, key_system, EmeMediaType::VIDEO,
+                                  candidate.videoCapabilities,
+                                  &config_state, &video_capabilities)) {
       return CONFIGURATION_NOT_SUPPORTED;
     }
 
     // 7.3. Add video capabilities to accumulated configuration.
     accumulated_configuration->videoCapabilities = video_capabilities;
   }
 
   // 8. If candidate configuration's audioCapabilities attribute is not empty,
   //    run the following steps:
   if (!candidate.audioCapabilities.isEmpty()) {
     // 8.1. Let audio capabilities be the result of executing the Get Supported
     //      Capabilities for Media Type algorithm on Audio, candidate
     //      configuration's audioCapabilities attribute, and accumulated
     //      configuration.
     // 8.2. If audio capabilities is null, return null.
     std::vector<blink::WebMediaKeySystemMediaCapability> audio_capabilities;
-    if (!GetSupportedCapabilities(key_system, candidate.audioCapabilities,
-                                  EmeMediaType::AUDIO, &audio_capabilities,
-                                  &config_state)) {
+    if (!GetSupportedCapabilities(key_systems, key_system, EmeMediaType::AUDIO,
+                                  candidate.audioCapabilities,
+                                  &config_state, &audio_capabilities)) {
       return CONFIGURATION_NOT_SUPPORTED;
     }
 
     // 8.3. Add audio capabilities to accumulated configuration.
     accumulated_configuration->audioCapabilities = audio_capabilities;
   }
 
   // 9. If accumulated configuration's distinctiveIdentifier value is
   //    "optional", follow the steps for the first matching condition from the
   //    following list:
   //      - If the implementation requires a Distinctive Identifier for any of
   //        the combinations in accumulated configuration, change accumulated
   //        configuration's distinctiveIdentifier value to "required".
   //      - Otherwise, change accumulated configuration's distinctiveIdentifier
   //        value to "not-allowed".
   if (accumulated_configuration->distinctiveIdentifier ==
       blink::WebMediaKeySystemConfiguration::Requirement::Optional) {
     EmeConfigRule not_allowed_rule =
-        GetDistinctiveIdentifierConfigRule(key_system, EME_FEATURE_NOT_ALLOWED);
+        key_systems.GetDistinctiveIdentifierConfigRule(
+            key_system, EME_FEATURE_NOT_ALLOWED);
     EmeConfigRule required_rule =
-        GetDistinctiveIdentifierConfigRule(key_system, EME_FEATURE_REQUIRED);
+        key_systems.GetDistinctiveIdentifierConfigRule(
+            key_system, EME_FEATURE_REQUIRED);
     bool not_allowed_supported = config_state.IsRuleSupported(not_allowed_rule);
     bool required_supported = config_state.IsRuleSupported(required_rule);
     if (not_allowed_supported) {
       bool prefer_required = config_state.IsIdentifierRequired() ||
                              (config_state.IsIdentifierRecommended() &&
                               config_state.IsPermissionPossible());
       if (required_supported && prefer_required) {
         accumulated_configuration->distinctiveIdentifier =
             blink::WebMediaKeySystemConfiguration::Requirement::Required;
         config_state.AddRule(required_rule);
@@ skipping 29 matching lines @@
   //     follow the steps for the first matching condition from the following
   //     list:
   //       - If the implementation requires persisting state for any of the
   //         combinations in accumulated configuration, change accumulated
   //         configuration's persistentState value to "required".
   //       - Otherwise, change accumulated configuration's persistentState value
   //         to "not-allowed".
   if (accumulated_configuration->persistentState ==
       blink::WebMediaKeySystemConfiguration::Requirement::Optional) {
     EmeConfigRule not_allowed_rule =
-        GetPersistentStateConfigRule(key_system, EME_FEATURE_NOT_ALLOWED);
+        key_systems.GetPersistentStateConfigRule(
+            key_system, EME_FEATURE_NOT_ALLOWED);
     EmeConfigRule required_rule =
-        GetPersistentStateConfigRule(key_system, EME_FEATURE_REQUIRED);
+        key_systems.GetPersistentStateConfigRule(
+            key_system, EME_FEATURE_REQUIRED);
     // Now that distinctiveIdentifier has been resolved, it is too late to allow
     // persistentState to affect the configuration.
     bool not_allowed_supported =
         config_state.IsRuleSupportedWithCurrentState(not_allowed_rule);
     bool required_supported =
         config_state.IsRuleSupportedWithCurrentState(required_rule);
     if (not_allowed_supported) {
       accumulated_configuration->persistentState =
           blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed;
     } else if (required_supported) {
@@ skipping 22 matching lines @@
 
   // 12. Return accumulated configuration.
   //
   // We also record the available session types so that createSession() can be
   // synchronous.
   std::vector<blink::WebEncryptedMediaSessionType> session_types;
   session_types.push_back(blink::WebEncryptedMediaSessionType::Temporary);
   if (accumulated_configuration->persistentState ==
       blink::WebMediaKeySystemConfiguration::Requirement::Required) {
     if (config_state.IsRuleSupportedWithCurrentState(
-            GetPersistentLicenseSessionConfigRule(key_system))) {
+            key_systems.GetPersistentLicenseSessionConfigRule(key_system))) {
       session_types.push_back(
           blink::WebEncryptedMediaSessionType::PersistentLicense);
     }
     if (config_state.IsRuleSupportedWithCurrentState(
-            GetPersistentReleaseMessageSessionConfigRule(key_system))) {
+            key_systems.GetPersistentReleaseMessageSessionConfigRule(
+                key_system))) {
       session_types.push_back(
           blink::WebEncryptedMediaSessionType::PersistentReleaseMessage);
     }
   }
   accumulated_configuration->sessionTypes = session_types;
 
   return CONFIGURATION_SUPPORTED;
 }
 
 // Report usage of key system to UMA. There are 2 different counts logged:
@@ skipping 42 matching lines @@
   }
 
   const std::string uma_name_;
   bool is_request_reported_;
   bool is_support_reported_;
 };
 
 WebEncryptedMediaClientImpl::WebEncryptedMediaClientImpl(
     scoped_ptr<CdmFactory> cdm_factory,
     MediaPermission* media_permission)
-    : cdm_factory_(cdm_factory.Pass()), media_permission_(media_permission),
+    : key_systems_(KeySystems::GetInstance()),
+      cdm_factory_(cdm_factory.Pass()),
+      media_permission_(media_permission),
       weak_factory_(this) {
   DCHECK(media_permission);
 }
 
 WebEncryptedMediaClientImpl::~WebEncryptedMediaClientImpl() {
 }
 
 void WebEncryptedMediaClientImpl::requestMediaKeySystemAccess(
     blink::WebEncryptedMediaRequest request) {
   // TODO(jrummell): This should be asynchronous, ideally not on the main
   // thread.
 
   // Continued from requestMediaKeySystemAccess(), step 7, from
   // https://w3c.github.io/encrypted-media/#requestmediakeysystemaccess
   //
   // 7.1. If keySystem is not one of the Key Systems supported by the user
   //      agent, reject promise with with a new DOMException whose name is
   //      NotSupportedError. String comparison is case-sensitive.
   if (!base::IsStringASCII(request.keySystem())) {
     request.requestNotSupported("Only ASCII keySystems are supported");
     return;
   }
 
   // Report this request to the UMA.
   std::string key_system = base::UTF16ToASCII(request.keySystem());
   GetReporter(key_system)->ReportRequested();
 
-  if (!IsSupportedKeySystem(key_system)) {
+  if (!key_systems_.IsSupportedKeySystem(key_system)) {
     request.requestNotSupported("Unsupported keySystem");
     return;
   }
 
   // 7.2-7.4. Implemented by SelectSupportedConfiguration().
   SelectSupportedConfiguration(request, false, false);
 }
 
 void WebEncryptedMediaClientImpl::SelectSupportedConfiguration(
     blink::WebEncryptedMediaRequest request,
@@ skipping 12 matching lines @@
     // 7.3.1. Let candidate configuration be the value.
     const blink::WebMediaKeySystemConfiguration& candidate_configuration =
         configurations[i];
     // 7.3.2. Let supported configuration be the result of executing the Get
     //        Supported Configuration algorithm on implementation, candidate
     //        configuration, and origin.
     // 7.3.3. If supported configuration is not null, [initialize and return a
     //        new MediaKeySystemAccess object.]
     blink::WebMediaKeySystemConfiguration accumulated_configuration;
     ConfigurationSupport supported = GetSupportedConfiguration(
-        key_system, candidate_configuration, was_permission_requested,
-        is_permission_granted, &accumulated_configuration);
+        key_systems_, key_system, candidate_configuration,
+        was_permission_requested, is_permission_granted,
+        &accumulated_configuration);
     switch (supported) {
       case CONFIGURATION_NOT_SUPPORTED:
         continue;
       case CONFIGURATION_REQUIRES_PERMISSION:
         if (was_permission_requested) {
           DVLOG(2) << "Rejecting requested configuration because "
                    << "permission was denied.";
           continue;
         }
         media_permission_->RequestPermission(
@@ skipping 42 matching lines @@
     return reporter;
 
   // Reporter not found, so create one.
   auto result =
       reporters_.add(uma_name, make_scoped_ptr(new Reporter(uma_name)));
   DCHECK(result.second);
   return result.first->second;
 }
 
 }  // namespace media