Don't update Media.EME.KeySystemSupport UMA for unprefixed 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 <string>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
@@ skipping 102 matching lines @@
 
   bool IsSupportedKeySystem(const std::string& key_system);
 
   bool IsSupportedKeySystemWithInitDataType(
       const std::string& key_system,
       const std::string& init_data_type);
 
   bool IsSupportedKeySystemWithMediaMimeType(
       const std::string& mime_type,
       const std::vector<std::string>& codecs,
-      const std::string& key_system);
+      const std::string& key_system,
+      bool reportToUma);
 
   std::string GetKeySystemNameForUMA(const std::string& key_system) const;
 
   bool UseAesDecryptor(const std::string& concrete_key_system);
 
 #if defined(ENABLE_PEPPER_CDMS)
   std::string GetPepperType(const std::string& concrete_key_system);
 #endif
 
   void AddContainerMask(const std::string& container, uint32 mask);
@@ skipping 334 matching lines @@
   EmeInitDataType eme_init_data_type = GetInitDataTypeForName(init_data_type);
   return (properties.supported_init_data_types & eme_init_data_type) != 0;
 }
 
 // TODO(sandersd): Reorganize to be more similar to
 // IsKeySystemSupportedWithInitDataType(). Note that a fork may still be
 // required; http://crbug.com/417461.
 bool KeySystems::IsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
-    const std::string& key_system) {
+    const std::string& key_system,
+    bool reportToUma) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If |key_system| is a parent key system, use its concrete child.
   const std::string& concrete_key_system = GetConcreteKeySystemName(key_system);
 
   bool has_type = !mime_type.empty();
 
-  key_systems_support_uma_.ReportKeySystemQuery(key_system, has_type);
+  if (reportToUma)
+    key_systems_support_uma_.ReportKeySystemQuery(key_system, has_type);
 
   // Check key system support.
   KeySystemPropertiesMap::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 (reportToUma)
+    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);
+  if (reportToUma)
+    key_systems_support_uma_.ReportKeySystemSupport(key_system, true);
   return true;
 }
 
 std::string KeySystems::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())
@@ skipping 90 matching lines @@
     const std::string& init_data_type) {
   return KeySystems::GetInstance().IsSupportedKeySystemWithInitDataType(
       key_system, init_data_type);
 }
 
 bool IsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system) {
   return KeySystems::GetInstance().IsSupportedKeySystemWithMediaMimeType(
-      mime_type, codecs, key_system);
+      mime_type, codecs, key_system, false);
+}
+
+bool PrefixedIsSupportedKeySystemWithMediaMimeType(
+    const std::string& mime_type,
+    const std::vector<std::string>& codecs,
+    const std::string& key_system) {
+  return KeySystems::GetInstance().IsSupportedKeySystemWithMediaMimeType(
+      mime_type, codecs, key_system, true);
 }
 
 std::string GetKeySystemNameForUMA(const std::string& key_system) {
   return KeySystems::GetInstance().GetKeySystemNameForUMA(key_system);
 }
 
 bool CanUseAesDecryptor(const std::string& concrete_key_system) {
   return KeySystems::GetInstance().UseAesDecryptor(concrete_key_system);
 }
 
@@ skipping 12 matching lines @@
 MEDIA_EXPORT void AddContainerMask(const std::string& container,
                                      uint32 mask) {
   KeySystems::GetInstance().AddContainerMask(container, mask);
 }
 
 MEDIA_EXPORT void AddCodecMask(const std::string& codec, uint32 mask) {
   KeySystems::GetInstance().AddCodecMask(codec, mask);
 }
 
 }  // namespace media