Collect profiler stats from browser child processes.

chrome/browser/metrics/tracking_synchronizer.cc

 // Copyright (c) 2011 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/tracking_synchronizer.h"
 
 #include "base/bind.h"
-#include "base/json/json_reader.h"
-#include "base/json/json_writer.h"
-#include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "base/process_util.h"
 #include "base/threading/thread.h"
 #include "base/tracked_objects.h"
-#include "chrome/browser/ui/webui/tracing_ui.h"
-#include "chrome/common/chrome_constants.h"
-#include "chrome/common/render_messages.h"
+#include "content/common/child_process_info.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/profiler_controller.h"
+#include "content/public/browser/profiler_synchronizer.h"
 
 using base::TimeTicks;
 using content::BrowserThread;
 
 namespace chrome_browser_metrics {
 
 // Negative numbers are never used as sequence numbers.  We explicitly pick a
 // negative number that is "so negative" that even when we add one (as is done
 // when we generated the next sequence number) that it will still be negative.
 // We have code that handles wrapping around on an overflow into negative
 // territory.
 static const int kNeverUsableSequenceNumber = -2;
 
+// TrackingSynchronizer methods and members.
+//
+// static
+TrackingSynchronizer* TrackingSynchronizer::tracking_synchronizer_ = NULL;
+
 TrackingSynchronizer::TrackingSynchronizer()
     : last_used_sequence_number_(kNeverUsableSequenceNumber) {
   DCHECK(tracking_synchronizer_ == NULL);
   tracking_synchronizer_ = this;
+  content::ProfilerController::GetInstance()->Register(this);
 }
 
 TrackingSynchronizer::~TrackingSynchronizer() {
+  content::ProfilerController::GetInstance()->Unregister(this);
+
   // Just in case we have any pending tasks, clear them out.
-  while (!outstanding_requests_.empty()) {
-    RequestContextMap::iterator it = outstanding_requests_.begin();
-    delete it->second;
-    outstanding_requests_.erase(it);
-  }
+  RequestContext::OnShutdown();
 
   tracking_synchronizer_ = NULL;
 }
 
 // static
-TrackingSynchronizer* TrackingSynchronizer::CurrentSynchronizer() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(tracking_synchronizer_ != NULL);
-  return tracking_synchronizer_;
-}
-
-// static
-void TrackingSynchronizer::FetchTrackingDataAsynchronously(
+void TrackingSynchronizer::FetchProfilerDataAsynchronously(
     const base::WeakPtr<ProfilerUI>& callback_object) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   TrackingSynchronizer* current_synchronizer = CurrentSynchronizer();
   if (current_synchronizer == NULL) {
     // System teardown is happening.
     return;
   }
 
   int sequence_number = current_synchronizer->RegisterAndNotifyAllProcesses(
       callback_object);
 
   // Post a task that would be called after waiting for wait_time.  This acts
   // as a watchdog, to cancel the requests for non-responsive processes.
   BrowserThread::PostDelayedTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(
-          current_synchronizer,
-          &TrackingSynchronizer::ForceTrackingSynchronizationDoneCallback,
-          sequence_number),
+      base::Bind(&RequestContext::Unregister, sequence_number),
       60000);
 }
 
