Don't update Media.EME.KeySystemSupport UMA for unprefixed EME

content/renderer/renderer_blink_platform_impl.cc

 // Copyright (c) 2012 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 "content/renderer/renderer_blink_platform_impl.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 401 matching lines @@
 
     // Chromium only supports ASCII parameters.
     if (!base::IsStringASCII(key_system))
       return IsNotSupported;
 
     std::string key_system_ascii =
         media::GetUnprefixedKeySystemName(base::UTF16ToASCII(key_system));
     std::vector<std::string> strict_codecs;
     net::ParseCodecString(ToASCIIOrEmpty(codecs), &strict_codecs, true);
 
     if (!media::IsSupportedKeySystemWithMediaMimeType(

[ddorwin, 2015/01/27 00:51:51]

Instead of adding a bool, the purpose of which is not obvious at the call site,
change the function name to contain "Prefixed". You can hide the bool internally
if necessary.

(I'm not sure where to put "Prefixed". Prefixing the function name would be the
most obvious, but is probably not style compliant. Still, as far as readability
is concerned, I think it's best.

[jrummell, 2015/02/03 00:40:49]

Done.

-            mime_type_ascii, strict_codecs, key_system_ascii)) {
+            mime_type_ascii, strict_codecs, key_system_ascii, true)) {
       return IsNotSupported;
     }
 
     // Continue processing the mime_type and codecs.
   }
 
   // Check list of strict codecs to see if it is supported.
   if (net::IsStrictMediaMimeType(mime_type_ascii)) {
     // Check if the codecs are a perfect match.
     std::vector<std::string> strict_codecs;
@@ skipping 17 matching lines @@
     const WebString& codecs) {
   const std::string mime_type_ascii = ToASCIIOrEmpty(mime_type);
   std::vector<std::string> parsed_codec_ids;
   net::ParseCodecString(ToASCIIOrEmpty(codecs), &parsed_codec_ids, false);
   if (mime_type_ascii.empty())
     return false;
   return media::StreamParserFactory::IsTypeSupported(
       mime_type_ascii, parsed_codec_ids);
 }
 
 bool RendererBlinkPlatformImpl::MimeRegistry::supportsEncryptedMediaMIMEType(

[ddorwin, 2015/01/27 00:51:51]

This function is currently used by unprefixed EME, but should not be:
https://code.google.com/p/chromium/issues/detail?id=385874#c14.

[jrummell, 2015/02/03 00:40:49]

Acknowledged.

     const WebString& key_system,
     const WebString& mime_type,
     const WebString& codecs) {
   // Chromium only supports ASCII parameters.
   if (!base::IsStringASCII(key_system) || !base::IsStringASCII(mime_type) ||
       !base::IsStringASCII(codecs)) {
     return false;
   }
 
   if (key_system.isEmpty())
     return false;
 
   const std::string mime_type_ascii = base::UTF16ToASCII(mime_type);
 
   std::vector<std::string> codec_vector;
   bool strip_suffix = !net::IsStrictMediaMimeType(mime_type_ascii);
   net::ParseCodecString(base::UTF16ToASCII(codecs), &codec_vector,
                         strip_suffix);
 
   return media::IsSupportedKeySystemWithMediaMimeType(
-      mime_type_ascii, codec_vector, base::UTF16ToASCII(key_system));
+      mime_type_ascii, codec_vector, base::UTF16ToASCII(key_system), true);

[ddorwin, 2015/01/27 00:51:51]

That makes true incorrect.

[jrummell, 2015/02/03 00:40:49]

Done.

 }
 
 WebString RendererBlinkPlatformImpl::MimeRegistry::mimeTypeForExtension(
     const WebString& file_extension) {
   if (IsPluginProcess())
     return SimpleWebMimeRegistryImpl::mimeTypeForExtension(file_extension);
 
   // The sandbox restricts our access to the registry, so we need to proxy
   // these calls over to the browser process.
   std::string mime_type;
@@ skipping 731 matching lines @@
 //------------------------------------------------------------------------------
 
 void RendererBlinkPlatformImpl::MockBatteryStatusChangedForTesting(
     const blink::WebBatteryStatus& status) {
   if (!g_test_battery_status_listener)
     return;
   g_test_battery_status_listener->updateBatteryStatus(status);
 }
 
 }  // namespace content