Support Android secure codecs in requestMediaKeySystemAccess().

media/base/key_systems.cc

Index: media/base/key_systems.cc
diff --git a/media/base/key_systems.cc b/media/base/key_systems.cc
index f89992572ea6258a481fdeba97157be69993e1cf..e834d47c09e6b1ea796d659c97952955581a9b95 100644
--- a/media/base/key_systems.cc
+++ b/media/base/key_systems.cc
@@ -202,7 +202,7 @@ class KeySystemsImpl : public KeySystems {
   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,
@@ -665,7 +665,7 @@ bool KeySystemsImpl::IsSupportedKeySystem(const std::string& key_system) const {
   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,
@@ -677,12 +677,12 @@ bool KeySystemsImpl::IsSupportedCodecCombination(
   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;
   }
@@ -692,26 +692,39 @@ bool KeySystemsImpl::IsSupportedCodecCombination(
       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(
@@ -771,6 +784,13 @@ EmeConfigRule KeySystemsImpl::GetRobustnessConfigRule(
   }
 #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;
 }