Move ChromeOS hardware class init out of MetricsService.

chrome/browser/metrics/metrics_service.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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It is
@@ skipping 190 matching lines @@
 #include "components/metrics/metrics_service_client.h"
 #include "components/variations/entropy_provider.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 
 #if defined(ENABLE_PLUGINS)
 // TODO(asvitkine): Move this out of MetricsService.
 #include "chrome/browser/metrics/plugin_metrics_provider.h"
 #endif
 
-#if defined(OS_CHROMEOS)
-#include "chrome/browser/chromeos/settings/cros_settings.h"
-#include "chrome/browser/metrics/chromeos_metrics_provider.h"
-#include "chromeos/system/statistics_provider.h"
-#endif
-
 #if defined(OS_WIN)
 #include "chrome/browser/metrics/google_update_metrics_provider_win.h"
 #endif
 
 #if defined(OS_ANDROID)
 // TODO(asvitkine): Move this out of MetricsService.
 #include "chrome/browser/metrics/android_metrics_provider.h"
 #endif
 
 using base::Time;
-using content::BrowserThread;
 using metrics::MetricsLogManager;
 
 namespace {
 
 // Check to see that we're being called on only one thread.
 bool IsSingleThreaded() {
   static base::PlatformThreadId thread_id = 0;
   if (!thread_id)
     thread_id = base::PlatformThread::CurrentId();
   return base::PlatformThread::CurrentId() == thread_id;
@@ skipping 173 matching lines @@
   RegisterMetricsProvider(scoped_ptr<metrics::MetricsProvider>(
       google_update_metrics_provider_));
 #endif
 
 #if defined(ENABLE_PLUGINS)
   plugin_metrics_provider_ = new PluginMetricsProvider(local_state_);
   RegisterMetricsProvider(scoped_ptr<metrics::MetricsProvider>(
       plugin_metrics_provider_));
 #endif
 
-#if defined(OS_CHROMEOS)
-  RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(new ChromeOSMetricsProvider));
-#endif
 }
 
 MetricsService::~MetricsService() {
   DisableRecording();
 }
 
 void MetricsService::InitializeMetricsRecordingState() {
   InitializeMetricsState();
 
   base::Closure callback = base::Bind(&MetricsService::StartScheduledUpload,
@@ skipping 257 matching lines @@
   local_state_->SetInt64(prefs::kStabilityLaunchTimeSec, Time::Now().ToTimeT());
 
   // Bookkeeping for the uninstall metrics.
   IncrementLongPrefsValue(prefs::kUninstallLaunchCount);
 
   // Kick off the process of saving the state (so the uptime numbers keep
   // getting updated) every n minutes.
   ScheduleNextStateSave();
 }
 
-// static
-void MetricsService::InitTaskGetHardwareClass(
-    base::WeakPtr<MetricsService> self,
-    base::MessageLoopProxy* target_loop) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-
-  std::string hardware_class;
-#if defined(OS_CHROMEOS)
-  chromeos::system::StatisticsProvider::GetInstance()->GetMachineStatistic(
-      "hardware_class", &hardware_class);
-#endif  // OS_CHROMEOS
-
-  target_loop->PostTask(FROM_HERE,
-      base::Bind(&MetricsService::OnInitTaskGotHardwareClass,
-          self, hardware_class));
-}
-
-void MetricsService::OnInitTaskGotHardwareClass(
-    const std::string& hardware_class) {
+void MetricsService::OnInitTaskGotHardwareClass() {
   DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
-  hardware_class_ = hardware_class;
 
   const base::Closure got_plugin_info_callback =
       base::Bind(&MetricsService::OnInitTaskGotPluginInfo,
                  self_ptr_factory_.GetWeakPtr());
 
 #if defined(ENABLE_PLUGINS)
   plugin_metrics_provider_->GetPluginInformation(got_plugin_info_callback);
 #else
   got_plugin_info_callback.Run();
 #endif
@@ skipping 117 matching lines @@
 void MetricsService::OpenNewLog() {
   DCHECK(!log_manager_.current_log());
 
   log_manager_.BeginLoggingWithLog(
       CreateLog(MetricsLog::ONGOING_LOG).PassAs<metrics::MetricsLogBase>());
   NotifyOnDidCreateMetricsLog();
   if (state_ == INITIALIZED) {
     // We only need to schedule that run once.
     state_ = INIT_TASK_SCHEDULED;
 
-    // TODO(blundell): Change the callback to be
-    // FinishedReceivingProfilerData() when the initial metrics gathering is
-    // moved to ChromeMetricsServiceClient.
-    client_->StartGatheringMetrics(base::Bind(&base::DoNothing));
-
-    // Schedules a task on the file thread for execution of slower
-    // initialization steps (such as plugin list generation) necessary
-    // for sending the initial log.  This avoids blocking the main UI
-    // thread.
-    BrowserThread::PostDelayedTask(
-        BrowserThread::FILE,
-        FROM_HERE,
-        base::Bind(&MetricsService::InitTaskGetHardwareClass,
-            self_ptr_factory_.GetWeakPtr(),
-            base::MessageLoop::current()->message_loop_proxy()),
-        base::TimeDelta::FromSeconds(kInitializationDelaySeconds));
+    // TODO(blundell): Move all initial metrics gathering to
+    // ChromeMetricsServiceClient.
+    client_->StartGatheringMetrics(
+        base::Bind(&MetricsService::OnInitTaskGotHardwareClass,
+                   self_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void MetricsService::CloseCurrentLog() {
   if (!log_manager_.current_log())
     return;
 
   // TODO(jar): Integrate bounds on log recording more consistently, so that we
   // can stop recording logs that are too big much sooner.
   if (log_manager_.current_log()->num_events() > kEventLimit) {
     UMA_HISTOGRAM_COUNTS("UMA.Discarded Log Events",
                          log_manager_.current_log()->num_events());
     log_manager_.DiscardCurrentLog();
     OpenNewLog();  // Start trivial log to hold our histograms.
   }
 
-  // Adds to ongoing logs.
-  log_manager_.current_log()->set_hardware_class(hardware_class_);

[blundell, 2014/05/27 13:14:19]

Two questions here:

(1) The timing of these calls have changed (it is now made inside the
RecordEnvironment() calls). Is this a problem?

(2) The hardware class is no longer being set to the empty string on platforms
other than ChromeOS. Is that a problem?

[Alexei Svitkine (slow), 2014/05/27 13:56:37]

I don't think so.
Let's keep the behaviour the same here and set it to the empty string first in
cross-platform code and let the ChromeOS-specific code set it to the real value.

[blundell, 2014/05/27 14:58:10]

Done.

-
   // Put incremental data (histogram deltas, and realtime stats deltas) at the
   // end of all log transmissions (initial log handles this separately).
   // RecordIncrementalStabilityElements only exists on the derived
   // MetricsLog class.
   MetricsLog* current_log =
       static_cast<MetricsLog*>(log_manager_.current_log());
   DCHECK(current_log);
   std::vector<variations::ActiveGroupId> synthetic_trials;
   GetCurrentSyntheticFieldTrials(&synthetic_trials);
   current_log->RecordEnvironment(metrics_providers_.get(), synthetic_trials);
@@ skipping 201 matching lines @@
 
   // Store unsent logs, including the stability log that was just saved, so
   // that they're not lost in case of a crash before upload time.
   log_manager_.PersistUnsentLogs();
 
   has_initial_stability_log_ = true;
 }
 
 void MetricsService::PrepareInitialMetricsLog() {
   DCHECK(state_ == INIT_TASK_DONE || state_ == SENDING_INITIAL_STABILITY_LOG);
-  initial_metrics_log_->set_hardware_class(hardware_class_);
 
   std::vector<variations::ActiveGroupId> synthetic_trials;
   GetCurrentSyntheticFieldTrials(&synthetic_trials);
   initial_metrics_log_->RecordEnvironment(metrics_providers_.get(),
                                           synthetic_trials);
   base::TimeDelta incremental_uptime;
   base::TimeDelta uptime;
   GetUptimes(local_state_, &incremental_uptime, &uptime);
 
   // Histograms only get written to the current log, so make the new log current
@@ skipping 284 matching lines @@
   RecordCurrentState(local_state_);
 }
 
 void MetricsService::RecordCurrentState(PrefService* pref) {
   pref->SetInt64(prefs::kStabilityLastTimestampSec, Time::Now().ToTimeT());
 
 #if defined(ENABLE_PLUGINS)
   plugin_metrics_provider_->RecordPluginChanges();
 #endif
 }