EME: Ensure that registered codecs match the MIME type.

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 <stddef.h>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
@@ skipping 15 matching lines @@
 // These names are used by UMA. Do not change them!
 const char kClearKeyKeySystemNameForUMA[] = "ClearKey";
 const char kUnknownKeySystemNameForUMA[] = "Unknown";
 
 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.
-// TODO(sandersd): This definition only makes sense for prefixed EME. Change it
-// when prefixed EME is removed. http://crbug.com/249976
-static NamedCodec kContainerToCodecMasks[] = {
+// Only audio codecs can belong to a "audio/*" mime_type, and only video codecs
+// can belong to a "video/*" mime_type.
+static const NamedCodec kMimeTypeToCodecMasks[] = {
     {"audio/webm", EME_CODEC_WEBM_AUDIO_ALL},
-    {"video/webm", EME_CODEC_WEBM_ALL},
+    {"video/webm", EME_CODEC_WEBM_VIDEO_ALL},
 #if defined(USE_PROPRIETARY_CODECS)
     {"audio/mp4", EME_CODEC_MP4_AUDIO_ALL},
-    {"video/mp4", EME_CODEC_MP4_ALL}
+    {"video/mp4", EME_CODEC_MP4_VIDEO_ALL}
 #endif  // defined(USE_PROPRIETARY_CODECS)
 };
 
 // Mapping between codec names and enum values.
-static NamedCodec kCodecStrings[] = {
-    {"opus", EME_CODEC_WEBM_OPUS},
-    {"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},
+static const NamedCodec kCodecStrings[] = {
+    {"opus", EME_CODEC_WEBM_OPUS},      // Opus.
+    {"vorbis", EME_CODEC_WEBM_VORBIS},  // Vorbis.
+    {"vp8", EME_CODEC_WEBM_VP8},        // VP8.
+    {"vp8.0", EME_CODEC_WEBM_VP8},      // VP8.
+    {"vp9", EME_CODEC_WEBM_VP9},        // VP9.
+    {"vp9.0", EME_CODEC_WEBM_VP9},      // VP9.
 #if defined(USE_PROPRIETARY_CODECS)
-    {"mp4a", EME_CODEC_MP4_AAC},
-    {"avc1", EME_CODEC_MP4_AVC1},
-    {"avc3", EME_CODEC_MP4_AVC1}
+    {"mp4a", EME_CODEC_MP4_AAC},   // AAC.
+    {"avc1", EME_CODEC_MP4_AVC1},  // AVC1.
+    {"avc3", EME_CODEC_MP4_AVC1}   // AVC3.
 #endif  // defined(USE_PROPRIETARY_CODECS)
 };
 
 static EmeRobustness ConvertRobustness(const std::string& robustness) {
   if (robustness.empty())
     return EmeRobustness::EMPTY;
   if (robustness == "SW_SECURE_CRYPTO")
     return EmeRobustness::SW_SECURE_CRYPTO;
   if (robustness == "SW_SECURE_DECODE")
     return EmeRobustness::SW_SECURE_DECODE;
@@ skipping 106 matching lines @@
   bool IsConcreteSupportedKeySystem(const std::string& key_system) const;
 
   std::string GetKeySystemNameForUMA(const std::string& key_system) const;
 
   bool UseAesDecryptor(const std::string& concrete_key_system) const;
 
 #if defined(ENABLE_PEPPER_CDMS)
   std::string GetPepperType(const std::string& concrete_key_system) const;
 #endif
 
-  void AddContainerMask(const std::string& container, uint32_t mask);
+  // These two functions are for testing purpose only.
   void AddCodecMask(EmeMediaType media_type,
                     const std::string& codec,
                     uint32_t mask);
+  void AddMimeTypeCodecMask(const std::string& mime_type, uint32_t 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;
 
   EmeConfigRule GetContentTypeConfigRule(
       const std::string& key_system,
       EmeMediaType media_type,
@@ skipping 21 matching lines @@
   KeySystemsImpl();
   ~KeySystemsImpl() override;
 
   void InitializeUMAInfo();
 
   void UpdateSupportedKeySystems();
 
   void AddConcreteSupportedKeySystems(
       const std::vector<KeySystemInfo>& concrete_key_systems);
 
+  void RegisterMimeType(const std::string& mime_type, EmeCodec codecs_mask);
+  bool IsValidMimeTypeCodecsCombination(const std::string& mime_type,
+                                        SupportedCodecs codecs_mask) const;
+
   friend struct base::DefaultLazyInstanceTraits<KeySystemsImpl>;
 
   typedef base::hash_map<std::string, KeySystemInfo> KeySystemInfoMap;
   typedef base::hash_map<std::string, std::string> ParentKeySystemMap;
-  typedef base::hash_map<std::string, SupportedCodecs> ContainerCodecsMap;
+  typedef base::hash_map<std::string, SupportedCodecs> MimeTypeCodecsMap;
   typedef base::hash_map<std::string, EmeCodec> CodecsMap;
   typedef base::hash_map<std::string, EmeInitDataType> InitDataTypesMap;
   typedef base::hash_map<std::string, std::string> KeySystemNameForUMAMap;
 
   // TODO(sandersd): Separate container enum from codec mask value.
   // http://crbug.com/417440
-  SupportedCodecs GetCodecMaskForContainer(
-      const std::string& container) const;
+  // Potentially pass EmeMediaType and a container enum.
+  SupportedCodecs GetCodecMaskForMimeType(
+      const std::string& container_mime_type) const;
   EmeCodec GetCodecForString(const std::string& codec) const;
 
-  // 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.
   KeySystemInfoMap 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_;
 
-  ContainerCodecsMap container_to_codec_mask_map_;
+  // This member should only be modified by RegisterMimeType().
+  MimeTypeCodecsMap mime_type_to_codec_mask_map_;
   CodecsMap codec_string_map_;
   KeySystemNameForUMAMap key_system_name_for_uma_map_;
 
   SupportedCodecs audio_codec_mask_;
   SupportedCodecs video_codec_mask_;
 
   // Makes sure all methods are called from the same thread.
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(KeySystemsImpl);
 };
 
 static base::LazyInstance<KeySystemsImpl>::Leaky g_key_systems =
     LAZY_INSTANCE_INITIALIZER;
 
 KeySystemsImpl* KeySystemsImpl::GetInstance() {
   KeySystemsImpl* key_systems = g_key_systems.Pointer();
   key_systems->UpdateIfNeeded();
   return key_systems;
 }
 
 // Because we use a LazyInstance, the key systems info must be populated when
 // the instance is lazily initiated.
 KeySystemsImpl::KeySystemsImpl() :
     audio_codec_mask_(EME_CODEC_AUDIO_ALL),
     video_codec_mask_(EME_CODEC_VIDEO_ALL) {
-  for (size_t i = 0; i < arraysize(kContainerToCodecMasks); ++i) {
-    const std::string& name = kContainerToCodecMasks[i].name;
-    DCHECK(!container_to_codec_mask_map_.count(name));
-    container_to_codec_mask_map_[name] = kContainerToCodecMasks[i].type;
-  }
   for (size_t i = 0; i < arraysize(kCodecStrings); ++i) {
     const std::string& name = kCodecStrings[i].name;
     DCHECK(!codec_string_map_.count(name));
     codec_string_map_[name] = kCodecStrings[i].type;
   }
+  for (size_t i = 0; i < arraysize(kMimeTypeToCodecMasks); ++i) {
+    RegisterMimeType(kMimeTypeToCodecMasks[i].name,
+                     kMimeTypeToCodecMasks[i].type);
+  }
 
   InitializeUMAInfo();
 
   // Always update supported key systems during construction.
   UpdateSupportedKeySystems();
 }
 
 KeySystemsImpl::~KeySystemsImpl() {
 }
 
-SupportedCodecs KeySystemsImpl::GetCodecMaskForContainer(
-    const std::string& container) const {
-  ContainerCodecsMap::const_iterator iter =
-      container_to_codec_mask_map_.find(container);
-  if (iter != container_to_codec_mask_map_.end())
-    return iter->second;
-  return EME_CODEC_NONE;
+SupportedCodecs KeySystemsImpl::GetCodecMaskForMimeType(
+    const std::string& container_mime_type) const {
+  MimeTypeCodecsMap::const_iterator iter =
+      mime_type_to_codec_mask_map_.find(container_mime_type);
+  if (iter == mime_type_to_codec_mask_map_.end())
+    return EME_CODEC_NONE;
+
+  DCHECK(IsValidMimeTypeCodecsCombination(container_mime_type, iter->second));
+  return iter->second;
 }
 
 EmeCodec KeySystemsImpl::GetCodecForString(const std::string& codec) const {
   CodecsMap::const_iterator iter = codec_string_map_.find(codec);
   if (iter != codec_string_map_.end())
     return iter->second;
   return EME_CODEC_NONE;
 }
 
 void KeySystemsImpl::InitializeUMAInfo() {
@@ skipping 103 matching lines @@
       DCHECK(!IsConcreteSupportedKeySystem(info.parent_key_system))
           << "Parent '" << info.parent_key_system << "' "
           << "already registered concrete";
       DCHECK(!parent_key_system_map_.count(info.parent_key_system))
           << "Parent '" << info.parent_key_system << "' already registered";
       parent_key_system_map_[info.parent_key_system] = info.key_system;
     }
   }
 }
 
+// Adds the MIME type with the codec mask after verifying the validity.
+// Only this function should modify |mime_type_to_codec_mask_map_|.
+void KeySystemsImpl::RegisterMimeType(const std::string& mime_type,
+                                      EmeCodec codecs_mask) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!mime_type_to_codec_mask_map_.count(mime_type));
+  DCHECK(IsValidMimeTypeCodecsCombination(mime_type, codecs_mask));
+
+  mime_type_to_codec_mask_map_[mime_type] = static_cast<EmeCodec>(codecs_mask);
+}
+
+// Returns whether |mime_type| follows a valid format and the specified codecs
+// are of the correct type based on |*_codec_mask_|.
+// Only audio/ or video/ MIME types with their respective codecs are allowed.
+bool KeySystemsImpl::IsValidMimeTypeCodecsCombination(
+    const std::string& mime_type,
+    SupportedCodecs codecs_mask) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!codecs_mask)
+    return false;
+  if (base::StartsWith(mime_type, "audio/", base::CompareCase::SENSITIVE))
+    return !(codecs_mask & ~audio_codec_mask_);
+  if (base::StartsWith(mime_type, "video/", base::CompareCase::SENSITIVE))
+    return !(codecs_mask & ~video_codec_mask_);
+
+  return false;
+}
+
 bool KeySystemsImpl::IsConcreteSupportedKeySystem(
     const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return concrete_key_system_map_.count(key_system) != 0;
 }
 
