Factor ChromeOS specific code out of MetricsLog.

chrome/browser/metrics/metrics_log.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/metrics/metrics_log.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 28 matching lines @@
 #include "chrome/common/metrics/proto/omnibox_event.pb.h"
 #include "chrome/common/metrics/proto/profiler_event.pb.h"
 #include "chrome/common/metrics/proto/system_profile.pb.h"
 #include "chrome/common/metrics/variations/variations_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "components/nacl/common/nacl_process_type.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/webplugininfo.h"
-#include "device/bluetooth/bluetooth_adapter.h"
-#include "device/bluetooth/bluetooth_adapter_factory.h"
-#include "device/bluetooth/bluetooth_device.h"
 #include "gpu/config/gpu_info.h"
 #include "ui/gfx/screen.h"
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/metro.h"
 
 // http://blogs.msdn.com/oldnewthing/archive/2004/10/25/247180.aspx
 extern "C" IMAGE_DOS_HEADER __ImageBase;
 #endif
 
-#if defined(OS_CHROMEOS)
-#include "chrome/browser/chromeos/login/user_manager.h"
-#endif
-
 using content::GpuDataManager;
 using metrics::OmniboxEventProto;
-using metrics::PerfDataProto;
 using metrics::ProfilerEventProto;
 using metrics::SystemProfileProto;
 using tracked_objects::ProcessDataSnapshot;
 typedef chrome_variations::ActiveGroupId ActiveGroupId;
 typedef SystemProfileProto::GoogleUpdate::ProductInfo ProductInfo;
-typedef SystemProfileProto::Hardware::Bluetooth::PairedDevice PairedDevice;
 
 namespace {
 
 // Returns the date at which the current metrics client ID was created as
 // a string containing seconds since the epoch, or "0" if none was found.
 std::string GetMetricsEnabledDate(PrefService* pref) {
   if (!pref) {
     NOTREACHED();
     return "0";
   }
@@ skipping 246 matching lines @@
             reinterpret_cast<LPARAM>(&si))) {
       hardware->set_max_dpi_x(si.max_dpi_x);
       hardware->set_max_dpi_y(si.max_dpi_y);
     }
     ReleaseDC(GetDesktopWindow(), desktop_dc);
   }
 }
 
 #endif  // defined(OS_WIN)
 
-#if defined(OS_CHROMEOS)
-PairedDevice::Type AsBluetoothDeviceType(
-    enum device::BluetoothDevice::DeviceType device_type) {
-  switch (device_type) {
-    case device::BluetoothDevice::DEVICE_UNKNOWN:
-      return PairedDevice::DEVICE_UNKNOWN;
-    case device::BluetoothDevice::DEVICE_COMPUTER:
-      return PairedDevice::DEVICE_COMPUTER;
-    case device::BluetoothDevice::DEVICE_PHONE:
-      return PairedDevice::DEVICE_PHONE;
-    case device::BluetoothDevice::DEVICE_MODEM:
-      return PairedDevice::DEVICE_MODEM;
-    case device::BluetoothDevice::DEVICE_AUDIO:
-      return PairedDevice::DEVICE_AUDIO;
-    case device::BluetoothDevice::DEVICE_CAR_AUDIO:
-      return PairedDevice::DEVICE_CAR_AUDIO;
-    case device::BluetoothDevice::DEVICE_VIDEO:
-      return PairedDevice::DEVICE_VIDEO;
-    case device::BluetoothDevice::DEVICE_PERIPHERAL:
-      return PairedDevice::DEVICE_PERIPHERAL;
-    case device::BluetoothDevice::DEVICE_JOYSTICK:
-      return PairedDevice::DEVICE_JOYSTICK;
-    case device::BluetoothDevice::DEVICE_GAMEPAD:
-      return PairedDevice::DEVICE_GAMEPAD;
-    case device::BluetoothDevice::DEVICE_KEYBOARD:
-      return PairedDevice::DEVICE_KEYBOARD;
-    case device::BluetoothDevice::DEVICE_MOUSE:
-      return PairedDevice::DEVICE_MOUSE;
-    case device::BluetoothDevice::DEVICE_TABLET:
-      return PairedDevice::DEVICE_TABLET;
-    case device::BluetoothDevice::DEVICE_KEYBOARD_MOUSE_COMBO:
-      return PairedDevice::DEVICE_KEYBOARD_MOUSE_COMBO;
-  }
-
-  NOTREACHED();
-  return PairedDevice::DEVICE_UNKNOWN;
-}
-#endif  // defined(OS_CHROMEOS)
-
 // Round a timestamp measured in seconds since epoch to one with a granularity
 // of an hour. This can be used before uploaded potentially sensitive
 // timestamps.
 int64 RoundSecondsToHour(int64 time_in_seconds) {
   return 3600 * (time_in_seconds / 3600);
 }
 
 }  // namespace
 
 GoogleUpdateMetrics::GoogleUpdateMetrics() : is_system_install(false) {}
 
 GoogleUpdateMetrics::~GoogleUpdateMetrics() {}
 
 static base::LazyInstance<std::string>::Leaky
     g_version_extension = LAZY_INSTANCE_INITIALIZER;
 
 MetricsLog::MetricsLog(const std::string& client_id, int session_id)
     : MetricsLogBase(client_id, session_id, MetricsLog::GetVersionString()),
       creation_time_(base::TimeTicks::Now()) {
 #if defined(OS_CHROMEOS)
-  UpdateMultiProfileUserCount();
-#endif
+  metrics_log_chromeos_.reset(new MetricsLogChromeOS(uma_proto()));
+#endif  // OS_CHROMEOS
 }
 
 MetricsLog::~MetricsLog() {}
 
 // static
 void MetricsLog::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterListPref(prefs::kStabilityPluginStats);
 }
 
 // static
