Refactor IsSupportedKeySystemWithMediaMimeType().

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 <string>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
@@ skipping 34 matching lines @@
 };
 
 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[] = {
     {"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 names and enum values.
@@ skipping 141 matching lines @@
 
   bool IsSupportedKeySystemWithInitDataType(
       const std::string& key_system,
       const std::string& init_data_type) const;
 
   bool PrefixedIsSupportedKeySystemWithMediaMimeType(
       const std::string& mime_type,
       const std::vector<std::string>& codecs,
       const std::string& key_system);
 
-  bool IsSupportedKeySystemWithMediaMimeType(
-      const std::string& mime_type,
-      const std::vector<std::string>& codecs,
-      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 mask);
-  void AddCodecMask(const std::string& codec, uint32 mask);
+  void AddCodecMask(
+      EmeMediaType media_type,
+      const std::string& codec,
+      uint32 mask);
 
   // Implementation of KeySystems interface.
   bool IsSupportedKeySystem(const std::string& key_system) const override;
 
   bool IsSupportedCodecCombination(
       const std::string& key_system,
       EmeMediaType media_type,
       const std::string& container_mime_type,
       const std::vector<std::string>& codecs) const override;
 
@@ skipping 67 matching lines @@
   // to represent its capabilities.
   ParentKeySystemMap parent_key_system_map_;
 
   KeySystemsSupportUMA key_systems_support_uma_;
 
   InitDataTypesMap init_data_type_name_map_;
   ContainerCodecsMap container_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> g_key_systems =
     LAZY_INSTANCE_INITIALIZER;
 
 KeySystemsImpl& KeySystemsImpl::GetInstance() {
   KeySystemsImpl& 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.
-KeySystemsImpl::KeySystemsImpl() {
+KeySystemsImpl::KeySystemsImpl() :
+    audio_codec_mask_(EME_CODEC_AUDIO_ALL),
+    video_codec_mask_(EME_CODEC_VIDEO_ALL) {
   for (size_t i = 0; i < arraysize(kInitDataTypeNames); ++i) {
     const std::string& name = kInitDataTypeNames[i].name;
     DCHECK(!init_data_type_name_map_.count(name));
     init_data_type_name_map_[name] = kInitDataTypeNames[i].type;
   }
   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;
   }
@@ skipping 203 matching lines @@
     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) {
-    // TODO(sandersd): This should fail for isTypeSupported().
-    // http://crbug.com/417461
     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".
@@ skipping 57 matching lines @@
       !IsSupportedContainerAndCodecs(
           mime_type, codecs, key_system_supported_codecs)) {
     return false;
   }
 
   key_systems_support_uma_.ReportKeySystemSupport(key_system, true);
 
   return true;
 }
 
-bool KeySystemsImpl::IsSupportedKeySystemWithMediaMimeType(
-    const std::string& mime_type,
-    const std::vector<std::string>& codecs,
-    const std::string& key_system) const {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  KeySystemInfoMap::const_iterator key_system_iter =
-      concrete_key_system_map_.find(key_system);
-  if (key_system_iter == concrete_key_system_map_.end())
-    return false;
-
-  if (mime_type.empty()) {
-    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;
-  }
-
-  return true;
-}
-
 std::string KeySystemsImpl::GetKeySystemNameForUMA(
     const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemNameForUMAMap::const_iterator iter =
       key_system_name_for_uma_map_.find(key_system);
   if (iter == key_system_name_for_uma_map_.end())
     return kUnknownKeySystemNameForUMA;
 
   return iter->second;
@@ skipping 24 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 mask) {
+void KeySystemsImpl::AddContainerMask(
+    const std::string& container,
+    uint32 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(const std::string& codec, uint32 mask) {
+void KeySystemsImpl::AddCodecMask(
+    EmeMediaType media_type,
+    const std::string& codec,
+    uint32 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;
+  }
 }
 
 bool KeySystemsImpl::IsSupportedKeySystem(const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return concrete_key_system_map_.count(key_system) != 0;
 }
 
-// TODO(sandersd): Make sure that the codecs also match the |media_type|.
-// http://crbug.com/457386
 bool KeySystemsImpl::IsSupportedCodecCombination(
     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;
   switch (media_type) {
     case EmeMediaType::AUDIO:
       if (!StartsWithASCII(container_mime_type, "audio/", true))
         return false;
+      media_type_codec_mask = audio_codec_mask_;
       break;
     case EmeMediaType::VIDEO:
       if (!StartsWithASCII(container_mime_type, "video/", true))
         return false;
+      media_type_codec_mask = video_codec_mask_;
       break;
   }
-  return IsSupportedKeySystemWithMediaMimeType(
-      container_mime_type, codecs, key_system);
+
+  // 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 false;
+  }
+  SupportedCodecs key_system_codec_mask =
+      key_system_iter->second.supported_codecs;
+
+  // 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;
+
+  // Check that the codecs are supported by the key system and container.
+  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 true;
 }
 
 EmeConfigRule KeySystemsImpl::GetRobustnessConfigRule(
     const std::string& key_system,
     EmeMediaType media_type,
     const std::string& requested_robustness) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   EmeRobustness robustness = ConvertRobustness(requested_robustness);
   if (robustness == EmeRobustness::INVALID)
@@ skipping 214 matching lines @@
   return true;
 }
 
 bool IsSupportedKeySystemWithInitDataType(
     const std::string& key_system,
     const std::string& init_data_type) {
   return KeySystemsImpl::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 KeySystemsImpl::GetInstance().IsSupportedKeySystemWithMediaMimeType(
-      mime_type, codecs, key_system);
-}
-
 bool PrefixedIsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system) {
   return KeySystemsImpl::GetInstance()
       .PrefixedIsSupportedKeySystemWithMediaMimeType(mime_type, codecs,
                                                      key_system);
 }
 
 std::string GetKeySystemNameForUMA(const std::string& key_system) {
@@ skipping 13 matching lines @@
 // 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 mask) {
   KeySystemsImpl::GetInstance().AddContainerMask(container, mask);
 }
 
-MEDIA_EXPORT void AddCodecMask(const std::string& codec, uint32 mask) {
-  KeySystemsImpl::GetInstance().AddCodecMask(codec, mask);
+MEDIA_EXPORT void AddCodecMask(
+    EmeMediaType media_type,
+    const std::string& codec,
+    uint32 mask) {
+  KeySystemsImpl::GetInstance().AddCodecMask(media_type, codec, mask);
 }
 
 }  // namespace media