-bool KeySystemsImpl::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)
-    canonical_container.replace(0, 6, "video/");
-
-  // A container is supported iif at least one codec in that container is
-  // supported.
-  SupportedCodecs supported_codecs =
-      GetCodecMaskForContainer(canonical_container);
-  return (supported_codecs & key_system_supported_codecs) != 0;
-}
-
-bool KeySystemsImpl::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));
-
-  SupportedCodecs container_supported_codecs =
-      GetCodecMaskForContainer(container);
-
-  for (size_t i = 0; i < codecs.size(); ++i) {
-    if (codecs[i].empty())
-      continue;
-
-    EmeCodec codec = GetCodecForString(codecs[i]);
-
-    // Unsupported codec.
-    if (!(codec & key_system_supported_codecs))
-      return false;
-
-    // Unsupported codec/container combination, e.g. "video/webm" and "avc1".
-    if (!(codec & container_supported_codecs))
-      return false;
-  }
-
-  return true;
-}
-
 bool KeySystemsImpl::IsSupportedInitDataType(
     const std::string& key_system,
     EmeInitDataType init_data_type) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Locate |key_system|. Only concrete key systems are supported.
   KeySystemInfoMap::const_iterator key_system_iter =
       concrete_key_system_map_.find(key_system);
   if (key_system_iter == concrete_key_system_map_.end()) {
     NOTREACHED();
@@ skipping 54 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 KeySystemsImpl::AddContainerMask(const std::string& container,
-                                      uint32_t mask) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!container_to_codec_mask_map_.count(container));
-  container_to_codec_mask_map_[container] = static_cast<EmeCodec>(mask);
-}
-
 void KeySystemsImpl::AddCodecMask(EmeMediaType media_type,
                                   const std::string& codec,
                                   uint32_t mask) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!codec_string_map_.count(codec));
   codec_string_map_[codec] = static_cast<EmeCodec>(mask);
   if (media_type == EmeMediaType::AUDIO) {
     audio_codec_mask_ |= mask;
   } else {
     video_codec_mask_ |= mask;
   }
 }
 
