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_constants.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 NamedInitDataType {
+  const char* name;
+  EmeInitDataType type;
 };
 
-// Mapping between container types and the masks of associated codecs.
+// Mapping between initialization data types names and enum values.

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

Add a comment to update IsSaneInitDataTypeWithContainer() if necessary when
adding new types.

[sandersd (OOO until July 31), 2014/09/24 22:22:34]

Done.

+static NamedInitDataType kInitDataTypes[] = {
+    {"cenc", EME_INIT_DATA_TYPE_CENC},

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

ifdef - this will fail to compile.
Also, remove the trailing ',' once reordered (below).

[sandersd (OOO until July 31), 2014/09/24 22:22:33]

Done.

+    {"webm", EME_INIT_DATA_TYPE_WEBM},

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

ditto on swapping order

[sandersd (OOO until July 31), 2014/09/24 22:22:33]

Done.

+};
+
+struct NamedCodec {
+  const char* name;
+  EmeCodec type;
+};
+
+// Mapping between containers and their codecs.
 // Only audio codec can belong to a "audio/*" container. Both audio and video
 // codecs can belong to a "video/*" container.
-CodecMask kContainerCodecMasks[] = {
+static NamedCodec kContainerCodecs[] = {
     {"audio/webm", EME_CODEC_WEBM_AUDIO_ALL},
     {"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[] = {
+// Mapping between codec names and enum values.
+static NamedCodec kCodecs[] = {
     {"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)
 };
 
 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_init_data_types = EME_INIT_DATA_TYPE_WEBM;
   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_init_data_types |= EME_INIT_DATA_TYPE_CENC;
   info.supported_codecs |= EME_CODEC_MP4_ALL;
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
   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
+      SupportedInitDataTypes supported_init_data_types,
       SupportedCodecs supported_codecs,
       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
+    SupportedInitDataTypes supported_init_data_types;
     SupportedCodecs supported_codecs;
   };
 

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

Is there a reason you removed the typedefs? They were shorter and easier to
locate.

[sandersd (OOO until July 31), 2014/09/24 22:22:34]

Only one of them was used more than once in the code, but separated from their
uses making it a pain to go back and forth.

I've put them back as requested.

-  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;
-
   KeySystems();
   ~KeySystems() {}
 
+  EmeInitDataType LookupInitDataType(const std::string& init_data_type) const;

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

nit: GetInitDataTypeForString()?

[sandersd (OOO until July 31), 2014/09/24 22:22:33]

Done.

+  SupportedCodecs LookupContainer(const std::string& container) const;

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

In the future, it'd be nice to have a container enum too and be able to
GetCodecMaskForContainer(), which would return the _ALL codecs value.

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

Is this more GetCodecsMaskForContainer()?

[sandersd (OOO until July 31), 2014/09/24 22:22:34]

Done.

[sandersd (OOO until July 31), 2014/09/24 22:22:34]

Done.

+  EmeCodec LookupCodec(const std::string& codec) const;

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

nit: GetCodecForString() or ConvertStringToCodec()?

[sandersd (OOO until July 31), 2014/09/24 22:22:34]

Done.

+
+  const std::string& GetConcreteKeySystem(const std::string& key_system) const;

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

nit: ...Name

[sandersd (OOO until July 31), 2014/09/24 22:22:33]

Done.

+
   // 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_;
+  base::hash_map<std::string, KeySystemProperties> 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_;
+  base::hash_map<std::string, std::string> parent_key_system_map_;
 
   KeySystemsSupportUMA key_systems_support_uma_;
 
-  CodecMaskMap container_codec_masks_;
-  CodecMaskMap codec_masks_;
+  base::hash_map<std::string, SupportedCodecs> container_codecs_;

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

container_to_codecs_map_?

[sandersd (OOO until July 31), 2014/09/24 22:22:33]

Done.

+  base::hash_map<std::string, EmeCodec> codecs_;

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

codec_string_map_?

[sandersd (OOO until July 31), 2014/09/24 22:22:33]

Done.

+  base::hash_map<std::string, EmeInitDataType> init_data_types_;

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

...map_

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

make this one first.

[sandersd (OOO until July 31), 2014/09/24 22:22:33]

Done.

[sandersd (OOO until July 31), 2014/09/24 22:22:33]

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;
+  for (size_t i = 0; i < arraysize(kContainerCodecs); ++i) {

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

You might be able to use a template function. However, a better solution is
probably to eliminate these tables in a future CL.

[sandersd (OOO until July 31), 2014/09/24 22:22:33]

Sounds good, I've mentioned that in the bug for refactoring
key_systems_unittest.cc

+    const std::string& name = kContainerCodecs[i].name;
+    DCHECK(container_codecs_.find(name) == container_codecs_.end());
+    container_codecs_[name] = kContainerCodecs[i].type;
   }
-  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;
+  for (size_t i = 0; i < arraysize(kCodecs); ++i) {
+    const std::string& name = kCodecs[i].name;
+    DCHECK(codecs_.find(name) == codecs_.end());
+    codecs_[name] = kCodecs[i].type;
+  }
+  for (size_t i = 0; i < arraysize(kInitDataTypes); ++i) {

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

move to line 214

[sandersd (OOO until July 31), 2014/09/24 22:22:33]

Done.

+    const std::string& name = kInitDataTypes[i].name;
+    DCHECK(init_data_types_.find(name) == init_data_types_.end());
+    init_data_types_[name] = kInitDataTypes[i].type;
   }
 
   UpdateSupportedKeySystems();
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
   key_systems_support_uma_.AddKeySystemToReport(kWidevineKeySystem);
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 }
 
+EmeInitDataType KeySystems::LookupInitDataType(
+    const std::string& init_data_type) const {
+  base::hash_map<std::string, EmeInitDataType>::const_iterator iter =
+      init_data_types_.find(init_data_type);
+  if (iter != init_data_types_.end())
+    return iter->second;
+  return EME_INIT_DATA_TYPE_NONE;
+}
+
+SupportedCodecs KeySystems::LookupContainer(
+    const std::string& container) const {
+  base::hash_map<std::string, SupportedCodecs>::const_iterator iter =
+      container_codecs_.find(container);
+  if (iter != container_codecs_.end())
+    return iter->second;
+  return EME_CODEC_NONE;
+}
+
+EmeCodec KeySystems::LookupCodec(const std::string& codec) const {
+  base::hash_map<std::string, EmeCodec>::const_iterator iter =
+      codecs_.find(codec);
+  if (iter != codecs_.end())
+    return iter->second;
+  return EME_CODEC_NONE;
+}
+
+const std::string& KeySystems::GetConcreteKeySystem(
+    const std::string& key_system) const {
+   base::hash_map<std::string, std::string>::const_iterator iter =
+      parent_key_system_map_.find(key_system);
+  if (iter != parent_key_system_map_.end())
+    return iter->second;
+  return key_system;
+}
+
 void KeySystems::UpdateIfNeeded() {
 #if defined(WIDEVINE_CDM_AVAILABLE)
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!needs_update_)
     return;
 
   // The update could involve a sync IPC to the browser process. Use a minimum
   // update interval to avoid unnecessary frequent IPC to the browser.
   static const int kMinUpdateIntervalInSeconds = 1;
   base::Time now = base::Time::Now();
@@ skipping 35 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,

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

move up

[sandersd (OOO until July 31), 2014/09/24 22:22:34]

Alright, now I'm sad that the compiler didn't warn about this one.

[ddorwin, 2014/09/27 00:41:24]

The danger of using masks!

     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;

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

ditto

[sandersd (OOO until July 31), 2014/09/24 22:22:34]

Done.

 
   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);
 }
 
 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.
   // TODO(xhwang): Replace this with real checks against supported initDataTypes
   // combined with supported demuxers.
   std::string canonical_container = container;
   if (container.find("audio/") == 0)

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

