Move MetricsService final log collection tasks to client.

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 166 matching lines @@
 #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/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/io_thread.h"
-#include "chrome/browser/memory_details.h"
 #include "chrome/browser/metrics/compression_utils.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/metrics/metrics_state_manager.h"
 #include "chrome/browser/metrics/omnibox_metrics_provider.h"
 #include "chrome/browser/metrics/time_ticks_experiment_win.h"
 #include "chrome/browser/metrics/tracking_synchronizer.h"
 #include "chrome/browser/net/http_pipelining_compatibility_client.h"
 #include "chrome/browser/net/network_stats.h"
 #include "chrome/browser/ui/browser_otr_state.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/crash_keys.h"
 #include "chrome/common/metrics/variations/variations_util.h"
 #include "chrome/common/net/test_server_locations.h"
 #include "chrome/common/pref_names.h"
-#include "chrome/common/render_messages.h"
 #include "components/metrics/metrics_log_manager.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_reporting_scheduler.h"
+#include "components/metrics/metrics_service_client.h"
 #include "components/variations/entropy_provider.h"
 #include "components/variations/metrics_util.h"
 #include "content/public/browser/child_process_data.h"
-#include "content/public/browser/histogram_fetcher.h"
 #include "content/public/browser/load_notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/webplugininfo.h"
 #include "extensions/browser/process_map.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 
 // TODO(port): port browser_distribution.h.
 #if !defined(OS_POSIX)
 #include "chrome/installer/util/browser_distribution.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chromeos/system/statistics_provider.h"
 #endif
 
 #if defined(OS_WIN)
 #include <windows.h>  // Needed for STATUS_* codes
 #include "base/win/registry.h"
 #endif
 
-#if !defined(OS_ANDROID)
-#include "chrome/browser/service_process/service_process_control.h"
-#endif
-
 using base::Time;
 using content::BrowserThread;
 using content::ChildProcessData;
 using content::LoadNotificationDetails;
 using content::PluginService;
 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;
 }
 
 // The delay, in seconds, after starting recording before doing expensive
 // initialization work.
 #if defined(OS_ANDROID) || defined(OS_IOS)
 // On mobile devices, a significant portion of sessions last less than a minute.
 // Use a shorter timer on these platforms to avoid losing data.
 // TODO(dfalcantara): To avoid delaying startup, tighten up initialization so
 //                    that it occurs after the user gets their initial page.
 const int kInitializationDelaySeconds = 5;
 #else
 const int kInitializationDelaySeconds = 30;
 #endif
 
-// This specifies the amount of time to wait for all renderers to send their
-// data.
-const int kMaxHistogramGatheringWaitDuration = 60000;  // 60 seconds.
-
 // The maximum number of events in a log uploaded to the UMA server.
 const int kEventLimit = 2400;
 
 // If an upload fails, and the transmission was over this byte count, then we
 // will discard the log, and not try to retransmit it.  We also don't persist
 // the log to the prefs for transmission during the next chrome session if this
 // limit is exceeded.
 const size_t kUploadLogAvoidRetransmitSize = 50000;
 
 // Interval, in minutes, between state saves.
@@ skipping 94 matching lines @@
   // load.
   int instances;
 
   // The number of times there was an error loading an instance of this child
   // process.
   int loading_errors;
 
   int process_type;
 };
 
-// Handles asynchronous fetching of memory details.
-// Will run the provided task after finished.
-class MetricsMemoryDetails : public MemoryDetails {
- public:
-  explicit MetricsMemoryDetails(const base::Closure& callback)
-      : callback_(callback) {}
-
-  virtual void OnDetailsAvailable() OVERRIDE {
-    base::MessageLoop::current()->PostTask(FROM_HERE, callback_);
-  }
-
- private:
-  virtual ~MetricsMemoryDetails() {}
-
-  base::Closure callback_;
-  DISALLOW_COPY_AND_ASSIGN(MetricsMemoryDetails);
-};
-
 // static
 void MetricsService::RegisterPrefs(PrefRegistrySimple* registry) {
   DCHECK(IsSingleThreaded());
   metrics::MetricsStateManager::RegisterPrefs(registry);
 
   registry->RegisterInt64Pref(prefs::kStabilityLaunchTimeSec, 0);
   registry->RegisterInt64Pref(prefs::kStabilityLastTimestampSec, 0);
   registry->RegisterStringPref(prefs::kStabilityStatsVersion, std::string());
   registry->RegisterInt64Pref(prefs::kStabilityStatsBuildTime, 0);
   registry->RegisterBooleanPref(prefs::kStabilityExitedCleanly, true);
@@ skipping 50 matching lines @@
       recording_active_(false),
       reporting_active_(false),
       test_mode_active_(false),
       state_(INITIALIZED),
       has_initial_stability_log_(false),
       idle_since_last_transmission_(false),
       session_id_(-1),
       next_window_id_(0),
       self_ptr_factory_(this),
       state_saver_factory_(this),
-      waiting_for_asynchronous_reporting_step_(false),
-      num_async_histogram_fetches_in_progress_(0) {
+      waiting_for_asynchronous_reporting_step_(false) {
   DCHECK(IsSingleThreaded());
   DCHECK(state_manager_);
   DCHECK(client_);
 
   // TODO(asvitkine): Move this out of MetricsService.
   RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new OmniboxMetricsProvider));
 
   BrowserChildProcessObserver::Add(this);
 }