@@ skipping 229 matching lines @@
     pref->SetInteger(prefs::kStabilityRendererHangCount, 0);
   }
 
   count = pref->GetInteger(prefs::kStabilityChildProcessCrashCount);
   if (count) {
     stability->set_child_process_crash_count(count);
     pref->SetInteger(prefs::kStabilityChildProcessCrashCount, 0);
   }
 
 #if defined(OS_CHROMEOS)
-  count = pref->GetInteger(prefs::kStabilityOtherUserCrashCount);
-  if (count) {
-    stability->set_other_user_crash_count(count);
-    pref->SetInteger(prefs::kStabilityOtherUserCrashCount, 0);
-  }
-
-  count = pref->GetInteger(prefs::kStabilityKernelCrashCount);
-  if (count) {
-    stability->set_kernel_crash_count(count);
-    pref->SetInteger(prefs::kStabilityKernelCrashCount, 0);
-  }
-
-  count = pref->GetInteger(prefs::kStabilitySystemUncleanShutdownCount);
-  if (count) {
-    stability->set_unclean_system_shutdown_count(count);
-    pref->SetInteger(prefs::kStabilitySystemUncleanShutdownCount, 0);
-  }
+  metrics_log_chromeos_->WriteRealtimeStabilityAttributes(pref, stability);
 #endif  // OS_CHROMEOS
 
   const uint64 uptime_sec = incremental_uptime.InSeconds();
   if (uptime_sec)
     stability->set_uptime_sec(uptime_sec);
 }
 
 void MetricsLog::WritePluginList(
     const std::vector<content::WebPluginInfo>& plugin_list) {
   DCHECK(!locked());
@@ skipping 105 matching lines @@
 
   WriteGoogleUpdateProto(google_update_metrics);
 
   WritePluginList(plugin_list);
 
   std::vector<ActiveGroupId> field_trial_ids;
   GetFieldTrialIds(&field_trial_ids);
   WriteFieldTrials(field_trial_ids, system_profile);
   WriteFieldTrials(synthetic_trials, system_profile);
 
-#if defined(OS_CHROMEOS)
-  PerfDataProto perf_data_proto;
-  if (perf_provider_.GetPerfData(&perf_data_proto))
-    uma_proto()->add_perf_data()->Swap(&perf_data_proto);
-
-  WriteBluetoothProto(hardware);
-  UpdateMultiProfileUserCount();
-#endif
-
   std::string serialied_system_profile;
   std::string base64_system_profile;
   if (system_profile->SerializeToString(&serialied_system_profile)) {
     base::Base64Encode(serialied_system_profile, &base64_system_profile);
     PrefService* local_state = GetPrefService();
     local_state->SetString(prefs::kStabilitySavedSystemProfile,
                            base64_system_profile);
     local_state->SetString(prefs::kStabilitySavedSystemProfileHash,
                            ComputeSHA1(serialied_system_profile));
   }
+
+#if defined(OS_CHROMEOS)
+  metrics_log_chromeos_->LogChromeOSMetrics(uma_proto());

[Alexei Svitkine (slow), 2014/01/30 16:30:45]

Please move this to where the old code was (above). It should be above the
SerializeToString() block, so that the updated system profile is correctly
serialized.

[tdresser, 2014/01/30 18:04:25]

Done.

+#endif  // OS_CHROMEOS
 }
 
 bool MetricsLog::LoadSavedEnvironmentFromPrefs() {
   PrefService* local_state = GetPrefService();
   const std::string base64_system_profile =
       local_state->GetString(prefs::kStabilitySavedSystemProfile);
   if (base64_system_profile.empty())
     return false;
 
   const std::string system_profile_hash =
@@ skipping 108 matching lines @@
     ProductDataToProto(google_update_metrics.google_update_data,
                        google_update->mutable_google_update_status());
   }
 
   if (!google_update_metrics.product_data.version.empty()) {
     ProductDataToProto(google_update_metrics.product_data,
                        google_update->mutable_client_status());
   }
 #endif  // defined(GOOGLE_CHROME_BUILD) && defined(OS_WIN)
 }
