Report disabled plugin in CreatePlugin.

chrome/renderer/plugins/plugin_uma.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.

[ddorwin, 2013/04/04 19:09:50]

same

[xhwang, 2013/04/04 23:10:33]

Done.

 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/renderer/plugins/plugin_uma.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 
 namespace {
 
-// String we will use to convert mime tyoe to plugin type.
+// String we will use to convert mime type to plugin type.
 const char kWindowsMediaPlayerType[] = "application/x-mplayer2";
 const char kSilverlightTypePrefix[] = "application/x-silverlight";
 const char kRealPlayerTypePrefix[] = "audio/x-pn-realaudio";
 const char kJavaTypeSubstring[] = "application/x-java-applet";
 const char kQuickTimeType[] = "video/quicktime";
 
 // Arrays containing file extensions connected with specific plugins.
 // The arrays must be sorted because binary search is used on them.
 const char* kWindowsMediaPlayerExtensions[] = {
     ".asx"
@@ skipping 12 matching lines @@
     ".moov",
     ".mov",
     ".qif",
     ".qt",
     ".qti",
     ".qtif"
 };
 
 }  // namespace.
 
-class UMASenderImpl : public MissingPluginReporter::UMASender {
-  virtual void SendPluginUMA(MissingPluginReporter::PluginType plugin_type)
-      OVERRIDE;
+class UMASenderImpl : public PluginUMAReporter::UMASender {
+  virtual void SendPluginUMA(
+      PluginUMAReporter::ReportType report_type,
+      PluginUMAReporter::PluginType plugin_type) OVERRIDE;
 };
 
-void UMASenderImpl::SendPluginUMA(
-    MissingPluginReporter::PluginType plugin_type) {
-  UMA_HISTOGRAM_ENUMERATION("Plugin.MissingPlugins",
-                            plugin_type,
-                            MissingPluginReporter::OTHER);
+void UMASenderImpl::SendPluginUMA(PluginUMAReporter::ReportType report_type,
+                                  PluginUMAReporter::PluginType plugin_type) {
+  // UMA_HISTOGRAM_ENUMERATION requires constant histogram name. Use string
+  // constants explicitly instead of trying to use variables for names.
+  switch (report_type) {
+    case PluginUMAReporter::MISSING_PLUGIN:
+      UMA_HISTOGRAM_ENUMERATION("Plugin.MissingPlugins",
+                                plugin_type,
+                                PluginUMAReporter::OTHER);
+      break;
+    case PluginUMAReporter::DISABLED_PLUGIN:
+      UMA_HISTOGRAM_ENUMERATION("Plugin.DisabledPlugins",
+                                plugin_type,
+                                PluginUMAReporter::OTHER);
+      break;
+    default:
+      NOTREACHED();
+  }
 }
 
 // static.
-MissingPluginReporter* MissingPluginReporter::GetInstance() {
-  return Singleton<MissingPluginReporter>::get();
+PluginUMAReporter* PluginUMAReporter::GetInstance() {
+  return Singleton<PluginUMAReporter>::get();
 }
 
-void MissingPluginReporter::ReportPluginMissing(
-    std::string plugin_mime_type, const GURL& plugin_src) {
-  PluginType plugin_type;
-  // If we know plugin's mime type, we use it to determine plugin's type. Else,
-  // we try to determine plugin type using plugin source's extension.
-  if (!plugin_mime_type.empty()) {
-    StringToLowerASCII(&plugin_mime_type);
-    plugin_type = MimeTypeToPluginType(plugin_mime_type);
-  } else {
-    plugin_type = SrcToPluginType(plugin_src);
-  }
-  report_sender_->SendPluginUMA(plugin_type);
+void PluginUMAReporter::ReportPluginMissing(
+    const std::string& plugin_mime_type, const GURL& plugin_src) {
+  report_sender_->SendPluginUMA(MISSING_PLUGIN,
+                                GetPluginType(plugin_mime_type, plugin_src));
 }
 
-void MissingPluginReporter::SetUMASender(UMASender* sender) {
-  report_sender_.reset(sender);
+void PluginUMAReporter::ReportPluginDisabled(
+    const std::string& plugin_mime_type, const GURL& plugin_src) {
+  report_sender_->SendPluginUMA(DISABLED_PLUGIN,
+                                GetPluginType(plugin_mime_type, plugin_src));
 }
 
-MissingPluginReporter::MissingPluginReporter()
-    : report_sender_(new UMASenderImpl()) {
+PluginUMAReporter::PluginUMAReporter() : report_sender_(new UMASenderImpl()) {
 }
 
-MissingPluginReporter::~MissingPluginReporter() {
+PluginUMAReporter::~PluginUMAReporter() {
 }
 
 // static.
-bool MissingPluginReporter::CompareCStrings(const char* first,
-                                           const char* second) {
+bool PluginUMAReporter::CompareCStrings(const char* first, const char* second) {
   return strcmp(first, second) < 0;
 }
 
-bool MissingPluginReporter::CStringArrayContainsCString(const char** array,
-                                                        size_t array_size,
-                                                        const char* str) {
+bool PluginUMAReporter::CStringArrayContainsCString(const char** array,
+                                                    size_t array_size,
+                                                    const char* str) {
   return std::binary_search(array, array + array_size, str, CompareCStrings);
 }
 
-void MissingPluginReporter::ExtractFileExtension(const GURL& src,
-    std::string* extension) {
+void PluginUMAReporter::ExtractFileExtension(const GURL& src,
+                                             std::string* extension) {
   std::string extension_file_path(src.ExtractFileName());
   if (extension_file_path.empty())
     extension_file_path = src.host();
 
   size_t last_dot = extension_file_path.find_last_of('.');
   if (last_dot != std::string::npos) {
     *extension = extension_file_path.substr(last_dot);
   } else {
     extension->clear();
   }
 
   StringToLowerASCII(extension);
 }
 
-MissingPluginReporter::PluginType MissingPluginReporter::SrcToPluginType(
+PluginUMAReporter::PluginType PluginUMAReporter::GetPluginType(
+    const std::string& plugin_mime_type, const GURL& plugin_src) {
+  // If we know plugin's mime type, we use it to determine plugin's type. Else,
+  // we try to determine plugin type using plugin source's extension.
+  if (!plugin_mime_type.empty())
+    return MimeTypeToPluginType(StringToLowerASCII(plugin_mime_type));
+
+  return SrcToPluginType(plugin_src);
+}
+
+PluginUMAReporter::PluginType PluginUMAReporter::SrcToPluginType(
     const GURL& src) {
   std::string file_extension;
   ExtractFileExtension(src, &file_extension);
   if (CStringArrayContainsCString(kWindowsMediaPlayerExtensions,
                                   arraysize(kWindowsMediaPlayerExtensions),
                                   file_extension.c_str())) {
     return WINDOWS_MEDIA_PLAYER;
   }
 
   if (CStringArrayContainsCString(kQuickTimeExtensions,
                                   arraysize(kQuickTimeExtensions),
                                   file_extension.c_str())) {
     return QUICKTIME;
   }
 
   if (CStringArrayContainsCString(kRealPlayerExtensions,
                                   arraysize(kRealPlayerExtensions),
                                   file_extension.c_str())) {
     return REALPLAYER;
   }
 
   return OTHER;
 }
 
-MissingPluginReporter::PluginType MissingPluginReporter::MimeTypeToPluginType(
+PluginUMAReporter::PluginType PluginUMAReporter::MimeTypeToPluginType(
     const std::string& mime_type) {
   if (strcmp(mime_type.c_str(), kWindowsMediaPlayerType) == 0)
     return WINDOWS_MEDIA_PLAYER;
 
   size_t prefix_length = strlen(kSilverlightTypePrefix);
   if (strncmp(mime_type.c_str(), kSilverlightTypePrefix, prefix_length) == 0)
     return SILVERLIGHT;
 
   prefix_length = strlen(kRealPlayerTypePrefix);
   if (strncmp(mime_type.c_str(), kRealPlayerTypePrefix, prefix_length) == 0)
     return REALPLAYER;
 
   if (strstr(mime_type.c_str(), kJavaTypeSubstring))
     return JAVA;
 
   if (strcmp(mime_type.c_str(), kQuickTimeType) == 0)
     return QUICKTIME;
 
   return OTHER;
 }
-