Simplify/Cleanup MediaClient

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>
 
@@ skipping 216 matching lines @@
 
   void RegisterMimeType(const std::string& mime_type, EmeCodec codecs_mask);
   bool IsValidMimeTypeCodecsCombination(const std::string& mime_type,
                                         SupportedCodecs codecs_mask) const;
 
   typedef base::hash_map<std::string, std::unique_ptr<KeySystemProperties>>
       KeySystemPropertiesMap;
   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 KeySystemProperties instance.
   KeySystemPropertiesMap key_system_properties_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_;
 
   DISALLOW_COPY_AND_ASSIGN(KeySystemsImpl);
 };
 
@@ skipping 11 matching lines @@
   for (size_t i = 0; i < arraysize(kCodecStrings); ++i) {
     const std::string& name = kCodecStrings[i].name;
     DCHECK(!codec_string_map_.count(name));
     codec_string_map_[name] = kCodecStrings[i].type;
   }
   for (size_t i = 0; i < arraysize(kMimeTypeToCodecMasks); ++i) {
     RegisterMimeType(kMimeTypeToCodecMasks[i].name,
                      kMimeTypeToCodecMasks[i].type);
   }
 
-  InitializeUMAInfo();
-
   // Always update supported key systems during construction.
   UpdateSupportedKeySystems();
 }
 
 KeySystemsImpl::~KeySystemsImpl() {
 }
 
 SupportedCodecs KeySystemsImpl::GetCodecMaskForMimeType(
     const std::string& container_mime_type) const {
   MimeTypeCodecsMap::const_iterator iter =
       mime_type_to_codec_mask_map_.find(container_mime_type);
   if (iter == mime_type_to_codec_mask_map_.end())
     return EME_CODEC_NONE;
 
   DCHECK(IsValidMimeTypeCodecsCombination(container_mime_type, iter->second));
   return iter->second;
 }
 
 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;
 }
 
-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;
-  }
-
-  // Clear Key is always supported.
-  key_system_name_for_uma_map_[kClearKeyKeySystem] =
-      kClearKeyKeySystemNameForUMA;
-}
-
 void KeySystemsImpl::UpdateIfNeeded() {
   if (GetMediaClient() && GetMediaClient()->IsKeySystemsUpdateNeeded())
     UpdateSupportedKeySystems();
 }
 
 void KeySystemsImpl::UpdateSupportedKeySystems() {
   DCHECK(thread_checker_.CalledOnValidThread());
   key_system_properties_map_.clear();
 
   std::vector<std::unique_ptr<KeySystemProperties>> key_systems_properties;
 
   // Add key systems supported by the MediaClient implementation.
-  if (GetMediaClient())
+  if (GetMediaClient()) {
     GetMediaClient()->AddSupportedKeySystems(&key_systems_properties);
+  } else {
+    DVLOG(1) << __func__ << " No media client to provide key systems";
+  }
 
   // Clear Key is always supported.
   key_systems_properties.emplace_back(new ClearKeyProperties());
 
   AddSupportedKeySystems(&key_systems_properties);
 }
 
 // Returns whether distinctive identifiers and persistent state can be reliably
 // blocked for |properties| (and therefore be safely configurable).
 static bool CanBlock(const KeySystemProperties& properties) {
@@ skipping 83 matching lines @@
 
 #if defined(OS_ANDROID)
     // Ensure that the renderer can access the decoders necessary to use the
     // key system.
     if (!properties->UseAesDecryptor() && !HasPlatformDecoderSupport()) {
       DLOG(WARNING) << properties->GetKeySystemName() << " not registered";
       continue;
     }
 #endif  // defined(OS_ANDROID)
 
+    DVLOG(1) << __func__
+             << " Adding key system:" << properties->GetKeySystemName();
     key_system_properties_map_[properties->GetKeySystemName()] =
         std::move(properties);
   }
 }
 
 // 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());
@@ skipping 31 matching lines @@
     NOTREACHED();
     return false;
   }
   return key_system_iter->second->IsSupportedInitDataType(init_data_type);
 }
 
 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;
+  // Here we maintain a short list of known key systems to facilitate UMA
+  // reporting. Mentioned key systems are not necessarily supported by
+  // the current platform.
+  if (key_system == kWidevineKeySystem)
+    return kWidevineKeySystemNameForUMA;
 
-  return iter->second;
+  if (key_system == kClearKeyKeySystem)
+    return kClearKeyKeySystemNameForUMA;
+
+  return kUnknownKeySystemNameForUMA;
 }
 
 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;
@@ skipping 223 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