Third patch in getting rid of caching MessageLoop pointers and always using C...

chrome/browser/net/dns_master.cc

 // Copyright (c) 2006-2008 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/dns_master.h"
 
 #include <algorithm>
 #include <set>
 #include <sstream>
 
 #include "base/compiler_specific.h"
 #include "base/histogram.h"
-#include "base/message_loop.h"
 #include "base/lock.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "base/time.h"
+#include "chrome/browser/chrome_thread.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/host_resolver.h"
 #include "net/base/net_errors.h"
 
 using base::TimeDelta;
 
 namespace chrome_browser_net {
 
 class DnsMaster::LookupRequest {
@@ skipping 35 matching lines @@
   DnsMaster* master_;  // Master which started us.
 
   const std::string hostname_;  // Hostname to resolve.
   net::SingleRequestHostResolver resolver_;
   net::AddressList addresses_;
 
   DISALLOW_COPY_AND_ASSIGN(LookupRequest);
 };
 
 DnsMaster::DnsMaster(net::HostResolver* host_resolver,
-                     MessageLoop* host_resolver_loop,
                      TimeDelta max_queue_delay,
                      size_t max_concurrent)
   : peak_pending_lookups_(0),
     shutdown_(false),
     max_concurrent_lookups_(max_concurrent),
     max_queue_delay_(max_queue_delay),
-    host_resolver_(host_resolver),
-    host_resolver_loop_(host_resolver_loop) {
+    host_resolver_(host_resolver) {
 }
 
 DnsMaster::~DnsMaster() {
   DCHECK(shutdown_);
 }
 
 void DnsMaster::Shutdown() {
   AutoLock auto_lock(lock_);
 
   DCHECK(!shutdown_);
   shutdown_ = true;
 
   std::set<LookupRequest*>::iterator it;
   for (it = pending_lookups_.begin(); it != pending_lookups_.end(); ++it)
     delete *it;
 }
 
 // Overloaded Resolve() to take a vector of names.
 void DnsMaster::ResolveList(const NameList& hostnames,
                             DnsHostInfo::ResolutionMotivation motivation) {
   AutoLock auto_lock(lock_);
 
-  // We need to run this on |host_resolver_loop_| since we may access
+  // We need to run this on the IO thread since we may access
   // |host_resolver_| which is not thread safe.
-  if (MessageLoop::current() != host_resolver_loop_) {
-    host_resolver_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &DnsMaster::ResolveList, hostnames, motivation));
+  if (!ChromeThread::CurrentlyOn(ChromeThread::IO)) {
+    ChromeThread::PostTask(
+        ChromeThread::IO, FROM_HERE,
+        NewRunnableMethod(
+            this, &DnsMaster::ResolveList, hostnames, motivation));
     return;
   }
 
   NameList::const_iterator it;
   for (it = hostnames.begin(); it < hostnames.end(); ++it)
     PreLockedResolve(*it, motivation);
 }
 
 // Basic Resolve() takes an invidual name, and adds it
 // to the queue.
 void DnsMaster::Resolve(const std::string& hostname,
                         DnsHostInfo::ResolutionMotivation motivation) {
   if (0 == hostname.length())
     return;
   AutoLock auto_lock(lock_);
 
-  // We need to run this on |host_resolver_loop_| since we may access
+  // We need to run this on the IO thread since we may access
   // |host_resolver_| which is not thread safe.
-  if (MessageLoop::current() != host_resolver_loop_) {
-    host_resolver_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &DnsMaster::Resolve, hostname, motivation));
+  if (!ChromeThread::CurrentlyOn(ChromeThread::IO)) {
+    ChromeThread::PostTask(
+        ChromeThread::IO, FROM_HERE,
+        NewRunnableMethod(this, &DnsMaster::Resolve, hostname, motivation));
     return;
   }
 
   PreLockedResolve(hostname, motivation);
 }
 
 bool DnsMaster::AccruePrefetchBenefits(const GURL& referrer,
                                       DnsHostInfo* navigation_info) {
   std::string hostname = navigation_info->hostname();
 
@@ skipping 58 matching lines @@
   std::string referring_host = referrer.host();
   if (referring_host.empty() || referring_host == navigation_info->hostname())
     return;
 
   referrers_[referring_host].SuggestHost(navigation_info->hostname());
 }
 
 void DnsMaster::NavigatingTo(const std::string& host_name) {
   AutoLock auto_lock(lock_);
 
-  // We need to run this on |host_resolver_loop_| since we may access
+  // We need to run this on the IO thread since we may access
   // |host_resolver_| which is not thread safe.
-  if (MessageLoop::current() != host_resolver_loop_) {
-    host_resolver_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &DnsMaster::NavigatingTo, host_name));
+  if (!ChromeThread::CurrentlyOn(ChromeThread::IO)) {
+    ChromeThread::PostTask(
+        ChromeThread::IO, FROM_HERE,
+        NewRunnableMethod(this, &DnsMaster::NavigatingTo, host_name));
     return;
   }
 
   Referrers::iterator it = referrers_.find(host_name);
   if (referrers_.end() == it)
     return;
   Referrer* referrer = &(it->second);
   for (Referrer::iterator future_host = referrer->begin();
        future_host != referrer->end(); ++future_host) {
     DnsHostInfo* queued_info = PreLockedResolve(
@@ skipping 184 matching lines @@
     return NULL;
   }
 
   info->SetQueuedState(motivation);
   work_queue_.Push(hostname, motivation);
   PreLockedScheduleLookups();
   return info;
 }
 
 void DnsMaster::PreLockedScheduleLookups() {
-  // We need to run this on |host_resolver_loop_| since we may access
-  // |host_resolver_| which is not thread safe.
-  DCHECK_EQ(MessageLoop::current(), host_resolver_loop_);
+  // We need to run this on the IO thread since we may access |host_resolver_|
+  // which is not thread safe.
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   while (!work_queue_.IsEmpty() &&
          pending_lookups_.size() < max_concurrent_lookups_) {
     const std::string hostname(work_queue_.Pop());
     DnsHostInfo* info = &results_[hostname];
     DCHECK(info->HasHostname(hostname));
     info->SetAssignedState();
 
     if (PreLockedCongestionControlPerformed(info)) {
       DCHECK(work_queue_.IsEmpty());
@@ skipping 29 matching lines @@
     if (work_queue_.IsEmpty())
       break;
     info = &results_[work_queue_.Pop()];
     info->SetAssignedState();
   }
   return true;
 }
 
 void DnsMaster::OnLookupFinished(LookupRequest* request,
                                  const std::string& hostname, bool found) {
-  DCHECK_EQ(MessageLoop::current(), host_resolver_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   AutoLock auto_lock(lock_);  // For map access (changing info values).
   PrelockedLookupFinished(request, hostname, found);
   pending_lookups_.erase(request);
   delete request;
 
   PreLockedScheduleLookups();
 }
 
 void DnsMaster::PrelockedLookupFinished(LookupRequest* request,
@@ skipping 132 matching lines @@
     std::string hostname(rush_queue_.front());
     rush_queue_.pop();
     return hostname;
   }
   std::string hostname(background_queue_.front());
   background_queue_.pop();
   return hostname;
 }
 
 }  // namespace chrome_browser_net