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

chrome/browser/safe_browsing/client_side_detection_host.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_host.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ skipping 59 matching lines @@
       ClientSideDetectionService* csd_service,
       SafeBrowsingDatabaseManager* database_manager,
       ClientSideDetectionHost* host)
       : params_(params),
         web_contents_(web_contents),
         csd_service_(csd_service),
         database_manager_(database_manager),
         host_(host),
         start_phishing_classification_cb_(start_phishing_classification),
         start_malware_classification_cb_(start_malware_classification) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(web_contents_);
     DCHECK(csd_service_);
     DCHECK(database_manager_.get());
     DCHECK(host_);
   }
 
   void Start() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     // We start by doing some simple checks that can run on the UI thread.
     UMA_HISTOGRAM_BOOLEAN("SBClientPhishing.ClassificationStart", 1);
     UMA_HISTOGRAM_BOOLEAN("SBClientMalware.ClassificationStart", 1);
 
     // Only classify [X]HTML documents.
     if (params_.contents_mime_type != "text/html" &&
         params_.contents_mime_type != "application/xhtml+xml") {
       DVLOG(1) << "Skipping phishing classification for URL: " << params_.url
                << " because it has an unsupported MIME type: "
@@ skipping 68 matching lines @@
     NO_CLASSIFY_RESULT_FROM_CACHE,
     NO_CLASSIFY_NOT_HTTP_URL,
 
     NO_CLASSIFY_MAX  // Always add new values before this one.
   };
 
   // The destructor can be called either from the UI or the IO thread.
   virtual ~ShouldClassifyUrlRequest() { }
 
   bool ShouldClassifyForPhishing() const {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     return !start_phishing_classification_cb_.is_null();
   }
 
   bool ShouldClassifyForMalware() const {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     return !start_malware_classification_cb_.is_null();
   }
 
   void DontClassifyForPhishing(PreClassificationCheckFailures reason) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     if (ShouldClassifyForPhishing()) {
       // Track the first reason why we stopped classifying for phishing.
       UMA_HISTOGRAM_ENUMERATION("SBClientPhishing.PreClassificationCheckFail",
                                 reason, NO_CLASSIFY_MAX);
       DVLOG(2) << "Failed phishing pre-classification checks.  Reason: "
                << reason;
       start_phishing_classification_cb_.Run(false);
     }
     start_phishing_classification_cb_.Reset();
   }
 
   void DontClassifyForMalware(PreClassificationCheckFailures reason) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     if (ShouldClassifyForMalware()) {
       // Track the first reason why we stopped classifying for malware.
       UMA_HISTOGRAM_ENUMERATION("SBClientMalware.PreClassificationCheckFail",
                                 reason, NO_CLASSIFY_MAX);
       DVLOG(2) << "Failed malware pre-classification checks.  Reason: "
                << reason;
       start_malware_classification_cb_.Run(false);
     }
     start_malware_classification_cb_.Reset();
   }
 
   void CheckSafeBrowsingDatabase(const GURL& url) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
     // We don't want to call the classification callbacks from the IO
     // thread so we simply pass the results of this method to CheckCache()
     // which is called on the UI thread;
     PreClassificationCheckFailures phishing_reason = NO_CLASSIFY_MAX;
     PreClassificationCheckFailures malware_reason = NO_CLASSIFY_MAX;
     if (!database_manager_.get()) {
       // We cannot check the Safe Browsing whitelists so we stop here
       // for safety.
       malware_reason = phishing_reason = NO_CLASSIFY_NO_DATABASE_MANAGER;
     } else {
@@ skipping 10 matching lines @@
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&ShouldClassifyUrlRequest::CheckCache,
                    this,
                    phishing_reason,
                    malware_reason));
   }
 
   void CheckCache(PreClassificationCheckFailures phishing_reason,
                   PreClassificationCheckFailures malware_reason) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     if (phishing_reason != NO_CLASSIFY_MAX)
       DontClassifyForPhishing(phishing_reason);
     if (malware_reason != NO_CLASSIFY_MAX)
       DontClassifyForMalware(malware_reason);
     if (!ShouldClassifyForMalware() && !ShouldClassifyForPhishing()) {
       return;  // No point in doing anything else.
     }
     // If result is cached, we don't want to run classification again.
     // In that case we're just trying to show the warning.
     bool is_phishing;
