favor DCHECK_CURRENTLY_ON for better logs in components/

components/metrics/profiler/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 "components/metrics/profiler/tracking_synchronizer.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/threading/thread.h"
 #include "base/tracked_objects.h"
@@ skipping 36 matching lines @@
       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));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     received_process_group_count_ = done;
   }
 
   // Methods for book keeping of processes_pending_.
   void IncrementProcessesPending() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     ++processes_pending_;
   }
 
   void AddProcessesPending(int processes_pending) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     processes_pending_ += processes_pending;
   }
 
   void DecrementProcessesPending() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(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));
+    DCHECK_CURRENTLY_ON(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));
+    DCHECK_CURRENTLY_ON(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));
+    DCHECK_CURRENTLY_ON(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
   // |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));
+    DCHECK_CURRENTLY_ON(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_;
@@ skipping 59 matching lines @@
 
   // Just in case we have any pending tasks, clear them out.
   RequestContext::OnShutdown();
 
   g_tracking_synchronizer = NULL;
 }
 
 // static
 void TrackingSynchronizer::FetchProfilerDataAsynchronously(
     const base::WeakPtr<TrackingSynchronizerObserver>& callback_object) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!g_tracking_synchronizer) {
     // System teardown is happening.
     return;
   }
 
   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));
+  DCHECK_CURRENTLY_ON(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,
     const tracked_objects::ProcessDataSnapshot& profiler_data,
     int process_type) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DecrementPendingProcessesAndSendData(sequence_number, profiler_data,
                                        process_type);
 }
 
 int TrackingSynchronizer::RegisterAndNotifyAllProcesses(
     const base::WeakPtr<TrackingSynchronizerObserver>& callback_object) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   int sequence_number = GetNextAvailableSequenceNumber();
 
   RequestContext* request =
       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.
   tracked_objects::ProcessDataSnapshot process_data;
   tracked_objects::ThreadData::Snapshot(&process_data);
   DecrementPendingProcessesAndSendData(sequence_number, process_data,
                                        content::PROCESS_TYPE_BROWSER);
 
   return sequence_number;
 }
 
 void TrackingSynchronizer::DecrementPendingProcessesAndSendData(
     int sequence_number,
     const tracked_objects::ProcessDataSnapshot& profiler_data,
     int process_type) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   RequestContext* request = RequestContext::GetRequestContext(sequence_number);
   if (!request)
     return;
 
   if (request->callback_object_.get()) {
     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));
+  DCHECK_CURRENTLY_ON(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_;
 }
 
 }  // namespace metrics