Implement Chromium side of MediaKeys.isTypeSupported().

content/renderer/media/crypto/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 "content/renderer/media/crypto/key_systems.h"
 
 #include <string>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/eme_codec.h"
+#include "content/public/common/eme_init_data_type.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/key_system_info.h"
 #include "content/renderer/media/crypto/key_systems_support_uma.h"
 
 #if defined(OS_ANDROID)
 #include "media/base/android/media_codec_bridge.h"
 #endif
 
 #include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR.
 
 namespace content {
 
 const char kClearKeyKeySystem[] = "org.w3.clearkey";
 const char kPrefixedClearKeyKeySystem[] = "webkit-org.w3.clearkey";
 const char kUnsupportedClearKeyKeySystem[] = "unsupported-org.w3.clearkey";
 
 struct CodecMask {
   const char* type;
   EmeCodec mask;
 };
 
+struct InitDataTypeMask {

[ddorwin, 2014/09/13 01:20:45]

nit: move IDT stuff before container and codec to match ITS order.

[sandersd (OOO until July 31), 2014/09/22 23:45:53]

Done.

+  const char* type;
+  EmeInitDataType mask;

[ddorwin, 2014/09/13 01:20:45]

This seems like more of a type string to enum map.

I see that CodecMask is named this way, though. :(
Maybe we can replace "mask" with "enum" throughout.

[sandersd (OOO until July 31), 2014/09/22 23:45:52]

I had a go at renaming these, hopefully it's better.

+};
+
 // Mapping between container types and the masks of associated codecs.
 // Only audio codec can belong to a "audio/*" container. Both audio and video
 // codecs can belong to a "video/*" container.
 CodecMask kContainerCodecMasks[] = {
     {"audio/webm", EME_CODEC_WEBM_AUDIO_ALL},

[ddorwin, 2014/09/13 03:51:05]

I wonder if we should just convert these to conversion functions with switch
statements. This might be a bit simpler to read, but then we have to build maps
and find() in them when we could just call the function. WDYT?

[sandersd (OOO until July 31), 2014/09/22 23:45:53]

They are mutable so that unit tests can inject new entries, but accessor methods
do look better to me.

[ddorwin, 2014/09/23 22:48:15]

:( Okay, let's keep this in mind. If we enabled container support without
software codec support, we could probably use real types in those tests. (There
is a bug for that, but nobody is working on it.)

     {"video/webm", EME_CODEC_WEBM_ALL},
 #if defined(USE_PROPRIETARY_CODECS)
     {"audio/mp4", EME_CODEC_MP4_AUDIO_ALL},
     {"video/mp4", EME_CODEC_MP4_ALL}
 #endif  // defined(USE_PROPRIETARY_CODECS)
 };
 
 // Mapping between codec types and their masks.
 CodecMask kCodecMasks[] = {
     {"vorbis", EME_CODEC_WEBM_VORBIS},
     {"vp8", EME_CODEC_WEBM_VP8},
     {"vp8.0", EME_CODEC_WEBM_VP8},
     {"vp9", EME_CODEC_WEBM_VP9},
     {"vp9.0", EME_CODEC_WEBM_VP9},
 #if defined(USE_PROPRIETARY_CODECS)
     {"mp4a", EME_CODEC_MP4_AAC},
     {"avc1", EME_CODEC_MP4_AVC1},
     {"avc3", EME_CODEC_MP4_AVC1}
 #endif  // defined(USE_PROPRIETARY_CODECS)
 };
 
+// Mapping between initialization data types and their masks.

[ddorwin, 2014/09/13 01:20:45]

ditto on moving

[sandersd (OOO until July 31), 2014/09/22 23:45:53]

Done.

+InitDataTypeMask kInitDataTypeMasks[] = {
+    {"cenc", EME_INIT_DATA_TYPE_CENC},

[ddorwin, 2014/09/13 03:51:05]

This is a straight conversion and never depends on the key system. Should we
just do the conversion from JS string to usable value in WebCDMImpl.cc?

[sandersd (OOO until July 31), 2014/09/22 23:45:53]

We can, but then blink needs to know what the supported values are (and the enum
needs to move there), which seems wrong.

[ddorwin, 2014/09/23 22:48:15]

I think it's probably reasonable for Blink to know the possibly supported
values. If one is registered, it can be added to that interface. It's still up
to Chromium _whether_ it is supported.

+    {"webm", EME_INIT_DATA_TYPE_WEBM},
+    {"keyids", EME_INIT_DATA_TYPE_KEYIDS},
+};
+
 static void AddClearKey(std::vector<KeySystemInfo>* concrete_key_systems) {
   KeySystemInfo info(kClearKeyKeySystem);
 
   // On Android, Vorbis, VP8, AAC and AVC1 are supported in MediaCodec:
   // http://developer.android.com/guide/appendix/media-formats.html
   // VP9 support is device dependent.
 
   info.supported_codecs = EME_CODEC_WEBM_ALL;
 
 #if defined(OS_ANDROID)
   // Temporarily disable VP9 support for Android.
   // TODO(xhwang): Use mime_util.h to query VP9 support on Android.
   info.supported_codecs &= ~EME_CODEC_WEBM_VP9;
 #endif  // defined(OS_ANDROID)
 
 #if defined(USE_PROPRIETARY_CODECS)
   info.supported_codecs |= EME_CODEC_MP4_ALL;
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
+  info.supported_init_data_types = EME_INIT_DATA_TYPE_ALL;

[ddorwin, 2014/09/13 01:20:46]

ditto on moving (also in other files)

[sandersd (OOO until July 31), 2014/09/22 23:45:52]

Done.

+
   info.use_aes_decryptor = true;
 
   concrete_key_systems->push_back(info);
 }
 
 class KeySystems {
  public:
   static KeySystems& GetInstance();
 
   void UpdateIfNeeded();
 
   bool IsConcreteSupportedKeySystem(const std::string& key_system);
 
+  bool IsSupportedKeySystem(const std::string& key_system);
+
+  bool IsSupportedKeySystemWithInitDataType(
+      const std::string& key_system,
+      const std::string& init_data_type);
+
   bool IsSupportedKeySystemWithMediaMimeType(
       const std::string& mime_type,
       const std::vector<std::string>& codecs,
       const std::string& key_system);
 
   bool UseAesDecryptor(const std::string& concrete_key_system);
 
 #if defined(ENABLE_PEPPER_CDMS)
   std::string GetPepperType(const std::string& concrete_key_system);
 #endif
 
   void AddContainerMask(const std::string& container, uint32 mask);
   void AddCodecMask(const std::string& codec, uint32 mask);
 
  private:
   void UpdateSupportedKeySystems();
 
   void AddConcreteSupportedKeySystems(
       const std::vector<KeySystemInfo>& concrete_key_systems);
 
   void AddConcreteSupportedKeySystem(
       const std::string& key_system,
       bool use_aes_decryptor,
 #if defined(ENABLE_PEPPER_CDMS)
       const std::string& pepper_type,
 #endif
       SupportedCodecs supported_codecs,
+      SupportedInitDataTypes supported_init_data_types,

[ddorwin, 2014/09/13 01:20:45]

nit: move up one line to match ITS order.

[sandersd (OOO until July 31), 2014/09/22 23:45:52]

Done.

       const std::string& parent_key_system);
 
   friend struct base::DefaultLazyInstanceTraits<KeySystems>;
 
   struct KeySystemProperties {
     KeySystemProperties()
         : use_aes_decryptor(false), supported_codecs(EME_CODEC_NONE) {}
 
     bool use_aes_decryptor;
 #if defined(ENABLE_PEPPER_CDMS)
     std::string pepper_type;
 #endif
     SupportedCodecs supported_codecs;
+    SupportedInitDataTypes supported_init_data_types;

[ddorwin, 2014/09/13 01:20:45]

ditto

[sandersd (OOO until July 31), 2014/09/22 23:45:52]

Done.

   };
 
   typedef base::hash_map<std::string, KeySystemProperties>
       KeySystemPropertiesMap;
   typedef base::hash_map<std::string, std::string> ParentKeySystemMap;
   typedef base::hash_map<std::string, EmeCodec> CodecMaskMap;
+  typedef base::hash_map<std::string, EmeInitDataType> InitDataTypeMaskMap;

[ddorwin, 2014/09/13 01:20:46]

ditto

[sandersd (OOO until July 31), 2014/09/22 23:45:53]

Done.

 
   KeySystems();
   ~KeySystems() {}
 
   // Returns whether a |container| type is supported by checking
   // |key_system_supported_codecs|.
   // TODO(xhwang): Update this to actually check initDataType support.
   bool IsSupportedContainer(const std::string& container,
                             SupportedCodecs key_system_supported_codecs) const;
 
   // Returns true if all |codecs| are supported in |container| by checking
   // |key_system_supported_codecs|.
   bool IsSupportedContainerAndCodecs(
       const std::string& container,
       const std::vector<std::string>& codecs,
       SupportedCodecs key_system_supported_codecs) const;
 
   // Map from key system string to capabilities.
   KeySystemPropertiesMap concrete_key_system_map_;
 
   // Map from parent key system to the concrete key system that should be used
   // to represent its capabilities.
   ParentKeySystemMap parent_key_system_map_;
 
   KeySystemsSupportUMA key_systems_support_uma_;
 
   CodecMaskMap container_codec_masks_;
   CodecMaskMap codec_masks_;
+  InitDataTypeMaskMap init_data_type_masks_;

[ddorwin, 2014/09/13 01:20:45]

ditto

[sandersd (OOO until July 31), 2014/09/22 23:45:53]

Done.

 
   bool needs_update_;
   base::Time last_update_time_;
 
   // Makes sure all methods are called from the same thread.
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(KeySystems);
 };
 
 static base::LazyInstance<KeySystems> g_key_systems = LAZY_INSTANCE_INITIALIZER;
 
 KeySystems& KeySystems::GetInstance() {
   KeySystems& key_systems = g_key_systems.Get();
   key_systems.UpdateIfNeeded();
   return key_systems;
 }
 
 // Because we use a LazyInstance, the key systems info must be populated when
 // the instance is lazily initiated.
 KeySystems::KeySystems() : needs_update_(true) {
   // Build container and codec masks for quick look up.
-  for (size_t i = 0; i < arraysize(kContainerCodecMasks); ++i) {
-    const CodecMask& container_codec_mask = kContainerCodecMasks[i];
-    DCHECK(container_codec_masks_.find(container_codec_mask.type) ==
-           container_codec_masks_.end());
-    container_codec_masks_[container_codec_mask.type] =
-        container_codec_mask.mask;
+#define BUILD_MASK(dst, src)                      \

[ddorwin, 2014/09/13 01:20:45]

Macros aren't allowed. Would a template function work?

[sandersd (OOO until July 31), 2014/09/22 23:45:52]

I've expanded the macro, but I do think the macro version is harder to typo.

+  for (size_t i = 0; i < arraysize(src); ++i) {   \
+    DCHECK(dst.find(src[i].type) == dst.end()); \
+    dst[src[i].type] = src[i].mask;              \
   }
-  for (size_t i = 0; i < arraysize(kCodecMasks); ++i) {
-    const CodecMask& codec_mask = kCodecMasks[i];
-    DCHECK(codec_masks_.find(codec_mask.type) == codec_masks_.end());
-    codec_masks_[codec_mask.type] = codec_mask.mask;
-  }
+  BUILD_MASK(container_codec_masks_, kContainerCodecMasks);
+  BUILD_MASK(codec_masks_, kCodecMasks);
+  BUILD_MASK(init_data_type_masks_, kInitDataTypeMasks);
+#undef BUILD_MASK
 
   UpdateSupportedKeySystems();
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
   key_systems_support_uma_.AddKeySystemToReport(kWidevineKeySystem);
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 }
 
 void KeySystems::UpdateIfNeeded() {
 #if defined(WIDEVINE_CDM_AVAILABLE)
@@ skipping 43 matching lines @@
   DCHECK(parent_key_system_map_.empty());
 
   for (size_t i = 0; i < concrete_key_systems.size(); ++i) {
     const KeySystemInfo& key_system_info = concrete_key_systems[i];
     AddConcreteSupportedKeySystem(key_system_info.key_system,
                                   key_system_info.use_aes_decryptor,
 #if defined(ENABLE_PEPPER_CDMS)
                                   key_system_info.pepper_type,
 #endif
                                   key_system_info.supported_codecs,
+                                  key_system_info.supported_init_data_types,
                                   key_system_info.parent_key_system);
   }
 }
 
 void KeySystems::AddConcreteSupportedKeySystem(
     const std::string& concrete_key_system,
     bool use_aes_decryptor,
 #if defined(ENABLE_PEPPER_CDMS)
     const std::string& pepper_type,
 #endif
     SupportedCodecs supported_codecs,
+    SupportedInitDataTypes supported_init_data_types,
     const std::string& parent_key_system) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!IsConcreteSupportedKeySystem(concrete_key_system))
       << "Key system '" << concrete_key_system << "' already registered";
   DCHECK(parent_key_system_map_.find(concrete_key_system) ==
          parent_key_system_map_.end())
       <<  "'" << concrete_key_system << " is already registered as a parent";
 
   KeySystemProperties properties;
   properties.use_aes_decryptor = use_aes_decryptor;
 #if defined(ENABLE_PEPPER_CDMS)
   DCHECK_EQ(use_aes_decryptor, pepper_type.empty());
   properties.pepper_type = pepper_type;
 #endif
 
   properties.supported_codecs = supported_codecs;
+  properties.supported_init_data_types = supported_init_data_types;
 
   concrete_key_system_map_[concrete_key_system] = properties;
 
   if (!parent_key_system.empty()) {
     DCHECK(!IsConcreteSupportedKeySystem(parent_key_system))
         << "Parent '" << parent_key_system << "' already registered concrete";
     DCHECK(parent_key_system_map_.find(parent_key_system) ==
            parent_key_system_map_.end())
         << "Parent '" << parent_key_system << "' already registered";
     parent_key_system_map_[parent_key_system] = concrete_key_system;
   }
 }
 
 bool KeySystems::IsConcreteSupportedKeySystem(const std::string& key_system) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return concrete_key_system_map_.find(key_system) !=
-      concrete_key_system_map_.end();
+  return concrete_key_system_map_.count(key_system);

[ddorwin, 2014/09/13 01:20:45]

Is there a reason you made this change? Not that it matters in practice, but his
requires iterating through the entire list even after one is found.

[sandersd (OOO until July 31), 2014/09/22 23:45:53]

It's a hash_map.

 }
 
 bool KeySystems::IsSupportedContainer(
     const std::string& container,
     SupportedCodecs key_system_supported_codecs) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!container.empty());
 
   // When checking container support for EME, "audio/foo" should be treated the
   // same as "video/foo". Convert the |container| to achieve this.