Note: If we also use enums for container types in the Blink layer, we may need
to pass the major type too so we can reject video codecs in "audio containers."

[sandersd (OOO until July 31), 2014/09/24 22:22:33]

Yes, we'll need both to be able to keep doing the container -> codec mask map
lookup.

     canonical_container.replace(0, 6, "video/");
 
-  CodecMaskMap::const_iterator container_iter =
-      container_codec_masks_.find(canonical_container);
-  // Unrecognized container.
-  if (container_iter == container_codec_masks_.end())
-    return false;
-
-  EmeCodec container_codec_mask = container_iter->second;
   // A container is supported iif at least one codec in that container is
   // supported.
-  return (container_codec_mask & key_system_supported_codecs) != 0;
+  SupportedCodecs supported_codecs = LookupContainer(canonical_container);
+  return (supported_codecs & key_system_supported_codecs) != 0;
 }
 
 bool KeySystems::IsSupportedContainerAndCodecs(
     const std::string& container,
     const std::vector<std::string>& codecs,
     SupportedCodecs key_system_supported_codecs) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!container.empty());
   DCHECK(!codecs.empty());
   DCHECK(IsSupportedContainer(container, key_system_supported_codecs));
 
-  CodecMaskMap::const_iterator container_iter =
-      container_codec_masks_.find(container);
-  EmeCodec container_codec_mask = container_iter->second;
+  SupportedCodecs container_supported_codecs = LookupContainer(container);
 
   for (size_t i = 0; i < codecs.size(); ++i) {
-    const std::string& codec = codecs[i];
-    if (codec.empty())
-      continue;
-    CodecMaskMap::const_iterator codec_iter = codec_masks_.find(codec);
-    if (codec_iter == codec_masks_.end())  // Unrecognized codec.
-      return false;
+    EmeCodec codec = LookupCodec(codecs[i]);

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

The "codec.empty()" logic was for a specific reason:
https://codereview.chromium.org/254913002.

We will get 0 now, which will cause us to fall into 411, changing the behavior.

It appears that I was unsure whether we wanted it to succeed or fail. For ITS,
we can probably be more strict. This might be breaking a layout test, though.
xhwang, do you recall more details?

[xhwang, 2014/09/29 21:27:17]

Yeah, see the CL description of https://codereview.chromium.org/254913002

',vorbis' will be split into "" and "vorbis":

https://code.google.com/p/chromium/codesearch#chromium/src/net/base/mime_util...

https://code.google.com/p/chromium/codesearch#chromium/src/base/strings/strin...

I am not a fan of this but this is what it is. And currently we have layout
tests covering this behavior. I'll be happy to enforce what the spec says.

For now, we should probably just keep the old code. An extra comment would be
nice.

[sandersd (OOO until July 31), 2014/09/29 21:38:48]

Acknowledged. (There is a bug reference comment now)

 
-    EmeCodec codec_mask = codec_iter->second;
-    if (!(codec_mask & key_system_supported_codecs))  // Unsupported codec.
+    // Unsupported codec.
+    if (!(codec & key_system_supported_codecs))
       return false;
 
     // Unsupported codec/container combination, e.g. "video/webm" and "avc1".
-    if (!(codec_mask & container_codec_mask))
+    if (!(codec & container_supported_codecs))
       return false;
   }
 
   return true;
 }
 
