EME: Remove the concept of a parent key system.

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 135 matching lines @@
     return true;
   if (key_system == kClearKey)
     return true;
 
   // External Clear Key is known and supports suffixes for testing.
   if (IsExternalClearKey(key_system))
     return true;
 
   // Chromecast defines behaviors for Cast clients within its reverse domain.
   const char kChromecastRoot[] = "com.chromecast";
-  if (IsParentKeySystemOf(kChromecastRoot, key_system))
+  if (IsChildKeySystemOf(key_system, kChromecastRoot))
     return true;
 
   // 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;
@@ skipping 61 matching lines @@
   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> 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_;
 
-  // Map from parent key system to the concrete key system that should be used
-  // to represent its capabilities.
-  ParentKeySystemMap parent_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.
   base::ThreadChecker thread_checker_;
@@ skipping 71 matching lines @@
 }
 
 void KeySystemsImpl::UpdateIfNeeded() {
   if (GetMediaClient() && GetMediaClient()->IsKeySystemsUpdateNeeded())
     UpdateSupportedKeySystems();
 }
 
 void KeySystemsImpl::UpdateSupportedKeySystems() {
   DCHECK(thread_checker_.CalledOnValidThread());
   concrete_key_system_map_.clear();
-  parent_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);
 }
 
 void KeySystemsImpl::AddConcreteSupportedKeySystems(
     const std::vector<KeySystemInfo>& concrete_key_systems) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(concrete_key_system_map_.empty());
-  DCHECK(parent_key_system_map_.empty());
 
   for (const KeySystemInfo& info : concrete_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);
@@ skipping 34 matching lines @@
 #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))
         << "Key system '" << info.key_system << "' already registered";
-    DCHECK(!parent_key_system_map_.count(info.key_system))
-        <<  "'" << info.key_system << "' is already registered as a parent";
     concrete_key_system_map_[info.key_system] = info;
-    if (!info.parent_key_system.empty()) {
-      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));
@@ skipping 360 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