Move ChromeOS hardware class init out of MetricsService.

chrome/browser/metrics/chromeos_metrics_provider.cc

 // Copyright 2014 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/chromeos_metrics_provider.h"
 
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/common/pref_names.h"
+#include "chromeos/system/statistics_provider.h"
 #include "components/metrics/proto/chrome_user_metrics_extension.pb.h"
+#include "content/public/browser/browser_thread.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/screen.h"
 
 #if defined(USE_X11)
 #include "ui/events/x/touch_factory_x11.h"
 #endif  // defined(USE_X11)
 
@@ skipping 60 matching lines @@
   PrefService* pref = g_browser_process->local_state();
   DCHECK(pref);
   int value = pref->GetInteger(path);
   pref->SetInteger(path, value + 1);
 }
 
 }  // namespace
 
 ChromeOSMetricsProvider::ChromeOSMetricsProvider()
     : registered_user_count_at_log_initialization_(false),
-      user_count_at_log_initialization_(0) {
+      user_count_at_log_initialization_(0),
+      weak_ptr_factory_(this) {
 }
 
 ChromeOSMetricsProvider::~ChromeOSMetricsProvider() {
 }
 
 // static
 void ChromeOSMetricsProvider::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterIntegerPref(prefs::kStabilityOtherUserCrashCount, 0);
   registry->RegisterIntegerPref(prefs::kStabilityKernelCrashCount, 0);
   registry->RegisterIntegerPref(prefs::kStabilitySystemUncleanShutdownCount, 0);
@@ skipping 17 matching lines @@
 
 void ChromeOSMetricsProvider::OnDidCreateMetricsLog() {
   registered_user_count_at_log_initialization_ = false;
   if (chromeos::UserManager::IsInitialized()) {
     registered_user_count_at_log_initialization_ = true;
     user_count_at_log_initialization_ =
         chromeos::UserManager::Get()->GetLoggedInUsers().size();
   }
 }
 
+void ChromeOSMetricsProvider::InitTaskGetHardwareClass(
+    const base::Closure& callback) {
+  // Run the (potentially expensive) task on the FILE thread to avoid blocking
+  // the UI thread.
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&ChromeOSMetricsProvider::InitTaskGetHardwareClassOnFileThread,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::MessageLoop::current()->message_loop_proxy(),
+                 callback));

[Alexei Svitkine (slow), 2014/05/28 15:50:10]

Can you avoid passing the two params by using PostTaskAndReply() here instead of
PostTask()?

[blundell, 2014/05/28 18:39:35]

Done.

+}
+
+void ChromeOSMetricsProvider::InitTaskGetHardwareClassOnFileThread(
+    base::MessageLoopProxy* target_loop,
+    const base::Closure& callback) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+
+  chromeos::system::StatisticsProvider::GetInstance()->GetMachineStatistic(
+      "hardware_class", &hardware_class_);
+
+  target_loop->PostTask(FROM_HERE, callback);
+}
+
 void ChromeOSMetricsProvider::ProvideSystemProfileMetrics(
     metrics::SystemProfileProto* system_profile_proto) {
   std::vector<PerfDataProto> perf_data;
   if (perf_provider_.GetPerfData(&perf_data)) {
     for (std::vector<PerfDataProto>::iterator iter = perf_data.begin();
          iter != perf_data.end();
          ++iter) {
       uma_proto_->add_perf_data()->Swap(&(*iter));
     }
   }
 
   WriteBluetoothProto(system_profile_proto);
   UpdateMultiProfileUserCount(system_profile_proto);
 
   metrics::SystemProfileProto::Hardware* hardware =
       system_profile_proto->mutable_hardware();
+  hardware->set_hardware_class(hardware_class_);
   gfx::Display::TouchSupport has_touch = ui::GetInternalDisplayTouchSupport();
   if (has_touch == gfx::Display::TOUCH_SUPPORT_AVAILABLE)
     hardware->set_internal_display_supports_touch(true);
   else if (has_touch == gfx::Display::TOUCH_SUPPORT_UNAVAILABLE)
     hardware->set_internal_display_supports_touch(false);
   WriteExternalTouchscreensProto(hardware);
 }
 
 void ChromeOSMetricsProvider::ProvideStabilityMetrics(
     metrics::SystemProfileProto* system_profile_proto) {
@@ skipping 93 matching lines @@
     }
 
     system_profile_proto->set_multi_profile_user_count(user_count);
   }
 }
 
 void ChromeOSMetricsProvider::SetBluetoothAdapter(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   adapter_ = adapter;
 }