favor DCHECK_CURRENTLY_ON for better logs in content/browser/[f-p]*

content/browser/histogram_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 "content/browser/histogram_synchronizer.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
@@ skipping 32 matching lines @@
 
   RequestContext(const base::Closure& callback, int sequence_number)
       : callback_(callback),
         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 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 histogram 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| in |outstanding_requests_| map for the given
   // |sequence_number|.
   static void Register(const base::Closure& callback, int sequence_number) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     RequestContext* request = new RequestContext(callback, sequence_number);
     outstanding_requests_.Get()[sequence_number] = 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 65 matching lines @@
 }
 
 // static
 void HistogramSynchronizer::FetchHistograms() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&HistogramSynchronizer::FetchHistograms));
     return;
   }
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   HistogramSynchronizer* current_synchronizer =
       HistogramSynchronizer::GetInstance();
   if (current_synchronizer == NULL)
     return;
 
   current_synchronizer->RegisterAndNotifyAllProcesses(
       HistogramSynchronizer::UNKNOWN,
       base::TimeDelta::FromMinutes(1));
 }
@@ skipping 18 matching lines @@
   current_synchronizer->SetCallbackTaskAndThread(
       callback_thread, callback);
 
   current_synchronizer->RegisterAndNotifyAllProcesses(
       HistogramSynchronizer::ASYNC_HISTOGRAMS, wait_time);
 }
 
 void HistogramSynchronizer::RegisterAndNotifyAllProcesses(
     ProcessHistogramRequester requester,
     base::TimeDelta wait_time) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   int sequence_number = GetNextAvailableSequenceNumber(requester);
 
   base::Closure callback = base::Bind(
       &HistogramSynchronizer::ForceHistogramSynchronizationDoneCallback,
       base::Unretained(this),
       sequence_number);
 
   RequestContext::Register(callback, sequence_number);
 
   // Get histogram data from renderer and browser child processes.
   HistogramController::GetInstance()->GetHistogramData(sequence_number);
 
   // 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),
       wait_time);
 }
 
 void HistogramSynchronizer::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 HistogramSynchronizer::OnHistogramDataCollected(
     int sequence_number,
     const std::vector<std::string>& pickled_histograms) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   base::HistogramDeltaSerialization::DeserializeAndAddSamples(
       pickled_histograms);
 
   RequestContext* request = RequestContext::GetRequestContext(sequence_number);
   if (!request)
     return;
 
   // Delete request if we have heard back from all child processes.
   request->DecrementProcessesPending();
@@ skipping 53 matching lines @@
         kHistogramSynchronizerReservedSequenceNumber + 1;
   }
   DCHECK_NE(last_used_sequence_number_,
             kHistogramSynchronizerReservedSequenceNumber);
   if (requester == ASYNC_HISTOGRAMS)
     async_sequence_number_ = last_used_sequence_number_;
   return last_used_sequence_number_;
 }
 
 }  // namespace content