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

chrome/browser/safe_browsing/client_side_detection_service.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/safe_browsing/client_side_detection_service.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 101 matching lines @@
                                  client_phishing_reports_.end());
   client_phishing_reports_.clear();
   STLDeleteContainerPairPointers(client_malware_reports_.begin(),
                                  client_malware_reports_.end());
   client_malware_reports_.clear();
 }
 
 // static
 ClientSideDetectionService* ClientSideDetectionService::Create(
     net::URLRequestContextGetter* request_context_getter) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return new ClientSideDetectionService(request_context_getter);
 }
 
 void ClientSideDetectionService::SetEnabledAndRefreshState(bool enabled) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SendModelToRenderers();  // always refresh the renderer state
   if (enabled == enabled_)
     return;
   enabled_ = enabled;
   if (enabled_) {
     // Refresh the model when the service is enabled.  This can happen when the
     // preference is toggled, or early during startup if the preference is
     // already enabled. In a lot of cases the model will be in the cache so it
     // won't actually be fetched from the network.
     // We delay the first model fetch to avoid slowing down browser startup.
@@ skipping 22 matching lines @@
     STLDeleteContainerPairPointers(client_malware_reports_.begin(),
                                    client_malware_reports_.end());
     client_malware_reports_.clear();
     cache_.clear();
   }
 }
 
 void ClientSideDetectionService::SendClientReportPhishingRequest(
     ClientPhishingRequest* verdict,
     const ClientReportPhishingRequestCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&ClientSideDetectionService::StartClientReportPhishingRequest,
                  weak_factory_.GetWeakPtr(), verdict, callback));
 }
 
 void ClientSideDetectionService::SendClientReportMalwareRequest(
     ClientMalwareRequest* verdict,
     const ClientReportMalwareRequestCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&ClientSideDetectionService::StartClientReportMalwareRequest,
                  weak_factory_.GetWeakPtr(), verdict, callback));
 }
 
 bool ClientSideDetectionService::IsPrivateIPAddress(
     const std::string& ip_address) const {
   net::IPAddressNumber ip_number;
   if (!net::ParseIPLiteralToNumber(ip_address, &ip_number)) {
@@ skipping 25 matching lines @@
         source->GetResponseCode(), source->GetCookies(), data);
   } else {
     NOTREACHED();
   }
 }
 
 void ClientSideDetectionService::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(type == content::NOTIFICATION_RENDERER_PROCESS_CREATED);
   if (!model_.get()) {
     // Model might not be ready or maybe there was an error.
     return;
   }
   SendModelToProcess(
       content::Source<content::RenderProcessHost>(source).ptr());
 }
 
 void ClientSideDetectionService::SendModelToProcess(
@@ skipping 64 matching lines @@
   }
   model_max_age_.reset();
 
   // Schedule the next model reload.
   ScheduleFetchModel(delay_ms);
 }
 
 void ClientSideDetectionService::StartClientReportPhishingRequest(
     ClientPhishingRequest* verdict,
     const ClientReportPhishingRequestCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_ptr<ClientPhishingRequest> request(verdict);
 
   if (!enabled_) {
     if (!callback.is_null())
       callback.Run(GURL(request->url()), false);
     return;
   }
 
   std::string request_data;
   if (!request->SerializeToString(&request_data)) {
@@ skipping 20 matching lines @@
   fetcher->SetUploadData("application/octet-stream", request_data);
   fetcher->Start();
 
   // Record that we made a request
   phishing_report_times_.push(base::Time::Now());
 }
 
 void ClientSideDetectionService::StartClientReportMalwareRequest(
     ClientMalwareRequest* verdict,
     const ClientReportMalwareRequestCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_ptr<ClientMalwareRequest> request(verdict);
 
   if (!enabled_) {
     if (!callback.is_null())
       callback.Run(GURL(request->url()), GURL(request->url()), false);
     return;
   }
 
   std::string request_data;
   if (!request->SerializeToString(&request_data)) {
@@ skipping 272 matching lines @@
 GURL ClientSideDetectionService::GetClientReportUrl(
     const std::string& report_url) {
   GURL url(report_url);
   std::string api_key = google_apis::GetAPIKey();
   if (!api_key.empty())
     url = url.Resolve("?key=" + net::EscapeQueryParamValue(api_key, true));
 
   return url;
 }
 }  // namespace safe_browsing