+bool KeySystems::IsSupportedKeySystem(const std::string& key_system) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return (concrete_key_system_map_.count(key_system) ||
+          parent_key_system_map_.count(key_system));
+}
+
+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.
+  const std::string& concrete_key_system = GetConcreteKeySystem(key_system);
+
+  // Locate |concrete_key_system|.
+  base::hash_map<std::string, KeySystemProperties>::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| and |key_system| x |init_data_type|.
+  const KeySystemProperties& properties = key_system_iter->second;
+  EmeInitDataType eme_init_data_type = LookupInitDataType(init_data_type);
+  return properties.supported_init_data_types & eme_init_data_type;
+}
+
+// TODO(sandersd): Remove if possible, otherwise reorganize in the same order as

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

See comments below.
canPlayType() calls this directly [1]. We might be able to replace that, but we
need to maintain the UMAs. (Changing the structure might help us report
consistent values for both prefixed and unprefixed.)

[1]
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/r...

[sandersd (OOO until July 31), 2014/09/24 22:22:33]

Done.

+// IsKeySystemSupportedWithInitDataType().
 bool KeySystems::IsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // If |key_system| is a parent key_system, use its concrete child.
-  // Otherwise, use |key_system|.
-  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;
+  // If |key_system| is a parent key system, use its concrete child.
+  const std::string& concrete_key_system = GetConcreteKeySystem(key_system);
 
   bool has_type = !mime_type.empty();
 
   key_systems_support_uma_.ReportKeySystemQuery(key_system, has_type);

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

We now have some paths, including the function above, that do not handle the
UMA. We might want to somehow differentiate the two APIs too.

xhwang, please advise on the best path.

[xhwang, 2014/09/29 21:27:17]

I checked the current UMA stats (under Counts) and don't find those stats very
interesting. We probably want to think more about what's worth reporting.

For, I think it's okay to leave alone the UMA stuff and worry about it later.

[sandersd (OOO until July 31), 2014/09/29 21:38:48]

Acknowledged.

 
   // Check key system support.
-  KeySystemPropertiesMap::const_iterator key_system_iter =
-      concrete_key_system_map_.find(concrete_key_system);
+  base::hash_map<std::string, KeySystemProperties>::const_iterator
+      key_system_iter = concrete_key_system_map_.find(concrete_key_system);
   if (key_system_iter == concrete_key_system_map_.end())
     return false;
 
   key_systems_support_uma_.ReportKeySystemSupport(key_system, false);
 
   if (!has_type) {

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

Note: The canPlayType() flow would always end up here, even if we really just
wanted to check IsSupportedKeySystem. Note that this also helps us handle UMAs
correctly.

[ddorwin, 2014/09/27 00:41:24]

+xhwang

[xhwang, 2014/09/29 21:27:17]

Acknowledged.

     DCHECK(codecs.empty());
     return true;
   }
 
   SupportedCodecs key_system_supported_codecs =
       key_system_iter->second.supported_codecs;
 
   if (!IsSupportedContainer(mime_type, key_system_supported_codecs))
     return false;
 
   if (!codecs.empty() &&
       !IsSupportedContainerAndCodecs(
           mime_type, codecs, key_system_supported_codecs)) {
     return false;
   }
 
   key_systems_support_uma_.ReportKeySystemSupport(key_system, true);
   return true;
 }
 
 bool KeySystems::UseAesDecryptor(const std::string& concrete_key_system) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  KeySystemPropertiesMap::iterator key_system_iter =
