Move initial metrics gathering tasks out of MetricsService.

chrome/browser/metrics/chrome_metrics_service_client.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/chrome_metrics_service_client.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/google/google_util.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/tracking_synchronizer.h"
 #include "chrome/browser/ui/browser_otr_state.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/crash_keys.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/histogram_fetcher.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 
-#if !defined(OS_ANDROID)
+#if defined(ENABLE_PLUGINS)
+#include "chrome/browser/metrics/plugin_metrics_provider.h"
+#endif
+
+#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(OS_CHROMEOS)
 #include "chrome/browser/metrics/chromeos_metrics_provider.h"
 #endif
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include "base/win/registry.h"
@@ skipping 80 matching lines @@
 scoped_ptr<ChromeMetricsServiceClient> ChromeMetricsServiceClient::Create(
     metrics::MetricsStateManager* state_manager) {
   // Perform two-phase initialization so that |client->metrics_service_| only
   // receives pointers to fully constructed objects.
   scoped_ptr<ChromeMetricsServiceClient> client(
       new ChromeMetricsServiceClient(state_manager));
   client->metrics_service_.reset(new MetricsService(
       state_manager, client.get(), g_browser_process->local_state()));
 
   // Register metrics providers.
+
   client->metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(
           new ExtensionsMetricsProvider(state_manager)));
+  client->metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(new NetworkMetricsProvider));
+  client->metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(new OmniboxMetricsProvider));
+  client->metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(new ChromeStabilityMetricsProvider));
+  client->metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(new GPUMetricsProvider()));
+
+#if defined(OS_ANDROID)
+  client->metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(
+          new AndroidMetricsProvider(local_state_)));
+#endif  // defined(OS_ANDROID)
+
+#if defined(OS_WIN)
+  GoogleUpdateMetricsProviderWin* google_update_metrics_provider =
+      new GoogleUpdateMetricsProviderWin;
+  client->google_update_metrics_provider_ = google_update_metrics_provider;
+  client->metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(google_update_metrics_provider));
+#endif
+
+#if defined(ENABLE_PLUGINS)
+  PluginMetricsProvider* plugin_metrics_provider =
+      new PluginMetricsProvider(g_browser_process->local_state());
+  client->plugin_metrics_provider_ = plugin_metrics_provider;
+  client->metrics_service_->RegisterMetricsProvider(
+      scoped_ptr<metrics::MetricsProvider>(plugin_metrics_provider));
+#endif
 
 #if defined(OS_CHROMEOS)
   ChromeOSMetricsProvider* chromeos_metrics_provider =
       new ChromeOSMetricsProvider;
   client->chromeos_metrics_provider_ = chromeos_metrics_provider;
   client->metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(chromeos_metrics_provider));
 #endif
 
   return client.Pass();
@@ skipping 188 matching lines @@
       metrics_service_->OnApplicationNotIdle();
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 void ChromeMetricsServiceClient::StartGatheringMetrics(
     const base::Closure& done_callback) {
-  // TODO(blundell): Move all metrics gathering tasks from MetricsService to
-  // here.
   // 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.
+  finished_gathering_initial_metrics_callback_ = done_callback;
   content::BrowserThread::PostDelayedTask(
       content::BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&ChromeMetricsServiceClient::InitTaskGetHardwareClass,
                  weak_ptr_factory_.GetWeakPtr(),
-                 base::MessageLoop::current()->message_loop_proxy(),
-                 done_callback),
+                 base::MessageLoop::current()->message_loop_proxy()),
       base::TimeDelta::FromSeconds(kInitializationDelaySeconds));
 }
 
 void ChromeMetricsServiceClient::InitTaskGetHardwareClass(
-    base::MessageLoopProxy* target_loop,
-    const base::Closure& done_callback) {
+    base::MessageLoopProxy* target_loop) {
+  base::Closure callback =
+      base::Bind(&ChromeMetricsServiceClient::OnInitTaskGotHardwareClass,
+                 weak_ptr_factory_.GetWeakPtr());
 #if defined(OS_CHROMEOS)
-  chromeos_metrics_provider_->InitTaskGetHardwareClass(target_loop,
-                                                       done_callback);
+  chromeos_metrics_provider_->InitTaskGetHardwareClass(target_loop, callback);
 #else
-  target_loop->PostTask(FROM_HERE, done_callback);
+  target_loop->PostTask(FROM_HERE, callback);
 #endif
 }
 
+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
+}
+
+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
+}
+
+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) {
+  metrics_service_->ReceivedProfilerData(process_data, process_type);
+}
+
+void ChromeMetricsServiceClient::FinishedReceivingProfilerData() {
+  finished_gathering_initial_metrics_callback_.Run();
+}
+
 #if defined(OS_WIN)
 void ChromeMetricsServiceClient::CountBrowserCrashDumpAttempts() {
   // Open the registry key for iteration.
   base::win::RegKey regkey;
   if (regkey.Open(HKEY_CURRENT_USER,
                   chrome::kBrowserCrashDumpAttemptsRegistryPath,
                   KEY_ALL_ACCESS) != ERROR_SUCCESS) {
     return;
   }
 
@@ skipping 31 matching lines @@
   // Capture the histogram samples.
   if (dumps_with_crash != 0)
     UMA_HISTOGRAM_COUNTS("Chrome.BrowserDumpsWithCrash", dumps_with_crash);
   if (dumps_with_no_crash != 0)
     UMA_HISTOGRAM_COUNTS("Chrome.BrowserDumpsWithNoCrash", dumps_with_no_crash);
   int total_dumps = dumps_with_crash + dumps_with_no_crash;
   if (total_dumps != 0)
     UMA_HISTOGRAM_COUNTS("Chrome.BrowserCrashDumpAttempts", total_dumps);
 }
 #endif  // defined(OS_WIN)