-// static
-void TrackingSynchronizer::SetTrackingStatus(bool enable) {
-  // To iterate over all processes, or to send messages to the hosts, we need
-  // to be on the UI thread.
+void TrackingSynchronizer::OnPendingProcesses(int sequence_number,
+                                              int pending_processes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  for (content::RenderProcessHost::iterator it(
-          content::RenderProcessHost::AllHostsIterator());
-       !it.IsAtEnd(); it.Advance()) {
-    content::RenderProcessHost* render_process_host = it.GetCurrentValue();
-    DCHECK(render_process_host);
-    // Ignore processes that don't have a connection, such as crashed tabs.
-    if (!render_process_host->HasConnection())
-      continue;
-
-    render_process_host->Send(new ChromeViewMsg_SetTrackingStatus(enable));
-  }
+  RequestContext* request = RequestContext::GetRequestContext(sequence_number);
+  if (!request)
+    return;
+  request->AddProcessesPending(pending_processes);
+  request->DecrementProcessGroupCount();
+  request->DeleteIfAllDone();
 }
 
-// static
-void TrackingSynchronizer::IsTrackingEnabled(int process_id) {
+void TrackingSynchronizer::OnProfilerDataCollected(
+    int sequence_number,
+    const base::DictionaryValue& profiler_data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  // To find the process, or to send messages to the hosts, we need to be on the
-  // UI thread.
+  base::DictionaryValue* dictionary_value = new base::DictionaryValue;
+  dictionary_value->MergeDictionary(&profiler_data);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(
-          &TrackingSynchronizer::SetTrackingStatusInProcess, process_id));
+      base::Bind(&TrackingSynchronizer::OnProfilerDataCollectedOnUI,
+                 base::Unretained(this),
+                 sequence_number,
+                 dictionary_value));
 }
 
-// static
-void TrackingSynchronizer::SetTrackingStatusInProcess(int process_id) {
-  // To find the process, or to send messages to the hosts, we need to be on the
-  // UI thread.
+void TrackingSynchronizer::OnProfilerDataCollectedOnUI(
+    int sequence_number,
+    base::DictionaryValue* profiler_data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  bool enable = tracked_objects::ThreadData::tracking_status();
-
-  content::RenderProcessHost* process =
-      content::RenderProcessHost::FromID(process_id);
-  // Ignore processes that don't have a connection, such as crashed tabs.
-  if (!process || !process->HasConnection())
-    return;
-  process->Send(new ChromeViewMsg_SetTrackingStatus(enable));
-}
-
-// static
-void TrackingSynchronizer::DeserializeTrackingList(
-    int sequence_number,
-    const std::string& tracking_data,
-    ChildProcessInfo::ProcessType process_type) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(
-          &TrackingSynchronizer::DeserializeTrackingListOnUI,
-          sequence_number, tracking_data, process_type));
-}
-
-// static
-void TrackingSynchronizer::DeserializeTrackingListOnUI(
-    int sequence_number,
-    const std::string& tracking_data,
-    ChildProcessInfo::ProcessType process_type) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  TrackingSynchronizer* current_synchronizer = CurrentSynchronizer();
-  if (current_synchronizer == NULL)
+  RequestContext* request = RequestContext::GetRequestContext(sequence_number);
+  if (!request)
     return;
 
