Support Android secure codecs in requestMediaKeySystemAccess().

media/base/key_systems.cc

 // 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.
 
 #include "media/base/key_systems.h"
 
 #include <string>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
@@ skipping 184 matching lines @@
       EmeMediaType media_type,
       const std::string& codec,
       uint32 mask);
 
   // Implementation of KeySystems interface.
   bool IsSupportedKeySystem(const std::string& key_system) const override;
 
   bool IsSupportedInitDataType(const std::string& key_system,
                                EmeInitDataType init_data_type) const override;
 
-  bool IsSupportedCodecCombination(
+  EmeConfigRule GetContentTypeConfigRule(
       const std::string& key_system,
       EmeMediaType media_type,
       const std::string& container_mime_type,
       const std::vector<std::string>& codecs) const override;
 
   EmeConfigRule GetRobustnessConfigRule(
       const std::string& key_system,
       EmeMediaType media_type,
       const std::string& requested_robustness) const override;
 
@@ skipping 442 matching lines @@
   } else {
     video_codec_mask_ |= mask;
   }
 }
 
 bool KeySystemsImpl::IsSupportedKeySystem(const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return concrete_key_system_map_.count(key_system) != 0;
 }
 
-bool KeySystemsImpl::IsSupportedCodecCombination(
+EmeConfigRule KeySystemsImpl::GetContentTypeConfigRule(
     const std::string& key_system,
     EmeMediaType media_type,
     const std::string& container_mime_type,
     const std::vector<std::string>& codecs) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Make sure the container matches |media_type|.
   SupportedCodecs media_type_codec_mask = EME_CODEC_NONE;
   switch (media_type) {
     case EmeMediaType::AUDIO:
       if (!StartsWithASCII(container_mime_type, "audio/", true))
-        return false;
+        return EmeConfigRule::NOT_SUPPORTED;
       media_type_codec_mask = audio_codec_mask_;
       break;
     case EmeMediaType::VIDEO:
       if (!StartsWithASCII(container_mime_type, "video/", true))
-        return false;
+        return EmeConfigRule::NOT_SUPPORTED;
       media_type_codec_mask = video_codec_mask_;
       break;
   }
 
   // Look up the key system's supported codecs.
   KeySystemInfoMap::const_iterator key_system_iter =
       concrete_key_system_map_.find(key_system);
   if (key_system_iter == concrete_key_system_map_.end()) {
     NOTREACHED();
-    return false;
+    return EmeConfigRule::NOT_SUPPORTED;
   }
   SupportedCodecs key_system_codec_mask =
       key_system_iter->second.supported_codecs;
+#if defined(OS_ANDROID)
+  SupportedCodecs key_system_secure_codec_mask =
+      key_system_iter->second.supported_secure_codecs;
+#endif  // defined(OS_ANDROID)
+
 
   // Check that the container is supported by the key system. (This check is
   // necessary because |codecs| may be empty.)
   SupportedCodecs container_codec_mask =
       GetCodecMaskForContainer(container_mime_type) & media_type_codec_mask;
   if ((key_system_codec_mask & container_codec_mask) == 0)
-    return false;
+    return EmeConfigRule::NOT_SUPPORTED;
 
   // Check that the codecs are supported by the key system and container.
+  EmeConfigRule support = EmeConfigRule::SUPPORTED;
   for (size_t i = 0; i < codecs.size(); i++) {
     SupportedCodecs codec = GetCodecForString(codecs[i]);
     if ((codec & key_system_codec_mask & container_codec_mask) == 0)
-      return false;
+      return EmeConfigRule::NOT_SUPPORTED;
+#if defined(OS_ANDROID)
+    // Check whether the codec supports a hardware-secure mode; if not, indicate
+    // that hardware-secure codecs are not available for all listed codecs.
+    // Because the check for regular codec support is early-exit, we don't have
+    // to consider codecs that are only supported in hardware-secure mode. We
+    // could do so, and make use of SECURE_CODECS_REQUIRED, if it turns out that
+    // hardware-secure-only codecs actually exist and are useful.
+    if ((codec & key_system_secure_codec_mask) == 0)
+      support = EmeConfigRule::SECURE_CODECS_NOT_ALLOWED;
+#endif  // defined(OS_ANDROID)
+
   }
 
-  return true;
+  return support;
 }
 
 EmeConfigRule KeySystemsImpl::GetRobustnessConfigRule(
     const std::string& key_system,
     EmeMediaType media_type,
     const std::string& requested_robustness) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   EmeRobustness robustness = ConvertRobustness(requested_robustness);
   if (robustness == EmeRobustness::INVALID)
@@ skipping 22 matching lines @@
   // and SW_SECURE_DECODE in some order. If they are exactly those two then the
   // robustness requirement is not supported.
   if ((max_robustness == EmeRobustness::HW_SECURE_CRYPTO &&
        robustness == EmeRobustness::SW_SECURE_DECODE) ||
       (max_robustness == EmeRobustness::SW_SECURE_DECODE &&
        robustness == EmeRobustness::HW_SECURE_CRYPTO) ||
       robustness > max_robustness) {
     return EmeConfigRule::NOT_SUPPORTED;
   }
 
+  if (key_system == kWidevineKeySystem) {
 #if defined(OS_CHROMEOS)
-  if (key_system == kWidevineKeySystem) {
     // Hardware security requires remote attestation.
     if (robustness >= EmeRobustness::HW_SECURE_CRYPTO)
       return EmeConfigRule::IDENTIFIER_REQUIRED;
 
     // For video, recommend remote attestation if HW_SECURE_ALL is available,
     // because it enables hardware accelerated decoding.
     // TODO(sandersd): Only do this when hardware accelerated decoding is
     // available for the requested codecs.
     if (media_type == EmeMediaType::VIDEO &&
         max_robustness == EmeRobustness::HW_SECURE_ALL) {
       return EmeConfigRule::IDENTIFIER_RECOMMENDED;
     }
+#elif defined(OS_ANDROID)
+    if (robustness > EmeRobustness::SW_SECURE_CRYPTO)
+      return EmeConfigRule::SECURE_CODECS_REQUIRED;
+#endif  // defined(OS_CHROMEOS)
   }
-#endif  // defined(OS_CHROMEOS)
 
   return EmeConfigRule::SUPPORTED;
 }
 
 EmeSessionTypeSupport KeySystemsImpl::GetPersistentLicenseSessionSupport(
     const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemInfoMap::const_iterator key_system_iter =
       concrete_key_system_map_.find(key_system);
@@ skipping 129 matching lines @@
 }
 
 MEDIA_EXPORT void AddCodecMask(
     EmeMediaType media_type,
     const std::string& codec,
     uint32 mask) {
   KeySystemsImpl::GetInstance()->AddCodecMask(media_type, codec, mask);
 }
 
 }  // namespace media