src/chrome/browser/metrics/chrome_browser_main_extra_parts_metrics.cc

   1 // Copyright (c) 2013 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/browser/metrics/chrome_browser_main_extra_parts_metrics.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/command_line.h"
  11 #include "base/cpu.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/metrics/sparse_histogram.h"
  14 #include "base/sys_info.h"
  15 #include "base/threading/sequenced_worker_pool.h"
  16 #include "base/time/time.h"
  17 #include "chrome/browser/about_flags.h"
  18 #include "chrome/browser/browser_process.h"
  19 #include "chrome/browser/chrome_browser_main.h"
  20 #include "chrome/browser/chrome_browser_metrics_service_observer.h"
  21 #include "chrome/browser/pref_service_flags_storage.h"
  22 #include "chrome/browser/shell_integration.h"
  23 #include "content/public/browser/browser_thread.h"
  24 #include "ui/base/touch/touch_device.h"
  25 #include "ui/base/ui_base_switches.h"
  26 #include "ui/events/event_switches.h"
  27
  28 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
  29 #include <gnu/libc-version.h>
  30
  31 #include "base/version.h"
  32 #include "ui/base/x/x11_util.h"
  33 #endif  // defined(OS_LINUX) && !defined(OS_CHROMEOS)
  34
  35 #if defined(OS_WIN)
  36 #include "chrome/installer/util/google_update_settings.h"
  37 #endif  // defined(OS_WIN)
  38
  39 namespace {
  40
  41 enum UMALinuxGlibcVersion {
  42   UMA_LINUX_GLIBC_NOT_PARSEABLE,
  43   UMA_LINUX_GLIBC_UNKNOWN,
  44   UMA_LINUX_GLIBC_2_11,
  45   UMA_LINUX_GLIBC_2_19 = UMA_LINUX_GLIBC_2_11 + 8,
  46   // NOTE: Add new version above this line and update the enum list in
  47   // tools/metrics/histograms/histograms.xml accordingly.
  48   UMA_LINUX_GLIBC_VERSION_COUNT
  49 };
  50
  51 enum UMALinuxWindowManager {
  52   UMA_LINUX_WINDOW_MANAGER_OTHER,
  53   UMA_LINUX_WINDOW_MANAGER_BLACKBOX,
  54   UMA_LINUX_WINDOW_MANAGER_CHROME_OS,
  55   UMA_LINUX_WINDOW_MANAGER_COMPIZ,
  56   UMA_LINUX_WINDOW_MANAGER_ENLIGHTENMENT,
  57   UMA_LINUX_WINDOW_MANAGER_ICE_WM,
  58   UMA_LINUX_WINDOW_MANAGER_KWIN,
  59   UMA_LINUX_WINDOW_MANAGER_METACITY,
  60   UMA_LINUX_WINDOW_MANAGER_MUFFIN,
  61   UMA_LINUX_WINDOW_MANAGER_MUTTER,
  62   UMA_LINUX_WINDOW_MANAGER_OPENBOX,
  63   UMA_LINUX_WINDOW_MANAGER_XFWM4,
  64   // NOTE: Add new window managers above this line and update the enum list in
  65   // tools/metrics/histograms/histograms.xml accordingly.
  66   UMA_LINUX_WINDOW_MANAGER_COUNT
  67 };
  68
  69 enum UMATouchEventsState {
  70   UMA_TOUCH_EVENTS_ENABLED,
  71   UMA_TOUCH_EVENTS_AUTO_ENABLED,
  72   UMA_TOUCH_EVENTS_AUTO_DISABLED,
  73   UMA_TOUCH_EVENTS_DISABLED,
  74   // NOTE: Add states only immediately above this line. Make sure to
  75   // update the enum list in tools/metrics/histograms/histograms.xml
  76   // accordingly.
  77   UMA_TOUCH_EVENTS_STATE_COUNT
  78 };
  79
  80 void RecordMicroArchitectureStats() {
  81 #if defined(ARCH_CPU_X86_FAMILY)
  82   base::CPU cpu;
  83   base::CPU::IntelMicroArchitecture arch = cpu.GetIntelMicroArchitecture();
  84   UMA_HISTOGRAM_ENUMERATION("Platform.IntelMaxMicroArchitecture", arch,
  85                             base::CPU::MAX_INTEL_MICRO_ARCHITECTURE);
  86 #endif  // defined(ARCH_CPU_X86_FAMILY)
  87   UMA_HISTOGRAM_SPARSE_SLOWLY("Platform.LogicalCpuCount",
  88                               base::SysInfo::NumberOfProcessors());
  89 }
  90
  91 // Called on the blocking pool some time after startup to avoid slowing down
  92 // startup with metrics that aren't trivial to compute.
  93 void RecordStartupMetricsOnBlockingPool() {
  94 #if defined(OS_WIN)
  95   GoogleUpdateSettings::RecordChromeUpdatePolicyHistograms();
  96 #endif  // defined(OS_WIN)
  97 }
  98
  99 void RecordLinuxGlibcVersion() {
 100 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 101   Version version(gnu_get_libc_version());
 102
 103   UMALinuxGlibcVersion glibc_version_result = UMA_LINUX_GLIBC_NOT_PARSEABLE;
 104   if (version.IsValid() && version.components().size() == 2) {
 105     glibc_version_result = UMA_LINUX_GLIBC_UNKNOWN;
 106     int glibc_major_version = version.components()[0];
 107     int glibc_minor_version = version.components()[1];
 108     if (glibc_major_version == 2) {
 109       // A constant to translate glibc 2.x minor versions to their
 110       // equivalent UMALinuxGlibcVersion values.
 111       const int kGlibcMinorVersionTranslationOffset = 11 - UMA_LINUX_GLIBC_2_11;
 112       int translated_glibc_minor_version =
 113           glibc_minor_version - kGlibcMinorVersionTranslationOffset;
 114       if (translated_glibc_minor_version >= UMA_LINUX_GLIBC_2_11 &&
 115           translated_glibc_minor_version <= UMA_LINUX_GLIBC_2_19) {
 116         glibc_version_result =
 117             static_cast<UMALinuxGlibcVersion>(translated_glibc_minor_version);
 118       }
 119     }
 120   }
 121   UMA_HISTOGRAM_ENUMERATION("Linux.GlibcVersion", glibc_version_result,
 122                             UMA_LINUX_GLIBC_VERSION_COUNT);
 123 #endif
 124 }
 125
 126 void RecordLinuxWindowManager() {
 127 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 128   ui::WindowManagerName name = ui::GuessWindowManager();
 129   UMALinuxWindowManager uma_name = UMA_LINUX_WINDOW_MANAGER_OTHER;
 130   switch (name) {
 131     case ui::WM_UNKNOWN:
 132       uma_name = UMA_LINUX_WINDOW_MANAGER_OTHER;
 133       break;
 134     case ui::WM_BLACKBOX:
 135       uma_name = UMA_LINUX_WINDOW_MANAGER_BLACKBOX;
 136       break;
 137     case ui::WM_CHROME_OS:
 138       uma_name = UMA_LINUX_WINDOW_MANAGER_CHROME_OS;
 139       break;
 140     case ui::WM_COMPIZ:
 141       uma_name = UMA_LINUX_WINDOW_MANAGER_COMPIZ;
 142       break;
 143     case ui::WM_ENLIGHTENMENT:
 144       uma_name = UMA_LINUX_WINDOW_MANAGER_ENLIGHTENMENT;
 145       break;
 146     case ui::WM_ICE_WM:
 147       uma_name = UMA_LINUX_WINDOW_MANAGER_ICE_WM;
 148       break;
 149     case ui::WM_KWIN:
 150       uma_name = UMA_LINUX_WINDOW_MANAGER_KWIN;
 151       break;
 152     case ui::WM_METACITY:
 153       uma_name = UMA_LINUX_WINDOW_MANAGER_METACITY;
 154       break;
 155     case ui::WM_MUFFIN:
 156       uma_name = UMA_LINUX_WINDOW_MANAGER_MUFFIN;
 157       break;
 158     case ui::WM_MUTTER:
 159       uma_name = UMA_LINUX_WINDOW_MANAGER_MUTTER;
 160       break;
 161     case ui::WM_OPENBOX:
 162       uma_name = UMA_LINUX_WINDOW_MANAGER_OPENBOX;
 163       break;
 164     case ui::WM_XFWM4:
 165       uma_name = UMA_LINUX_WINDOW_MANAGER_XFWM4;
 166       break;
 167   }
 168   UMA_HISTOGRAM_ENUMERATION("Linux.WindowManager", uma_name,
 169                             UMA_LINUX_WINDOW_MANAGER_COUNT);
 170 #endif
 171 }
 172
 173 void RecordTouchEventState() {
 174   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 175   const std::string touch_enabled_switch =
 176       command_line.HasSwitch(switches::kTouchEvents) ?
 177       command_line.GetSwitchValueASCII(switches::kTouchEvents) :
 178       switches::kTouchEventsAuto;
 179
 180   UMATouchEventsState state;
 181   if (touch_enabled_switch.empty() ||
 182       touch_enabled_switch == switches::kTouchEventsEnabled) {
 183     state = UMA_TOUCH_EVENTS_ENABLED;
 184   } else if (touch_enabled_switch == switches::kTouchEventsAuto) {
 185     state = ui::IsTouchDevicePresent() ?
 186         UMA_TOUCH_EVENTS_AUTO_ENABLED : UMA_TOUCH_EVENTS_AUTO_DISABLED;
 187   } else if (touch_enabled_switch == switches::kTouchEventsDisabled) {
 188     state = UMA_TOUCH_EVENTS_DISABLED;
 189   } else {
 190     NOTREACHED();
 191     return;
 192   }
 193
 194   UMA_HISTOGRAM_ENUMERATION("Touchscreen.TouchEventsEnabled", state,
 195                             UMA_TOUCH_EVENTS_STATE_COUNT);
 196 }
 197
 198 }  // namespace
 199
 200 ChromeBrowserMainExtraPartsMetrics::ChromeBrowserMainExtraPartsMetrics() {
 201 }
 202
 203 ChromeBrowserMainExtraPartsMetrics::~ChromeBrowserMainExtraPartsMetrics() {
 204 }
 205
 206 void ChromeBrowserMainExtraPartsMetrics::PreProfileInit() {
 207   RecordMicroArchitectureStats();
 208 }
 209
 210 void ChromeBrowserMainExtraPartsMetrics::PreBrowserStart() {
 211   about_flags::PrefServiceFlagsStorage flags_storage_(
 212       g_browser_process->local_state());
 213   about_flags::RecordUMAStatistics(&flags_storage_);
 214 }
 215
 216 void ChromeBrowserMainExtraPartsMetrics::PostBrowserStart() {
 217   RecordLinuxGlibcVersion();
 218   RecordLinuxWindowManager();
 219   RecordTouchEventState();
 220
 221   const int kStartupMetricsGatheringDelaySeconds = 45;
 222   content::BrowserThread::GetBlockingPool()->PostDelayedTask(
 223       FROM_HERE,
 224       base::Bind(&RecordStartupMetricsOnBlockingPool),
 225       base::TimeDelta::FromSeconds(kStartupMetricsGatheringDelaySeconds));
 226
 227   // Create the metrics log observer.
 228   // We only need this for Android for now.
 229 #if defined(ANDROID)
 230   metrics_service_observer_.reset(new ChromeBrowserMetricsServiceObserver());
 231 #endif
 232 }
 233
 234 namespace chrome {
 235
 236 void AddMetricsExtraParts(ChromeBrowserMainParts* main_parts) {
 237   main_parts->AddParts(new ChromeBrowserMainExtraPartsMetrics());
 238 }
 239
 240 }  // namespace chrome