Remove prefixed EME.

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"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "media/base/key_system_info.h"
-#include "media/base/key_systems_support_uma.h"
 #include "media/base/media_client.h"
 #include "media/cdm/key_system_names.h"
 #include "third_party/widevine/cdm/widevine_cdm_common.h"
 
 namespace media {
 
 const char kClearKeyKeySystem[] = "org.w3.clearkey";
-const char kPrefixedClearKeyKeySystem[] = "webkit-org.w3.clearkey";
-const char kUnsupportedClearKeyKeySystem[] = "unsupported-org.w3.clearkey";
 
 // 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;
 };
 
@@ skipping 35 matching lines @@
     return EmeRobustness::SW_SECURE_DECODE;
   if (robustness == "HW_SECURE_CRYPTO")
     return EmeRobustness::HW_SECURE_CRYPTO;
   if (robustness == "HW_SECURE_DECODE")
     return EmeRobustness::HW_SECURE_DECODE;
   if (robustness == "HW_SECURE_ALL")
     return EmeRobustness::HW_SECURE_ALL;
   return EmeRobustness::INVALID;
 }
 
+// TODO(ddorwin): Remove reference to "concrete" key systems. crbug.com/249976.
 static void AddClearKey(std::vector<KeySystemInfo>* concrete_key_systems) {
   KeySystemInfo info;
   info.key_system = 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 =
       kInitDataTypeMaskWebM | kInitDataTypeMaskKeyIds;
@@ skipping 78 matching lines @@
 }
 
 class KeySystemsImpl : public KeySystems {
  public:
   static KeySystemsImpl* GetInstance();
 
   void UpdateIfNeeded();
 
   bool IsConcreteSupportedKeySystem(const std::string& key_system) const;
 
-  bool PrefixedIsSupportedKeySystemWithMediaMimeType(
-      const std::string& mime_type,
-      const std::vector<std::string>& codecs,
-      const std::string& key_system);
-
   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);
   void AddCodecMask(EmeMediaType media_type,
@@ skipping 48 matching lines @@
   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;
   EmeCodec GetCodecForString(const std::string& codec) const;
 
-  const std::string& PrefixedGetConcreteKeySystemNameFor(
-      const std::string& key_system) 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_;
 
-  KeySystemsSupportUMA key_systems_support_uma_;
-
   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_;
 
@@ skipping 43 matching lines @@
   return EME_CODEC_NONE;
 }
 
 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;
 }
 
-const std::string& KeySystemsImpl::PrefixedGetConcreteKeySystemNameFor(
-    const std::string& key_system) const {
-  ParentKeySystemMap::const_iterator iter =
-      parent_key_system_map_.find(key_system);
-  if (iter != parent_key_system_map_.end())
-    return iter->second;
-  return key_system;
-}
-
 void KeySystemsImpl::InitializeUMAInfo() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(key_system_name_for_uma_map_.empty());
 
   std::vector<KeySystemInfoForUMA> key_systems_info_for_uma;
   if (GetMediaClient())
     GetMediaClient()->AddKeySystemsInfoForUMA(&key_systems_info_for_uma);
 
   for (const KeySystemInfoForUMA& info : key_systems_info_for_uma) {
     key_system_name_for_uma_map_[info.key_system] =
         info.key_system_name_for_uma;
-    if (info.reports_key_system_support_to_uma)
-      key_systems_support_uma_.AddKeySystemToReport(info.key_system);
   }
 
   // Clear Key is always supported.
   key_system_name_for_uma_map_[kClearKeyKeySystem] =
       kClearKeyKeySystemNameForUMA;
 }
 
 void KeySystemsImpl::UpdateIfNeeded() {
   if (GetMediaClient() && GetMediaClient()->IsKeySystemsUpdateNeeded())
     UpdateSupportedKeySystems();
@@ skipping 145 matching lines @@
   }
 
   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 in unprefixed.
+  // 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();
     return false;
   }
 
   // Check |init_data_type|.
   InitDataTypeMask available_init_data_types =
       key_system_iter->second.supported_init_data_types;
   switch (init_data_type) {
     case EmeInitDataType::UNKNOWN:
       return false;
     case EmeInitDataType::WEBM:
       return (available_init_data_types & kInitDataTypeMaskWebM) != 0;
     case EmeInitDataType::CENC:
       return (available_init_data_types & kInitDataTypeMaskCenc) != 0;
     case EmeInitDataType::KEYIDS:
       return (available_init_data_types & kInitDataTypeMaskKeyIds) != 0;
   }
   NOTREACHED();
   return false;
 }
 
-bool KeySystemsImpl::PrefixedIsSupportedKeySystemWithMediaMimeType(
-    const std::string& mime_type,
-    const std::vector<std::string>& codecs,
-    const std::string& key_system) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  const std::string& concrete_key_system =
-      PrefixedGetConcreteKeySystemNameFor(key_system);
-
-  bool has_type = !mime_type.empty();
-
-  key_systems_support_uma_.ReportKeySystemQuery(key_system, has_type);
-
-  // Check key system support.
-  KeySystemInfoMap::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) {
-    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;
-}
-
 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 260 matching lines @@
   }
   return key_system_iter->second.distinctive_identifier_support;
 }
 
 KeySystems* KeySystems::GetInstance() {
   return KeySystemsImpl::GetInstance();
 }
 
 //------------------------------------------------------------------------------
 
-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 PrefixedIsSupportedConcreteKeySystem(const std::string& key_system) {
-  return KeySystemsImpl::GetInstance()->IsConcreteSupportedKeySystem(
-      key_system);
-}
-
 bool IsSupportedKeySystemWithInitDataType(const std::string& key_system,
                                           EmeInitDataType init_data_type) {
   return KeySystemsImpl::GetInstance()->IsSupportedInitDataType(key_system,
                                                                 init_data_type);
 }
 
-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) {
   return KeySystemsImpl::GetInstance()->GetKeySystemNameForUMA(key_system);
 }
 
 bool CanUseAesDecryptor(const std::string& concrete_key_system) {
   return KeySystemsImpl::GetInstance()->UseAesDecryptor(concrete_key_system);
 }
 
 #if defined(ENABLE_PEPPER_CDMS)
 std::string GetPepperType(const std::string& concrete_key_system) {
@@ skipping 12 matching lines @@
   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);
 }
 
 }  // namespace media