@@ skipping 227 matching lines @@
   // Tell any pending classification request that it is being canceled.
   if (classification_request_.get()) {
     classification_request_->Cancel();
   }
   // Cancel all pending feature extractions.
   feature_extractor_.reset();
 }
 
 void ClientSideDetectionHost::OnPhishingPreClassificationDone(
     bool should_classify) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (browse_info_.get() && should_classify) {
     DVLOG(1) << "Instruct renderer to start phishing detection for URL: "
              << browse_info_->url;
     content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
     rvh->Send(new SafeBrowsingMsg_StartPhishingDetection(
         rvh->GetRoutingID(), browse_info_->url));
   }
 }
 
 void ClientSideDetectionHost::OnMalwarePreClassificationDone(
     bool should_classify) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // If classification checks failed we should stop extracting malware features.
   DVLOG(2) << "Malware pre-classification checks done. Should classify: "
            << should_classify;
   should_extract_malware_features_ = should_classify;
   should_classify_for_malware_ = should_classify;
   MaybeStartMalwareFeatureExtraction();
 }
 
 void ClientSideDetectionHost::DidStopLoading() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!csd_service_ || !browse_info_.get())
     return;
   DVLOG(2) << "Page finished loading.";
   pageload_complete_ = true;
   MaybeStartMalwareFeatureExtraction();
 }
 
 void ClientSideDetectionHost::MaybeStartMalwareFeatureExtraction() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (csd_service_ && browse_info_.get() &&
       should_classify_for_malware_ &&
       pageload_complete_) {
     scoped_ptr<ClientMalwareRequest> malware_request(
         new ClientMalwareRequest);
     // Start browser-side malware feature extraction.  Once we're done it will
     // send the malware client verdict request.
     malware_request->set_url(browse_info_->url.spec());
     const GURL& referrer = browse_info_->referrer;
     if (referrer.SchemeIs("http")) {  // Only send http urls.
       malware_request->set_referrer_url(referrer.spec());
     }
     // This function doesn't expect browse_info_ to stay around after this
     // function returns.
     feature_extractor_->ExtractMalwareFeatures(
         browse_info_.get(),
         malware_request.release(),
         base::Bind(&ClientSideDetectionHost::MalwareFeatureExtractionDone,
                    weak_factory_.GetWeakPtr()));
     should_classify_for_malware_ = false;
   }
 }
 
 void ClientSideDetectionHost::OnPhishingDetectionDone(
     const std::string& verdict_str) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // There is something seriously wrong if there is no service class but
   // this method is called.  The renderer should not start phishing detection
   // if there isn't any service class in the browser.
   DCHECK(csd_service_);
   DCHECK(browse_info_.get());
 
   // We parse the protocol buffer here.  If we're unable to parse it we won't
   // send the verdict further.
   scoped_ptr<ClientPhishingRequest> verdict(new ClientPhishingRequest);
   if (csd_service_ &&
@@ skipping 14 matching lines @@
           browse_info_.get(),
           verdict.release(),
           base::Bind(&ClientSideDetectionHost::FeatureExtractionDone,
                      weak_factory_.GetWeakPtr()));
     }
   }
 }
 
 void ClientSideDetectionHost::MaybeShowPhishingWarning(GURL phishing_url,
                                                        bool is_phishing) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(2) << "Received server phishing verdict for URL:" << phishing_url
            << " is_phishing:" << is_phishing;
   if (is_phishing) {
     DCHECK(web_contents());
     if (ui_manager_.get()) {
       SafeBrowsingUIManager::UnsafeResource resource;
       resource.url = phishing_url;
       resource.original_url = phishing_url;
       resource.is_subresource = false;
       resource.threat_type = SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL;
@@ skipping 10 matching lines @@
     }
     // If there is true phishing verdict, invalidate weakptr so that no longer
     // consider the malware vedict.
     weak_factory_.InvalidateWeakPtrs();
   }
 }
 
 void ClientSideDetectionHost::MaybeShowMalwareWarning(GURL original_url,
                                                       GURL malware_url,
                                                       bool is_malware) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(2) << "Received server malawre IP verdict for URL:" << malware_url
            << " is_malware:" << is_malware;
   if (is_malware && malware_url.is_valid() && original_url.is_valid()) {
     DCHECK(web_contents());
     if (ui_manager_.get()) {
       SafeBrowsingUIManager::UnsafeResource resource;
       resource.url = malware_url;
       resource.original_url = original_url;
       resource.is_subresource = (malware_url.host() != original_url.host());
       resource.threat_type = SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL;
@@ skipping 67 matching lines @@
     }
   } else if (it->second.size() < kMaxUrlsPerIP) {
     it->second.push_back(IPUrlInfo(url, method, referrer, resource_type));
   }
 }
 
 void ClientSideDetectionHost::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(type, content::NOTIFICATION_RESOURCE_RESPONSE_STARTED);
   const ResourceRequestDetails* req = content::Details<ResourceRequestDetails>(
       details).ptr();
   if (req && browse_info_.get() &&
       should_extract_malware_features_ && req->url.is_valid()) {
     UpdateIPUrlMap(req->socket_address.host() /* ip */,
                    req->url.spec()  /* url */,
                    req->method,
                    req->referrer,
                    req->resource_type);
@@ skipping 21 matching lines @@
     ui_manager_->RemoveObserver(this);
 
   ui_manager_ = ui_manager;
   if (ui_manager)
     ui_manager_->AddObserver(this);
 
   database_manager_ = database_manager;
 }
 
 }  // namespace safe_browsing