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

chrome/browser/net/predictor.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/net/predictor.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 #include <sstream>
@@ skipping 138 matching lines @@
           TimeDelta::FromMilliseconds(g_max_queueing_delay_ms)),
       host_resolver_(NULL),
       transport_security_state_(NULL),
       ssl_config_service_(NULL),
       proxy_service_(NULL),
       preconnect_enabled_(preconnect_enabled),
       consecutive_omnibox_preconnect_count_(0),
       next_trim_time_(base::TimeTicks::Now() +
                       TimeDelta::FromHours(kDurationBetweenTrimmingsHours)),
       observer_(NULL) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 Predictor::~Predictor() {
   // TODO(rlp): Add DCHECK for CurrentlyOn(BrowserThread::IO) when the
   // ProfileManagerTest has been updated with a mock profile.
   DCHECK(shutdown_);
 }
 
 // static
 Predictor* Predictor::CreatePredictor(bool preconnect_enabled,
@@ skipping 10 matching lines @@
   registry->RegisterListPref(prefs::kDnsPrefetchingHostReferralList);
 }
 
 // --------------------- Start UI methods. ------------------------------------
 
 void Predictor::InitNetworkPredictor(PrefService* user_prefs,
                                      PrefService* local_state,
                                      IOThread* io_thread,
                                      net::URLRequestContextGetter* getter,
                                      ProfileIOData* profile_io_data) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   user_prefs_ = user_prefs;
   url_request_context_getter_ = getter;
 
   // Gather the list of hostnames to prefetch on startup.
   UrlList urls = GetPredictedUrlListAtStartup(user_prefs, local_state);
 
   base::ListValue* referral_list =
       static_cast<base::ListValue*>(user_prefs->GetList(
           prefs::kDnsPrefetchingHostReferralList)->DeepCopy());
 
   // Now that we have the statistics in memory, wipe them from the Preferences
   // file. They will be serialized back on a clean shutdown. This way we only
   // have to worry about clearing our in-memory state when Clearing Browsing
   // Data.
   user_prefs->ClearPref(prefs::kDnsPrefetchingStartupList);
   user_prefs->ClearPref(prefs::kDnsPrefetchingHostReferralList);
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &Predictor::FinalizeInitializationOnIOThread,
           base::Unretained(this),
           urls, referral_list,
           io_thread, profile_io_data));
 }
 
 void Predictor::AnticipateOmniboxUrl(const GURL& url, bool preconnectable) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!predictor_enabled_)
     return;
   if (!url.is_valid() || !url.has_host())
     return;
   if (!CanPreresolveAndPreconnect())
     return;
 
   std::string host = url.HostNoBrackets();
   bool is_new_host_request = (host != last_omnibox_host_);
   last_omnibox_host_ = host;
