Store SupportedCodecs in KeySystemInfo and KeySystems.

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 <map>
 #include <string>
 
+#include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "content/public/common/content_client.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"
+#include "media/cdm/encrypted_media_codecs.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";
 
-const char kAudioWebM[] = "audio/webm";
-const char kVideoWebM[] = "video/webm";
-const char kVorbis[] = "vorbis";
-const char kVP8[] = "vp8";
-const char kVP80[] = "vp8.0";
+using media::SupportedCodecs;
+using media::SupportedCodecMask;
 
+struct CodecMaskMap {
+  const char* type;
+  SupportedCodecMask mask;
+};
+
+// Mapping between container types and the masks of associated codecs.
+// A container is supported iif a codec that belongs to it is supported.

[ddorwin, 2014/04/22 21:24:41]

This is the cause of the problem I mentioned earlier.

[xhwang, 2014/04/23 17:29:14]

Done.

+// Only audio codec can belong to a "audio/*" container. Both audio and video
+// codecs can belong to a "video/*" container.
+CodecMaskMap kContainerMasks[] = {
+    {"audio/webm", media::WEBM_AUDIO},
+    {"video/webm", media::WEBM_CODECS},

[ddorwin, 2014/04/22 21:24:41]

I mentioned this in the .h file later, but see how AUDIO and CODECS don't look
right together?

[xhwang, 2014/04/23 17:29:14]

Done.

 #if defined(USE_PROPRIETARY_CODECS)
-const char kAudioMp4[] = "audio/mp4";
-const char kVideoMp4[] = "video/mp4";
-const char kMp4a[] = "mp4a";
-const char kAvc1[] = "avc1";
-const char kAvc3[] = "avc3";
+    {"audio/mp4", media::MP4_AUDIO},
+    {"video/mp4", media::MP4_CODECS}
 #endif  // defined(USE_PROPRIETARY_CODECS)
+};
+
+// Mapping between codec types and their masks.
+CodecMaskMap kCodecMasks[] = {
+    {"vorbis", media::WEBM_VORBIS},
+    {"vp8", media::WEBM_VP8},
+    {"vp8.0", media::WEBM_VP8},
+#if defined(USE_PROPRIETARY_CODECS)
+    {"mp4a", media::MP4_AAC},
+    {"avc1", media::MP4_AVC1},
+    {"avc3", media::MP4_AVC1}
+#endif  // defined(USE_PROPRIETARY_CODECS)
+};
 
 static void AddClearKey(std::vector<KeySystemInfo>* concrete_key_systems) {
   KeySystemInfo info(kClearKeyKeySystem);
 
 #if defined(OS_ANDROID)
   // If MediaCodecBridge is not available. EME should not be enabled at all.
   // See SetRuntimeFeatureDefaultsForPlatform().
   // VP8 and AVC1 are supported on all MediaCodec implementations:
   // http://developer.android.com/guide/appendix/media-formats.html
   DCHECK(media::MediaCodecBridge::IsAvailable());
 #endif
 
-  info.supported_types[kAudioWebM].insert(kVorbis);
-  info.supported_types[kVideoWebM] = info.supported_types[kAudioWebM];
-  info.supported_types[kVideoWebM].insert(kVP8);
-  info.supported_types[kVideoWebM].insert(kVP80);
+  info.supported_codecs = media::WEBM_CODECS;

[ddorwin, 2014/04/22 21:24:41]

OOC, what will this look like when we selectively enable VP9? We'll either be
building it from the base codecs or subtracting VP9. The same may eventually
apply to Opus.

[xhwang, 2014/04/23 17:29:14]

VP9 will be device dependent on Android. So we really can't build the
information statically here. 

Short term plan: Enable VP9 everywhere except here (clearkey + android).

Long term plan: We'll need to do something similar to AddAndroidWidevine() to
query that information from the browser process. WDYT?

 #if defined(USE_PROPRIETARY_CODECS)
-  info.supported_types[kAudioMp4].insert(kMp4a);
-  info.supported_types[kVideoMp4] = info.supported_types[kAudioMp4];
-  info.supported_types[kVideoMp4].insert(kAvc1);
-  info.supported_types[kVideoMp4].insert(kAvc3);
+  info.supported_codecs |= media::MP4_CODECS;
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
   info.use_aes_decryptor = true;
 
   concrete_key_systems->push_back(info);
 }
 
 class KeySystems {
  public:
   static KeySystems& GetInstance();
 
   bool IsConcreteSupportedKeySystem(const std::string& key_system);
 
   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:
-  typedef KeySystemInfo::CodecSet CodecSet;
-  typedef KeySystemInfo::ContainerCodecsMap ContainerCodecsMap;
-
   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
-      const ContainerCodecsMap& supported_types,
+      const SupportedCodecs& supported_codecs,

[ddorwin, 2014/04/22 21:24:41]

an integer, so can remove '&'

[xhwang, 2014/04/23 17:29:14]

Done.

       const std::string& parent_key_system);
 
   friend struct base::DefaultLazyInstanceTraits<KeySystems>;
