Support Android secure codecs in requestMediaKeySystemAccess().

media/blink/key_system_config_selector.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 "key_system_config_selector.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 159 matching lines @@
         return !is_identifier_not_allowed_ && IsPermissionPossible();
       case EmeConfigRule::IDENTIFIER_RECOMMENDED:
         return true;
       case EmeConfigRule::PERSISTENCE_NOT_ALLOWED:
         return !is_persistence_required_;
       case EmeConfigRule::PERSISTENCE_REQUIRED:
         return !is_persistence_not_allowed_;
       case EmeConfigRule::IDENTIFIER_AND_PERSISTENCE_REQUIRED:
         return (!is_identifier_not_allowed_ && IsPermissionPossible() &&
                 !is_persistence_not_allowed_);
+#if defined(OS_ANDROID)
+      case EmeConfigRule::SECURE_CODECS_NOT_ALLOWED:
+        return !are_secure_codecs_required_;
+      case EmeConfigRule::SECURE_CODECS_REQUIRED:
+        return !are_secure_codecs_not_allowed_;
+#endif  // defined(OS_ANDROID)
       case EmeConfigRule::SUPPORTED:
         return true;
     }
     NOTREACHED();
     return false;
   }
 
   // Add a rule to the accumulated configuration state.
   void AddRule(EmeConfigRule rule) {
     DCHECK(IsRuleSupported(rule));
@@ skipping 13 matching lines @@
       case EmeConfigRule::PERSISTENCE_NOT_ALLOWED:
         is_persistence_not_allowed_ = true;
         return;
       case EmeConfigRule::PERSISTENCE_REQUIRED:
         is_persistence_required_ = true;
         return;
       case EmeConfigRule::IDENTIFIER_AND_PERSISTENCE_REQUIRED:
         is_identifier_required_ = true;
         is_persistence_required_ = true;
         return;
+#if defined(OS_ANDROID)
+      case EmeConfigRule::SECURE_CODECS_NOT_ALLOWED:
+        are_secure_codecs_not_allowed_ = true;
+        return;
+      case EmeConfigRule::SECURE_CODECS_REQUIRED:
+        are_secure_codecs_required_ = true;
+        return;
+#endif  // defined(OS_ANDROID)
       case EmeConfigRule::SUPPORTED:
         return;
     }
     NOTREACHED();
   }
 
  private:
   // Whether permission to use a distinctive identifier was requested. If set,
   // |is_permission_granted_| represents the final decision.
-  const bool was_permission_requested_;
+  // (Not changed by adding rules.)
+  bool was_permission_requested_;
 
   // Whether permission to use a distinctive identifier has been granted.
-  const bool is_permission_granted_;
+  // (Not changed by adding rules.)
+  bool is_permission_granted_;
 
   // Whether a rule has been added that requires or blocks a distinctive
   // identifier.
   bool is_identifier_required_ = false;
   bool is_identifier_not_allowed_ = false;
 
   // Whether a rule has been added that recommends a distinctive identifier.
   bool is_identifier_recommended_ = false;
 
   // Whether a rule has been added that requires or blocks persistent state.
   bool is_persistence_required_ = false;
   bool is_persistence_not_allowed_ = false;
 