@@ skipping 73 matching lines @@
   UrlInfo::ResolutionMotivation motivation(UrlInfo::EARLY_LOAD_MOTIVATED);
   const int kConnectionsNeeded = 1;
   PreconnectUrl(CanonicalizeUrl(url), first_party_for_cookies,
                 motivation, kConnectionsNeeded);
   PredictFrameSubresources(url.GetWithEmptyPath(), first_party_for_cookies);
 }
 
 UrlList Predictor::GetPredictedUrlListAtStartup(
     PrefService* user_prefs,
     PrefService* local_state) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   UrlList urls;
   // Recall list of URLs we learned about during last session.
   // This may catch secondary hostnames, pulled in by the homepages.  It will
   // also catch more of the "primary" home pages, since that was (presumably)
   // rendered first (and will be rendered first this time too).
   const base::ListValue* startup_list =
       user_prefs->GetList(prefs::kDnsPrefetchingStartupList);
 
   if (startup_list) {
     base::ListValue::const_iterator it = startup_list->begin();
@@ skipping 33 matching lines @@
     }
   }
 
   if (urls.empty())
     urls.push_back(GURL("http://www.google.com:80"));
 
   return urls;
 }
 
 void Predictor::set_max_queueing_delay(int max_queueing_delay_ms) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   g_max_queueing_delay_ms = max_queueing_delay_ms;
 }
 
 void Predictor::set_max_parallel_resolves(size_t max_parallel_resolves) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   g_max_parallel_resolves = max_parallel_resolves;
 }
 
 void Predictor::ShutdownOnUIThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&Predictor::Shutdown, base::Unretained(this)));
 }
 
 // ---------------------- End UI methods. -------------------------------------
 
 // --------------------- Start IO methods. ------------------------------------
 
 void Predictor::Shutdown() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!shutdown_);
   shutdown_ = true;
 
   STLDeleteElements(&pending_lookups_);
 }
 
 void Predictor::DiscardAllResults() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Delete anything listed so far in this session that shows in about:dns.
   referrers_.clear();
 
 
   // Try to delete anything in our work queue.
   while (!work_queue_.IsEmpty()) {
     // Emulate processing cycle as though host was not found.
     GURL url = work_queue_.Pop();
     UrlInfo* info = &results_[url];
     DCHECK(info->HasUrl(url));
@@ skipping 20 matching lines @@
   // Put back in the names being worked on.
   for (Results::iterator it = assignees.begin(); assignees.end() != it; ++it) {
     DCHECK(it->second.is_marked_to_delete());
     results_[it->first] = it->second;
   }
 }
 
 // Overloaded Resolve() to take a vector of names.
 void Predictor::ResolveList(const UrlList& urls,
                             UrlInfo::ResolutionMotivation motivation) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   for (UrlList::const_iterator it = urls.begin(); it < urls.end(); ++it) {
     AppendToResolutionQueue(*it, motivation);
   }
 }
 
 // Basic Resolve() takes an invidual name, and adds it
 // to the queue.
 void Predictor::Resolve(const GURL& url,
                         UrlInfo::ResolutionMotivation motivation) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!url.has_host())
     return;
   AppendToResolutionQueue(url, motivation);
 }
 
 void Predictor::LearnFromNavigation(const GURL& referring_url,
                                     const GURL& target_url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!predictor_enabled_ || !CanPreresolveAndPreconnect())
     return;
   DCHECK_EQ(referring_url, Predictor::CanonicalizeUrl(referring_url));
   DCHECK_NE(referring_url, GURL::EmptyGURL());
   DCHECK_EQ(target_url, Predictor::CanonicalizeUrl(target_url));
   DCHECK_NE(target_url, GURL::EmptyGURL());
 
   referrers_[referring_url].SuggestHost(target_url);
   // Possibly do some referrer trimming.
   TrimReferrers();
 }
 
 //-----------------------------------------------------------------------------
 // This section supports the about:dns page.
 
 void Predictor::PredictorGetHtmlInfo(Predictor* predictor,
                                      std::string* output) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   output->append("<html><head><title>About DNS</title>"
                  // We'd like the following no-cache... but it doesn't work.
                  // "<META HTTP-EQUIV=\"Pragma\" CONTENT=\"no-cache\">"
                  "</head><body>");
   if (predictor && predictor->predictor_enabled() &&
       predictor->CanPreresolveAndPreconnect()) {
     predictor->GetHtmlInfo(output);
   } else {
     output->append("DNS pre-resolution and TCP pre-connection is disabled.");
@@ skipping 18 matching lines @@
     std::string reversed_host = JoinString(parts, '.');
 
     // Return the new URL.
     GURL::Replacements url_components;
     url_components.SetHostStr(reversed_host);
     return url.ReplaceComponents(url_components).spec();
   }
 };
 
 void Predictor::GetHtmlReferrerLists(std::string* output) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (referrers_.empty())
     return;
 
   // TODO(jar): Remove any plausible JavaScript from names before displaying.
 
   typedef std::set<GURL, struct RightToLeftStringSorter>
       SortedNames;
   SortedNames sorted_names;
 
   for (Referrers::iterator it = referrers_.begin();
@@ skipping 32 matching lines @@
           static_cast<int>(future_url->second.preconnection_count()),
           static_cast<int>(future_url->second.preresolution_count()),
           static_cast<double>(future_url->second.subresource_use_rate()),
           future_url->first.spec().c_str());
     }
   }
   output->append("</table>");
 }
 
 void Predictor::GetHtmlInfo(std::string* output) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (initial_observer_.get())
     initial_observer_->GetFirstResolutionsHtml(output);
   // Show list of subresource predictions and stats.
   GetHtmlReferrerLists(output);
 
   // Local lists for calling UrlInfo
   UrlInfo::UrlInfoTable name_not_found;
   UrlInfo::UrlInfoTable name_preresolved;
 
   // Get copies of all useful data.
