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

chrome/browser/safe_browsing/ui_manager.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/ui_manager.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/debug/leak_tracker.h"
@@ skipping 40 matching lines @@
 SafeBrowsingUIManager::UnsafeResource::~UnsafeResource() { }
 
 SafeBrowsingUIManager::SafeBrowsingUIManager(
     const scoped_refptr<SafeBrowsingService>& service)
     : sb_service_(service) {
 }
 
 SafeBrowsingUIManager::~SafeBrowsingUIManager() { }
 
 void SafeBrowsingUIManager::StopOnIOThread(bool shutdown) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (shutdown)
     sb_service_ = NULL;
 }
 
 void SafeBrowsingUIManager::LogPauseDelay(base::TimeDelta time) {
   UMA_HISTOGRAM_LONG_TIMES("SB2.Delay", time);
 }
 
 // Only report SafeBrowsing related stats when UMA is enabled. User must also
 // ensure that safe browsing is enabled from the calling profile.
 bool SafeBrowsingUIManager::CanReportStats() const {
   const metrics::MetricsService* metrics = g_browser_process->metrics_service();
   return metrics && metrics->reporting_active();
 }
 
 void SafeBrowsingUIManager::OnBlockingPageDone(
     const std::vector<UnsafeResource>& resources,
     bool proceed) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (std::vector<UnsafeResource>::const_iterator iter = resources.begin();
        iter != resources.end(); ++iter) {
     const UnsafeResource& resource = *iter;
     if (!resource.callback.is_null())
       resource.callback.Run(proceed);
 
     if (proceed) {
       BrowserThread::PostTask(
           BrowserThread::UI,
           FROM_HERE,
           base::Bind(&SafeBrowsingUIManager::UpdateWhitelist, this, resource));
     }
   }
 }
 
 void SafeBrowsingUIManager::DisplayBlockingPage(
     const UnsafeResource& resource) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (resource.is_subresource && !resource.is_subframe) {
     // Sites tagged as serving Unwanted Software should only show a warning for
     // main-frame or sub-frame resource. Similar warning restrictions should be
     // applied to malware sites tagged as "landing sites" (see "Types of
     // Malware sites" under
     // https://developers.google.com/safe-browsing/developers_guide_v3#UserWarnings).
     safe_browsing::MalwarePatternType proto;
     if (resource.threat_type == SB_THREAT_TYPE_URL_UNWANTED ||
         (resource.threat_type == SB_THREAT_TYPE_URL_MALWARE &&
          !resource.threat_metadata.empty() &&
@@ skipping 86 matching lines @@
 
 // A safebrowsing hit is sent after a blocking page for malware/phishing
 // or after the warning dialog for download urls, only for UMA users.
 void SafeBrowsingUIManager::ReportSafeBrowsingHit(
     const GURL& malicious_url,
     const GURL& page_url,
     const GURL& referrer_url,
     bool is_subresource,
     SBThreatType threat_type,
     const std::string& post_data) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!CanReportStats())
     return;
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SafeBrowsingUIManager::ReportSafeBrowsingHitOnIOThread, this,
                  malicious_url, page_url, referrer_url, is_subresource,
                  threat_type, post_data));
 }
 
 void SafeBrowsingUIManager::ReportInvalidCertificateChain(
     const std::string& hostname,
     const net::SSLInfo& ssl_info,
     const base::Closure& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
           &SafeBrowsingUIManager::ReportInvalidCertificateChainOnIOThread, this,
           hostname, ssl_info),
       callback);
 }
 
 void SafeBrowsingUIManager::AddObserver(Observer* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observer_list_.AddObserver(observer);
 }
 
 void SafeBrowsingUIManager::RemoveObserver(Observer* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observer_list_.RemoveObserver(observer);
 }
 
 void SafeBrowsingUIManager::ReportSafeBrowsingHitOnIOThread(
     const GURL& malicious_url,
     const GURL& page_url,
     const GURL& referrer_url,
     bool is_subresource,
     SBThreatType threat_type,
     const std::string& post_data) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // The service may delete the ping manager (i.e. when user disabling service,
   // etc). This happens on the IO thread.
   if (sb_service_.get() == NULL || sb_service_->ping_manager() == NULL)
     return;
 
   DVLOG(1) << "ReportSafeBrowsingHit: " << malicious_url << " " << page_url
            << " " << referrer_url << " " << is_subresource << " "
            << threat_type;
   sb_service_->ping_manager()->ReportSafeBrowsingHit(
       malicious_url, page_url,
       referrer_url, is_subresource,
       threat_type, post_data);
 }
 
 void SafeBrowsingUIManager::ReportInvalidCertificateChainOnIOThread(
     const std::string& hostname,
     const net::SSLInfo& ssl_info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // The service may delete the ping manager (i.e. when user disabling service,
   // etc). This happens on the IO thread.
   if (!sb_service_ || !sb_service_->ping_manager())
     return;
 
   sb_service_->ping_manager()->ReportInvalidCertificateChain(hostname,
                                                              ssl_info);
 }
 
 // If the user had opted-in to send MalwareDetails, this gets called
 // when the report is ready.
 void SafeBrowsingUIManager::SendSerializedMalwareDetails(
     const std::string& serialized) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // The service may delete the ping manager (i.e. when user disabling service,
   // etc). This happens on the IO thread.
   if (sb_service_.get() == NULL || sb_service_->ping_manager() == NULL)
     return;
 
   if (!serialized.empty()) {
     DVLOG(1) << "Sending serialized malware details.";
     sb_service_->ping_manager()->ReportMalwareDetails(serialized);
   }
 }
 
 void SafeBrowsingUIManager::UpdateWhitelist(const UnsafeResource& resource) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Whitelist this domain and warning type for the given tab.
   WhiteListedEntry entry;
   entry.render_process_host_id = resource.render_process_host_id;
   entry.render_view_id = resource.render_view_id;
   entry.domain = net::registry_controlled_domains::GetDomainAndRegistry(
       resource.url,
       net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
   entry.threat_type = resource.threat_type;
   white_listed_entries_.push_back(entry);
 }
 
 bool SafeBrowsingUIManager::IsWhitelisted(const UnsafeResource& resource) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Check if the user has already ignored our warning for this render_view
   // and domain.
   for (size_t i = 0; i < white_listed_entries_.size(); ++i) {
     const WhiteListedEntry& entry = white_listed_entries_[i];
     if (entry.render_process_host_id == resource.render_process_host_id &&
         entry.render_view_id == resource.render_view_id &&
         // Threat type must be the same or they can either be client-side
         // phishing/malware URL or a SafeBrowsing phishing/malware URL.
         // If we show one type of phishing/malware warning we don't want to show
         // a second phishing/malware warning.
         (entry.threat_type == resource.threat_type ||
          (entry.threat_type == SB_THREAT_TYPE_URL_PHISHING &&
           resource.threat_type == SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL) ||
          (entry.threat_type == SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL &&
           resource.threat_type == SB_THREAT_TYPE_URL_PHISHING) ||
          (entry.threat_type == SB_THREAT_TYPE_URL_MALWARE &&
           resource.threat_type == SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL) ||
          (entry.threat_type == SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL &&
           resource.threat_type == SB_THREAT_TYPE_URL_MALWARE))) {
       return entry.domain ==
           net::registry_controlled_domains::GetDomainAndRegistry(
               resource.url,
               net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
     }
   }
   return false;
 }