Remove remaining uses of KeySystemInfo and InitDataTypeMask

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 <memory>
 
 #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_system_names.h"
 #include "media/base/key_system_properties.h"
 #include "media/base/media.h"
 #include "media/base/media_client.h"
 #include "media/media_features.h"
 #include "third_party/widevine/cdm/widevine_cdm_common.h"
 
 namespace media {
 
 const char kClearKeyKeySystem[] = "org.w3.clearkey";
@@ skipping 30 matching lines @@
 #if defined(USE_PROPRIETARY_CODECS)
 #if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
     {"vp09", EME_CODEC_MP4_VP9},  // VP9 in MP4.
 #endif
     {"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;
-  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;
-}
-
 class ClearKeyProperties : public KeySystemProperties {
  public:
   std::string GetKeySystemName() const override { return kClearKeyKeySystem; }
 
   bool IsSupportedInitDataType(EmeInitDataType init_data_type) const override {
 #if defined(USE_PROPRIETARY_CODECS)
     if (init_data_type == EmeInitDataType::CENC)
       return true;
 #endif
     return init_data_type == EmeInitDataType::WEBM ||
@@ skipping 88 matching lines @@
   // Implementations that do not have a specification or appropriate glue code
   // can use the "x-" prefix to avoid conflicting with and advertising support
   // for real key system names. Use is discouraged.
   const char kExcludedPrefix[] = "x-";
   if (key_system.find(kExcludedPrefix, 0, arraysize(kExcludedPrefix) - 1) == 0)
     return true;
 
   return false;
 }
 
-InfoBasedKeySystemProperties::InfoBasedKeySystemProperties(
-    const KeySystemInfo& info)
-    : info_(info) {
-  DCHECK(info.max_audio_robustness != EmeRobustness::INVALID);
-  DCHECK(info.max_video_robustness != EmeRobustness::INVALID);
-}
-
-std::string InfoBasedKeySystemProperties::GetKeySystemName() const {
-  return info_.key_system;
-}
-
-SupportedCodecs InfoBasedKeySystemProperties::GetSupportedCodecs() const {
-  return info_.supported_codecs;
-}
-#if defined(OS_ANDROID)
-SupportedCodecs InfoBasedKeySystemProperties::GetSupportedSecureCodecs() const {
-  return info_.supported_secure_codecs;
-}
-#endif
-
 class KeySystemsImpl : public KeySystems {
  public:
   static KeySystemsImpl* GetInstance();
 
   void UpdateIfNeeded();
 
   std::string GetKeySystemNameForUMA(const std::string& key_system) const;
 
   bool UseAesDecryptor(const std::string& key_system) const;
 
@@ skipping 287 matching lines @@
 
   KeySystemPropertiesMap::const_iterator key_system_iter =
       key_system_properties_map_.find(key_system);
   if (key_system_iter == key_system_properties_map_.end()) {
     NOTREACHED();
     return false;
   }
   return key_system_iter->second->IsSupportedInitDataType(init_data_type);
 }
 
-bool InfoBasedKeySystemProperties::IsSupportedInitDataType(
-    EmeInitDataType init_data_type) const {
-  // Check |init_data_type|.
-  InitDataTypeMask available_init_data_types = info_.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;
-}
-
 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;
 }
 
 bool KeySystemsImpl::UseAesDecryptor(const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemPropertiesMap::const_iterator key_system_iter =
       key_system_properties_map_.find(key_system);
   if (key_system_iter == key_system_properties_map_.end()) {
     DLOG(ERROR) << key_system << " is not a known system";
     return false;
   }
   return key_system_iter->second->UseAesDecryptor();
 }
 
-bool InfoBasedKeySystemProperties::UseAesDecryptor() const {
-  return info_.use_aes_decryptor;
-}
-
 #if defined(ENABLE_PEPPER_CDMS)
 std::string KeySystemsImpl::GetPepperType(const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemPropertiesMap::const_iterator key_system_iter =
       key_system_properties_map_.find(key_system);
   if (key_system_iter == key_system_properties_map_.end()) {
     DLOG(FATAL) << key_system << " is not a known system";
     return std::string();
   }
   const std::string& type = key_system_iter->second->GetPepperType();
   DLOG_IF(FATAL, type.empty()) << key_system_iter->second->GetKeySystemName()
                                << " is not Pepper-based";
   return type;
 }
 
-std::string InfoBasedKeySystemProperties::GetPepperType() const {
-  return info_.pepper_type;
-}
 #endif
 
 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;
@@ skipping 100 matching lines @@
   KeySystemPropertiesMap::const_iterator key_system_iter =
       key_system_properties_map_.find(key_system);
   if (key_system_iter == key_system_properties_map_.end()) {
     NOTREACHED();
     return EmeConfigRule::NOT_SUPPORTED;
   }
   return key_system_iter->second->GetRobustnessConfigRule(media_type,
                                                           requested_robustness);
 }
 
