[UMA] Use proper C++ objects to serialize tracked_objects across process boundaries.

chrome/browser/metrics/tracking_synchronizer.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.
 
 #include "chrome/browser/metrics/tracking_synchronizer.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
 #include "base/threading/thread.h"
 #include "base/tracked_objects.h"
+#include "chrome/browser/metrics/tracking_synchronizer_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/profiler_controller.h"
-#include "content/public/common/process_type.h"
 
 using base::TimeTicks;
 using content::BrowserThread;
 
+namespace {
+
+// 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.
+const int kNeverUsableSequenceNumber = -2;
+
+// This singleton instance should be started during the single threaded
+// portion of main(). It initializes globals to provide support for all future
+// calls. This object is created on the UI thread, and it is destroyed after
+// all the other threads have gone away. As a result, it is ok to call it
+// from the UI thread, or for about:profiler.
+static chrome_browser_metrics::TrackingSynchronizer* g_tracking_synchronizer =
+    NULL;
+
+}  // anonymous namespace
+
 namespace chrome_browser_metrics {
 
 // The "RequestContext" structure describes an individual request received
 // from the UI. All methods are accessible on UI thread.
-class RequestContext {
+class TrackingSynchronizer::RequestContext {
  public:
   // A map from sequence_number_ to the actual RequestContexts.
   typedef std::map<int, RequestContext*> RequestContextMap;
 
-  ~RequestContext() {}
-
-  RequestContext(const base::WeakPtr<ProfilerUI>& callback_object,
-                 int sequence_number)
+  RequestContext(
+      const base::WeakPtr<TrackingSynchronizerObserver>& callback_object,
+      int sequence_number)
       : callback_object_(callback_object),
         sequence_number_(sequence_number),
         received_process_group_count_(0),
         processes_pending_(0) {
   }
+  ~RequestContext() {}
 
   void SetReceivedProcessGroupCount(bool done) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     received_process_group_count_ = done;
   }
 
   // Methods for book keeping of processes_pending_.
   void IncrementProcessesPending() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     ++processes_pending_;
   }
 
   void AddProcessesPending(int processes_pending) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     processes_pending_ += processes_pending;
   }
 
   void DecrementProcessesPending() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     --processes_pending_;
   }
 
   // Records that we are waiting for one less tracking data from a process for
   // the given sequence number. If |received_process_group_count_| and
   // |processes_pending_| are zero, then delete the current object by calling
   // Unregister.
   void DeleteIfAllDone() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-    if (processes_pending_ <= 0 && received_process_group_count_) {
+    if (processes_pending_ <= 0 && received_process_group_count_)
       RequestContext::Unregister(sequence_number_);
-    }
   }
 
 
   // Register |callback_object| in |outstanding_requests_| map for the given
   // |sequence_number|.
   static RequestContext* Register(
       int sequence_number,
-      const base::WeakPtr<ProfilerUI>& callback_object) {
+      const base::WeakPtr<TrackingSynchronizerObserver>& callback_object) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     RequestContext* request = new RequestContext(
         callback_object, sequence_number);
     outstanding_requests_.Get()[sequence_number] = request;
 
     return request;
   }
 
   // Find the |RequestContext| in |outstanding_requests_| map for the given
   // |sequence_number|.
   static 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_);
+    RequestContext* request = it->second;
+    DCHECK_EQ(sequence_number, request->sequence_number_);
     return request;
   }
 
   // Delete the entry for the given sequence_number| from
   // |outstanding_requests_| map. This method is called when all changes have
   // been acquired, or when the wait time expires (whichever is sooner).
   static void 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_);
+    DCHECK_EQ(sequence_number, request->sequence_number_);
     bool received_process_group_count = request->received_process_group_count_;
     int unresponsive_processes = request->processes_pending_;
 
-    delete it->second;
+    request->callback_object_->FinishedReceivingProfilerData();
+
+    delete request;
     outstanding_requests_.Get().erase(it);
 
     UMA_HISTOGRAM_BOOLEAN("Profiling.ReceivedProcessGroupCount",
                           received_process_group_count);
     UMA_HISTOGRAM_COUNTS("Profiling.PendingProcessNotResponding",
                          unresponsive_processes);
   }
 
 
   // Delete all the entries in |outstanding_requests_| map.
   static void 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);
     }
   }
 
   // Requests are made to asynchronously send data to the |callback_object_|.
-  base::WeakPtr<ProfilerUI> callback_object_;
+  base::WeakPtr<TrackingSynchronizerObserver> callback_object_;
 
   // The sequence number used by the most recent update request to contact all
   // processes.
   int sequence_number_;
 
   // Indicates if we have received all pending processes count.
   bool received_process_group_count_;
 
   // The number of pending processes (browser, all renderer processes and
   // browser child processes) that have not yet responded to requests.
   int processes_pending_;
 
   // Map of all outstanding RequestContexts, from sequence_number_ to
   // RequestContext.
   static base::LazyInstance<RequestContextMap> outstanding_requests_;
 };
 
