Move initial metrics gathering tasks out of MetricsService.

This CL moves the coordination of initial metrics gathering tasks out of
MetricsService and into ChromeMetricsServiceClient. As part of this move, it
also does the following:
- Moves registration of metrics providers from MetricsService to
  ChromeMetricsServiceClient
- Moves registration of prefs for individual metrics providers from
  MetricsService to ChromeMetricsServiceClient
- Eliminates MetricsService being a TrackingSynchronizerObserver in favor of
  ChromeMetricsServiceClient being a TrackingSynchronizerObserver

BUG=374218,375776,376288
TBR=thakis

Review URL: https://codereview.chromium.org/293393010

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@275753 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 211 insertions, 195 deletions

diff --git a/chrome/browser/metrics/chrome_metrics_service_client.cc b/chrome/browser/metrics/chrome_metrics_service_client.cc
index c970657..95063b6 100644
--- a/chrome/browser/metrics/chrome_metrics_service_client.cc
+++ b/chrome/browser/metrics/chrome_metrics_service_client.cc
@@ -9,8 +9,10 @@
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
+#include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
@@ -21,8 +23,14 @@
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/google/google_brand.h"
 #include "chrome/browser/memory_details.h"
+#include "chrome/browser/metrics/chrome_stability_metrics_provider.h"
 #include "chrome/browser/metrics/extensions_metrics_provider.h"
+#include "chrome/browser/metrics/gpu_metrics_provider.h"
 #include "chrome/browser/metrics/metrics_service.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/browser/ui/browser_otr_state.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
@@ -36,10 +44,16 @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 
-#if !defined(OS_ANDROID)
+#if defined(OS_ANDROID)
+#include "chrome/browser/metrics/android_metrics_provider.h"
+#else
 #include "chrome/browser/service_process/service_process_control.h"
 #endif
 
+#if defined(ENABLE_PLUGINS)
+#include "chrome/browser/metrics/plugin_metrics_provider.h"
+#endif
+
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/metrics/chromeos_metrics_provider.h"
 #endif
@@ -128,22 +142,18 @@ scoped_ptr<ChromeMetricsServiceClient> ChromeMetricsServiceClient::Create(
   return client.Pass();
 }
 
