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

net/base/host_resolver.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 "net/base/host_resolver.h"
 
 #if defined(OS_WIN)
 #include <ws2tcpip.h>
 #include <wspiapi.h>  // Needed for Win2k compat.
 #elif defined(OS_POSIX)
 #include <netdb.h>
 #include <sys/socket.h>
 #endif
 #if defined(OS_LINUX)
 #include <resolv.h>
 #endif
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/worker_pool.h"
 #include "net/base/address_list.h"
+#include "net/base/dns_resolution_observer.h"
 #include "net/base/net_errors.h"
 
 #if defined(OS_LINUX)
 #include "base/singleton.h"
 #include "base/thread_local_storage.h"
 #endif
 
 #if defined(OS_WIN)
 #include "net/base/winsock_init.h"
 #endif
@@ skipping 136 matching lines @@
     return HostResolverProc(mapped_host, out);
   } else {
     return HostResolverProc(host, out);
   }
 }
 
 //-----------------------------------------------------------------------------
 
 class HostResolver::Request {
  public:
-  Request(CompletionCallback* callback, AddressList* addresses, int port)
-      : job_(NULL), callback_(callback), addresses_(addresses), port_(port) {}
+  Request(int id, const RequestInfo& info, CompletionCallback* callback,
+          AddressList* addresses)
+      : id_(id), info_(info), job_(NULL), callback_(callback),
+        addresses_(addresses) {}
 
   // Mark the request as cancelled.
   void Cancel() {
     job_ = NULL;
     callback_ = NULL;
     addresses_ = NULL;
   }
 
   bool was_cancelled() const {
     return callback_ == NULL;
   }
 
   void set_job(Job* job) {
     DCHECK(job != NULL);
     // Identify which job the request is waiting on.
     job_ = job;
   }
 
   void OnComplete(int error, const AddressList& addrlist) {
     if (error == OK)
-      addresses_->SetFrom(addrlist, port_);
+      addresses_->SetFrom(addrlist, port());
     callback_->Run(error);
   }
 
   int port() const {
-    return port_;
+    return info_.port();
   }
 
   Job* job() const {
     return job_;
   }
 
+  int id() const {
+    return id_;
+  }
+
+  const RequestInfo& info() const {
+    return info_;
+  }
+
  private:
+  // Unique ID for this request. Used by observers to identify requests.
+  int id_;
+
+  // The request info that started the request.
+  RequestInfo info_;
+
   // The resolve job (running in worker pool) that this request is dependent on.
   Job* job_;
 
   // The user's callback to invoke when the request completes.
   CompletionCallback* callback_;
 
   // The address list to save result into.
   AddressList* addresses_;
 
-  // The desired port number for the socket addresses.
-  int port_;
-
   DISALLOW_COPY_AND_ASSIGN(Request);
 };
 
 //-----------------------------------------------------------------------------
 
 // This class represents a request to the worker pool for a "getaddrinfo()"
 // call.
 class HostResolver::Job : public base::RefCountedThreadSafe<HostResolver::Job> {
  public:
   Job(HostResolver* resolver, const std::string& host)
@@ skipping 124 matching lines @@
   // Assigned on the worker thread, read on the origin thread.
   int error_;
   struct addrinfo* results_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 //-----------------------------------------------------------------------------
 
 HostResolver::HostResolver(int max_cache_entries, int cache_duration_ms)
-    : cache_(max_cache_entries, cache_duration_ms) {
+    : cache_(max_cache_entries, cache_duration_ms), next_request_id_(0) {
 #if defined(OS_WIN)
   EnsureWinsockInit();
 #endif
 }
 
 HostResolver::~HostResolver() {
   // Cancel the outstanding jobs. Those jobs may contain several attached
   // requests, which will now never be completed.
   for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ++it)
     it->second->Cancel();
 
   // In case we are being deleted during the processing of a callback.
   if (cur_completing_job_)
     cur_completing_job_->Cancel();
 }
 
 // TODO(eroman): Don't create cache entries for hostnames which are simply IP
 // address literals.
-int HostResolver::Resolve(const std::string& hostname, int port,
+int HostResolver::Resolve(const RequestInfo& info,
                           AddressList* addresses,
                           CompletionCallback* callback,
                           Request** out_req) {
+  // Choose a unique ID number for observers to see.
+  int request_id = next_request_id_++;
+
+  // Notify registered observers.
+  NotifyObserversStartRequest(request_id, info);
+
   // If we have an unexpired cache entry, use it.
-  const HostCache::Entry* cache_entry = cache_.Lookup(
-      hostname, base::TimeTicks::Now());
-  if (cache_entry) {
-    addresses->SetFrom(cache_entry->addrlist, port);
-    return OK;
+  if (info.allow_cached_response()) {
+    const HostCache::Entry* cache_entry = cache_.Lookup(
+        info.hostname(), base::TimeTicks::Now());
+    if (cache_entry) {
+      addresses->SetFrom(cache_entry->addrlist, info.port());
+      return OK;
+    }
   }
 
   // If no callback was specified, do a synchronous resolution.
   if (!callback) {
     struct addrinfo* results;
-    int error = ResolveAddrInfo(host_mapper, hostname, &results);
+    int error = ResolveAddrInfo(host_mapper, info.hostname(), &results);
 
     // Adopt the address list.
     AddressList addrlist;
     if (error == OK) {
       addrlist.Adopt(results);
-      addrlist.SetPort(port);
+      addrlist.SetPort(info.port());
       *addresses = addrlist;
     }
 
     // Write to cache.
-    cache_.Set(hostname, error, addrlist, base::TimeTicks::Now());
+    cache_.Set(info.hostname(), error, addrlist, base::TimeTicks::Now());
+
+    // Notify registered observers.
+    NotifyObserversFinishRequest(request_id, info, error);
 
     return error;
   }
 
   // Create a handle for this request, and pass it back to the user if they
   // asked for it (out_req != NULL).
-  Request* req = new Request(callback, addresses, port);
+  Request* req = new Request(request_id, info, callback, addresses);
   if (out_req)
     *out_req = req;
 
   // Next we need to attach our request to a "job". This job is responsible for
   // calling "getaddrinfo(hostname)" on a worker thread.
   scoped_refptr<Job> job;
 
-  // If there is already an outstanding job to resolve |hostname|, use it.
-  // This prevents starting concurrent resolves for the same hostname.
-  job = FindOutstandingJob(hostname);
+  // If there is already an outstanding job to resolve |info.hostname()|, use
+  // it. This prevents starting concurrent resolves for the same hostname.
+  job = FindOutstandingJob(info.hostname());
   if (job) {
     job->AddRequest(req);
   } else {
     // Create a new job for this request.
-    job = new Job(this, hostname);
+    job = new Job(this, info.hostname());
     job->AddRequest(req);
     AddOutstandingJob(job);
     // TODO(eroman): Bound the total number of concurrent jobs.
     // http://crbug.com/9598
     job->Start();
   }
 
   // Completion happens during OnJobComplete(Job*).
   return ERR_IO_PENDING;
 }
 
 // See OnJobComplete(Job*) for why it is important not to clean out
 // cancelled requests from Job::requests_.
 void HostResolver::CancelRequest(Request* req) {
   DCHECK(req);
   DCHECK(req->job());
   // NULL out the fields of req, to mark it as cancelled.
   req->Cancel();
 }
 
+void HostResolver::AddObserver(DnsResolutionObserver* observer) {
+  observers_.push_back(observer);
+}
+
+void HostResolver::RemoveObserver(DnsResolutionObserver* observer) {
+  ObserversList::iterator it =
+      std::find(observers_.begin(), observers_.end(), observer);
+
+  // Observer must exist.
+  DCHECK(it != observers_.end());
+
+  observers_.erase(it);
+}
+
 void HostResolver::AddOutstandingJob(Job* job) {
   scoped_refptr<Job>& found_job = jobs_[job->host()];
   DCHECK(!found_job);
   found_job = job;
 }
 
 HostResolver::Job* HostResolver::FindOutstandingJob(
     const std::string& hostname) {
   JobMap::iterator it = jobs_.find(hostname);
   if (it != jobs_.end())
@@ skipping 20 matching lines @@
   // HostResolver is deleted by a callback invocation.
   DCHECK(!cur_completing_job_);
   cur_completing_job_ = job;
 
   // Complete all of the requests that were attached to the job.
   for (RequestsList::const_iterator it = job->requests().begin();
        it != job->requests().end(); ++it) {
     Request* req = *it;
     if (!req->was_cancelled()) {
       DCHECK_EQ(job, req->job());
+
+      // Notify registered observers.
+      NotifyObserversFinishRequest(req->id(), req->info(), error);
+
       req->OnComplete(error, addrlist);
 
       // Check if the job was cancelled as a result of running the callback.
       // (Meaning that |this| was deleted).
       if (job->was_cancelled())
         return;
     }
   }
 
   cur_completing_job_ = NULL;
 }
 
+void HostResolver::NotifyObserversStartRequest(int request_id,
+                                               const RequestInfo& info) {
+  for (ObserversList::iterator it = observers_.begin();
+       it != observers_.end(); ++it) {
+    (*it)->OnStartResolution(request_id, info);
+  }
+}
+
+void HostResolver::NotifyObserversFinishRequest(int request_id,
+                                                const RequestInfo& info,
+                                                int error) {
+  bool was_resolved = error == OK;
+  for (ObserversList::iterator it = observers_.begin();
+       it != observers_.end(); ++it) {
+    (*it)->OnFinishResolutionWithStatus(request_id, was_resolved, info);
+  }
+}
+
 //-----------------------------------------------------------------------------
 
 SingleRequestHostResolver::SingleRequestHostResolver(HostResolver* resolver)
     : resolver_(resolver),
       cur_request_(NULL),
       cur_request_callback_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           callback_(this, &SingleRequestHostResolver::OnResolveCompletion)) {
   DCHECK(resolver_ != NULL);
 }
 
 SingleRequestHostResolver::~SingleRequestHostResolver() {
   if (cur_request_) {
     resolver_->CancelRequest(cur_request_);
   }
 }
 
-int SingleRequestHostResolver::Resolve(
-    const std::string& hostname, int port,
-    AddressList* addresses,
-    CompletionCallback* callback) {
+int SingleRequestHostResolver::Resolve(const HostResolver::RequestInfo& info,
+                                       AddressList* addresses,
+                                       CompletionCallback* callback) {
   DCHECK(!cur_request_ && !cur_request_callback_) << "resolver already in use";
 
   HostResolver::Request* request = NULL;
 
   // We need to be notified of completion before |callback| is called, so that
   // we can clear out |cur_request_*|.
   CompletionCallback* transient_callback = callback ? &callback_ : NULL;
 
-  int rv = resolver_->Resolve(
-      hostname, port, addresses, transient_callback, &request);
+  int rv = resolver_->Resolve(info, addresses, transient_callback, &request);
 
   if (rv == ERR_IO_PENDING) {
     // Cleared in OnResolveCompletion().
     cur_request_ = request;
     cur_request_callback_ = callback;
   }
 
   return rv;
 }
 
 void SingleRequestHostResolver::OnResolveCompletion(int result) {
   DCHECK(cur_request_ && cur_request_callback_);
 
   CompletionCallback* callback = cur_request_callback_;
 
   // Clear the outstanding request information.
   cur_request_ = NULL;
   cur_request_callback_ = NULL;
 
   // Call the user's original callback.
   callback->Run(result);
 }
 
 }  // namespace net