-// 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;
+// static
+base::LazyInstance<TrackingSynchronizer::RequestContext::RequestContextMap>
+    TrackingSynchronizer::RequestContext::outstanding_requests_ =
+        LAZY_INSTANCE_INITIALIZER;
 
 // TrackingSynchronizer methods and members.
-//
-// static
-TrackingSynchronizer* TrackingSynchronizer::tracking_synchronizer_ = NULL;
 
 TrackingSynchronizer::TrackingSynchronizer()
     : last_used_sequence_number_(kNeverUsableSequenceNumber) {
-  DCHECK(tracking_synchronizer_ == NULL);
-  tracking_synchronizer_ = this;
+  DCHECK(!g_tracking_synchronizer);
+  g_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.
   RequestContext::OnShutdown();
 
-  tracking_synchronizer_ = NULL;
+  g_tracking_synchronizer = NULL;
 }
 
 // static
 void TrackingSynchronizer::FetchProfilerDataAsynchronously(
-    const base::WeakPtr<ProfilerUI>& callback_object) {
+    const base::WeakPtr<TrackingSynchronizerObserver>& callback_object) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  TrackingSynchronizer* current_synchronizer = CurrentSynchronizer();
-  if (current_synchronizer == NULL) {
+  if (!g_tracking_synchronizer) {
     // System teardown is happening.
     return;
   }
 
-  int sequence_number = current_synchronizer->RegisterAndNotifyAllProcesses(
+  int sequence_number = g_tracking_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,
       base::Bind(&RequestContext::Unregister, sequence_number),
       base::TimeDelta::FromMinutes(1));
 }
 
 void TrackingSynchronizer::OnPendingProcesses(int sequence_number,
                                               int pending_processes,
                                               bool end) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   RequestContext* request = RequestContext::GetRequestContext(sequence_number);
   if (!request)
     return;
   request->AddProcessesPending(pending_processes);
   request->SetReceivedProcessGroupCount(end);
   request->DeleteIfAllDone();
 }
 
 void TrackingSynchronizer::OnProfilerDataCollected(
     int sequence_number,
-    base::DictionaryValue* profiler_data) {
+    const tracked_objects::ProcessDataSnapshot& profiler_data,
+    content::ProcessType process_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  RequestContext* request = RequestContext::GetRequestContext(sequence_number);
-  if (!request)
-    return;
-
-  DecrementPendingProcessesAndSendData(sequence_number, profiler_data);
+  DecrementPendingProcessesAndSendData(sequence_number, profiler_data,
+                                       process_type);
 }
 
 int TrackingSynchronizer::RegisterAndNotifyAllProcesses(
-    const base::WeakPtr<ProfilerUI>& callback_object) {
+    const base::WeakPtr<TrackingSynchronizerObserver>& callback_object) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   int sequence_number = GetNextAvailableSequenceNumber();
 
   RequestContext* request =
-    RequestContext::Register(sequence_number, callback_object);
+      RequestContext::Register(sequence_number, callback_object);
 
   // Increment pending process count for sending browser's profiler data.
   request->IncrementProcessesPending();
 
   // Get profiler data from renderer and browser child processes.
   content::ProfilerController::GetInstance()->GetProfilerData(sequence_number);
 
   // Send profiler_data from browser process.
-  base::DictionaryValue* value = tracked_objects::ThreadData::ToValue(false);
-  const std::string process_type =
-      content::GetProcessTypeNameInEnglish(content::PROCESS_TYPE_BROWSER);
-  value->SetString("process_type", process_type);
-  value->SetInteger("process_id", base::GetCurrentProcId());
-  DecrementPendingProcessesAndSendData(sequence_number, value);
+  tracked_objects::ProcessDataSnapshot process_data;
+  tracked_objects::ThreadData::Snapshot(false, &process_data);
+  DecrementPendingProcessesAndSendData(sequence_number, process_data,
+                                       content::PROCESS_TYPE_BROWSER);
 
   return sequence_number;
 }
 
 void TrackingSynchronizer::DecrementPendingProcessesAndSendData(
     int sequence_number,
-    base::DictionaryValue* value) {
+    const tracked_objects::ProcessDataSnapshot& profiler_data,
+    content::ProcessType process_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   RequestContext* request = RequestContext::GetRequestContext(sequence_number);
-  if (!request) {
-    delete value;
+  if (!request)
     return;
-  }
 
-  if (value && request->callback_object_) {
-    // Transfers ownership of |value| to |callback_object_|.
-    request->callback_object_->ReceivedData(value);
-  } else {
-    delete value;
+  if (request->callback_object_) {
+    request->callback_object_->ReceivedProfilerData(profiler_data,
+                                                    process_type);
   }
 
   // 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::CurrentSynchronizer() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(tracking_synchronizer_ != NULL);
-  return tracking_synchronizer_;
-}
-
-// static
-base::LazyInstance<RequestContext::RequestContextMap>
-    RequestContext::outstanding_requests_ = LAZY_INSTANCE_INITIALIZER;
-
 }  // namespace chrome_browser_metrics