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/mac/bluetooth_utility.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 #include "ui/gfx/screen.h"
  28
  29 #if defined(OS_ANDROID) && defined(__arm__)
  30 #include <cpu-features.h>
  31 #endif  // defined(OS_ANDROID) && defined(__arm__)
  32
  33 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
  34 #include <gnu/libc-version.h>
  35
  36 #include "base/version.h"
  37 #if defined(USE_X11)
  38 #include "ui/base/x/x11_util.h"
  39 #endif
  40 #endif  // defined(OS_LINUX) && !defined(OS_CHROMEOS)
  41
  42 #if defined(OS_WIN)
  43 #include "chrome/installer/util/google_update_settings.h"
  44 #endif  // defined(OS_WIN)
  45
  46 namespace {
  47
  48 enum UMALinuxGlibcVersion {
  49   UMA_LINUX_GLIBC_NOT_PARSEABLE,
  50   UMA_LINUX_GLIBC_UNKNOWN,
  51   UMA_LINUX_GLIBC_2_11,
  52   // To log newer versions, just update tools/metrics/histograms/histograms.xml.
  53 };
  54
  55 enum UMALinuxWindowManager {
  56   UMA_LINUX_WINDOW_MANAGER_OTHER,
  57   UMA_LINUX_WINDOW_MANAGER_BLACKBOX,
  58   UMA_LINUX_WINDOW_MANAGER_CHROME_OS,  // Deprecated.
  59   UMA_LINUX_WINDOW_MANAGER_COMPIZ,
  60   UMA_LINUX_WINDOW_MANAGER_ENLIGHTENMENT,
  61   UMA_LINUX_WINDOW_MANAGER_ICE_WM,
  62   UMA_LINUX_WINDOW_MANAGER_KWIN,
  63   UMA_LINUX_WINDOW_MANAGER_METACITY,
  64   UMA_LINUX_WINDOW_MANAGER_MUFFIN,
  65   UMA_LINUX_WINDOW_MANAGER_MUTTER,
  66   UMA_LINUX_WINDOW_MANAGER_OPENBOX,
  67   UMA_LINUX_WINDOW_MANAGER_XFWM4,
  68   UMA_LINUX_WINDOW_MANAGER_AWESOME,
  69   UMA_LINUX_WINDOW_MANAGER_I3,
  70   UMA_LINUX_WINDOW_MANAGER_ION3,
  71   UMA_LINUX_WINDOW_MANAGER_MATCHBOX,
  72   UMA_LINUX_WINDOW_MANAGER_NOTION,
  73   UMA_LINUX_WINDOW_MANAGER_QTILE,
  74   UMA_LINUX_WINDOW_MANAGER_RATPOISON,
  75   UMA_LINUX_WINDOW_MANAGER_STUMPWM,
  76   UMA_LINUX_WINDOW_MANAGER_WMII,
  77   UMA_LINUX_WINDOW_MANAGER_FLUXBOX,
  78   // NOTE: Append new window managers to the list above this line (i.e. don't
  79   // renumber) and update LinuxWindowManagerName in
  80   // tools/metrics/histograms/histograms.xml accordingly.
  81   UMA_LINUX_WINDOW_MANAGER_COUNT
  82 };
  83
  84 enum UMATouchEventsState {
  85   UMA_TOUCH_EVENTS_ENABLED,
  86   UMA_TOUCH_EVENTS_AUTO_ENABLED,
  87   UMA_TOUCH_EVENTS_AUTO_DISABLED,
  88   UMA_TOUCH_EVENTS_DISABLED,
  89   // NOTE: Add states only immediately above this line. Make sure to
  90   // update the enum list in tools/metrics/histograms/histograms.xml
  91   // accordingly.
  92   UMA_TOUCH_EVENTS_STATE_COUNT
  93 };
  94
  95 #if defined(OS_ANDROID) && defined(__arm__)
  96 enum UMAAndroidArmFpu {
  97   UMA_ANDROID_ARM_FPU_VFPV3_D16, // The ARM CPU only supports vfpv3-d16.
  98   UMA_ANDROID_ARM_FPU_NEON,      // The Arm CPU supports NEON.
  99   UMA_ANDROID_ARM_FPU_COUNT
 100 };
 101 #endif  // defined(OS_ANDROID) && defined(__arm__)
 102
 103 void RecordMicroArchitectureStats() {
 104 #if defined(ARCH_CPU_X86_FAMILY)
 105   base::CPU cpu;
 106   base::CPU::IntelMicroArchitecture arch = cpu.GetIntelMicroArchitecture();
 107   UMA_HISTOGRAM_ENUMERATION("Platform.IntelMaxMicroArchitecture", arch,
 108                             base::CPU::MAX_INTEL_MICRO_ARCHITECTURE);
 109 #endif  // defined(ARCH_CPU_X86_FAMILY)
 110 #if defined(OS_ANDROID) && defined(__arm__)
 111   // Detect NEON support.
 112   // TODO(fdegans): Remove once non-NEON support has been removed.
 113   if (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) {
 114     UMA_HISTOGRAM_ENUMERATION("Android.ArmFpu",
 115                               UMA_ANDROID_ARM_FPU_NEON,
 116                               UMA_ANDROID_ARM_FPU_COUNT);
 117   } else {
 118     UMA_HISTOGRAM_ENUMERATION("Android.ArmFpu",
 119                               UMA_ANDROID_ARM_FPU_VFPV3_D16,
 120                               UMA_ANDROID_ARM_FPU_COUNT);
 121   }
 122 #endif  // defined(OS_ANDROID) && defined(__arm__)
 123   UMA_HISTOGRAM_SPARSE_SLOWLY("Platform.LogicalCpuCount",
 124                               base::SysInfo::NumberOfProcessors());
 125 }
 126
 127 // Called on the blocking pool some time after startup to avoid slowing down
 128 // startup with metrics that aren't trivial to compute.
 129 void RecordStartupMetricsOnBlockingPool() {
 130 #if defined(OS_WIN)
 131   GoogleUpdateSettings::RecordChromeUpdatePolicyHistograms();
 132 #endif  // defined(OS_WIN)
 133
 134 #if defined(OS_MACOSX) && !defined(OS_IOS)
 135   bluetooth_utility::BluetoothAvailability availability =
 136       bluetooth_utility::GetBluetoothAvailability();
 137   UMA_HISTOGRAM_ENUMERATION("OSX.BluetoothAvailability",
 138                             availability,
 139                             bluetooth_utility::BLUETOOTH_AVAILABILITY_COUNT);
 140 #endif   // defined(OS_MACOSX) && !defined(OS_IOS)
 141 }
 142
 143 void RecordLinuxGlibcVersion() {
 144 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 145   Version version(gnu_get_libc_version());
 146
 147   UMALinuxGlibcVersion glibc_version_result = UMA_LINUX_GLIBC_NOT_PARSEABLE;
 148   if (version.IsValid() && version.components().size() == 2) {
 149     glibc_version_result = UMA_LINUX_GLIBC_UNKNOWN;
 150     uint32_t glibc_major_version = version.components()[0];
 151     uint32_t glibc_minor_version = version.components()[1];
 152     if (glibc_major_version == 2) {
 153       // A constant to translate glibc 2.x minor versions to their
 154       // equivalent UMALinuxGlibcVersion values.
 155       const int kGlibcMinorVersionTranslationOffset = 11 - UMA_LINUX_GLIBC_2_11;
 156       uint32_t translated_glibc_minor_version =
 157           glibc_minor_version - kGlibcMinorVersionTranslationOffset;
 158       if (translated_glibc_minor_version >= UMA_LINUX_GLIBC_2_11) {
 159         glibc_version_result =
 160             static_cast<UMALinuxGlibcVersion>(translated_glibc_minor_version);
 161       }
 162     }
 163   }
 164   UMA_HISTOGRAM_SPARSE_SLOWLY("Linux.GlibcVersion", glibc_version_result);
 165 #endif
 166 }
 167
 168 #if defined(USE_X11) && !defined(OS_CHROMEOS)
 169 UMALinuxWindowManager GetLinuxWindowManager() {
 170   switch (ui::GuessWindowManager()) {
 171     case ui::WM_UNKNOWN:
 172       return UMA_LINUX_WINDOW_MANAGER_OTHER;
 173     case ui::WM_AWESOME:
 174       return UMA_LINUX_WINDOW_MANAGER_AWESOME;
 175     case ui::WM_BLACKBOX:
 176       return UMA_LINUX_WINDOW_MANAGER_BLACKBOX;
 177     case ui::WM_COMPIZ:
 178       return UMA_LINUX_WINDOW_MANAGER_COMPIZ;
 179     case ui::WM_ENLIGHTENMENT:
 180       return UMA_LINUX_WINDOW_MANAGER_ENLIGHTENMENT;
 181     case ui::WM_FLUXBOX:
 182       return UMA_LINUX_WINDOW_MANAGER_FLUXBOX;
 183     case ui::WM_I3:
 184       return UMA_LINUX_WINDOW_MANAGER_I3;
 185     case ui::WM_ICE_WM:
 186       return UMA_LINUX_WINDOW_MANAGER_ICE_WM;
 187     case ui::WM_ION3:
 188       return UMA_LINUX_WINDOW_MANAGER_ION3;
 189     case ui::WM_KWIN:
 190       return UMA_LINUX_WINDOW_MANAGER_KWIN;
 191     case ui::WM_MATCHBOX:
 192       return UMA_LINUX_WINDOW_MANAGER_MATCHBOX;
 193     case ui::WM_METACITY:
 194       return UMA_LINUX_WINDOW_MANAGER_METACITY;
 195     case ui::WM_MUFFIN:
 196       return UMA_LINUX_WINDOW_MANAGER_MUFFIN;
 197     case ui::WM_MUTTER:
 198       return UMA_LINUX_WINDOW_MANAGER_MUTTER;
 199     case ui::WM_NOTION:
 200       return UMA_LINUX_WINDOW_MANAGER_NOTION;
 201     case ui::WM_OPENBOX:
 202       return UMA_LINUX_WINDOW_MANAGER_OPENBOX;
 203     case ui::WM_QTILE:
 204       return UMA_LINUX_WINDOW_MANAGER_QTILE;
 205     case ui::WM_RATPOISON:
 206       return UMA_LINUX_WINDOW_MANAGER_RATPOISON;
 207     case ui::WM_STUMPWM:
 208       return UMA_LINUX_WINDOW_MANAGER_STUMPWM;
 209     case ui::WM_WMII:
 210       return UMA_LINUX_WINDOW_MANAGER_WMII;
 211     case ui::WM_XFWM4:
 212       return UMA_LINUX_WINDOW_MANAGER_XFWM4;
 213   }
 214   return UMA_LINUX_WINDOW_MANAGER_OTHER;
 215 }
 216 #endif
 217
 218 void RecordTouchEventState() {
 219   const base::CommandLine& command_line =
 220       *base::CommandLine::ForCurrentProcess();
 221   const std::string touch_enabled_switch =
 222       command_line.HasSwitch(switches::kTouchEvents) ?
 223       command_line.GetSwitchValueASCII(switches::kTouchEvents) :
 224       switches::kTouchEventsAuto;
 225
 226   UMATouchEventsState state;
 227   if (touch_enabled_switch.empty() ||
 228       touch_enabled_switch == switches::kTouchEventsEnabled) {
 229     state = UMA_TOUCH_EVENTS_ENABLED;
 230   } else if (touch_enabled_switch == switches::kTouchEventsAuto) {
 231     state = ui::IsTouchDevicePresent() ?
 232         UMA_TOUCH_EVENTS_AUTO_ENABLED : UMA_TOUCH_EVENTS_AUTO_DISABLED;
 233   } else if (touch_enabled_switch == switches::kTouchEventsDisabled) {
 234     state = UMA_TOUCH_EVENTS_DISABLED;
 235   } else {
 236     NOTREACHED();
 237     return;
 238   }
 239
 240   UMA_HISTOGRAM_ENUMERATION("Touchscreen.TouchEventsEnabled", state,
 241                             UMA_TOUCH_EVENTS_STATE_COUNT);
 242 }
 243
 244 }  // namespace
 245
 246 ChromeBrowserMainExtraPartsMetrics::ChromeBrowserMainExtraPartsMetrics()
 247     : display_count_(0), is_screen_observer_(false) {
 248 }
 249
 250 ChromeBrowserMainExtraPartsMetrics::~ChromeBrowserMainExtraPartsMetrics() {
 251   if (is_screen_observer_)
 252     gfx::Screen::GetNativeScreen()->RemoveObserver(this);
 253 }
 254
 255 void ChromeBrowserMainExtraPartsMetrics::PreProfileInit() {
 256   RecordMicroArchitectureStats();
 257 }
 258
 259 void ChromeBrowserMainExtraPartsMetrics::PreBrowserStart() {
 260   about_flags::PrefServiceFlagsStorage flags_storage_(
 261       g_browser_process->local_state());
 262   about_flags::RecordUMAStatistics(&flags_storage_);
 263 }
 264
 265 void ChromeBrowserMainExtraPartsMetrics::PostBrowserStart() {
 266   RecordLinuxGlibcVersion();
 267 #if defined(USE_X11) && !defined(OS_CHROMEOS)
 268   UMA_HISTOGRAM_ENUMERATION("Linux.WindowManager",
 269                             GetLinuxWindowManager(),
 270                             UMA_LINUX_WINDOW_MANAGER_COUNT);
 271 #endif
 272   RecordTouchEventState();
 273
 274 #if defined(OS_MACOSX) && !defined(OS_IOS)
 275   RecordMacMetrics();
 276 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 277
 278   const int kStartupMetricsGatheringDelaySeconds = 45;
 279   content::BrowserThread::GetBlockingPool()->PostDelayedTask(
 280       FROM_HERE,
 281       base::Bind(&RecordStartupMetricsOnBlockingPool),
 282       base::TimeDelta::FromSeconds(kStartupMetricsGatheringDelaySeconds));
 283
 284   display_count_ = gfx::Screen::GetNativeScreen()->GetNumDisplays();
 285   UMA_HISTOGRAM_COUNTS_100("Hardware.Display.Count.OnStartup", display_count_);
 286   gfx::Screen::GetNativeScreen()->AddObserver(this);
 287   is_screen_observer_ = true;
 288
 289 #if !defined(OS_ANDROID)
 290   first_web_contents_profiler_ =
 291       FirstWebContentsProfiler::CreateProfilerForFirstWebContents(this).Pass();
 292 #endif  // !defined(OS_ANDROID)
 293 }
 294
 295 void ChromeBrowserMainExtraPartsMetrics::OnDisplayAdded(
 296     const gfx::Display& new_display) {
 297   EmitDisplaysChangedMetric();
 298 }
 299
 300 void ChromeBrowserMainExtraPartsMetrics::OnDisplayRemoved(
 301     const gfx::Display& old_display) {
 302   EmitDisplaysChangedMetric();
 303 }
 304
 305 void ChromeBrowserMainExtraPartsMetrics::OnDisplayMetricsChanged(
 306     const gfx::Display& display,
 307     uint32_t changed_metrics) {
 308 }
 309
 310 void ChromeBrowserMainExtraPartsMetrics::ProfilerFinishedCollectingMetrics() {
 311   first_web_contents_profiler_.reset();
 312 }
 313
 314 void ChromeBrowserMainExtraPartsMetrics::EmitDisplaysChangedMetric() {
 315   int display_count = gfx::Screen::GetNativeScreen()->GetNumDisplays();
 316   if (display_count != display_count_) {
 317     display_count_ = display_count;
 318     UMA_HISTOGRAM_COUNTS_100("Hardware.Display.Count.OnChange", display_count_);
 319   }
 320 }
 321
 322 namespace chrome {
 323
 324 void AddMetricsExtraParts(ChromeBrowserMainParts* main_parts) {
 325   main_parts->AddParts(new ChromeBrowserMainExtraPartsMetrics());
 326 }
 327
 328 }  // namespace chrome