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)
+    // We don't support the inverse (only hardware-secure codecs allowed) for

[ddorwin, 2015/04/30 18:18:04]

The subject of "the inverse" is not clearly specified. (Presumably it's line
712, but that's not directly related.) It seems there should be a comment before
this explaining what is happening. Then you can say that the inverse is not
supported.

[sandersd (OOO until July 31), 2015/04/30 19:57:44]

Done.

+    // simplicity, but such support could be added here.

[ddorwin, 2015/04/30 18:18:04]

What do you mean "could be added"? Does this mean, if we need support, it would
be added here?

[sandersd (OOO until July 31), 2015/04/30 19:57:45]

Done.

+    if ((codec & key_system_secure_codec_mask) == 0)
+      support = EmeConfigRule::SECURE_CODECS_NOT_ALLOWED;

[jrummell, 2015/04/30 02:08:37]

If |codecs| contains 2 codecs, both of which are in |key_system_codec_mask| but
only 1 in |key_system_secure_codec_mask|, is this the correct response? Does it
depend on order?

[sandersd (OOO until July 31), 2015/04/30 18:19:34]

I believe this is correct; and codec that does not support hardware-secure
decode, anywhere (that is, as any codec in any capability), prevents use of all
secure codecs.

This is because we can't switch security modes on the fly, so we have to pick
one or the other at the start, but we need to be able to support any/all of the
capabilities we accept.

+#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 23 matching lines @@
   // 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 defined(OS_CHROMEOS)
   if (key_system == kWidevineKeySystem) {

[ddorwin, 2015/04/30 18:18:04]

We might extract the WV logic into a function for clarity and potential
refactoring later.

[sandersd (OOO until July 31), 2015/04/30 19:57:44]

Acknowledged.

     // 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;
     }
   }
 #endif  // defined(OS_CHROMEOS)

[ddorwin, 2015/04/30 18:18:04]

#elif

[sandersd (OOO until July 31), 2015/04/30 19:57:44]

Done.

 
+#if defined(OS_ANDROID)
+  if (key_system == kWidevineKeySystem &&
+      robustness > EmeRobustness::SW_SECURE_CRYPTO) {
+    return EmeConfigRule::SECURE_CODECS_REQUIRED;
+  }
+#endif  // defined(OS_ANDROID)
+
   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);
   if (key_system_iter == concrete_key_system_map_.end()) {
@@ skipping 128 matching lines @@
 }
 
 MEDIA_EXPORT void AddCodecMask(
     EmeMediaType media_type,
     const std::string& codec,
     uint32 mask) {
   KeySystemsImpl::GetInstance()->AddCodecMask(media_type, codec, mask);
 }
 
 }  // namespace media