+  friend class KeySystemsTest;

[ddorwin, 2014/04/22 21:24:41]

I don't think this is right. This class is local.

[xhwang, 2014/04/23 17:29:14]

I forgot to remove this. Removed.

 
   struct KeySystemProperties {
     KeySystemProperties() : use_aes_decryptor(false) {}
 
     bool use_aes_decryptor;
 #if defined(ENABLE_PEPPER_CDMS)
     std::string pepper_type;
 #endif
-    ContainerCodecsMap supported_types;
+    SupportedCodecs supported_codecs;
   };
 
-  typedef std::map<std::string, KeySystemProperties> KeySystemPropertiesMap;
-
-  typedef std::map<std::string, std::string> ParentKeySystemMap;
+  typedef base::hash_map<std::string, KeySystemProperties>
+      KeySystemPropertiesMap;
+  typedef base::hash_map<std::string, std::string> ParentKeySystemMap;
+  typedef base::hash_map<std::string, SupportedCodecMask> MaskMap;
 
   KeySystems();
   ~KeySystems() {}
 
   bool IsSupportedKeySystemWithContainerAndCodec(const std::string& mime_type,
                                                  const std::string& codec,
                                                  const std::string& key_system);

[ddorwin, 2014/04/22 21:24:41]

Should be const method?

[xhwang, 2014/04/23 17:29:14]

This function has been refactored. The new function is 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_;
 
