chrome/renderer/plugins/plugin_uma.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/renderer/plugins/plugin_uma.h"
   6
   7 #include <algorithm>
   8 #include <cstring>
   9
  10 #include "base/metrics/histogram.h"
  11 #include "base/strings/string_util.h"
  12 #include "content/public/common/content_constants.h"
  13 #include "third_party/widevine/cdm/widevine_cdm_common.h"
  14
  15 namespace {
  16
  17 // String we will use to convert mime type to plugin type.
  18 const char kWindowsMediaPlayerType[] = "application/x-mplayer2";
  19 const char kSilverlightTypePrefix[] = "application/x-silverlight";
  20 const char kRealPlayerTypePrefix[] = "audio/x-pn-realaudio";
  21 const char kJavaTypeSubstring[] = "application/x-java-applet";
  22 const char kQuickTimeType[] = "video/quicktime";
  23
  24 // Arrays containing file extensions connected with specific plugins.
  25 // Note: THE ARRAYS MUST BE SORTED BECAUSE BINARY SEARCH IS USED ON THEM!
  26 const char* const kWindowsMediaPlayerExtensions[] = {".asx"};
  27
  28 const char* const kRealPlayerExtensions[] = {".ra",  ".ram", ".rm",
  29                                              ".rmm", ".rmp", ".rpm"};
  30
  31 const char* const kQuickTimeExtensions[] = {".moov", ".mov", ".qif",
  32                                             ".qt",   ".qti", ".qtif"};
  33
  34 const char* const kShockwaveFlashExtensions[] = {".spl", ".swf"};
  35
  36 }  // namespace.
  37
  38 class UMASenderImpl : public PluginUMAReporter::UMASender {
  39   void SendPluginUMA(PluginUMAReporter::ReportType report_type,
  40                      PluginUMAReporter::PluginType plugin_type) override;
  41 };
  42
  43 void UMASenderImpl::SendPluginUMA(PluginUMAReporter::ReportType report_type,
  44                                   PluginUMAReporter::PluginType plugin_type) {
  45   // UMA_HISTOGRAM_ENUMERATION requires constant histogram name. Use string
  46   // constants explicitly instead of trying to use variables for names.
  47   switch (report_type) {
  48     case PluginUMAReporter::MISSING_PLUGIN:
  49       UMA_HISTOGRAM_ENUMERATION("Plugin.MissingPlugins",
  50                                 plugin_type,
  51                                 PluginUMAReporter::PLUGIN_TYPE_MAX);
  52       break;
  53     case PluginUMAReporter::DISABLED_PLUGIN:
  54       UMA_HISTOGRAM_ENUMERATION("Plugin.DisabledPlugins",
  55                                 plugin_type,
  56                                 PluginUMAReporter::PLUGIN_TYPE_MAX);
  57       break;
  58     default:
  59       NOTREACHED();
  60   }
  61 }
  62
  63 // static.
  64 PluginUMAReporter* PluginUMAReporter::GetInstance() {
  65   return Singleton<PluginUMAReporter>::get();
  66 }
  67
  68 void PluginUMAReporter::ReportPluginMissing(const std::string& plugin_mime_type,
  69                                             const GURL& plugin_src) {
  70   report_sender_->SendPluginUMA(MISSING_PLUGIN,
  71                                 GetPluginType(plugin_mime_type, plugin_src));
  72 }
  73
  74 void PluginUMAReporter::ReportPluginDisabled(
  75     const std::string& plugin_mime_type,
  76     const GURL& plugin_src) {
  77   report_sender_->SendPluginUMA(DISABLED_PLUGIN,
  78                                 GetPluginType(plugin_mime_type, plugin_src));
  79 }
  80
  81 PluginUMAReporter::PluginUMAReporter() : report_sender_(new UMASenderImpl()) {}
  82
  83 PluginUMAReporter::~PluginUMAReporter() {}
  84
  85 // static.
  86 bool PluginUMAReporter::CompareCStrings(const char* first, const char* second) {
  87   return strcmp(first, second) < 0;
  88 }
  89
  90 bool PluginUMAReporter::CStringArrayContainsCString(const char* const* array,
  91                                                     size_t array_size,
  92                                                     const char* str) {
  93   return std::binary_search(array, array + array_size, str, CompareCStrings);
  94 }
  95
  96 void PluginUMAReporter::ExtractFileExtension(const GURL& src,
  97                                              std::string* extension) {
  98   std::string extension_file_path(src.ExtractFileName());
  99   if (extension_file_path.empty())
 100     extension_file_path = src.host();
 101
 102   size_t last_dot = extension_file_path.find_last_of('.');
 103   if (last_dot != std::string::npos) {
 104     *extension = extension_file_path.substr(last_dot);
 105   } else {
 106     extension->clear();
 107   }
 108
 109   base::StringToLowerASCII(extension);
 110 }
 111
 112 PluginUMAReporter::PluginType PluginUMAReporter::GetPluginType(
 113     const std::string& plugin_mime_type,
 114     const GURL& plugin_src) {
 115   // If we know plugin's mime type, we use it to determine plugin's type. Else,
 116   // we try to determine plugin type using plugin source's extension.
 117   if (!plugin_mime_type.empty())
 118     return MimeTypeToPluginType(base::StringToLowerASCII(plugin_mime_type));
 119
 120   return SrcToPluginType(plugin_src);
 121 }
 122
 123 PluginUMAReporter::PluginType PluginUMAReporter::SrcToPluginType(
 124     const GURL& src) {
 125   std::string file_extension;
 126   ExtractFileExtension(src, &file_extension);
 127   if (CStringArrayContainsCString(kWindowsMediaPlayerExtensions,
 128                                   arraysize(kWindowsMediaPlayerExtensions),
 129                                   file_extension.c_str())) {
 130     return WINDOWS_MEDIA_PLAYER;
 131   }
 132
 133   if (CStringArrayContainsCString(kQuickTimeExtensions,
 134                                   arraysize(kQuickTimeExtensions),
 135                                   file_extension.c_str())) {
 136     return QUICKTIME;
 137   }
 138
 139   if (CStringArrayContainsCString(kRealPlayerExtensions,
 140                                   arraysize(kRealPlayerExtensions),
 141                                   file_extension.c_str())) {
 142     return REALPLAYER;
 143   }
 144
 145   if (CStringArrayContainsCString(kShockwaveFlashExtensions,
 146                                   arraysize(kShockwaveFlashExtensions),
 147                                   file_extension.c_str())) {
 148     return SHOCKWAVE_FLASH;
 149   }
 150
 151   return UNSUPPORTED_EXTENSION;
 152 }
 153
 154 PluginUMAReporter::PluginType PluginUMAReporter::MimeTypeToPluginType(
 155     const std::string& mime_type) {
 156   if (mime_type == kWindowsMediaPlayerType)
 157     return WINDOWS_MEDIA_PLAYER;
 158
 159   size_t prefix_length = strlen(kSilverlightTypePrefix);
 160   if (strncmp(mime_type.c_str(), kSilverlightTypePrefix, prefix_length) == 0)
 161     return SILVERLIGHT;
 162
 163   prefix_length = strlen(kRealPlayerTypePrefix);
 164   if (strncmp(mime_type.c_str(), kRealPlayerTypePrefix, prefix_length) == 0)
 165     return REALPLAYER;
 166
 167   if (strstr(mime_type.c_str(), kJavaTypeSubstring))
 168     return JAVA;
 169
 170   if (mime_type == kQuickTimeType)
 171     return QUICKTIME;
 172
 173   if (mime_type == content::kBrowserPluginMimeType)
 174     return BROWSER_PLUGIN;
 175
 176   if (mime_type == content::kFlashPluginSwfMimeType ||
 177       mime_type == content::kFlashPluginSplMimeType) {
 178     return SHOCKWAVE_FLASH;
 179   }
 180
 181 #if defined(ENABLE_PEPPER_CDMS)
 182   if (mime_type == kWidevineCdmPluginMimeType)
 183     return WIDEVINE_CDM;
 184 #endif
 185
 186   return UNSUPPORTED_MIMETYPE;
 187 }