-  base::Value* value =
-      base::JSONReader().JsonToValue(tracking_data, false, true);
-  DCHECK(value->GetType() == base::Value::TYPE_DICTIONARY);
-  base::DictionaryValue* dictionary_value =
-      static_cast<DictionaryValue*>(value);
-  dictionary_value->SetString(
-      "process_type", ChildProcessInfo::GetTypeNameInEnglish(process_type));
-
-  current_synchronizer->DecrementPendingProcessesAndSendData(
-      sequence_number, dictionary_value);
+  DecrementPendingProcessesAndSendData(sequence_number, profiler_data);
 }
 
 int TrackingSynchronizer::RegisterAndNotifyAllProcesses(
     const base::WeakPtr<ProfilerUI>& callback_object) {
-  // To iterate over all processes, or to send messages to the hosts, we need
-  // to be on the UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   int sequence_number = GetNextAvailableSequenceNumber();
 
-  // Initialize processes_pending with one because we are going to send
-  // browser's ThreadData.
-  RequestContext* request = new RequestContext(
-      callback_object, sequence_number, 1, TimeTicks::Now());
-  outstanding_requests_[sequence_number] = request;
+  RequestContext* request =
+    RequestContext::Register(sequence_number, callback_object);
 
-  DCHECK_GT(request->processes_pending_, 0);
-  for (content::RenderProcessHost::iterator it(
-          content::RenderProcessHost::AllHostsIterator());
-       !it.IsAtEnd(); it.Advance()) {
-    content::RenderProcessHost* render_process_host = it.GetCurrentValue();
-    DCHECK(render_process_host);
-    // Ignore processes that don't have a connection, such as crashed tabs.
-    if (!render_process_host->HasConnection())
-      continue;
+  // Increment pending process count for sending browser's profiler data.
+  request->IncrementProcessesPending();
 
-    ++request->processes_pending_;
-    if (!render_process_host->Send(
-        new ChromeViewMsg_GetRendererTrackedData(sequence_number))) {
-      DecrementPendingProcesses(sequence_number);
-    }
-  }
+  // Get profiler data from renderer and browser child processes.
+  int process_group_count = content::GetProfilerData(sequence_number);
 
-  // Get the ThreadData for the browser process and send it back.
+  request->AddProcessGroupCount(process_group_count);
+
+  // Send profiler_data from browser process.
   base::DictionaryValue* value = tracked_objects::ThreadData::ToValue();
   const std::string process_type =
       ChildProcessInfo::GetTypeNameInEnglish(ChildProcessInfo::BROWSER_PROCESS);
   value->SetString("process_type", process_type);
   value->SetInteger("process_id", base::GetCurrentProcId());
-  DCHECK_GT(request->processes_pending_, 0);
   DecrementPendingProcessesAndSendData(sequence_number, value);
 
   return sequence_number;
 }
 
 void TrackingSynchronizer::DecrementPendingProcessesAndSendData(
     int sequence_number,
     base::DictionaryValue* value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  RequestContextMap::iterator it =
-      outstanding_requests_.find(sequence_number);
-  if (it == outstanding_requests_.end()) {
+  RequestContext* request = RequestContext::GetRequestContext(sequence_number);
+  if (!request) {
     delete value;
     return;
   }
 
-  RequestContext* request = NULL;
-  request = it->second;
-  DCHECK(sequence_number == request->sequence_number_);
-
   if (value && request->callback_object_) {
     // Transfers ownership of |value| to |callback_object_|.
     request->callback_object_->ReceivedData(value);
   } else {
     delete value;
   }
 
-  if (--request->processes_pending_ <= 0)
-    ForceTrackingSynchronizationDoneCallback(sequence_number);
-}
-
-void TrackingSynchronizer::DecrementPendingProcesses(int sequence_number) {
-  DecrementPendingProcessesAndSendData(sequence_number, NULL);
-}
-
-void TrackingSynchronizer::ForceTrackingSynchronizationDoneCallback(
-    int sequence_number) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  int unresponsive_processes;
-  RequestContextMap::iterator it =
-      outstanding_requests_.find(sequence_number);
-  if (it == outstanding_requests_.end())
-    return;
-
-  RequestContext* request = it->second;
-
-  DCHECK(sequence_number == request->sequence_number_);
-
-  unresponsive_processes = request->processes_pending_;
-
-  delete it->second;
-  outstanding_requests_.erase(it);
-
-  UMA_HISTOGRAM_COUNTS("Tracking.ProcessNotRespondingAsynchronous",
-                       unresponsive_processes);
+  // Delete request if we have heard back from all child processes.
+  request->DecrementProcessesPending();
+  request->DeleteIfAllDone();
 }
 
 int TrackingSynchronizer::GetNextAvailableSequenceNumber() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ++last_used_sequence_number_;
 
   // Watch out for wrapping to a negative number.
   if (last_used_sequence_number_ < 0)
     last_used_sequence_number_ = 1;
   return last_used_sequence_number_;
 }
 
 // static
