Histograms - Support histograms for Plugins, GPU

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"
@@ skipping 68 matching lines @@
   // 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_)
       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<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 = it->second;
     DCHECK_EQ(sequence_number, request->sequence_number_);
     return request;
   }
 
-  // Delete the entry for the given sequence_number| from
+  // 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_EQ(sequence_number, request->sequence_number_);
     bool received_process_group_count = request->received_process_group_count_;
     int unresponsive_processes = request->processes_pending_;
 
     if (request->callback_object_)
       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<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_;
+  static base::LazyInstance<RequestContextMap>::Leaky outstanding_requests_;
 };
 
 // static
-base::LazyInstance<TrackingSynchronizer::RequestContext::RequestContextMap>
-    TrackingSynchronizer::RequestContext::outstanding_requests_ =
-        LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance
+    <TrackingSynchronizer::RequestContext::RequestContextMap>::Leaky
+        TrackingSynchronizer::RequestContext::outstanding_requests_ =
+            LAZY_INSTANCE_INITIALIZER;
 
 // TrackingSynchronizer methods and members.
 
 TrackingSynchronizer::TrackingSynchronizer()
     : last_used_sequence_number_(kNeverUsableSequenceNumber) {
   DCHECK(!g_tracking_synchronizer);
   g_tracking_synchronizer = this;
   content::ProfilerController::GetInstance()->Register(this);
 }
 
@@ skipping 98 matching lines @@
 
   ++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_;
 }
 
 }  // namespace chrome_browser_metrics