-      concrete_key_system_map_.find(concrete_key_system);
+  base::hash_map<std::string, KeySystemProperties>::const_iterator
+      key_system_iter = concrete_key_system_map_.find(concrete_key_system);
   if (key_system_iter == concrete_key_system_map_.end()) {
       DLOG(FATAL) << concrete_key_system << " is not a known concrete system";
       return false;
   }
 
   return key_system_iter->second.use_aes_decryptor;
 }
 
 #if defined(ENABLE_PEPPER_CDMS)
 std::string KeySystems::GetPepperType(const std::string& concrete_key_system) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  KeySystemPropertiesMap::iterator key_system_iter =
-      concrete_key_system_map_.find(concrete_key_system);
+  base::hash_map<std::string, KeySystemProperties>::const_iterator
+      key_system_iter = concrete_key_system_map_.find(concrete_key_system);
   if (key_system_iter == concrete_key_system_map_.end()) {
       DLOG(FATAL) << concrete_key_system << " is not a known concrete system";
       return std::string();
   }
 
   const std::string& type = key_system_iter->second.pepper_type;
   DLOG_IF(FATAL, type.empty()) << concrete_key_system << " is not Pepper-based";
   return type;
 }
 #endif
 
 void KeySystems::AddContainerMask(const std::string& container, uint32 mask) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(container_codec_masks_.find(container) ==
-         container_codec_masks_.end());
+  DCHECK(container_codecs_.find(container) == container_codecs_.end());
 
-  container_codec_masks_[container] = static_cast<EmeCodec>(mask);
+  container_codecs_[container] = static_cast<EmeCodec>(mask);
 }
 
 void KeySystems::AddCodecMask(const std::string& codec, uint32 mask) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(codec_masks_.find(codec) == codec_masks_.end());
+  DCHECK(codecs_.find(codec) == codecs_.end());
 
-  codec_masks_[codec] = static_cast<EmeCodec>(mask);
+  codecs_[codec] = static_cast<EmeCodec>(mask);
 }
 
 //------------------------------------------------------------------------------
 
 std::string GetUnprefixedKeySystemName(const std::string& key_system) {
   if (key_system == kClearKeyKeySystem)
     return kUnsupportedClearKeyKeySystem;
 
   if (key_system == kPrefixedClearKeyKeySystem)
     return kClearKeyKeySystem;
 
   return key_system;
 }
 
 std::string GetPrefixedKeySystemName(const std::string& key_system) {
   DCHECK_NE(key_system, kPrefixedClearKeyKeySystem);
 
   if (key_system == kClearKeyKeySystem)
     return kPrefixedClearKeyKeySystem;
 
   return key_system;
 }
 
+bool IsSaneInitDataTypeWithContainer(
+    const std::string& init_data_type,
+    const std::string& container) {
+  if (init_data_type == "cenc") {
+    return container != "audio/webm" && container != "video/webm";

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

Why not positive checks?
This is actually wrong if someone decided to add video/ogg or whatever.

[sandersd (OOO until July 31), 2014/09/24 22:22:34]

I was assuming the goal was to exclude bad combinations, but either way is fine.

+  } else if (init_data_type == "webm") {
+    return  container != "audio/mp4" && container != "video/mp4";
+  } else {
+    return true;

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

Related to enums, it would be nice to be able to have a switch with a NOTREACHED
here. On some platforms, the lack of a default would also force new types to be
considered here.

[sandersd (OOO until July 31), 2014/09/24 22:22:33]

Sounds reasonable, I've just added the NOTREACHED for now.

+  }
+}
+
 bool IsConcreteSupportedKeySystem(const std::string& key_system) {
   return KeySystems::GetInstance().IsConcreteSupportedKeySystem(key_system);
 }
 
+bool IsSupportedKeySystem(const std::string& key_system) {

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

Related to UMAs, if someone refactored the code such that prefixed flowed
through here, our UMAs might be broken.

[sandersd (OOO until July 31), 2014/09/24 22:22:34]

I added a comment to the implementation.

+  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