-TrackingSynchronizer* TrackingSynchronizer::tracking_synchronizer_ = NULL;
+TrackingSynchronizer* TrackingSynchronizer::CurrentSynchronizer() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(tracking_synchronizer_ != NULL);
+  return tracking_synchronizer_;
+}
+
+// RequestContext methods and members.
+//
+// static
+base::LazyInstance<RequestContext::RequestContextMap>
+    RequestContext::outstanding_requests_ = LAZY_INSTANCE_INITIALIZER;
+
+RequestContext::RequestContext(const base::WeakPtr<ProfilerUI>& callback_object,
+                               int sequence_number)
+    : callback_object_(callback_object),
+      sequence_number_(sequence_number),
+      process_group_count_(0),
+      processes_pending_(0) {
+}
+
+RequestContext::~RequestContext() {
+}
+
+void RequestContext::AddProcessGroupCount(int process_group_count) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  process_group_count_ += process_group_count;
+}
+
+void RequestContext::DecrementProcessGroupCount() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  --process_group_count_;
+}
+
+void RequestContext::IncrementProcessesPending() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  ++processes_pending_;
+}
+
+void RequestContext::AddProcessesPending(int processes_pending) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  processes_pending_ += processes_pending;
+}
+
+void RequestContext::DecrementProcessesPending() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  --processes_pending_;
+}
+
+void RequestContext::DeleteIfAllDone() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (processes_pending_ <= 0 && process_group_count_ <= 0) {

[jam, 2011/11/28 18:48:16]

one more thing: if one of the processes crash, will this ever get to 0? i dont
think so. that's another reason to not do the process counter stuff

[ramant (doing other things), 2011/11/29 01:32:20]

In FetchProfilerDataAsynchronously, we post a delayed task to unregister
(cleanup) after 60 secs. 

We upload an UMA stat on how many processes were unresponsive (and may be
collect stats on how long it took to send a response from all processes).

Wondered if it is worth book keeping of how many  processes have responded etc,
but jar and I had thought it is good to do it.

many many thanks for your comments.

+    RequestContext::Unregister(sequence_number_);
+  }
+}
+
+// static
+RequestContext* RequestContext::Register(
+    int sequence_number,
+    const base::WeakPtr<ProfilerUI>& callback_object) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  RequestContext* request = new RequestContext(
+      callback_object, sequence_number);
+  outstanding_requests_.Get()[sequence_number] = request;
+
+  return request;
+}
+
+// static
+RequestContext* RequestContext::GetRequestContext(
+    int sequence_number) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  RequestContextMap::iterator it =
+      outstanding_requests_.Get().find(sequence_number);
+  if (it == outstanding_requests_.Get().end())
+    return NULL;
+
+  RequestContext* request = NULL;
+  request = it->second;
+  DCHECK(sequence_number == request->sequence_number_);
+  return request;
+}
+
+// static
+void RequestContext::Unregister(int sequence_number) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  RequestContextMap::iterator it =
+      outstanding_requests_.Get().find(sequence_number);
+  if (it == outstanding_requests_.Get().end())
+    return;
+
+  RequestContext* request = it->second;
+  DCHECK(sequence_number == request->sequence_number_);
+  int process_group_count = request->process_group_count_;
+  int unresponsive_processes = request->processes_pending_;
+
+  delete it->second;
+  outstanding_requests_.Get().erase(it);
+
+  UMA_HISTOGRAM_COUNTS("Profiling.ProcessGroupCount",
+                       process_group_count);
+  UMA_HISTOGRAM_COUNTS("Profiling.PendingProcessNotResponding",
+                       unresponsive_processes);
+}
+
+// static
+void RequestContext::OnShutdown() {
+  // Just in case we have any pending tasks, clear them out.
+  while (!outstanding_requests_.Get().empty()) {
+    RequestContextMap::iterator it = outstanding_requests_.Get().begin();
+    delete it->second;
+    outstanding_requests_.Get().erase(it);
+  }
+}
 
 }  // namespace chrome_browser_metrics