@@ skipping 748 matching lines @@
     scheduler_->UploadFinished(true /* healthy */, false /* no unsent logs */);
     return;
   }
   // If there are unsent logs, send the next one. If not, start the asynchronous
   // process of finalizing the current log for upload.
   if (state_ == SENDING_OLD_LOGS) {
     DCHECK(log_manager_.has_unsent_logs());
     log_manager_.StageNextLogForUpload();
     SendStagedLog();
   } else {
-    StartFinalLogInfoCollection();
+    client_->CollectFinalMetrics(
+        base::Bind(&MetricsService::OnFinalLogInfoCollectionDone,
+                   self_ptr_factory_.GetWeakPtr()));
   }
 }
 
-void MetricsService::StartFinalLogInfoCollection() {
-  // Begin the multi-step process of collecting memory usage histograms:
-  // First spawn a task to collect the memory details; when that task is
-  // finished, it will call OnMemoryDetailCollectionDone. That will in turn
-  // call HistogramSynchronization to collect histograms from all renderers and
-  // then call OnHistogramSynchronizationDone to continue processing.
-  DCHECK(!waiting_for_asynchronous_reporting_step_);
-  waiting_for_asynchronous_reporting_step_ = true;
-
-  base::Closure callback =
-      base::Bind(&MetricsService::OnMemoryDetailCollectionDone,
-                 self_ptr_factory_.GetWeakPtr());
-
-  scoped_refptr<MetricsMemoryDetails> details(
-      new MetricsMemoryDetails(callback));
-  details->StartFetch(MemoryDetails::UPDATE_USER_METRICS);
-
-  // Collect WebCore cache information to put into a histogram.
-  for (content::RenderProcessHost::iterator i(
-          content::RenderProcessHost::AllHostsIterator());
-       !i.IsAtEnd(); i.Advance())
-    i.GetCurrentValue()->Send(new ChromeViewMsg_GetCacheResourceStats());
-}
-
-void MetricsService::OnMemoryDetailCollectionDone() {
-  DCHECK(IsSingleThreaded());
-  // This function should only be called as the callback from an ansynchronous
-  // step.
-  DCHECK(waiting_for_asynchronous_reporting_step_);
-
-  // Create a callback_task for OnHistogramSynchronizationDone.
-  base::Closure callback = base::Bind(
-      &MetricsService::OnHistogramSynchronizationDone,
-      self_ptr_factory_.GetWeakPtr());
-
-  base::TimeDelta timeout =
-      base::TimeDelta::FromMilliseconds(kMaxHistogramGatheringWaitDuration);
-
-  DCHECK_EQ(num_async_histogram_fetches_in_progress_, 0);
-
-#if defined(OS_ANDROID)
-  // Android has no service process.
-  num_async_histogram_fetches_in_progress_ = 1;
-#else  // OS_ANDROID
-  num_async_histogram_fetches_in_progress_ = 2;
-  // Run requests to service and content in parallel.
-  if (!ServiceProcessControl::GetInstance()->GetHistograms(callback, timeout)) {
-    // Assume |num_async_histogram_fetches_in_progress_| is not changed by
-    // |GetHistograms()|.
-    DCHECK_EQ(num_async_histogram_fetches_in_progress_, 2);
-    // Assign |num_async_histogram_fetches_in_progress_| above and decrement it
-    // here to make code work even if |GetHistograms()| fired |callback|.
-    --num_async_histogram_fetches_in_progress_;
-  }
-#endif  // OS_ANDROID
-
-  // Set up the callback to task to call after we receive histograms from all
-  // child processes. Wait time specifies how long to wait before absolutely
-  // calling us back on the task.
-  content::FetchHistogramsAsynchronously(base::MessageLoop::current(), callback,
-                                         timeout);
-}
-
-void MetricsService::OnHistogramSynchronizationDone() {
-  DCHECK(IsSingleThreaded());
-  // This function should only be called as the callback from an ansynchronous
-  // step.
-  DCHECK(waiting_for_asynchronous_reporting_step_);
-  DCHECK_GT(num_async_histogram_fetches_in_progress_, 0);
-
-  // Check if all expected requests finished.
-  if (--num_async_histogram_fetches_in_progress_ > 0)
-    return;
-
-  waiting_for_asynchronous_reporting_step_ = false;
-  OnFinalLogInfoCollectionDone();
-}
-
 void MetricsService::OnFinalLogInfoCollectionDone() {
   // If somehow there is a fetch in progress, we return and hope things work
   // out. The scheduler isn't informed since if this happens, the scheduler
   // will get a response from the upload.
   DCHECK(!current_fetch_.get());
   if (current_fetch_.get())
     return;
 
   // Abort if metrics were turned off during the final info gathering.
   if (!recording_active()) {
@@ skipping 633 matching lines @@
   if (metrics_service)
     metrics_service->AddObserver(observer);
 }
 
 void MetricsServiceHelper::RemoveMetricsServiceObserver(
     MetricsServiceObserver* observer) {
   MetricsService* metrics_service = g_browser_process->metrics_service();
   if (metrics_service)
     metrics_service->RemoveObserver(observer);
 }