EME: Remove reference to "concrete" key systems.

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 57 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) {
+static void AddClearKey(std::vector<KeySystemInfo>* 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;
   info.supported_codecs = EME_CODEC_WEBM_ALL;
@@ skipping 16 matching lines @@
   info.max_audio_robustness = EmeRobustness::EMPTY;
   info.max_video_robustness = EmeRobustness::EMPTY;
   info.persistent_license_support = EmeSessionTypeSupport::NOT_SUPPORTED;
   info.persistent_release_message_support =
       EmeSessionTypeSupport::NOT_SUPPORTED;
   info.persistent_state_support = EmeFeatureSupport::NOT_SUPPORTED;
   info.distinctive_identifier_support = EmeFeatureSupport::NOT_SUPPORTED;
 
   info.use_aes_decryptor = true;
 
-  concrete_key_systems->push_back(info);
+  key_systems->push_back(info);
 }
 
 // Returns whether the |key_system| is known to Chromium and is thus likely to
 // be implemented in an interoperable way.
 // True is always returned for a |key_system| that begins with "x-".
 //
 // As with other web platform features, advertising support for a key system
 // implies that it adheres to a defined and interoperable specification.
 //
 // To ensure interoperability, implementations of a specific |key_system| string
@@ skipping 38 matching lines @@
 
   return false;
 }
 
 class KeySystemsImpl : public KeySystems {
  public:
   static KeySystemsImpl* GetInstance();
 
   void UpdateIfNeeded();
 
-  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;
+  bool UseAesDecryptor(const std::string& key_system) const;
 
 #if defined(ENABLE_PEPPER_CDMS)
-  std::string GetPepperType(const std::string& concrete_key_system) const;
+  std::string GetPepperType(const std::string& key_system) const;
 #endif
 
   // 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;
@@ skipping 25 matching lines @@
       const std::string& key_system) const override;
 
  private:
   KeySystemsImpl();
   ~KeySystemsImpl() override;
 
   void InitializeUMAInfo();
 
   void UpdateSupportedKeySystems();
 
-  void AddConcreteSupportedKeySystems(
-      const std::vector<KeySystemInfo>& concrete_key_systems);
+  void AddSupportedKeySystems(const std::vector<KeySystemInfo>& 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, 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
   // Potentially pass EmeMediaType and a container enum.
   SupportedCodecs GetCodecMaskForMimeType(
       const std::string& container_mime_type) const;
   EmeCodec GetCodecForString(const std::string& codec) const;
 
   // Map from key system string to capabilities.
-  KeySystemInfoMap concrete_key_system_map_;
+  KeySystemInfoMap key_system_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.
@@ skipping 71 matching lines @@
       kClearKeyKeySystemNameForUMA;
 }
 
 void KeySystemsImpl::UpdateIfNeeded() {
   if (GetMediaClient() && GetMediaClient()->IsKeySystemsUpdateNeeded())
     UpdateSupportedKeySystems();
 }
 
 void KeySystemsImpl::UpdateSupportedKeySystems() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  concrete_key_system_map_.clear();
+  key_system_map_.clear();
 
   // Build KeySystemInfo.
   std::vector<KeySystemInfo> key_systems_info;
 
   // Add key systems supported by the MediaClient implementation.
   if (GetMediaClient())
     GetMediaClient()->AddSupportedKeySystems(&key_systems_info);
 
   // Clear Key is always supported.
   AddClearKey(&key_systems_info);
 
-  AddConcreteSupportedKeySystems(key_systems_info);
+  AddSupportedKeySystems(key_systems_info);
 }
 
