Move initial metrics gathering tasks 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 163 matching lines @@
 #include "base/metrics/statistics_recorder.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/tracked_objects.h"
 #include "base/values.h"
-#include "chrome/browser/metrics/chrome_stability_metrics_provider.h"
-#include "chrome/browser/metrics/gpu_metrics_provider.h"
-#include "chrome/browser/metrics/network_metrics_provider.h"
-#include "chrome/browser/metrics/omnibox_metrics_provider.h"
-#include "chrome/browser/metrics/profiler_metrics_provider.h"
-#include "chrome/browser/metrics/tracking_synchronizer.h"
 #include "chrome/common/pref_names.h"
 #include "components/metrics/metrics_log.h"
 #include "components/metrics/metrics_log_manager.h"
 #include "components/metrics/metrics_log_uploader.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_reporting_scheduler.h"
 #include "components/metrics/metrics_service_client.h"
 #include "components/metrics/metrics_state_manager.h"
 #include "components/variations/entropy_provider.h"
 #include "content/public/browser/browser_thread.h"
 
-#if defined(ENABLE_PLUGINS)
-// TODO(asvitkine): Move this out of MetricsService.
-#include "chrome/browser/metrics/plugin_metrics_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 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();
@@ skipping 94 matching lines @@
   registry->RegisterIntegerPref(metrics::prefs::kMetricsSessionID, -1);
 
   registry->RegisterListPref(metrics::prefs::kMetricsInitialLogs);
   registry->RegisterListPref(metrics::prefs::kMetricsOngoingLogs);
 
   registry->RegisterInt64Pref(prefs::kInstallDate, 0);
   registry->RegisterInt64Pref(prefs::kUninstallLaunchCount, 0);
   registry->RegisterInt64Pref(prefs::kUninstallMetricsUptimeSec, 0);
   registry->RegisterInt64Pref(prefs::kUninstallLastLaunchTimeSec, 0);
   registry->RegisterInt64Pref(prefs::kUninstallLastObservedRunTimeSec, 0);
-
-  // TODO(asvitkine): Move this out of here.
-  ChromeStabilityMetricsProvider::RegisterPrefs(registry);
-
-#if defined(OS_ANDROID)
-  // TODO(asvitkine): Move this out of here.
-  AndroidMetricsProvider::RegisterPrefs(registry);
-#endif  // defined(OS_ANDROID)
-
-#if defined(ENABLE_PLUGINS)
-  // TODO(asvitkine): Move this out of here.
-  PluginMetricsProvider::RegisterPrefs(registry);
-#endif
 }
 
 MetricsService::MetricsService(metrics::MetricsStateManager* state_manager,
                                metrics::MetricsServiceClient* client,
                                PrefService* local_state)
     : log_manager_(local_state, kUploadLogAvoidRetransmitSize),
       histogram_snapshot_manager_(this),
       state_manager_(state_manager),
       client_(client),
       local_state_(local_state),
       recording_active_(false),
       reporting_active_(false),
       test_mode_active_(false),
       state_(INITIALIZED),
       has_initial_stability_log_(false),
       log_upload_in_progress_(false),
       idle_since_last_transmission_(false),
       session_id_(-1),
       self_ptr_factory_(this),
       state_saver_factory_(this) {
   DCHECK(IsSingleThreaded());
   DCHECK(state_manager_);
   DCHECK(client_);
   DCHECK(local_state_);
-
-#if defined(OS_ANDROID)
-  // TODO(asvitkine): Move this out of MetricsService.
-  RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(new AndroidMetricsProvider(
-          local_state_)));
-#endif  // defined(OS_ANDROID)
-
-  // TODO(asvitkine): Move these out of MetricsService.
-  RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(new NetworkMetricsProvider));
-  RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(new OmniboxMetricsProvider));
-  RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(new ChromeStabilityMetricsProvider));
-  RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(new GPUMetricsProvider()));
-  profiler_metrics_provider_ = new ProfilerMetricsProvider;
-  RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(profiler_metrics_provider_));
-
-#if defined(OS_WIN)
-  google_update_metrics_provider_ = new GoogleUpdateMetricsProviderWin;
-  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
-
 }
 
 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();
 }
 