-
-void MetricsLog::SetBluetoothAdapter(
-    scoped_refptr<device::BluetoothAdapter> adapter) {
-  adapter_ = adapter;
-}
-
-void MetricsLog::WriteBluetoothProto(
-    SystemProfileProto::Hardware* hardware) {
-#if defined(OS_CHROMEOS)
-  // BluetoothAdapterFactory::GetAdapter is synchronous on Chrome OS; if that
-  // changes this will fail at the DCHECK().
-  device::BluetoothAdapterFactory::GetAdapter(
-      base::Bind(&MetricsLog::SetBluetoothAdapter,
-                 base::Unretained(this)));
-  DCHECK(adapter_.get());
-
-  SystemProfileProto::Hardware::Bluetooth* bluetooth =
-      hardware->mutable_bluetooth();
-
-  bluetooth->set_is_present(adapter_->IsPresent());
-  bluetooth->set_is_enabled(adapter_->IsPowered());
-
-  device::BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
-  for (device::BluetoothAdapter::DeviceList::iterator iter =
-           devices.begin(); iter != devices.end(); ++iter) {
-    PairedDevice* paired_device = bluetooth->add_paired_device();
-
-    device::BluetoothDevice* device = *iter;
-    paired_device->set_bluetooth_class(device->GetBluetoothClass());
-    paired_device->set_type(AsBluetoothDeviceType(device->GetDeviceType()));
-
-    // address is xx:xx:xx:xx:xx:xx, extract the first three components and
-    // pack into a uint32
-    std::string address = device->GetAddress();
-    if (address.size() > 9 &&
-        address[2] == ':' && address[5] == ':' && address[8] == ':') {
-      std::string vendor_prefix_str;
-      uint64 vendor_prefix;
-
-      base::RemoveChars(address.substr(0, 9), ":", &vendor_prefix_str);
-      DCHECK_EQ(6U, vendor_prefix_str.size());
-      base::HexStringToUInt64(vendor_prefix_str, &vendor_prefix);
-
-      paired_device->set_vendor_prefix(vendor_prefix);
-    }
-
-    paired_device->set_vendor_id(device->GetVendorID());
-    paired_device->set_product_id(device->GetProductID());
-    paired_device->set_device_id(device->GetDeviceID());
-  }
-#endif  // defined(OS_CHROMEOS)
-}
-
-#if defined(OS_CHROMEOS)
-void MetricsLog::UpdateMultiProfileUserCount() {
-  if (chromeos::UserManager::IsInitialized() &&
-      chromeos::UserManager::Get()->IsMultipleProfilesAllowed()) {
-    uint32 user_count = chromeos::UserManager::Get()
-        ->GetLoggedInUsers().size();
-    SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
-
-    // We invalidate the user count if it changed while the log was open.
-    if (system_profile->has_multi_profile_user_count() &&
-        user_count != system_profile->multi_profile_user_count())
-      user_count = 0;
-
-    system_profile->set_multi_profile_user_count(user_count);
-  }
-}
-#endif