* Move the global "DnsResolutionObserver" code depended on by DNS prefetcher,...

chrome/browser/net/dns_global.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_global.h"
 
 #include <map>
 #include <string>
 
 #include "base/singleton.h"
@@ skipping 115 matching lines @@
 // When we navigate, we may know in advance some other domains that will need to
 // be resolved.  This function initiates those side effects.
 static void NavigatingTo(const std::string& host_name) {
   if (!dns_prefetch_enabled || NULL == dns_master)
     return;
   dns_master->NavigatingTo(host_name);
 }
 
 // The observer class needs to connect starts and finishes of HTTP network
 // resolutions.  We use the following type for that map.
-typedef std::map<void*, DnsHostInfo> ObservedResolutionMap;
+typedef std::map<int, DnsHostInfo> ObservedResolutionMap;
 
 // There will only be one instance ever created of the following Observer
 // class.  As a result, we get away with using static members for data local
 // to that instance (to better comply with a google style guide exemption).
 class PrefetchObserver : public net::DnsResolutionObserver {
  public:
   PrefetchObserver();
   ~PrefetchObserver();
 
-  virtual void OnStartResolution(const std::string& host_name,
-                                 void* context);
-  virtual void OnFinishResolutionWithStatus(bool was_resolved,
-                                            const GURL& referrer,
-                                            void* context);
+  virtual void OnStartResolution(
+      int request_id,
+      const net::HostResolver::RequestInfo& request_info);
+  virtual void OnFinishResolutionWithStatus(
+      int request_id,
+      bool was_resolved,
+      const net::HostResolver::RequestInfo& request_info);
 
   static void DnsGetFirstResolutionsHtml(std::string* output);
   static void SaveStartupListAsPref(PrefService* local_state);
 
  private:
   static void StartupListAppend(const DnsHostInfo& navigation_info);
 
   // We avoid using member variables to better comply with the style guide.
   // We had permission to instantiate only a very minimal class as a global
   // data item, so we avoid putting members in that class.
@@ skipping 21 matching lines @@
 PrefetchObserver::~PrefetchObserver() {
   DCHECK(lock && resolutions && first_resolutions);
   delete first_resolutions;
   first_resolutions = NULL;
   delete resolutions;
   resolutions = NULL;
   delete lock;
   lock = NULL;
 }
 
-void PrefetchObserver::OnStartResolution(const std::string& host_name,
-                                         void* context) {
-  DCHECK_NE(0U, host_name.length());
+void PrefetchObserver::OnStartResolution(
+    int request_id,
+    const net::HostResolver::RequestInfo& request_info) {
+  if (request_info.is_speculative())
+    return;  // One of our own requests.
+  DCHECK_NE(0U, request_info.hostname().length());
   DnsHostInfo navigation_info;
-  navigation_info.SetHostname(host_name);
+  navigation_info.SetHostname(request_info.hostname());
   navigation_info.SetStartedState();
 
-  NavigatingTo(host_name);
+  NavigatingTo(request_info.hostname());
+
+  // TODO(eroman): If the resolve request is cancelled, then
+  // OnFinishResolutionWithStatus will not be called, and |resolutions| will
+  // grow unbounded!
 
   AutoLock auto_lock(*lock);
-  (*resolutions)[context] = navigation_info;
+  (*resolutions)[request_id] = navigation_info;
 }
 
-void PrefetchObserver::OnFinishResolutionWithStatus(bool was_resolved,
-                                                    const GURL& referrer,
-                                                    void* context) {
+void PrefetchObserver::OnFinishResolutionWithStatus(
+    int request_id,
+    bool was_resolved,
+    const net::HostResolver::RequestInfo& request_info) {
+  if (request_info.is_speculative())
+    return;  // One of our own requests.
   DnsHostInfo navigation_info;
   size_t startup_count;
   {
     AutoLock auto_lock(*lock);
-    ObservedResolutionMap::iterator it = resolutions->find(context);
+    ObservedResolutionMap::iterator it = resolutions->find(request_id);
     if (resolutions->end() == it) {
       DCHECK(false);
       return;
     }
     navigation_info = it->second;
     resolutions->erase(it);
     startup_count = first_resolutions->size();
   }
   navigation_info.SetFinishedState(was_resolved);  // Get timing info
-  AccruePrefetchBenefits(referrer, &navigation_info);
+  AccruePrefetchBenefits(request_info.referrer(), &navigation_info);
   if (kStartupResolutionCount <= startup_count || !was_resolved)
     return;
   // TODO(jar): Don't add host to our list if it is a non-linked lookup, and
   // instead rely on Referrers to pull this in automatically with the enclosing
   // page load (once we start to persist elements of our referrer tree).
   StartupListAppend(navigation_info);
 }
 
 // static
 void PrefetchObserver::StartupListAppend(const DnsHostInfo& navigation_info) {
@@ skipping 159 matching lines @@
     Singleton<OffTheRecordObserver>::get()->Register();
 
     if (user_prefs) {
       bool enabled = user_prefs->GetBoolean(prefs::kDnsPrefetchingEnabled);
       EnableDnsPrefetch(enabled);
     }
 
     DLOG(INFO) << "DNS Prefetch service started";
 
     // Start observing real HTTP stack resolutions.
-    net::AddDnsResolutionObserver(&dns_resolution_observer);
+    // TODO(eroman): really this should be called from IO thread (since that is
+    // where the host resolver lives). Since this occurs before requests have
+    // started it is not a race yet.
+    GetGlobalHostResolver()->AddObserver(&dns_resolution_observer);
   }
 }
 
 void EnsureDnsPrefetchShutdown() {
   if (NULL != dns_master)
     dns_master->Shutdown();
   FreeGlobalHostResolver();
 }
 
 void FreeDnsPrefetchResources() {
@@ skipping 102 matching lines @@
   dns_master->DeserializeReferrers(*referral_list);
 }
 
 void TrimSubresourceReferrers() {
   if (NULL == dns_master)
     return;
   dns_master->TrimReferrers();
 }
 
 }  // namespace chrome_browser_net