[chrome/browser/safe_browsing] favor DCHECK_CURRENTLY_ON for better logs

chrome/browser/safe_browsing/malware_details_cache.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.
 //
 // Implementation of the MalwareDetails class.
 
 #include "chrome/browser/safe_browsing/malware_details.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 38 matching lines @@
   has_started_ = true;
 
   // Post a task in the message loop, so the callers don't need to
   // check if we call their callback immediately.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MalwareDetailsCacheCollector::OpenEntry, this));
 }
 
 bool MalwareDetailsCacheCollector::HasStarted() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return has_started_;
 }
 
 MalwareDetailsCacheCollector::~MalwareDetailsCacheCollector() {}
 
 // Fetch a URL and advance to the next one when done.
 void MalwareDetailsCacheCollector::OpenEntry() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "OpenEntry";
 
   if (resources_it_ == resources_->end()) {
     AllDone(true);
     return;
   }
 
   if (!request_context_getter_.get()) {
     DVLOG(1) << "Missing request context getter";
     AllDone(false);
@@ skipping 15 matching lines @@
   safe_browsing::ResourceMap::iterator it = resources_->find(url.spec());
   if (it != resources_->end()) {
     return it->second.get();
   }
   return NULL;
 }
 
 void MalwareDetailsCacheCollector::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DVLOG(1) << "OnUrlFetchComplete";
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(current_fetch_.get());
   if (source->GetStatus().status() != net::URLRequestStatus::SUCCESS &&
       source->GetStatus().error() == net::ERR_CACHE_MISS) {
     // Cache miss, skip this resource.
     DVLOG(1) << "Cache miss for url: " << source->GetURL();
     AdvanceEntry();
     return;
   }
 
   if (source->GetStatus().status() != net::URLRequestStatus::SUCCESS) {
@@ skipping 18 matching lines @@
   std::string data;
   source->GetResponseAsString(&data);
   ReadData(resource, data);
   AdvanceEntry();
 }
 
 void MalwareDetailsCacheCollector::ReadResponse(
     ClientMalwareReportRequest::Resource* pb_resource,
     const net::URLFetcher* source) {
   DVLOG(1) << "ReadResponse";
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::HttpResponseHeaders* headers = source->GetResponseHeaders();
   if (!headers) {
     DVLOG(1) << "Missing response headers.";
     return;
   }
 
   ClientMalwareReportRequest::HTTPResponse* pb_response =
       pb_resource->mutable_response();
   pb_response->mutable_firstline()->set_code(headers->response_code());
   void* iter = NULL;
@@ skipping 12 matching lines @@
 
   if (!source->WasFetchedViaProxy()) {
     pb_response->set_remote_ip(source->GetSocketAddress().ToString());
   }
 }
 
 void MalwareDetailsCacheCollector::ReadData(
     ClientMalwareReportRequest::Resource* pb_resource,
     const std::string& data) {
   DVLOG(1) << "ReadData";
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ClientMalwareReportRequest::HTTPResponse* pb_response =
       pb_resource->mutable_response();
   if (data.size() <= kMaxBodySizeBytes) {  // Only send small bodies for now.
     pb_response->set_body(data);
   }
   pb_response->set_bodylength(data.size());
   pb_response->set_bodydigest(base::MD5String(data));
 }
 
 void MalwareDetailsCacheCollector::AdvanceEntry() {
   DVLOG(1) << "AdvanceEntry";
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Advance to the next resource.
   ++resources_it_;
   current_fetch_.reset(NULL);
 
   // Create a task so we don't take over the IO thread for too long.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MalwareDetailsCacheCollector::OpenEntry, this));
 }
 
 void MalwareDetailsCacheCollector::AllDone(bool success) {
   DVLOG(1) << "AllDone";
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   *result_ = success;
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, callback_);
   callback_.Reset();
 }