-void ChromeMetricsServiceClient::Initialize() {
-  metrics_service_.reset(new MetricsService(
-      metrics_state_manager_, this, g_browser_process->local_state()));
+// static
+void ChromeMetricsServiceClient::RegisterPrefs(PrefRegistrySimple* registry) {
+  MetricsService::RegisterPrefs(registry);
+  ChromeStabilityMetricsProvider::RegisterPrefs(registry);
 
-  // Register metrics providers.
-  metrics_service_->RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(
-          new ExtensionsMetricsProvider(metrics_state_manager_)));
+#if defined(OS_ANDROID)
+  AndroidMetricsProvider::RegisterPrefs(registry);
+#endif  // defined(OS_ANDROID)
 
-#if defined(OS_CHROMEOS)
-  ChromeOSMetricsProvider* chromeos_metrics_provider =
-      new ChromeOSMetricsProvider;
-  chromeos_metrics_provider_ = chromeos_metrics_provider;
-  metrics_service_->RegisterMetricsProvider(
-      scoped_ptr<metrics::MetricsProvider>(chromeos_metrics_provider));
-#endif
+#if defined(ENABLE_PLUGINS)
+  PluginMetricsProvider::RegisterPrefs(registry);
+#endif  // defined(ENABLE_PLUGINS)
 }
 
 void ChromeMetricsServiceClient::SetClientID(const std::string& client_id) {
@@ -193,13 +203,16 @@ void ChromeMetricsServiceClient::OnLogUploadComplete() {
 
 void ChromeMetricsServiceClient::StartGatheringMetrics(
     const base::Closure& done_callback) {
-// TODO(blundell): Move all metrics gathering tasks from MetricsService to
-// here.
+  finished_gathering_initial_metrics_callback_ = done_callback;
+  base::Closure got_hardware_class_callback =
+      base::Bind(&ChromeMetricsServiceClient::OnInitTaskGotHardwareClass,
+                 weak_ptr_factory_.GetWeakPtr());
 #if defined(OS_CHROMEOS)
-  chromeos_metrics_provider_->InitTaskGetHardwareClass(done_callback);
+  chromeos_metrics_provider_->InitTaskGetHardwareClass(
+      got_hardware_class_callback);
 #else
-  done_callback.Run();
-#endif
+  got_hardware_class_callback.Run();
+#endif  // defined(OS_CHROMEOS)
 }
 
 void ChromeMetricsServiceClient::CollectFinalMetrics(
@@ -243,6 +256,104 @@ ChromeMetricsServiceClient::CreateUploader(
           on_upload_complete));
 }
 
+void ChromeMetricsServiceClient::LogPluginLoadingError(
+    const base::FilePath& plugin_path) {
+#if defined(ENABLE_PLUGINS)
+  plugin_metrics_provider_->LogPluginLoadingError(plugin_path);
+#else
+  NOTREACHED();
+#endif  // defined(ENABLE_PLUGINS)
+}
+
+void ChromeMetricsServiceClient::Initialize() {
+  metrics_service_.reset(new MetricsService(
+      metrics_state_manager_, this, g_browser_process->local_state()));
+
+  // Register metrics providers.
+  metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(
+          new ExtensionsMetricsProvider(metrics_state_manager_)));
+  metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(new NetworkMetricsProvider));
+  metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(new OmniboxMetricsProvider));
+  metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(new ChromeStabilityMetricsProvider));
+  metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(new GPUMetricsProvider()));
+  profiler_metrics_provider_ = new ProfilerMetricsProvider;
+  metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(profiler_metrics_provider_));
+
+#if defined(OS_ANDROID)
+  metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(
+          new AndroidMetricsProvider(g_browser_process->local_state())));
+#endif  // defined(OS_ANDROID)
+
+#if defined(OS_WIN)
+  google_update_metrics_provider_ = new GoogleUpdateMetricsProviderWin;
+  metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(google_update_metrics_provider_));
+#endif  // defined(OS_WIN)
+
+#if defined(ENABLE_PLUGINS)
+  plugin_metrics_provider_ =
+      new PluginMetricsProvider(g_browser_process->local_state());
+  metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(plugin_metrics_provider_));
+#endif  // defined(ENABLE_PLUGINS)
+
+#if defined(OS_CHROMEOS)
+  ChromeOSMetricsProvider* chromeos_metrics_provider =
+      new ChromeOSMetricsProvider;
+  chromeos_metrics_provider_ = chromeos_metrics_provider;
+  metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(chromeos_metrics_provider));
+#endif  // defined(OS_CHROMEOS)
+}
+
+void ChromeMetricsServiceClient::OnInitTaskGotHardwareClass() {
+  const base::Closure got_plugin_info_callback =
+      base::Bind(&ChromeMetricsServiceClient::OnInitTaskGotPluginInfo,
+                 weak_ptr_factory_.GetWeakPtr());
+
+#if defined(ENABLE_PLUGINS)
+  plugin_metrics_provider_->GetPluginInformation(got_plugin_info_callback);
+#else
+  got_plugin_info_callback.Run();
+#endif  // defined(ENABLE_PLUGINS)
+}
+
+void ChromeMetricsServiceClient::OnInitTaskGotPluginInfo() {
+  const base::Closure got_metrics_callback =
+      base::Bind(&ChromeMetricsServiceClient::OnInitTaskGotGoogleUpdateData,
+                 weak_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  // defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
+}
+
+void ChromeMetricsServiceClient::OnInitTaskGotGoogleUpdateData() {
+  // 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(
+      weak_ptr_factory_.GetWeakPtr());
+}
+
+void ChromeMetricsServiceClient::ReceivedProfilerData(
+    const tracked_objects::ProcessDataSnapshot& process_data,
+    int process_type) {
+  profiler_metrics_provider_->RecordProfilerData(process_data, process_type);
+}
+
+void ChromeMetricsServiceClient::FinishedReceivingProfilerData() {
+  finished_gathering_initial_metrics_callback_.Run();
+}
+
 void ChromeMetricsServiceClient::OnMemoryDetailCollectionDone() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
