1// Copyright 2014 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/chromeos_metrics_provider.h"
6
7#include "base/prefs/pref_registry_simple.h"
8#include "base/prefs/pref_service.h"
9#include "base/strings/string_number_conversions.h"
10#include "base/strings/string_util.h"
11#include "base/strings/utf_string_conversions.h"
12#include "chrome/browser/browser_process.h"
13#include "chrome/common/pref_names.h"
14#include "chromeos/system/statistics_provider.h"
15#include "components/metrics/metrics_service.h"
16#include "components/metrics/proto/chrome_user_metrics_extension.pb.h"
17#include "components/user_manager/user_manager.h"
18#include "content/public/browser/browser_thread.h"
19#include "device/bluetooth/bluetooth_adapter.h"
20#include "device/bluetooth/bluetooth_adapter_factory.h"
21#include "device/bluetooth/bluetooth_device.h"
22#include "ui/events/event_utils.h"
23#include "ui/gfx/screen.h"
24
25#if defined(USE_X11)
26#include "ui/events/x/touch_factory_x11.h"
27#endif  // defined(USE_X11)
28
29using metrics::ChromeUserMetricsExtension;
30using metrics::SampledProfile;
31using metrics::SystemProfileProto;
32typedef SystemProfileProto::Hardware::Bluetooth::PairedDevice PairedDevice;
33
34namespace {
35
36PairedDevice::Type AsBluetoothDeviceType(
37    device::BluetoothDevice::DeviceType device_type) {
38  switch (device_type) {
39    case device::BluetoothDevice::DEVICE_UNKNOWN:
40      return PairedDevice::DEVICE_UNKNOWN;
41    case device::BluetoothDevice::DEVICE_COMPUTER:
42      return PairedDevice::DEVICE_COMPUTER;
43    case device::BluetoothDevice::DEVICE_PHONE:
44      return PairedDevice::DEVICE_PHONE;
45    case device::BluetoothDevice::DEVICE_MODEM:
46      return PairedDevice::DEVICE_MODEM;
47    case device::BluetoothDevice::DEVICE_AUDIO:
48      return PairedDevice::DEVICE_AUDIO;
49    case device::BluetoothDevice::DEVICE_CAR_AUDIO:
50      return PairedDevice::DEVICE_CAR_AUDIO;
51    case device::BluetoothDevice::DEVICE_VIDEO:
52      return PairedDevice::DEVICE_VIDEO;
53    case device::BluetoothDevice::DEVICE_PERIPHERAL:
54      return PairedDevice::DEVICE_PERIPHERAL;
55    case device::BluetoothDevice::DEVICE_JOYSTICK:
56      return PairedDevice::DEVICE_JOYSTICK;
57    case device::BluetoothDevice::DEVICE_GAMEPAD:
58      return PairedDevice::DEVICE_GAMEPAD;
59    case device::BluetoothDevice::DEVICE_KEYBOARD:
60      return PairedDevice::DEVICE_KEYBOARD;
61    case device::BluetoothDevice::DEVICE_MOUSE:
62      return PairedDevice::DEVICE_MOUSE;
63    case device::BluetoothDevice::DEVICE_TABLET:
64      return PairedDevice::DEVICE_TABLET;
65    case device::BluetoothDevice::DEVICE_KEYBOARD_MOUSE_COMBO:
66      return PairedDevice::DEVICE_KEYBOARD_MOUSE_COMBO;
67  }
68
69  NOTREACHED();
70  return PairedDevice::DEVICE_UNKNOWN;
71}
72
73void WriteExternalTouchscreensProto(SystemProfileProto::Hardware* hardware) {
74#if defined(USE_X11)
75  std::set<std::pair<int, int> > touchscreen_ids =
76      ui::TouchFactory::GetInstance()->GetTouchscreenIds();
77  for (std::set<std::pair<int, int> >::iterator it = touchscreen_ids.begin();
78       it != touchscreen_ids.end();
79       ++it) {
80    SystemProfileProto::Hardware::TouchScreen* touchscreen =
81        hardware->add_external_touchscreen();
82    touchscreen->set_vendor_id(it->first);
83    touchscreen->set_product_id(it->second);
84  }
85#endif  // defined(USE_X11)
86}
87
88void IncrementPrefValue(const char* path) {
89  PrefService* pref = g_browser_process->local_state();
90  DCHECK(pref);
91  int value = pref->GetInteger(path);
92  pref->SetInteger(path, value + 1);
93}
94
95}  // namespace
96
97ChromeOSMetricsProvider::ChromeOSMetricsProvider()
98    : registered_user_count_at_log_initialization_(false),
99      user_count_at_log_initialization_(0),
100      weak_ptr_factory_(this) {
101}
102
103ChromeOSMetricsProvider::~ChromeOSMetricsProvider() {
104}
105
106// static
107void ChromeOSMetricsProvider::RegisterPrefs(PrefRegistrySimple* registry) {
108  registry->RegisterIntegerPref(prefs::kStabilityOtherUserCrashCount, 0);
109  registry->RegisterIntegerPref(prefs::kStabilityKernelCrashCount, 0);
110  registry->RegisterIntegerPref(prefs::kStabilitySystemUncleanShutdownCount, 0);
111}
112
113// static
114void ChromeOSMetricsProvider::LogCrash(const std::string& crash_type) {
115  if (crash_type == "user")
116    IncrementPrefValue(prefs::kStabilityOtherUserCrashCount);
117  else if (crash_type == "kernel")
118    IncrementPrefValue(prefs::kStabilityKernelCrashCount);
119  else if (crash_type == "uncleanshutdown")
120    IncrementPrefValue(prefs::kStabilitySystemUncleanShutdownCount);
121  else
122    NOTREACHED() << "Unexpected Chrome OS crash type " << crash_type;
123
124  // Wake up metrics logs sending if necessary now that new
125  // log data is available.
126  g_browser_process->metrics_service()->OnApplicationNotIdle();
127}
128
129void ChromeOSMetricsProvider::OnDidCreateMetricsLog() {
130  registered_user_count_at_log_initialization_ = false;
131  if (user_manager::UserManager::IsInitialized()) {
132    registered_user_count_at_log_initialization_ = true;
133    user_count_at_log_initialization_ =
134        user_manager::UserManager::Get()->GetLoggedInUsers().size();
135  }
136}
137
138void ChromeOSMetricsProvider::InitTaskGetHardwareClass(
139    const base::Closure& callback) {
140  // Run the (potentially expensive) task on the FILE thread to avoid blocking
141  // the UI thread.
142  content::BrowserThread::PostTaskAndReply(
143      content::BrowserThread::FILE,
144      FROM_HERE,
145      base::Bind(&ChromeOSMetricsProvider::InitTaskGetHardwareClassOnFileThread,
146                 weak_ptr_factory_.GetWeakPtr()),
147      callback);
148}
149
150void ChromeOSMetricsProvider::InitTaskGetHardwareClassOnFileThread() {
151  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
152  chromeos::system::StatisticsProvider::GetInstance()->GetMachineStatistic(
153      "hardware_class", &hardware_class_);
154}
155
156void ChromeOSMetricsProvider::ProvideSystemProfileMetrics(
157    metrics::SystemProfileProto* system_profile_proto) {
158  WriteBluetoothProto(system_profile_proto);
159  UpdateMultiProfileUserCount(system_profile_proto);
160
161  metrics::SystemProfileProto::Hardware* hardware =
162      system_profile_proto->mutable_hardware();
163  hardware->set_hardware_class(hardware_class_);
164  gfx::Display::TouchSupport has_touch = ui::GetInternalDisplayTouchSupport();
165  if (has_touch == gfx::Display::TOUCH_SUPPORT_AVAILABLE)
166    hardware->set_internal_display_supports_touch(true);
167  else if (has_touch == gfx::Display::TOUCH_SUPPORT_UNAVAILABLE)
168    hardware->set_internal_display_supports_touch(false);
169  WriteExternalTouchscreensProto(hardware);
170}
171
172void ChromeOSMetricsProvider::ProvideStabilityMetrics(
173    metrics::SystemProfileProto* system_profile_proto) {
174  metrics::SystemProfileProto::Stability* stability_proto =
175      system_profile_proto->mutable_stability();
176  PrefService* pref = g_browser_process->local_state();
177  int count = pref->GetInteger(prefs::kStabilityOtherUserCrashCount);
178  if (count) {
179    stability_proto->set_other_user_crash_count(count);
180    pref->SetInteger(prefs::kStabilityOtherUserCrashCount, 0);
181  }
182
183  count = pref->GetInteger(prefs::kStabilityKernelCrashCount);
184  if (count) {
185    stability_proto->set_kernel_crash_count(count);
186    pref->SetInteger(prefs::kStabilityKernelCrashCount, 0);
187  }
188
189  count = pref->GetInteger(prefs::kStabilitySystemUncleanShutdownCount);
190  if (count) {
191    stability_proto->set_unclean_system_shutdown_count(count);
192    pref->SetInteger(prefs::kStabilitySystemUncleanShutdownCount, 0);
193  }
194}
195
196void ChromeOSMetricsProvider::ProvideGeneralMetrics(
197    metrics::ChromeUserMetricsExtension* uma_proto) {
198  std::vector<SampledProfile> sampled_profiles;
199  if (perf_provider_.GetSampledProfiles(&sampled_profiles)) {
200    for (std::vector<SampledProfile>::iterator iter = sampled_profiles.begin();
201         iter != sampled_profiles.end();
202         ++iter) {
203      uma_proto->add_sampled_profile()->Swap(&(*iter));
204    }
205  }
206}
207
208void ChromeOSMetricsProvider::WriteBluetoothProto(
209    metrics::SystemProfileProto* system_profile_proto) {
210  metrics::SystemProfileProto::Hardware* hardware =
211      system_profile_proto->mutable_hardware();
212
213  // BluetoothAdapterFactory::GetAdapter is synchronous on Chrome OS; if that
214  // changes this will fail at the DCHECK().
215  device::BluetoothAdapterFactory::GetAdapter(base::Bind(
216      &ChromeOSMetricsProvider::SetBluetoothAdapter, base::Unretained(this)));
217  DCHECK(adapter_.get());
218
219  SystemProfileProto::Hardware::Bluetooth* bluetooth =
220      hardware->mutable_bluetooth();
221
222  bluetooth->set_is_present(adapter_->IsPresent());
223  bluetooth->set_is_enabled(adapter_->IsPowered());
224
225  device::BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
226  for (device::BluetoothAdapter::DeviceList::iterator iter = devices.begin();
227       iter != devices.end();
228       ++iter) {
229    device::BluetoothDevice* device = *iter;
230    // Don't collect information about LE devices yet.
231    if (!device->IsPaired())
232      continue;
233
234    PairedDevice* paired_device = bluetooth->add_paired_device();
235    paired_device->set_bluetooth_class(device->GetBluetoothClass());
236    paired_device->set_type(AsBluetoothDeviceType(device->GetDeviceType()));
237
238    // |address| is xx:xx:xx:xx:xx:xx, extract the first three components and
239    // pack into a uint32.
240    std::string address = device->GetAddress();
241    if (address.size() > 9 && address[2] == ':' && address[5] == ':' &&
242        address[8] == ':') {
243      std::string vendor_prefix_str;
244      uint64 vendor_prefix;
245
246      base::RemoveChars(address.substr(0, 9), ":", &vendor_prefix_str);
247      DCHECK_EQ(6U, vendor_prefix_str.size());
248      base::HexStringToUInt64(vendor_prefix_str, &vendor_prefix);
249
250      paired_device->set_vendor_prefix(vendor_prefix);
251    }
252
253    switch (device->GetVendorIDSource()) {
254      case device::BluetoothDevice::VENDOR_ID_BLUETOOTH:
255        paired_device->set_vendor_id_source(PairedDevice::VENDOR_ID_BLUETOOTH);
256        break;
257      case device::BluetoothDevice::VENDOR_ID_USB:
258        paired_device->set_vendor_id_source(PairedDevice::VENDOR_ID_USB);
259        break;
260      default:
261        paired_device->set_vendor_id_source(PairedDevice::VENDOR_ID_UNKNOWN);
262    }
263
264    paired_device->set_vendor_id(device->GetVendorID());
265    paired_device->set_product_id(device->GetProductID());
266    paired_device->set_device_id(device->GetDeviceID());
267  }
268}
269
270void ChromeOSMetricsProvider::UpdateMultiProfileUserCount(
271    metrics::SystemProfileProto* system_profile_proto) {
272  if (user_manager::UserManager::IsInitialized()) {
273    size_t user_count =
274        user_manager::UserManager::Get()->GetLoggedInUsers().size();
275
276    // We invalidate the user count if it changed while the log was open.
277    if (registered_user_count_at_log_initialization_ &&
278        user_count != user_count_at_log_initialization_) {
279      user_count = 0;
280    }
281
282    system_profile_proto->set_multi_profile_user_count(user_count);
283  }
284}
285
286void ChromeOSMetricsProvider::SetBluetoothAdapter(
287    scoped_refptr<device::BluetoothAdapter> adapter) {
288  adapter_ = adapter;
289}
290