@@ skipping 21 matching lines @@
 #endif  // NDEBUG
 
   // Call for display of each table, along with title.
   UrlInfo::GetHtmlTable(name_preresolved,
       "Preresolution DNS records performed for ", brief, output);
   UrlInfo::GetHtmlTable(name_not_found,
       "Preresolving DNS records revealed non-existence for ", brief, output);
 }
 
 void Predictor::TrimReferrersNow() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Just finish up work if an incremental trim is in progress.
   if (urls_being_trimmed_.empty())
     LoadUrlsForTrimming();
   IncrementalTrimReferrers(true);  // Do everything now.
 }
 
 void Predictor::SerializeReferrers(base::ListValue* referral_list) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   referral_list->Clear();
   referral_list->Append(new base::FundamentalValue(kPredictorReferrerVersion));
   for (Referrers::const_iterator it = referrers_.begin();
        it != referrers_.end(); ++it) {
     // Serialize the list of subresource names.
     base::Value* subresource_list(it->second.Serialize());
 
     // Create a list for each referer.
     base::ListValue* motivator(new base::ListValue);
     motivator->Append(new base::StringValue(it->first.spec()));
     motivator->Append(subresource_list);
 
     referral_list->Append(motivator);
   }
 }
 
 void Predictor::DeserializeReferrers(const base::ListValue& referral_list) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   int format_version = -1;
   if (referral_list.GetSize() > 0 &&
       referral_list.GetInteger(0, &format_version) &&
       format_version == kPredictorReferrerVersion) {
     for (size_t i = 1; i < referral_list.GetSize(); ++i) {
       const base::ListValue* motivator;
       if (!referral_list.GetList(i, &motivator)) {
         NOTREACHED();
         return;
       }
@@ skipping 14 matching lines @@
   }
 }
 
 void Predictor::DeserializeReferrersThenDelete(
     base::ListValue* referral_list) {
   DeserializeReferrers(*referral_list);
   delete referral_list;
 }
 
 void Predictor::DiscardInitialNavigationHistory() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (initial_observer_.get())
     initial_observer_->DiscardInitialNavigationHistory();
 }
 
 void Predictor::FinalizeInitializationOnIOThread(
     const UrlList& startup_urls,
     base::ListValue* referral_list,
     IOThread* io_thread,
     ProfileIOData* profile_io_data) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   profile_io_data_ = profile_io_data;
   initial_observer_.reset(new InitialObserver());
   host_resolver_ = io_thread->globals()->host_resolver.get();
 
   net::URLRequestContext* context =
       url_request_context_getter_->GetURLRequestContext();
   transport_security_state_ = context->transport_security_state();
   ssl_config_service_ = context->ssl_config_service();
   proxy_service_ = context->proxy_service();
@@ skipping 12 matching lines @@
 }
 
 //-----------------------------------------------------------------------------
 // This section intermingles prefetch results with actual browser HTTP
 // network activity.  It supports calculating of the benefit of a prefetch, as
 // well as recording what prefetched hostname resolutions might be potentially
 // helpful during the next chrome-startup.
 //-----------------------------------------------------------------------------
 
 void Predictor::LearnAboutInitialNavigation(const GURL& url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!predictor_enabled_ || NULL == initial_observer_.get() ||
       !CanPreresolveAndPreconnect()) {
     return;
   }
   initial_observer_->Append(url, this);
 }
 
 // This API is only used in the browser process.
 // It is called from an IPC message originating in the renderer.  It currently
 // includes both Page-Scan, and Link-Hover prefetching.
 // TODO(jar): Separate out link-hover prefetching, and page-scan results.
 void Predictor::DnsPrefetchList(const NameList& hostnames) {
   // TODO(jar): Push GURL transport further back into renderer, but this will
   // require a Webkit change in the observer :-/.
   UrlList urls;
   for (NameList::const_iterator it = hostnames.begin();
        it < hostnames.end();
        ++it) {
     urls.push_back(GURL("http://" + *it + ":80"));
   }
 
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DnsPrefetchMotivatedList(urls, UrlInfo::PAGE_SCAN_MOTIVATED);
 }
 
 void Predictor::DnsPrefetchMotivatedList(
     const UrlList& urls,
     UrlInfo::ResolutionMotivation motivation) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!predictor_enabled_)
     return;
