Automatically adapt to faster/slower uploads of renderer histograms...

chrome/browser/metrics/metrics_service.cc

 // Copyright (c) 2006-2009 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
@@ skipping 163 matching lines @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/load_notification_details.h"
 #include "chrome/browser/memory_details.h"
 #include "chrome/browser/plugin_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/common/child_process_info.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/histogram_synchronizer.h"
 #include "chrome/common/libxml_utils.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/render_messages.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_flags.h"
 #include "third_party/bzip2/bzlib.h"
 
 #if defined(OS_POSIX)
 // TODO(port): Move these headers above as they are ported.
 #include "chrome/common/temp_scaffolding_stubs.h"
 #else
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/google_update_settings.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 
 // Check to see that we're being called on only one thread.
 static bool IsSingleThreaded();
 
 static const char kMetricsType[] = "application/vnd.mozilla.metrics.bz2";
 
 // The delay, in seconds, after startup before sending the first log message.
 static const int kInitialInterlogDuration = 60;  // one minute
 
+// This specifies the amount of time to wait for all renderers to send their
+// data.
+static const int kMaxHistogramGatheringWaitDuration = 60000;  // 60 seconds.
+
 // The default maximum number of events in a log uploaded to the UMA server.
 static const int kInitialEventLimit = 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.
 static const int kUploadLogAvoidRetransmitSize = 50000;
 
 // When we have logs from previous Chrome sessions to send, how long should we
@@ skipping 652 matching lines @@
   // If timer_pending is true because the fetch is waiting for a response,
   // we return for now and let the response handler start the timer.
   if (timer_pending_)
     return;
 
   // Before starting the timer, set timer_pending_ to true.
   timer_pending_ = true;
 
   // Right before the UMA transmission gets started, there's one more thing we'd
   // like to record: the histogram of memory usage, so we spawn a task to
-  // collect the memory details and when that task is finished, we arrange for
-  // TryToStartTransmission to take over.
+  // collect the memory details and when that task is finished, it will call
+  // OnMemoryDetailCollectionDone, which will call HistogramSynchronization to
+  // collect histograms from all renderers and then we will call
+  // OnHistogramSynchronizationDone to continue processing.
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       log_sender_factory_.
-          NewRunnableMethod(&MetricsService::CollectMemoryDetails),
+          NewRunnableMethod(&MetricsService::LogTransmissionTimerDone),
       static_cast<int>(interlog_duration_.InMilliseconds()));
 }
 
-void MetricsService::TryToStartTransmission() {
+void MetricsService::LogTransmissionTimerDone() {
+  Task* task = log_sender_factory_.
+      NewRunnableMethod(&MetricsService::OnMemoryDetailCollectionDone);
+
+  MetricsMemoryDetails* details = new MetricsMemoryDetails(task);
+  details->StartFetch();
+
+  // Collect WebCore cache information to put into a histogram.
+  for (RenderProcessHost::iterator it = RenderProcessHost::begin();
+       it != RenderProcessHost::end(); ++it) {
+    it->second->Send(new ViewMsg_GetCacheResourceStats());
+  }
+}
+
+void MetricsService::OnMemoryDetailCollectionDone() {
+  DCHECK(IsSingleThreaded());
+
+  // HistogramSynchronizer will Collect histograms from all renderers and it
+  // will call OnHistogramSynchronizationDone (if wait time elapses before it
+  // heard from all renderers, then also it will call
+  // OnHistogramSynchronizationDone).
+
+  // Create a callback_task for OnHistogramSynchronizationDone.
+  Task* callback_task = log_sender_factory_.NewRunnableMethod(
+      &MetricsService::OnHistogramSynchronizationDone);
+
+  // Set up the callback to task to call after we receive histograms from all
+  // renderer processes. Wait time specifies how long to wait before absolutely
+  // calling us back on the task.
+  HistogramSynchronizer::FetchRendererHistogramsAsynchronously(
+      MessageLoop::current(), callback_task,
+      kMaxHistogramGatheringWaitDuration);
+}
+
+void MetricsService::OnHistogramSynchronizationDone() {
   DCHECK(IsSingleThreaded());
 
   // This function should only be called via timer, so timer_pending_
   // should be true.
   DCHECK(timer_pending_);
   timer_pending_ = false;
 
   DCHECK(!current_fetch_.get());
 
   // If we're getting no notifications, then the log won't have much in it, and
@@ skipping 125 matching lines @@
     case SEND_OLD_INITIAL_LOGS:
     case SENDING_OLD_LOGS:
       return true;
 
     case SENDING_CURRENT_LOGS:
     default:
       return false;
   }
 }
 
-void MetricsService::CollectMemoryDetails() {
-  Task* task = log_sender_factory_.
-      NewRunnableMethod(&MetricsService::TryToStartTransmission);
-  MetricsMemoryDetails* details = new MetricsMemoryDetails(task);
-  details->StartFetch();
-
-  // Collect WebCore cache information to put into a histogram.
-  for (RenderProcessHost::iterator it = RenderProcessHost::begin();
-       it != RenderProcessHost::end(); ++it) {
-    it->second->Send(new ViewMsg_GetCacheResourceStats());
-  }
-}
-
 void MetricsService::PrepareInitialLog() {
   DCHECK(state_ == PLUGIN_LIST_ARRIVED);
   std::vector<WebPluginInfo> plugins;
   PluginService::GetInstance()->GetPlugins(false, &plugins);
 
   MetricsLog* log = new MetricsLog(client_id_, session_id_);
   log->RecordEnvironment(plugins, profile_dictionary_.get());
 
   // Histograms only get written to current_log_, so setup for the write.
   MetricsLog* save_log = current_log_;
@@ skipping 713 matching lines @@
   pref->SetBoolean(path, value);
   RecordCurrentState(pref);
 }
 
 void MetricsService::RecordCurrentState(PrefService* pref) {
   pref->SetInt64(prefs::kStabilityLastTimestampSec, Time::Now().ToTimeT());
 
   RecordPluginChanges(pref);
 }
 
-void MetricsService::CollectRendererHistograms() {
-  for (RenderProcessHost::iterator it = RenderProcessHost::begin();
-       it != RenderProcessHost::end(); ++it) {
-    it->second->Send(new ViewMsg_GetRendererHistograms());
-  }
-}
-
 void MetricsService::RecordCurrentHistograms() {
   DCHECK(current_log_);
 
-  CollectRendererHistograms();
-
-  // TODO(raman): Delay the metrics collection activities until we get all the
-  // updates from the renderers, or we time out (1 second?  3 seconds?).
-
   StatisticsRecorder::Histograms histograms;
   StatisticsRecorder::GetHistograms(&histograms);
   for (StatisticsRecorder::Histograms::iterator it = histograms.begin();
        histograms.end() != it;
        ++it) {
     if ((*it)->flags() & kUmaTargetedHistogramFlag)
       // TODO(petersont): Only record historgrams if they are not precluded by
       // the UMA response data.
       // Bug http://code.google.com/p/chromium/issues/detail?id=2739.
       RecordHistogram(**it);
@@ skipping 53 matching lines @@
       L"." + key;
   prof_prefs->SetInteger(pref_key.c_str(), value);
 }
 
 static bool IsSingleThreaded() {
   static PlatformThreadId thread_id = 0;
   if (!thread_id)
     thread_id = PlatformThread::CurrentId();
   return PlatformThread::CurrentId() == thread_id;
 }