-void MetricsService::OnInitTaskGotHardwareClass() {
-  DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
-
-  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
-}
-
-void MetricsService::OnInitTaskGotPluginInfo() {
-  DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
-
-  const base::Closure got_metrics_callback =
-      base::Bind(&MetricsService::OnInitTaskGotGoogleUpdateData,
-                 self_ptr_factory_.GetWeakPtr());
-
-#if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
-  google_update_metrics_provider_->GetGoogleUpdateData(got_metrics_callback);
-#else
-  got_metrics_callback.Run();
-#endif
-}
-
-void MetricsService::OnInitTaskGotGoogleUpdateData() {
-  DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
-
-  // Start the next part of the init task: fetching performance data.  This will
-  // call into |FinishedReceivingProfilerData()| when the task completes.
-  chrome_browser_metrics::TrackingSynchronizer::FetchProfilerDataAsynchronously(
-      self_ptr_factory_.GetWeakPtr());
-}
-
 void MetricsService::OnUserAction(const std::string& action) {
   if (!ShouldLogEvents())
     return;
 
   log_manager_.current_log()->RecordUserAction(action);
   HandleIdleSinceLastTransmission(false);
 }
 
-void MetricsService::ReceivedProfilerData(
-    const tracked_objects::ProcessDataSnapshot& process_data,
-    int process_type) {
-  DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
-
-  profiler_metrics_provider_->RecordProfilerData(process_data, process_type);
-}
-
-void MetricsService::FinishedReceivingProfilerData() {
+void MetricsService::FinishedGatheringInitialMetrics() {
   DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
   state_ = INIT_TASK_DONE;
 
   // Create the initial log.
   if (!initial_metrics_log_.get()) {
     initial_metrics_log_ = CreateLog(MetricsLog::ONGOING_LOG);
     NotifyOnDidCreateMetricsLog();
   }
 
   scheduler_->InitTaskComplete();
@@ skipping 74 matching lines @@
     content::BrowserThread::PostDelayedTask(
         content::BrowserThread::UI,
         FROM_HERE,
         base::Bind(&MetricsService::StartGatheringMetrics,
                    self_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromSeconds(kInitializationDelaySeconds));
   }
 }
 
 void MetricsService::StartGatheringMetrics() {
-  // TODO(blundell): Move all initial metrics gathering to
-  // ChromeMetricsServiceClient.
   client_->StartGatheringMetrics(
-      base::Bind(&MetricsService::OnInitTaskGotHardwareClass,
+      base::Bind(&MetricsService::FinishedGatheringInitialMetrics,
                  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) {
@@ skipping 449 matching lines @@
 
   // Redundant setting to assure that we always reset this value at shutdown
   // (and that we don't use some alternate path, and not call LogCleanShutdown).
   clean_shutdown_status_ = CLEANLY_SHUTDOWN;
 
   RecordBooleanPrefValue(prefs::kStabilityExitedCleanly, true);
   local_state_->SetInteger(prefs::kStabilityExecutionPhase,
                            MetricsService::SHUTDOWN_COMPLETE);
 }
 
-void MetricsService::LogPluginLoadingError(const base::FilePath& plugin_path) {
-#if defined(ENABLE_PLUGINS)
-  plugin_metrics_provider_->LogPluginLoadingError(plugin_path);
-#endif
-}
-
 bool MetricsService::ShouldLogEvents() {
   // We simply don't log events to UMA if there is a single incognito
   // session visible. The problem is that we always notify using the orginal
   // profile in order to simplify notification processing.
   return !client_->IsOffTheRecordSessionActive();
 }
 
 void MetricsService::RecordBooleanPrefValue(const char* path, bool value) {
   DCHECK(IsSingleThreaded());
   local_state_->SetBoolean(path, value);
   RecordCurrentState(local_state_);
 }
 
 void MetricsService::RecordCurrentState(PrefService* pref) {
   pref->SetInt64(prefs::kStabilityLastTimestampSec, Time::Now().ToTimeT());
 
   for (size_t i = 0; i < metrics_providers_.size(); ++i)
     metrics_providers_[i]->RecordCurrentState();
 }