@@ skipping 13 matching lines @@
 
 //-----------------------------------------------------------------------------
 // Functions to handle saving of hostnames from one session to the next, to
 // expedite startup times.
 
 static void SaveDnsPrefetchStateForNextStartupAndTrimOnIOThread(
     base::ListValue* startup_list,
     base::ListValue* referral_list,
     base::WaitableEvent* completion,
     Predictor* predictor) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (NULL == predictor) {
     completion->Signal();
     return;
   }
   predictor->SaveDnsPrefetchStateForNextStartupAndTrim(
       startup_list, referral_list, completion);
 }
 
 void Predictor::SaveStateForNextStartupAndTrim() {
@@ skipping 33 matching lines @@
       base::ThreadRestrictions::ScopedAllowWait allow_wait;
       completion.Wait();
     }
   }
 }
 
 void Predictor::SaveDnsPrefetchStateForNextStartupAndTrim(
     base::ListValue* startup_list,
     base::ListValue* referral_list,
     base::WaitableEvent* completion) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (initial_observer_.get())
     initial_observer_->GetInitialDnsResolutionList(startup_list);
 
   // Do at least one trim at shutdown, in case the user wasn't running long
   // enough to do any regular trimming of referrers.
   // TODO(lizeb): Should trimming really be done at each shutdown? This could be
   // a frequent occurrence on Android.
   TrimReferrersNow();
   SerializeReferrers(referral_list);
 
@@ skipping 58 matching lines @@
         FROM_HERE,
         base::Bind(&Predictor::PrepareFrameSubresources,
                    base::Unretained(this), url, first_party_for_cookies));
   }
 }
 
 bool Predictor::CanPrefetchAndPrerender() const {
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     return chrome_browser_net::CanPrefetchAndPrerenderUI(user_prefs_);
   } else {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
     return chrome_browser_net::CanPrefetchAndPrerenderIO(profile_io_data_);
   }
 }
 
 bool Predictor::CanPreresolveAndPreconnect() const {
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     return chrome_browser_net::CanPreresolveAndPreconnectUI(user_prefs_);
   } else {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
     return chrome_browser_net::CanPreresolveAndPreconnectIO(profile_io_data_);
   }
 }
 
 enum SubresourceValue {
   PRECONNECTION,
   PRERESOLUTION,
   TOO_NEW,
   SUBRESOURCE_VALUE_MAX
 };
 
 void Predictor::PrepareFrameSubresources(const GURL& original_url,
                                          const GURL& first_party_for_cookies) {
   // Apply HSTS redirect early so it is taken into account when looking up
   // subresources.
   GURL url = GetHSTSRedirectOnIOThread(original_url);
 
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(url.GetWithEmptyPath(), url);
   Referrers::iterator it = referrers_.find(url);
   if (referrers_.end() == it) {
     // Only when we don't know anything about this url, make 2 connections
     // available.  We could do this completely via learning (by prepopulating
     // the referrer_ list with this expected value), but it would swell the
     // size of the list with all the "Leaf" nodes in the tree (nodes that don't
     // load any subresources).  If we learn about this resource, we will instead
     // provide a more carefully estimated preconnection count.
     if (preconnect_enabled_) {
@@ skipping 32 matching lines @@
       if (queued_info)
         queued_info->SetReferringHostname(url);
     }
     UMA_HISTOGRAM_ENUMERATION("Net.PreconnectSubresourceEval", evalution,
                               SUBRESOURCE_VALUE_MAX);
   }
 }
 
 void Predictor::OnLookupFinished(LookupRequest* request, const GURL& url,
                                  bool found) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   LookupFinished(request, url, found);
   pending_lookups_.erase(request);
   delete request;
 
   StartSomeQueuedResolutions();
 }
 
 void Predictor::LookupFinished(LookupRequest* request, const GURL& url,
                                bool found) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   UrlInfo* info = &results_[url];
   DCHECK(info->HasUrl(url));
   if (info->is_marked_to_delete()) {
     results_.erase(url);
   } else {
     if (found)
       info->SetFoundState();
     else
       info->SetNoSuchNameState();
   }
 }
 
 bool Predictor::WouldLikelyProxyURL(const GURL& url) {
   if (!proxy_service_)
     return false;
 
   net::ProxyInfo info;
   bool synchronous_success = proxy_service_->TryResolveProxySynchronously(
       url, net::LOAD_NORMAL, &info, NULL, net::BoundNetLog());
 
   return synchronous_success && !info.is_direct();
 }
 
 UrlInfo* Predictor::AppendToResolutionQueue(
     const GURL& url,
     UrlInfo::ResolutionMotivation motivation) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(url.has_host());
 
   if (shutdown_)
     return NULL;
 
   UrlInfo* info = &results_[url];
   info->SetUrl(url);  // Initialize or DCHECK.
   // TODO(jar):  I need to discard names that have long since expired.
   // Currently we only add to the domain map :-/
 