diff --git a/chrome/browser/metrics/chrome_metrics_service_client.h b/chrome/browser/metrics/chrome_metrics_service_client.h
index 63bf92e..a60960a 100644
--- a/chrome/browser/metrics/chrome_metrics_service_client.h
+++ b/chrome/browser/metrics/chrome_metrics_service_client.h
@@ -13,12 +13,21 @@
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "chrome/browser/metrics/network_stats_uploader.h"
+#include "chrome/browser/metrics/tracking_synchronizer_observer.h"
 #include "components/metrics/metrics_service_client.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 class ChromeOSMetricsProvider;
+class GoogleUpdateMetricsProviderWin;
 class MetricsService;
+class PluginMetricsProvider;
+class PrefRegistrySimple;
+class ProfilerMetricsProvider;
+
+namespace base {
+class FilePath;
+}
 
 namespace metrics {
 class MetricsStateManager;
@@ -26,8 +35,10 @@ class MetricsStateManager;
 
 // ChromeMetricsServiceClient provides an implementation of MetricsServiceClient
 // that depends on chrome/.
-class ChromeMetricsServiceClient : public metrics::MetricsServiceClient,
-                                   public content::NotificationObserver {
+class ChromeMetricsServiceClient
+    : public metrics::MetricsServiceClient,
+      public chrome_browser_metrics::TrackingSynchronizerObserver,
+      public content::NotificationObserver {
  public:
   virtual ~ChromeMetricsServiceClient();
 
@@ -36,6 +47,9 @@ class ChromeMetricsServiceClient : public metrics::MetricsServiceClient,
       metrics::MetricsStateManager* state_manager,
       PrefService* local_state);
 
+  // Registers local state prefs used by this class.
+  static void RegisterPrefs(PrefRegistrySimple* registry);
+
   // metrics::MetricsServiceClient:
   virtual void SetClientID(const std::string& client_id) OVERRIDE;
   virtual bool IsOffTheRecordSessionActive() OVERRIDE;
@@ -56,6 +70,8 @@ class ChromeMetricsServiceClient : public metrics::MetricsServiceClient,
 
   MetricsService* metrics_service() { return metrics_service_.get(); }
 
+  void LogPluginLoadingError(const base::FilePath& plugin_path);
+
  private:
   explicit ChromeMetricsServiceClient(
       metrics::MetricsStateManager* state_manager);
@@ -63,6 +79,23 @@ class ChromeMetricsServiceClient : public metrics::MetricsServiceClient,
   // Completes the two-phase initialization of ChromeMetricsServiceClient.
   void Initialize();
 
+  // Callback that continues the init task by loading plugin information.
+  void OnInitTaskGotHardwareClass();
+
+  // Called after the Plugin init task has been completed that continues the
+  // init task by launching a task to gather Google Update statistics.
+  void OnInitTaskGotPluginInfo();
+
+  // Called after GoogleUpdate init task has been completed that continues the
+  // init task by loading profiler data.
+  void OnInitTaskGotGoogleUpdateData();
+
+  // TrackingSynchronizerObserver:
+  virtual void ReceivedProfilerData(
+      const tracked_objects::ProcessDataSnapshot& process_data,
+      int process_type) OVERRIDE;
+  virtual void FinishedReceivingProfilerData() OVERRIDE;
+
   // Callbacks for various stages of final log info collection. Do not call
   // these directly.
   void OnMemoryDetailCollectionDone();
@@ -113,6 +146,25 @@ class ChromeMetricsServiceClient : public metrics::MetricsServiceClient,
   // Number of async histogram fetch requests in progress.
   int num_async_histogram_fetches_in_progress_;
 
+  // The ProfilerMetricsProvider instance that was registered with
+  // MetricsService. Has the same lifetime as |metrics_service_|.
+  ProfilerMetricsProvider* profiler_metrics_provider_;
+
+#if defined(ENABLE_PLUGINS)
+  // The PluginMetricsProvider instance that was registered with
+  // MetricsService. Has the same lifetime as |metrics_service_|.
+  PluginMetricsProvider* plugin_metrics_provider_;
+#endif
+
+#if defined(OS_WIN)
+  // The GoogleUpdateMetricsProviderWin instance that was registered with
+  // MetricsService. Has the same lifetime as |metrics_service_|.
+  GoogleUpdateMetricsProviderWin* google_update_metrics_provider_;
+#endif
+
+  // Callback that is called when initial metrics gathering is complete.
+  base::Closure finished_gathering_initial_metrics_callback_;
+
   base::WeakPtrFactory<ChromeMetricsServiceClient> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeMetricsServiceClient);
diff --git a/chrome/browser/metrics/metrics_service.cc b/chrome/browser/metrics/metrics_service.cc
index 6869d40..ac4127b 100644
--- a/chrome/browser/metrics/metrics_service.cc
+++ b/chrome/browser/metrics/metrics_service.cc
@@ -181,12 +181,6 @@
 #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"
@@ -198,20 +192,6 @@
 #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;
 
@@ -326,19 +306,6 @@ void MetricsService::RegisterPrefs(PrefRegistrySimple* registry) {
   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,
@@ -363,39 +330,6 @@ MetricsService::MetricsService(metrics::MetricsStateManager* state_manager,
   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() {
@@ -673,43 +607,6 @@ void MetricsService::InitializeMetricsState() {
   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;
@@ -718,15 +615,7 @@ void MetricsService::OnUserAction(const std::string& 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;
 
@@ -821,10 +710,8 @@ void MetricsService::OpenNewLog() {
 }
 
 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()));
 }
 
@@ -1294,12 +1181,6 @@ void MetricsService::LogCleanShutdown() {
                            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
diff --git a/chrome/browser/metrics/metrics_service.h b/chrome/browser/metrics/metrics_service.h
index e35baef..e20c23f 100644
--- a/chrome/browser/metrics/metrics_service.h
+++ b/chrome/browser/metrics/metrics_service.h
@@ -13,7 +13,6 @@
 #include <vector>
 
 #include "base/basictypes.h"
-#include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
@@ -26,19 +25,15 @@
 #include "base/strings/string16.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
-#include "chrome/browser/metrics/tracking_synchronizer_observer.h"
 #include "components/metrics/metrics_log.h"
 #include "components/metrics/metrics_log_manager.h"
 #include "components/metrics/metrics_provider.h"
 #include "components/metrics/metrics_service_observer.h"
 #include "components/variations/active_field_trials.h"
 
-class GoogleUpdateMetricsProviderWin;
 class MetricsReportingScheduler;
 class PrefService;
 class PrefRegistrySimple;
-class PluginMetricsProvider;
-class ProfilerMetricsProvider;
 
 namespace base {
 class DictionaryValue;
@@ -88,9 +83,7 @@ struct SyntheticTrialGroup {
   SyntheticTrialGroup(uint32 trial, uint32 group);
 };
 
-class MetricsService
-    : public base::HistogramFlattener,
-      public chrome_browser_metrics::TrackingSynchronizerObserver {
+class MetricsService : public base::HistogramFlattener {
  public:
   // The execution phase of the browser.
   enum ExecutionPhase {
@@ -207,9 +200,6 @@ class MetricsService
   bool recording_active() const;
   bool reporting_active() const;
 
-  // TODO(blundell): Move this to ChromeMetricsServiceClient.
-  void LogPluginLoadingError(const base::FilePath& plugin_path);
-
   // Redundant test to ensure that we are notified of a clean exit.
   // This value should be true when process has completed shutdown.
   static bool UmaMetricsProperlyShutdown();
@@ -262,26 +252,12 @@ class MetricsService
   // Calls into the client to start metrics gathering.
   void StartGatheringMetrics();
 
-  // Callback that continues the init task by loading plugin information.
-  void OnInitTaskGotHardwareClass();
-
-  // Called after the Plugin init task has been completed that continues the
-  // init task by launching a task to gather Google Update statistics.
-  void OnInitTaskGotPluginInfo();
-
-  // Called after GoogleUpdate init task has been completed that continues the
-  // init task by loading profiler data.
-  void OnInitTaskGotGoogleUpdateData();
+  // Callback that moves the state to INIT_TASK_DONE. When this is called, the
+  // state should be INIT_TASK_SCHEDULED.
+  void FinishedGatheringInitialMetrics();
 
   void OnUserAction(const std::string& action);
 
-  // TrackingSynchronizerObserver:
-  virtual void ReceivedProfilerData(
-      const tracked_objects::ProcessDataSnapshot& process_data,
-      int process_type) OVERRIDE;
-  // Callback that moves the state to INIT_TASK_DONE.
-  virtual void FinishedReceivingProfilerData() OVERRIDE;
-
   // Get the amount of uptime since this process started and since the last
   // call to this function.  Also updates the cumulative uptime metric (stored
   // as a pref) for uninstall.  Uptimes are measured using TimeTicks, which
@@ -435,16 +411,6 @@ class MetricsService
   // Whether the initial stability log has been recorded during startup.
   bool has_initial_stability_log_;
 
-  ProfilerMetricsProvider* profiler_metrics_provider_;
-
-#if defined(ENABLE_PLUGINS)
-  PluginMetricsProvider* plugin_metrics_provider_;
-#endif
-
-#if defined(OS_WIN)
-  GoogleUpdateMetricsProviderWin* google_update_metrics_provider_;
-#endif
-
   // The initial metrics log, used to record startup metrics (histograms and
   // profiler data). Note that if a crash occurred in the previous session, an
   // initial stability log may be sent before this.
diff --git a/chrome/browser/metrics/metrics_services_manager.cc b/chrome/browser/metrics/metrics_services_manager.cc
index 8a4698c..b8e835c 100644
--- a/chrome/browser/metrics/metrics_services_manager.cc
+++ b/chrome/browser/metrics/metrics_services_manager.cc
@@ -7,7 +7,6 @@
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/metrics/chrome_metrics_service_client.h"
-#include "chrome/browser/metrics/extensions_metrics_provider.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/browser/metrics/variations/variations_service.h"
 #include "chrome/common/chrome_switches.h"
@@ -29,15 +28,7 @@ MetricsServicesManager::~MetricsServicesManager() {
 
 MetricsService* MetricsServicesManager::GetMetricsService() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!metrics_service_client_) {
-    metrics_service_client_ =
-        ChromeMetricsServiceClient::Create(GetMetricsStateManager(),
-                                           local_state_);
-    metrics_service_client_->metrics_service()->RegisterMetricsProvider(
-        scoped_ptr<metrics::MetricsProvider>(
-            new ExtensionsMetricsProvider(GetMetricsStateManager())));
-  }
-  return metrics_service_client_->metrics_service();
+  return GetChromeMetricsServiceClient()->metrics_service();
 }
 
 rappor::RapporService* MetricsServicesManager::GetRapporService() {
@@ -60,7 +51,17 @@ MetricsServicesManager::GetVariationsService() {
 
 void MetricsServicesManager::OnPluginLoadingError(
     const base::FilePath& plugin_path) {
-  GetMetricsService()->LogPluginLoadingError(plugin_path);
+  GetChromeMetricsServiceClient()->LogPluginLoadingError(plugin_path);
+}
+
+ChromeMetricsServiceClient*
+MetricsServicesManager::GetChromeMetricsServiceClient() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!metrics_service_client_) {
+    metrics_service_client_ = ChromeMetricsServiceClient::Create(
+        GetMetricsStateManager(), local_state_);
+  }
+  return metrics_service_client_.get();
 }
 
 metrics::MetricsStateManager* MetricsServicesManager::GetMetricsStateManager() {
diff --git a/chrome/browser/metrics/metrics_services_manager.h b/chrome/browser/metrics/metrics_services_manager.h
index 1d77177..24fc1d5 100644
--- a/chrome/browser/metrics/metrics_services_manager.h
+++ b/chrome/browser/metrics/metrics_services_manager.h
@@ -38,7 +38,8 @@ class MetricsServicesManager {
   explicit MetricsServicesManager(PrefService* local_state);
   virtual ~MetricsServicesManager();
 
-  // Returns the MetricsService, creating it if it hasn't been created yet.
+  // Returns the MetricsService, creating it if it hasn't been created yet (and
+  // additionally creating the ChromeMetricsServiceClient in that case).
   MetricsService* GetMetricsService();
 
   // Returns the GetRapporService, creating it if it hasn't been created yet.
@@ -51,6 +52,10 @@ class MetricsServicesManager {
   void OnPluginLoadingError(const base::FilePath& plugin_path);
 
  private:
+  // Returns the ChromeMetricsServiceClient, creating it if it hasn't been
+  // created yet (and additionally creating the MetricsService in that case).
+  ChromeMetricsServiceClient* GetChromeMetricsServiceClient();
+
   metrics::MetricsStateManager* GetMetricsStateManager();
 
   // Returns true iff metrics reporting is enabled.
diff --git a/chrome/browser/prefs/browser_prefs.cc b/chrome/browser/prefs/browser_prefs.cc
index 898f126..9a241528 100644
--- a/chrome/browser/prefs/browser_prefs.cc
+++ b/chrome/browser/prefs/browser_prefs.cc
@@ -33,7 +33,7 @@
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/media_device_id_salt.h"
 #include "chrome/browser/media/media_stream_devices_controller.h"
-#include "chrome/browser/metrics/metrics_service.h"
+#include "chrome/browser/metrics/chrome_metrics_service_client.h"
 #include "chrome/browser/metrics/variations/variations_service.h"
 #include "chrome/browser/net/http_server_properties_manager.h"
 #include "chrome/browser/net/net_pref_observer.h"
@@ -227,6 +227,7 @@ void RegisterLocalState(PrefRegistrySimple* registry) {
   AppListService::RegisterPrefs(registry);
   browser_shutdown::RegisterPrefs(registry);
   BrowserProcessImpl::RegisterPrefs(registry);
+  ChromeMetricsServiceClient::RegisterPrefs(registry);
   chrome_prefs::RegisterPrefs(registry);
   chrome_variations::VariationsService::RegisterPrefs(registry);
   component_updater::RegisterPrefsForRecoveryComponent(registry);
@@ -238,7 +239,6 @@ void RegisterLocalState(PrefRegistrySimple* registry) {
   IntranetRedirectDetector::RegisterPrefs(registry);
   IOThread::RegisterPrefs(registry);
   KeywordEditorController::RegisterPrefs(registry);
-  MetricsService::RegisterPrefs(registry);
   network_time::NetworkTimeTracker::RegisterPrefs(registry);
   PrefProxyConfigTrackerImpl::RegisterPrefs(registry);
   ProfileInfoCache::RegisterPrefs(registry);