EME on Android: Improve accuracy of Key System availability.

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 259 matching lines @@
     : key_systems_(key_systems),
       media_permission_(media_permission),
       weak_factory_(this) {
   DCHECK(key_systems_);
   DCHECK(media_permission_);
 }
 
 KeySystemConfigSelector::~KeySystemConfigSelector() {
 }
 
-bool IsSupportedClearMediaFormat(const std::string& container_mime_type,
-                                 const std::string& codecs) {
+bool IsSupportedMediaFormat(const std::string& container_mime_type,
+                            const std::string& codecs,
+                            bool use_aes_decryptor) {
   std::vector<std::string> codec_vector;
-  media::ParseCodecString(codecs, &codec_vector, false);
-  media::SupportsType support_result =
-      media::IsSupportedEncryptedMediaFormat(container_mime_type, codec_vector);
+  ParseCodecString(codecs, &codec_vector, false);
+  // AesDecryptor decrypts the stream in the demuxer before it reaches the
+  // decoder so check whether the media format is supported when clear.
+  SupportsType support_result =
+      use_aes_decryptor
+          ? IsSupportedMediaFormat(container_mime_type, codec_vector)
+          : IsSupportedEncryptedMediaFormat(container_mime_type, codec_vector);
   switch (support_result) {
-    case media::IsSupported:
+    case IsSupported:
       return true;
-    case media::MayBeSupported:
+    case MayBeSupported:
       // If no codecs were specified, the best possible result is
       // MayBeSupported, indicating support for the container.
       return codec_vector.empty();
-    case media::IsNotSupported:
+    case IsNotSupported:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 // 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) {
   // 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 (!IsSupportedClearMediaFormat(container_mime_type, codecs))
+  if (!IsSupportedMediaFormat(container_mime_type, 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;
-  media::ParseCodecString(codecs, &stripped_codec_vector, true);
+  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);
 
   return true;
 }
 
 bool KeySystemConfigSelector::GetSupportedCapabilities(
@@ skipping 461 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(std::move(request));
 }
 
 }  // namespace media