EME: Correctly handle container-only contentType strings

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 "media/blink/key_system_config_selector.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 292 matching lines @@
 }
 
 // TODO(sandersd): Move contentType parsing from Blink to here so that invalid
 // parameters can be rejected. http://crbug.com/417561
 bool KeySystemConfigSelector::IsSupportedContentType(
     const std::string& key_system,
     EmeMediaType media_type,
     const std::string& container_mime_type,
     const std::string& codecs,
     KeySystemConfigSelector::ConfigState* config_state) {
+  // From RFC6838: "Both top-level type and subtype names are case-insensitive."
+  std::string container_lower = base::ToLowerASCII(container_mime_type);
+
+  // contentTypes must provide a codec string unless the container implies a
+  // particular codec. For EME, none of the currently supported containers
+  // imply a codec, so |codecs| must be provided.
+  if (codecs.empty()) {
+    // Since the spec didn't initially require this, add an exemption for
+    // some existing containers to give clients time to adapt.
+    // TODO(jrummell): Remove this exemption once the number of contentTypes
+    // without codecs drops low enough (UMA added in the blink code).
+    // http://crbug.com/605661.
+    if (container_lower != "audio/webm" && container_lower != "video/webm" &&
+        container_lower != "audio/mp4" && container_lower != "video/mp4") {
+      return false;
+    }
+  }
+
   // Check that |container_mime_type| and |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 (!IsSupportedMediaFormat(container_mime_type, codecs,
+  if (!IsSupportedMediaFormat(container_lower, codecs,
                               CanUseAesDecryptor(key_system))) {
     return false;
   }
 
-  // TODO(servolk): Converting |container_mime_type| to lower-case could be
-  // moved to KeySystemsImpl::GetContentTypeConfigRule, plus we could add some
-  // upper-case container name test cases in media/base/key_systems_unittest.cc.
-  std::string container_lower = base::ToLowerASCII(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 (extended codec information was checked above).
   std::vector<std::string> stripped_codec_vector;
   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);
@@ skipping 230 matching lines @@
     //       configuration.
     // 10.2. If video capabilities is null, return null.
     std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities;
     if (!GetSupportedCapabilities(key_system, EmeMediaType::VIDEO,
                                   candidate.videoCapabilities, config_state,
                                   &video_capabilities)) {
       return CONFIGURATION_NOT_SUPPORTED;
     }
 
     // 10.3. Add video capabilities to accumulated configuration.
+    accumulated_configuration->hasVideoCapabilities = true;
     accumulated_configuration->videoCapabilities = video_capabilities;
   }
 
   // 11. If the audioCapabilities member is present in candidate configuration:
   if (candidate.hasAudioCapabilities) {
     // 11.1. Let audio capabilities be the result of executing the Get Supported
     //       Capabilities for Media Type algorithm on Audio, candidate
     //       configuration's audioCapabilities member, and accumulated
     //       configuration.
     // 11.2. If audio capabilities is null, return null.
     std::vector<blink::WebMediaKeySystemMediaCapability> audio_capabilities;
     if (!GetSupportedCapabilities(key_system, EmeMediaType::AUDIO,
                                   candidate.audioCapabilities, config_state,
                                   &audio_capabilities)) {
       return CONFIGURATION_NOT_SUPPORTED;
     }
 
     // 11.3. Add audio capabilities to accumulated configuration.
+    accumulated_configuration->hasAudioCapabilities = true;
     accumulated_configuration->audioCapabilities = audio_capabilities;
   }
 
   // 12. 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
@@ skipping 198 matching lines @@
 
 void KeySystemConfigSelector::OnPermissionResult(
     std::unique_ptr<SelectionRequest> request,
     bool is_permission_granted) {
   request->was_permission_requested = true;
   request->is_permission_granted = is_permission_granted;
   SelectConfigInternal(std::move(request));
 }
 
 }  // namespace media