-void KeySystemsImpl::AddConcreteSupportedKeySystems(
-    const std::vector<KeySystemInfo>& concrete_key_systems) {
+void KeySystemsImpl::AddSupportedKeySystems(
+    const std::vector<KeySystemInfo>& key_systems) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(concrete_key_system_map_.empty());
+  DCHECK(key_system_map_.empty());
 
-  for (const KeySystemInfo& info : concrete_key_systems) {
+  for (const KeySystemInfo& info : key_systems) {
     DCHECK(!info.key_system.empty());
     DCHECK(info.max_audio_robustness != EmeRobustness::INVALID);
     DCHECK(info.max_video_robustness != EmeRobustness::INVALID);
     DCHECK(info.persistent_license_support != EmeSessionTypeSupport::INVALID);
     DCHECK(info.persistent_release_message_support !=
            EmeSessionTypeSupport::INVALID);
     DCHECK(info.persistent_state_support != EmeFeatureSupport::INVALID);
     DCHECK(info.distinctive_identifier_support != EmeFeatureSupport::INVALID);
 
     // Supporting persistent state is a prerequsite for supporting persistent
@@ skipping 30 matching lines @@
     if (!info.pepper_type.empty())
       can_block = true;
 #endif
     if (!can_block) {
       DCHECK(info.distinctive_identifier_support ==
              EmeFeatureSupport::ALWAYS_ENABLED);
       DCHECK(info.persistent_state_support ==
              EmeFeatureSupport::ALWAYS_ENABLED);
     }
 
-    DCHECK(!IsConcreteSupportedKeySystem(info.key_system))
+    DCHECK_EQ(key_system_map_.count(info.key_system), 0u)
         << "Key system '" << info.key_system << "' already registered";
-    concrete_key_system_map_[info.key_system] = info;
+    key_system_map_[info.key_system] = info;
   }
 }
 
 // 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));
@@ skipping 11 matching lines @@
   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::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()) {
+      key_system_map_.find(key_system);
+  if (key_system_iter == 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;
@@ skipping 13 matching lines @@
   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& concrete_key_system) const {
+bool KeySystemsImpl::UseAesDecryptor(const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemInfoMap::const_iterator key_system_iter =
-      concrete_key_system_map_.find(concrete_key_system);
-  if (key_system_iter == concrete_key_system_map_.end()) {
-    DLOG(ERROR) << concrete_key_system << " is not a known concrete system";
+      key_system_map_.find(key_system);
+  if (key_system_iter == key_system_map_.end()) {
+    DLOG(ERROR) << key_system << " is not a known system";
     return false;
   }
 
   return key_system_iter->second.use_aes_decryptor;
 }
 
 #if defined(ENABLE_PEPPER_CDMS)
-std::string KeySystemsImpl::GetPepperType(
-    const std::string& concrete_key_system) const {
+std::string KeySystemsImpl::GetPepperType(const std::string& key_system) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   KeySystemInfoMap::const_iterator key_system_iter =
-      concrete_key_system_map_.find(concrete_key_system);
-  if (key_system_iter == concrete_key_system_map_.end()) {
-      DLOG(FATAL) << concrete_key_system << " is not a known concrete system";
-      return std::string();
+      key_system_map_.find(key_system);
+  if (key_system_iter == key_system_map_.end()) {
+    DLOG(FATAL) << key_system << " is not a known 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";
+  DLOG_IF(FATAL, type.empty()) << key_system << " is not Pepper-based";
   return 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;
   } 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))
+  if (!key_system_map_.count(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;
   }
@@ skipping 17 matching lines @@
       break;
     case EmeMediaType::VIDEO:
       if (!base::StartsWith(container_mime_type, "video/",
                             base::CompareCase::SENSITIVE))
         return EmeConfigRule::NOT_SUPPORTED;
       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()) {
+      key_system_map_.find(key_system);
+  if (key_system_iter == 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)
 
@@ skipping 32 matching lines @@
     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)
     return EmeConfigRule::NOT_SUPPORTED;
 
   KeySystemInfoMap::const_iterator key_system_iter =
-      concrete_key_system_map_.find(key_system);
-  if (key_system_iter == concrete_key_system_map_.end()) {
+      key_system_map_.find(key_system);
+  if (key_system_iter == key_system_map_.end()) {
     NOTREACHED();
     return EmeConfigRule::NOT_SUPPORTED;
   }
 
   EmeRobustness max_robustness = EmeRobustness::INVALID;
   switch (media_type) {
     case EmeMediaType::AUDIO:
       max_robustness = key_system_iter->second.max_audio_robustness;
       break;
     case EmeMediaType::VIDEO:
@@ skipping 43 matching lines @@
 #endif  // defined(OS_CHROMEOS)
 
   return EmeConfigRule::SUPPORTED;
 }
 
 EmeSessionTypeSupport KeySystemsImpl::GetPersistentLicenseSessionSupport(
     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()) {
+      key_system_map_.find(key_system);
+  if (key_system_iter == key_system_map_.end()) {
     NOTREACHED();
     return EmeSessionTypeSupport::INVALID;
   }
   return key_system_iter->second.persistent_license_support;
 }
 
 EmeSessionTypeSupport KeySystemsImpl::GetPersistentReleaseMessageSessionSupport(
     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()) {
+      key_system_map_.find(key_system);
+  if (key_system_iter == key_system_map_.end()) {
     NOTREACHED();
     return EmeSessionTypeSupport::INVALID;
   }
   return key_system_iter->second.persistent_release_message_support;
 }
 
 EmeFeatureSupport KeySystemsImpl::GetPersistentStateSupport(
     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()) {
+      key_system_map_.find(key_system);
+  if (key_system_iter == key_system_map_.end()) {
     NOTREACHED();
     return EmeFeatureSupport::INVALID;
   }
   return key_system_iter->second.persistent_state_support;
 }
 
 EmeFeatureSupport KeySystemsImpl::GetDistinctiveIdentifierSupport(
     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()) {
+      key_system_map_.find(key_system);
+  if (key_system_iter == key_system_map_.end()) {
     NOTREACHED();
     return EmeFeatureSupport::INVALID;
   }
   return key_system_iter->second.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);
 }
 
 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);
+bool CanUseAesDecryptor(const std::string& key_system) {
+  return KeySystemsImpl::GetInstance()->UseAesDecryptor(key_system);
 }
 
 #if defined(ENABLE_PEPPER_CDMS)
-std::string GetPepperType(const std::string& concrete_key_system) {
-  return KeySystemsImpl::GetInstance()->GetPepperType(concrete_key_system);
+std::string GetPepperType(const std::string& key_system) {
+  return KeySystemsImpl::GetInstance()->GetPepperType(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 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