@@ skipping 18 matching lines @@
   }
 
   info->SetQueuedState(motivation);
   work_queue_.Push(url, motivation);
 
   StartSomeQueuedResolutions();
   return info;
 }
 
 bool Predictor::CongestionControlPerformed(UrlInfo* info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Note: queue_duration is ONLY valid after we go to assigned state.
   if (info->queue_duration() < max_dns_queue_delay_)
     return false;
   // We need to discard all entries in our queue, as we're keeping them waiting
   // too long.  By doing this, we'll have a chance to quickly service urgent
   // resolutions, and not have a bogged down system.
   while (true) {
     info->RemoveFromQueue();
     if (work_queue_.IsEmpty())
       break;
     info = &results_[work_queue_.Pop()];
     info->SetAssignedState();
   }
   return true;
 }
 
 void Predictor::StartSomeQueuedResolutions() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   while (!work_queue_.IsEmpty() &&
          pending_lookups_.size() < max_concurrent_dns_lookups_) {
     const GURL url(work_queue_.Pop());
     UrlInfo* info = &results_[url];
     DCHECK(info->HasUrl(url));
     info->SetAssignedState();
 
     if (CongestionControlPerformed(info)) {
       DCHECK(work_queue_.IsEmpty());
@@ skipping 20 matching lines @@
       // Completed synchronously (was already cached by HostResolver), or else
       // there was (equivalently) some network error that prevents us from
       // finding the name.  Status net::OK means it was "found."
       LookupFinished(request, url, status == net::OK);
       delete request;
     }
   }
 }
 
 void Predictor::TrimReferrers() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!urls_being_trimmed_.empty())
     return;   // There is incremental trimming in progress already.
 
   // Check to see if it is time to trim yet.
   base::TimeTicks now = base::TimeTicks::Now();
   if (now < next_trim_time_)
     return;
   next_trim_time_ = now + TimeDelta::FromHours(kDurationBetweenTrimmingsHours);
 
   LoadUrlsForTrimming();
@@ skipping 29 matching lines @@
     urls_being_trimmed_.pop_back();
     if (it == referrers_.end())
       continue;  // Defensive code: It got trimmed away already.
     if (!it->second.Trim(kReferrerTrimRatio, kDiscardableExpectedValue))
       referrers_.erase(it);
   }
   PostIncrementalTrimTask();
 }
 
 GURL Predictor::GetHSTSRedirectOnIOThread(const GURL& url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!transport_security_state_)
     return url;
   if (!url.SchemeIs("http"))
     return url;
   if (!transport_security_state_->ShouldUpgradeToSSL(url.host()))
     return url;
 
   url::Replacements<char> replacements;
   const char kNewScheme[] = "https";
@@ skipping 43 matching lines @@
 // Member definitions for InitialObserver class.
 
 Predictor::InitialObserver::InitialObserver() {
 }
 
 Predictor::InitialObserver::~InitialObserver() {
 }
 
 void Predictor::InitialObserver::Append(const GURL& url,
                                         Predictor* predictor) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // TODO(rlp): Do we really need the predictor check here?
   if (NULL == predictor)
     return;
   if (kStartupResolutionCount <= first_navigations_.size())
     return;
 
   DCHECK(url.SchemeIsHTTPOrHTTPS());
   DCHECK_EQ(url, Predictor::CanonicalizeUrl(url));
   if (first_navigations_.find(url) == first_navigations_.end())
     first_navigations_[url] = base::TimeTicks::Now();
 }
 
 void Predictor::InitialObserver::GetInitialDnsResolutionList(
     base::ListValue* startup_list) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(startup_list);
   startup_list->Clear();
   DCHECK_EQ(0u, startup_list->GetSize());
   startup_list->Append(
       new base::FundamentalValue(kPredictorStartupFormatVersion));
   for (FirstNavigations::iterator it = first_navigations_.begin();
        it != first_navigations_.end();
        ++it) {
     DCHECK(it->first == Predictor::CanonicalizeUrl(it->first));
     startup_list->Append(new base::StringValue(it->first.spec()));
   }
 }
 
 void Predictor::InitialObserver::GetFirstResolutionsHtml(
     std::string* output) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   UrlInfo::UrlInfoTable resolution_list;
   {
     for (FirstNavigations::iterator it(first_navigations_.begin());
          it != first_navigations_.end();
          it++) {
       UrlInfo info;
       info.SetUrl(it->first);
       info.set_time(it->second);
       resolution_list.push_back(info);
@@ skipping 41 matching lines @@
 }
 
 void SimplePredictor::ShutdownOnUIThread() {
   SetShutdown(true);
 }
 
 bool SimplePredictor::CanPrefetchAndPrerender() const { return true; }
 bool SimplePredictor::CanPreresolveAndPreconnect() const { return true; }
 
 }  // namespace chrome_browser_net