chrome/browser/metrics/tracking_synchronizer.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/metrics/tracking_synchronizer.h"
   6
   7 #include "base/bind.h"
   8 #include "base/metrics/histogram.h"
   9 #include "base/threading/thread.h"
  10 #include "base/tracked_objects.h"
  11 #include "chrome/browser/metrics/tracking_synchronizer_observer.h"
  12 #include "content/public/browser/browser_thread.h"
  13 #include "content/public/browser/profiler_controller.h"
  14 #include "content/public/common/process_type.h"
  15
  16 using base::TimeTicks;
  17 using content::BrowserThread;
  18
  19 namespace {
  20
  21 // Negative numbers are never used as sequence numbers.  We explicitly pick a
  22 // negative number that is "so negative" that even when we add one (as is done
  23 // when we generated the next sequence number) that it will still be negative.
  24 // We have code that handles wrapping around on an overflow into negative
  25 // territory.
  26 const int kNeverUsableSequenceNumber = -2;
  27
  28 // This singleton instance should be started during the single threaded
  29 // portion of main(). It initializes globals to provide support for all future
  30 // calls. This object is created on the UI thread, and it is destroyed after
  31 // all the other threads have gone away. As a result, it is ok to call it
  32 // from the UI thread, or for about:profiler.
  33 static chrome_browser_metrics::TrackingSynchronizer* g_tracking_synchronizer =
  34     NULL;
  35
  36 }  // anonymous namespace
  37
  38 namespace chrome_browser_metrics {
  39
  40 // The "RequestContext" structure describes an individual request received
  41 // from the UI. All methods are accessible on UI thread.
  42 class TrackingSynchronizer::RequestContext {
  43  public:
  44   // A map from sequence_number_ to the actual RequestContexts.
  45   typedef std::map<int, RequestContext*> RequestContextMap;
  46
  47   RequestContext(
  48       const base::WeakPtr<TrackingSynchronizerObserver>& callback_object,
  49       int sequence_number)
  50       : callback_object_(callback_object),
  51         sequence_number_(sequence_number),
  52         received_process_group_count_(0),
  53         processes_pending_(0) {
  54   }
  55   ~RequestContext() {}
  56
  57   void SetReceivedProcessGroupCount(bool done) {
  58     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  59     received_process_group_count_ = done;
  60   }
  61
  62   // Methods for book keeping of processes_pending_.
  63   void IncrementProcessesPending() {
  64     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  65     ++processes_pending_;
  66   }
  67
  68   void AddProcessesPending(int processes_pending) {
  69     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  70     processes_pending_ += processes_pending;
  71   }
  72
  73   void DecrementProcessesPending() {
  74     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  75     --processes_pending_;
  76   }
  77
  78   // Records that we are waiting for one less tracking data from a process for
  79   // the given sequence number. If |received_process_group_count_| and
  80   // |processes_pending_| are zero, then delete the current object by calling
  81   // Unregister.
  82   void DeleteIfAllDone() {
  83     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  84
  85     if (processes_pending_ <= 0 && received_process_group_count_)
  86       RequestContext::Unregister(sequence_number_);
  87   }
  88
  89   // Register |callback_object| in |outstanding_requests_| map for the given
  90   // |sequence_number|.
  91   static RequestContext* Register(
  92       int sequence_number,
  93       const base::WeakPtr<TrackingSynchronizerObserver>& callback_object) {
  94     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  95
  96     RequestContext* request = new RequestContext(
  97         callback_object, sequence_number);
  98     outstanding_requests_.Get()[sequence_number] = request;
  99
 100     return request;
 101   }
 102
 103   // Find the |RequestContext| in |outstanding_requests_| map for the given
 104   // |sequence_number|.
 105   static RequestContext* GetRequestContext(int sequence_number) {
 106     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 107
 108     RequestContextMap::iterator it =
 109         outstanding_requests_.Get().find(sequence_number);
 110     if (it == outstanding_requests_.Get().end())
 111       return NULL;
 112
 113     RequestContext* request = it->second;
 114     DCHECK_EQ(sequence_number, request->sequence_number_);
 115     return request;
 116   }
 117
 118   // Delete the entry for the given |sequence_number| from
 119   // |outstanding_requests_| map. This method is called when all changes have
 120   // been acquired, or when the wait time expires (whichever is sooner).
 121   static void Unregister(int sequence_number) {
 122     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 123
 124     RequestContextMap::iterator it =
 125         outstanding_requests_.Get().find(sequence_number);
 126     if (it == outstanding_requests_.Get().end())
 127       return;
 128
 129     RequestContext* request = it->second;
 130     DCHECK_EQ(sequence_number, request->sequence_number_);
 131     bool received_process_group_count = request->received_process_group_count_;
 132     int unresponsive_processes = request->processes_pending_;
 133
 134     if (request->callback_object_.get())
 135       request->callback_object_->FinishedReceivingProfilerData();
 136
 137     delete request;
 138     outstanding_requests_.Get().erase(it);
 139
 140     UMA_HISTOGRAM_BOOLEAN("Profiling.ReceivedProcessGroupCount",
 141                           received_process_group_count);
 142     UMA_HISTOGRAM_COUNTS("Profiling.PendingProcessNotResponding",
 143                          unresponsive_processes);
 144   }
 145
 146   // Delete all the entries in |outstanding_requests_| map.
 147   static void OnShutdown() {
 148     // Just in case we have any pending tasks, clear them out.
 149     while (!outstanding_requests_.Get().empty()) {
 150       RequestContextMap::iterator it = outstanding_requests_.Get().begin();
 151       delete it->second;
 152       outstanding_requests_.Get().erase(it);
 153     }
 154   }
 155
 156   // Requests are made to asynchronously send data to the |callback_object_|.
 157   base::WeakPtr<TrackingSynchronizerObserver> callback_object_;
 158
 159   // The sequence number used by the most recent update request to contact all
 160   // processes.
 161   int sequence_number_;
 162
 163   // Indicates if we have received all pending processes count.
 164   bool received_process_group_count_;
 165
 166   // The number of pending processes (browser, all renderer processes and
 167   // browser child processes) that have not yet responded to requests.
 168   int processes_pending_;
 169
 170   // Map of all outstanding RequestContexts, from sequence_number_ to
 171   // RequestContext.
 172   static base::LazyInstance<RequestContextMap>::Leaky outstanding_requests_;
 173 };
 174
 175 // static
 176 base::LazyInstance
 177     <TrackingSynchronizer::RequestContext::RequestContextMap>::Leaky
 178         TrackingSynchronizer::RequestContext::outstanding_requests_ =
 179             LAZY_INSTANCE_INITIALIZER;
 180
 181 // TrackingSynchronizer methods and members.
 182
 183 TrackingSynchronizer::TrackingSynchronizer()
 184     : last_used_sequence_number_(kNeverUsableSequenceNumber) {
 185   DCHECK(!g_tracking_synchronizer);
 186   g_tracking_synchronizer = this;
 187   content::ProfilerController::GetInstance()->Register(this);
 188 }
 189
 190 TrackingSynchronizer::~TrackingSynchronizer() {
 191   content::ProfilerController::GetInstance()->Unregister(this);
 192
 193   // Just in case we have any pending tasks, clear them out.
 194   RequestContext::OnShutdown();
 195
 196   g_tracking_synchronizer = NULL;
 197 }
 198
 199 // static
 200 void TrackingSynchronizer::FetchProfilerDataAsynchronously(
 201     const base::WeakPtr<TrackingSynchronizerObserver>& callback_object) {
 202   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 203
 204   if (!g_tracking_synchronizer) {
 205     // System teardown is happening.
 206     return;
 207   }
 208
 209   int sequence_number = g_tracking_synchronizer->RegisterAndNotifyAllProcesses(
 210       callback_object);
 211
 212   // Post a task that would be called after waiting for wait_time.  This acts
 213   // as a watchdog, to cancel the requests for non-responsive processes.
 214   BrowserThread::PostDelayedTask(
 215       BrowserThread::UI, FROM_HERE,
 216       base::Bind(&RequestContext::Unregister, sequence_number),
 217       base::TimeDelta::FromMinutes(1));
 218 }
 219
 220 void TrackingSynchronizer::OnPendingProcesses(int sequence_number,
 221                                               int pending_processes,
 222                                               bool end) {
 223   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 224
 225   RequestContext* request = RequestContext::GetRequestContext(sequence_number);
 226   if (!request)
 227     return;
 228   request->AddProcessesPending(pending_processes);
 229   request->SetReceivedProcessGroupCount(end);
 230   request->DeleteIfAllDone();
 231 }
 232
 233 void TrackingSynchronizer::OnProfilerDataCollected(
 234     int sequence_number,
 235     const tracked_objects::ProcessDataSnapshot& profiler_data,
 236     int process_type) {
 237   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 238   DecrementPendingProcessesAndSendData(sequence_number, profiler_data,
 239                                        process_type);
 240 }
 241
 242 int TrackingSynchronizer::RegisterAndNotifyAllProcesses(
 243     const base::WeakPtr<TrackingSynchronizerObserver>& callback_object) {
 244   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 245
 246   int sequence_number = GetNextAvailableSequenceNumber();
 247
 248   RequestContext* request =
 249       RequestContext::Register(sequence_number, callback_object);
 250
 251   // Increment pending process count for sending browser's profiler data.
 252   request->IncrementProcessesPending();
 253
 254   // Get profiler data from renderer and browser child processes.
 255   content::ProfilerController::GetInstance()->GetProfilerData(sequence_number);
 256
 257   // Send profiler_data from browser process.
 258   tracked_objects::ProcessDataSnapshot process_data;
 259   tracked_objects::ThreadData::Snapshot(false, &process_data);
 260   DecrementPendingProcessesAndSendData(sequence_number, process_data,
 261                                        content::PROCESS_TYPE_BROWSER);
 262
 263   return sequence_number;
 264 }
 265
 266 void TrackingSynchronizer::DecrementPendingProcessesAndSendData(
 267     int sequence_number,
 268     const tracked_objects::ProcessDataSnapshot& profiler_data,
 269     int process_type) {
 270   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 271
 272   RequestContext* request = RequestContext::GetRequestContext(sequence_number);
 273   if (!request)
 274     return;
 275
 276   if (request->callback_object_.get()) {
 277     request->callback_object_
 278         ->ReceivedProfilerData(profiler_data, process_type);
 279   }
 280
 281   // Delete request if we have heard back from all child processes.
 282   request->DecrementProcessesPending();
 283   request->DeleteIfAllDone();
 284 }
 285
 286 int TrackingSynchronizer::GetNextAvailableSequenceNumber() {
 287   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 288
 289   ++last_used_sequence_number_;
 290
 291   // Watch out for wrapping to a negative number.
 292   if (last_used_sequence_number_ < 0)
 293     last_used_sequence_number_ = 1;
 294   return last_used_sequence_number_;
 295 }
 296
 297 }  // namespace chrome_browser_metrics