-  DISALLOW_COPY_AND_ASSIGN(ConfigState);
+#if defined(OS_ANDROID)
+  // Whether a rule has been added that requires or blocks secure codecs.
+  bool are_secure_codecs_required_ = false;
+  bool are_secure_codecs_not_allowed_ = false;
+#endif  // defined(OS_ANDROID)
 };
 
 KeySystemConfigSelector::KeySystemConfigSelector(
     const KeySystems* key_systems,
     MediaPermission* media_permission)
     : key_systems_(key_systems),
       media_permission_(media_permission),
       weak_factory_(this) {
   DCHECK(key_systems_);
   DCHECK(media_permission_);
 }
 
 KeySystemConfigSelector::~KeySystemConfigSelector() {
 }
 
 bool KeySystemConfigSelector::IsSupportedContentType(
     const std::string& key_system,
     EmeMediaType media_type,
     const std::string& container_mime_type,
-    const std::string& codecs) {
+    const std::string& codecs,
+    KeySystemConfigSelector::ConfigState* config_state) {
   // TODO(sandersd): Move contentType parsing from Blink to here so that invalid
   // parameters can be rejected. http://crbug.com/417561
   std::string container_lower = base::StringToLowerASCII(container_mime_type);
 
-  // Check that |container_mime_type| and |codecs| are supported by the CDM.
-  // This check does not handle extended codecs, so extended codec information
-  // is stripped.
-  std::vector<std::string> codec_vector;
-  net::ParseCodecString(codecs, &codec_vector, true);
-  if (!key_systems_->IsSupportedCodecCombination(
-          key_system, media_type, container_lower, codec_vector)) {
+  // Check that |container_mime_type| is supported by Chrome.
+  if (!net::IsSupportedMediaMimeType(container_lower))
     return false;
-  }
-
-  // Check that |container_mime_type| is supported by Chrome. This can only
-  // happen if the CDM declares support for a container that Chrome does not.
-  if (!net::IsSupportedMediaMimeType(container_lower)) {
-    NOTREACHED();
-    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 could complicate the robustness
   // algorithm).
-  if (codec_vector.empty())
-    return true;
-  codec_vector.clear();
+  std::vector<std::string> codec_vector;
   net::ParseCodecString(codecs, &codec_vector, false);
-  return (net::IsSupportedStrictMediaMimeType(container_lower, codec_vector) ==
-          net::IsSupported);
+  if (!codec_vector.empty() &&
+      (net::IsSupportedStrictMediaMimeType(container_lower, codec_vector) !=
+       net::IsSupported)) {
+    return false;
+  }
+
+  // Check that |container_mime_type| and |codecs| are supported by the CDM.
+  // This check does not handle extended codecs, so extended codec information
+  // is stripped.

[ddorwin, 2015/05/01 20:39:12]

Validation of the correctness of such strings was handled above.

[sandersd (OOO until July 31), 2015/05/01 21:57:01]

Done.

+  std::vector<std::string> stripped_codec_vector;
+  net::ParseCodecString(codecs, &stripped_codec_vector, true);
+  EmeConfigRule codecs_rule = key_systems_->GetContentTypeConfigRule(
+      key_system, media_type, container_lower, stripped_codec_vector);
+  if (!config_state->IsRuleSupported(codecs_rule))
+    return false;
+  config_state->AddRule(codecs_rule);

[ddorwin, 2015/05/01 20:39:12]

nit: empty line

[sandersd (OOO until July 31), 2015/05/01 21:57:02]

Done.

+  return true;
 }
 
 bool KeySystemConfigSelector::GetSupportedCapabilities(
     const std::string& key_system,
     EmeMediaType media_type,
     const blink::WebVector<blink::WebMediaKeySystemMediaCapability>&
         requested_media_capabilities,
     KeySystemConfigSelector::ConfigState* config_state,
     std::vector<blink::WebMediaKeySystemMediaCapability>*
         supported_media_capabilities) {
@@ skipping 10 matching lines @@
     // 3.1. Let contentType be the value's contentType member.
     // 3.2. Let robustness be the value's robustness member.
     const blink::WebMediaKeySystemMediaCapability& capability =
         requested_media_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().)
+    ConfigState proposed_config_state = *config_state;
     if (!base::IsStringASCII(capability.mimeType) ||
         !base::IsStringASCII(capability.codecs) ||
         !IsSupportedContentType(key_system, media_type,
                                 base::UTF16ToASCII(capability.mimeType),
-                                base::UTF16ToASCII(capability.codecs))) {
+                                base::UTF16ToASCII(capability.codecs),
+                                &proposed_config_state)) {
       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.
       if (!base::IsStringASCII(capability.robustness))
         continue;
       EmeConfigRule robustness_rule = key_systems_->GetRobustnessConfigRule(
           key_system, media_type, base::UTF16ToASCII(capability.robustness));
-      if (!config_state->IsRuleSupported(robustness_rule))
+      if (!proposed_config_state.IsRuleSupported(robustness_rule))
         continue;
-      config_state->AddRule(robustness_rule);
+      proposed_config_state.AddRule(robustness_rule);
       // 3.12.2. Add robustness to configuration.
       //         (It's already added, we use capability as 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 local accumulated capabilities,
     //       continue to the next iteration.
-    //       (This is handled when adding rules to |config_state|.)
+    //       (This is handled when adding rules to |proposed_config_state|.)
     // 3.14. Add configuration to supported media capabilities.
     supported_media_capabilities->push_back(capability);
     // 3.15. Add configuration to local accumulated capabilities.
-    //       (Skipped as we directly update |config_state|.)
+    *config_state = proposed_config_state;
   }
   // 4. If supported media capabilities is empty, return null.
   if (supported_media_capabilities->empty()) {
     DVLOG(2) << "Rejecting requested configuration because "
              << "no capabilities were supported.";
     return false;
   }
   // 5. Return media type capabilities.
   return true;
 }
 
 KeySystemConfigSelector::ConfigurationSupport
 KeySystemConfigSelector::GetSupportedConfiguration(
     const std::string& key_system,
     const blink::WebMediaKeySystemConfiguration& candidate,
     ConfigState* config_state,
     blink::WebMediaKeySystemConfiguration* accumulated_configuration) {
+  // TODO(sandersd): Set state of SECURE_CODECS from renderer pref.
   // From https://w3c.github.io/encrypted-media/#get-supported-configuration
   // 1. Let accumulated configuration be empty. (Done by caller.)
   // 2. If the initDataTypes member is present in candidate configuration, run
   //    the following steps:
   if (candidate.hasInitDataTypes) {
     // 2.1. Let supported types be empty.
     std::vector<blink::WebEncryptedMediaInitDataType> supported_types;
 
     // 2.2. For each value in candidate configuration's initDataTypes member:
     for (size_t i = 0; i < candidate.initDataTypes.size(); i++) {
@@ skipping 348 matching lines @@
 
 void KeySystemConfigSelector::OnPermissionResult(
     scoped_ptr<SelectionRequest> request,
     bool is_permission_granted) {
   request->was_permission_requested = true;
   request->is_permission_granted = is_permission_granted;
   SelectConfigInternal(request.Pass());
 }
 
 }  // namespace media