@@ skipping 41 matching lines @@
       return false;
 
     // Unsupported codec/container combination, e.g. "video/webm" and "avc1".
     if (!(codec_mask & container_codec_mask))
       return false;
   }
 
   return true;
 }
 
+bool KeySystems::IsSupportedKeySystem(const std::string& key_system) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return (parent_key_system_map_.count(key_system) ||

[ddorwin, 2014/09/13 01:20:45]

ditto.

[sandersd (OOO until July 31), 2014/09/22 23:45:53]

Acknowledged.

+          concrete_key_system_map_.count(key_system));

[ddorwin, 2014/09/13 01:20:45]

minor: We're more likely to see concrete key system queries, so check that one
first.

[sandersd (OOO until July 31), 2014/09/22 23:45:53]

Done.

+}
+
+bool KeySystems::IsSupportedKeySystemWithInitDataType(
+    const std::string& key_system,
+    const std::string& init_data_type) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // If |key_system| is a parent key system, use its concrete child.
+  std::string concrete_key_system = key_system;
+  ParentKeySystemMap::const_iterator parent_key_system_iter =
+      parent_key_system_map_.find(key_system);
+  if (parent_key_system_iter != parent_key_system_map_.end())
+    concrete_key_system = parent_key_system_iter->second;
+
+  // Locate |concrete_key_system|.
+  KeySystemPropertiesMap::const_iterator key_system_iter =
+      concrete_key_system_map_.find(concrete_key_system);
+  if (key_system_iter == concrete_key_system_map_.end())
+    return false;
+
+  // Check |init_data_type|.
+  InitDataTypeMaskMap::const_iterator init_data_type_iter =
+      init_data_type_masks_.find(init_data_type);
+  if (init_data_type_iter == init_data_type_masks_.end())
+    return false;
+
+  // Check |key_system| x |init_data_type|.
+  const KeySystemProperties& properties = key_system_iter->second;
+  const EmeInitDataType& init_data_type_mask = init_data_type_iter->second;
+  if (!(properties.supported_init_data_types & init_data_type_mask))
+    return false;
+
+  return true;
+}
+
 bool KeySystems::IsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system) {

[ddorwin, 2014/09/13 01:20:45]

note: This ordering is odd (probably to match CPT). we should fix it sometime.
We'd also re-order the checks to match the function above.

[sandersd (OOO until July 31), 2014/09/22 23:45:52]

I agree, and some of the Is____ methods are probably entirely obsolete now too
(especially this one).

   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If |key_system| is a parent key_system, use its concrete child.

[ddorwin, 2014/09/13 01:20:45]

Please remove second '_'

[sandersd (OOO until July 31), 2014/09/22 23:45:53]

Done.

   // Otherwise, use |key_system|.

[ddorwin, 2014/09/13 01:20:45]

442-449 are different from 408-412. The code should at least be consistent.
Better yet, maybe it makes sense to have a private function called
GetConcreteKeySystem(). That replaces all of the comments and code with one line
in each function.

[sandersd (OOO until July 31), 2014/09/22 23:45:52]

Done.

   std::string concrete_key_system;
   ParentKeySystemMap::iterator parent_key_system_iter =
       parent_key_system_map_.find(key_system);
   if (parent_key_system_iter != parent_key_system_map_.end())
     concrete_key_system = parent_key_system_iter->second;
   else
     concrete_key_system = key_system;
 
   bool has_type = !mime_type.empty();
 
@@ skipping 91 matching lines @@
   if (key_system == kClearKeyKeySystem)
     return kPrefixedClearKeyKeySystem;
 
   return key_system;
 }
 
 bool IsConcreteSupportedKeySystem(const std::string& key_system) {
   return KeySystems::GetInstance().IsConcreteSupportedKeySystem(key_system);
 }
 
+bool IsSupportedKeySystem(const std::string& key_system) {
+  return KeySystems::GetInstance().IsSupportedKeySystem(key_system);
+}
+
+bool IsSupportedKeySystemWithInitDataType(
+    const std::string& key_system,
+    const std::string& init_data_type) {
+  return KeySystems::GetInstance().IsSupportedKeySystemWithInitDataType(
+      key_system, init_data_type);
+}
+
 bool IsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system) {
   return KeySystems::GetInstance().IsSupportedKeySystemWithMediaMimeType(
       mime_type, codecs, key_system);
 }
 
 std::string KeySystemNameForUMA(const std::string& key_system) {
   if (key_system == kClearKeyKeySystem)
@@ skipping 24 matching lines @@
 CONTENT_EXPORT void AddContainerMask(const std::string& container,
                                      uint32 mask) {
   KeySystems::GetInstance().AddContainerMask(container, mask);
 }
 
 CONTENT_EXPORT void AddCodecMask(const std::string& codec, uint32 mask) {
   KeySystems::GetInstance().AddCodecMask(codec, mask);
 }
 
 }  // namespace content