-EmeConfigRule InfoBasedKeySystemProperties::GetRobustnessConfigRule(
-    EmeMediaType media_type,
-    const std::string& requested_robustness) const {
-  EmeRobustness robustness = ConvertRobustness(requested_robustness);
-  if (robustness == EmeRobustness::INVALID)
-    return EmeConfigRule::NOT_SUPPORTED;
-
-  EmeRobustness max_robustness = EmeRobustness::INVALID;
-  switch (media_type) {
-    case EmeMediaType::AUDIO:
-      max_robustness = info_.max_audio_robustness;
-      break;
-    case EmeMediaType::VIDEO:
-      max_robustness = info_.max_video_robustness;
-      break;
-  }
-
-  // We can compare robustness levels whenever they are not HW_SECURE_CRYPTO
-  // and SW_SECURE_DECODE in some order. If they are exactly those two then the
-  // robustness requirement is not supported.
-  if ((max_robustness == EmeRobustness::HW_SECURE_CRYPTO &&
-       robustness == EmeRobustness::SW_SECURE_DECODE) ||
-      (max_robustness == EmeRobustness::SW_SECURE_DECODE &&
-       robustness == EmeRobustness::HW_SECURE_CRYPTO) ||
-      robustness > max_robustness) {
-    return EmeConfigRule::NOT_SUPPORTED;
-  }
-
-#if defined(OS_CHROMEOS)
-  if (info_.key_system == kWidevineKeySystem) {
-    // TODO(ddorwin): Remove this once we have confirmed it is not necessary.
-    // See https://crbug.com/482277
-    if (robustness == EmeRobustness::EMPTY)
-      return EmeConfigRule::SUPPORTED;
-
-    // Hardware security requires remote attestation.
-    if (robustness >= EmeRobustness::HW_SECURE_CRYPTO)
-      return EmeConfigRule::IDENTIFIER_REQUIRED;
-
-    // For video, recommend remote attestation if HW_SECURE_ALL is available,
-    // because it enables hardware accelerated decoding.
-    // TODO(sandersd): Only do this when hardware accelerated decoding is
-    // available for the requested codecs.
-    if (media_type == EmeMediaType::VIDEO &&
-        max_robustness == EmeRobustness::HW_SECURE_ALL) {
-      return EmeConfigRule::IDENTIFIER_RECOMMENDED;
-    }
-  }
-#elif defined(OS_ANDROID)
-  // Require hardware secure codecs for Widevine when SW_SECURE_DECODE or above
-  // is specified, or for all other key systems (excluding Clear Key).
-  if ((info_.key_system == kWidevineKeySystem &&
-       robustness >= EmeRobustness::SW_SECURE_DECODE) ||
-      !IsClearKey(info_.key_system)) {
-    return EmeConfigRule::HW_SECURE_CODECS_REQUIRED;
-  }
-#endif  // defined(OS_CHROMEOS)
-
-  return EmeConfigRule::SUPPORTED;
-}
-
 EmeSessionTypeSupport KeySystemsImpl::GetPersistentLicenseSessionSupport(
     const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemPropertiesMap::const_iterator key_system_iter =
       key_system_properties_map_.find(key_system);
   if (key_system_iter == key_system_properties_map_.end()) {
     NOTREACHED();
     return EmeSessionTypeSupport::INVALID;
   }
   return key_system_iter->second->GetPersistentLicenseSessionSupport();
 }
 
-EmeSessionTypeSupport
-InfoBasedKeySystemProperties::GetPersistentLicenseSessionSupport() const {
-  return info_.persistent_license_support;
-}
-
 EmeSessionTypeSupport KeySystemsImpl::GetPersistentReleaseMessageSessionSupport(
     const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemPropertiesMap::const_iterator key_system_iter =
       key_system_properties_map_.find(key_system);
   if (key_system_iter == key_system_properties_map_.end()) {
     NOTREACHED();
     return EmeSessionTypeSupport::INVALID;
   }
   return key_system_iter->second->GetPersistentReleaseMessageSessionSupport();
 }
 
-EmeSessionTypeSupport
-InfoBasedKeySystemProperties::GetPersistentReleaseMessageSessionSupport()
-    const {
-  return info_.persistent_release_message_support;
-}
-
 EmeFeatureSupport KeySystemsImpl::GetPersistentStateSupport(
     const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemPropertiesMap::const_iterator key_system_iter =
       key_system_properties_map_.find(key_system);
   if (key_system_iter == key_system_properties_map_.end()) {
     NOTREACHED();
     return EmeFeatureSupport::INVALID;
   }
   return key_system_iter->second->GetPersistentStateSupport();
 }
 
-EmeFeatureSupport InfoBasedKeySystemProperties::GetPersistentStateSupport()
-    const {
-  return info_.persistent_state_support;
-}
-
 EmeFeatureSupport KeySystemsImpl::GetDistinctiveIdentifierSupport(
     const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemPropertiesMap::const_iterator key_system_iter =
       key_system_properties_map_.find(key_system);
   if (key_system_iter == key_system_properties_map_.end()) {
     NOTREACHED();
     return EmeFeatureSupport::INVALID;
   }
   return key_system_iter->second->GetDistinctiveIdentifierSupport();
 }
 
-EmeFeatureSupport
-InfoBasedKeySystemProperties::GetDistinctiveIdentifierSupport() const {
-  return info_.distinctive_identifier_support;
-}
-
 KeySystems* KeySystems::GetInstance() {
   return KeySystemsImpl::GetInstance();
 }
 
 //------------------------------------------------------------------------------
 
 bool IsSupportedKeySystemWithInitDataType(const std::string& key_system,
                                           EmeInitDataType init_data_type) {
   return KeySystemsImpl::GetInstance()->IsSupportedInitDataType(key_system,
                                                                 init_data_type);
@@ skipping 24 matching lines @@
                                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