+  MaskMap container_masks_;
+  MaskMap codec_masks_;
+
   DISALLOW_COPY_AND_ASSIGN(KeySystems);
 };
 
 static base::LazyInstance<KeySystems> g_key_systems = LAZY_INSTANCE_INITIALIZER;
 
 KeySystems& KeySystems::GetInstance() {
   return g_key_systems.Get();
 }
 
 // Because we use a LazyInstance, the key systems info must be populated when
 // the instance is lazily initiated.
 KeySystems::KeySystems() {
+  // Build container and codec masks for quick look up.
+  for (size_t i = 0; i < arraysize(kContainerMasks); ++i) {
+    container_masks_[kContainerMasks[i].type] = kContainerMasks[i].mask;

[ddorwin, 2014/04/22 21:24:41]

DCHECK(!find())?

[xhwang, 2014/04/23 17:29:14]

Done.

+  }
+  for (size_t i = 0; i < arraysize(kCodecMasks); ++i) {
+    codec_masks_[kCodecMasks[i].type] = kCodecMasks[i].mask;
+  }
+
   std::vector<KeySystemInfo> key_systems_info;
   GetContentClient()->renderer()->AddKeySystems(&key_systems_info);
   // Clear Key is always supported.
   AddClearKey(&key_systems_info);
   AddConcreteSupportedKeySystems(key_systems_info);
 #if defined(WIDEVINE_CDM_AVAILABLE)
   key_systems_support_uma_.AddKeySystemToReport(kWidevineKeySystem);
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 }
 
 void KeySystems::AddConcreteSupportedKeySystems(
     const std::vector<KeySystemInfo>& concrete_key_systems) {
   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_types,
+                                  key_system_info.supported_codecs,
                                   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
-    const ContainerCodecsMap& supported_types,
+    const SupportedCodecs& supported_codecs,
     const std::string& parent_key_system) {
   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_types = supported_types;
+  properties.supported_codecs = supported_codecs;
 
   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) {
   return concrete_key_system_map_.find(key_system) !=
       concrete_key_system_map_.end();
 }
 
 bool KeySystems::IsSupportedKeySystemWithContainerAndCodec(
     const std::string& mime_type,
     const std::string& codec,

[ddorwin, 2014/04/22 21:24:41]

We query each codec? Maybe we should pass multiple now (or a future CL) since
we're using a mask anyway.

[xhwang, 2014/04/23 17:29:14]

Done.

     const std::string& key_system) {
   bool has_type = !mime_type.empty();
   DCHECK(has_type || codec.empty());
 
   key_systems_support_uma_.ReportKeySystemQuery(key_system, has_type);
 
   KeySystemPropertiesMap::const_iterator key_system_iter =
       concrete_key_system_map_.find(key_system);
   if (key_system_iter == concrete_key_system_map_.end())
     return false;
 
   key_systems_support_uma_.ReportKeySystemSupport(key_system, false);
 
   if (mime_type.empty())
     return true;
 
-  const ContainerCodecsMap& mime_types_map =
-      key_system_iter->second.supported_types;
-  ContainerCodecsMap::const_iterator mime_iter = mime_types_map.find(mime_type);
-  if (mime_iter == mime_types_map.end())
+  const SupportedCodecs& supported_codecs =

[ddorwin, 2014/04/22 21:24:41]

ditto: '&'.

[xhwang, 2014/04/23 17:29:14]

Done.

+      key_system_iter->second.supported_codecs;
+

[ddorwin, 2014/04/22 21:24:41]

This code is not obvious. It might help to either use variable names or
comments.

I assume this is looking up supported codecs for a key system then using that to
determine the associated mime type and whether it's supported by the key system.
It's hard to reason about. Then we check actual codecs below.

This also assumes that the inferred initDataType is supported. I guess we strip
the codecs if the MIME type is not supported elsewhere? That's also not obvious.

[xhwang, 2014/04/23 17:29:14]

Done.

+  MaskMap::const_iterator container_iter = container_masks_.find(mime_type);
+  if (container_iter == container_masks_.end() ||
+      !(container_iter->second & supported_codecs)) {
     return false;
+  }
 
   if (codec.empty()) {
     key_systems_support_uma_.ReportKeySystemSupport(key_system, true);
     return true;
   }
 
-  const CodecSet& codecs = mime_iter->second;
-  if (codecs.find(codec) == codecs.end())
+  MaskMap::const_iterator codec_iter = codec_masks_.find(codec);
+  if (codec_iter == codec_masks_.end() ||
+      !(codec_iter->second & supported_codecs)) {

[ddorwin, 2014/04/22 21:24:41]

Even this is a bit confusing.

[xhwang, 2014/04/23 17:29:14]

Done.

+    return false;
+  }
+
+  // Unsupported codec/container combination, e.g. "video/webm" and "avc1".
+  if (!(codec_iter->second & container_iter->second))
     return false;
 
   key_systems_support_uma_.ReportKeySystemSupport(key_system, true);
   return true;
 }
 
 bool KeySystems::IsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system) {
@@ skipping 41 matching lines @@
       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(container_masks_.find(container) == container_masks_.end());
+  container_masks_[container] = static_cast<media::SupportedCodecMask>(mask);
+}
+
+void KeySystems::AddCodecMask(const std::string& codec, uint32 mask) {
+  DCHECK(codec_masks_.find(codec) == codec_masks_.end());
+  codec_masks_[codec] = static_cast<media::SupportedCodecMask>(mask);
+}
+
 //------------------------------------------------------------------------------
 
 std::string GetUnprefixedKeySystemName(const std::string& key_system) {
   if (key_system == kClearKeyKeySystem)
     return kUnsupportedClearKeyKeySystem;
 
   if (key_system == kPrefixedClearKeyKeySystem)
     return kClearKeyKeySystem;
 
   return key_system;
@@ skipping 33 matching lines @@
 bool CanUseAesDecryptor(const std::string& concrete_key_system) {
   return KeySystems::GetInstance().UseAesDecryptor(concrete_key_system);
 }
 
 #if defined(ENABLE_PEPPER_CDMS)
 std::string GetPepperType(const std::string& concrete_key_system) {
   return KeySystems::GetInstance().GetPepperType(concrete_key_system);
 }
 #endif
 
+void AddContainerMask(const std::string& container, uint32 mask) {
+  KeySystems::GetInstance().AddContainerMask(container, mask);
+}
+
+void AddCodecMask(const std::string& codec, uint32 mask) {
+  KeySystems::GetInstance().AddCodecMask(codec, mask);
+}
+
 }  // namespace content