+void KeySystemsImpl::AddMimeTypeCodecMask(const std::string& mime_type,
+                                          uint32_t codecs_mask) {
+  RegisterMimeType(mime_type, static_cast<EmeCodec>(codecs_mask));
+}
+
 bool KeySystemsImpl::IsSupportedKeySystem(const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!IsConcreteSupportedKeySystem(key_system))
     return false;
 
   // TODO(ddorwin): Move this to where we add key systems when prefixed EME is
   // removed (crbug.com/249976).
   if (!IsPotentiallySupportedKeySystem(key_system)) {
     // If you encounter this path, see the comments for the above function.
     DLOG(ERROR) << "Unrecognized key system " << key_system
                 << ". See code comments.";
     return false;
   }
 
   return true;
 }
 
 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;
+  // Make sure the container MIME type matches |media_type|.
   switch (media_type) {
     case EmeMediaType::AUDIO:
       if (!base::StartsWith(container_mime_type, "audio/",
                             base::CompareCase::SENSITIVE))
         return EmeConfigRule::NOT_SUPPORTED;
-      media_type_codec_mask = audio_codec_mask_;
       break;
     case EmeMediaType::VIDEO:
       if (!base::StartsWith(container_mime_type, "video/",
                             base::CompareCase::SENSITIVE))
         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 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)
+  SupportedCodecs mime_type_codec_mask =
+      GetCodecMaskForMimeType(container_mime_type);
+  if ((key_system_codec_mask & mime_type_codec_mask) == 0)
     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)
+    if ((codec & key_system_codec_mask & mime_type_codec_mask) == 0)
       return EmeConfigRule::NOT_SUPPORTED;
 #if defined(OS_ANDROID)
     // Check whether the codec supports a hardware-secure mode. The goal is to
     // prevent mixing of non-hardware-secure codecs with hardware-secure codecs,
     // since the mode is fixed at CDM creation.
     //
     // Because the check for regular codec support is early-exit, we don't have
     // to consider codecs that are only supported in hardware-secure mode. We
     // could do so, and make use of HW_SECURE_CODECS_REQUIRED, if it turns out
     // that hardware-secure-only codecs actually exist and are useful.
@@ skipping 153 matching lines @@
   return KeySystemsImpl::GetInstance()->GetPepperType(concrete_key_system);
 }
 #endif
 
 // These two functions are for testing purpose only. The declaration in the
 // header file is guarded by "#if defined(UNIT_TEST)" so that they can be used
 // by tests but not non-test code. However, this .cc file is compiled as part of
 // "media" where "UNIT_TEST" is not defined. So we need to specify
 // "MEDIA_EXPORT" here again so that they are visible to tests.
 
-MEDIA_EXPORT void AddContainerMask(const std::string& container,
-                                   uint32_t mask) {
-  KeySystemsImpl::GetInstance()->AddContainerMask(container, mask);
-}
-
 MEDIA_EXPORT void AddCodecMask(EmeMediaType media_type,
                                const std::string& codec,
                                uint32_t mask) {
   KeySystemsImpl::GetInstance()->AddCodecMask(media_type, codec, mask);
 }
 
+MEDIA_EXPORT void AddMimeTypeCodecMask(const std::string& mime_type,
+                                       uint32_t mask) {
+  KeySystemsImpl::GetInstance()->AddMimeTypeCodecMask(mime_type, mask);
+}
+
 }  // namespace media