[Refactor] Rename DnsResolutionObserver --> HostResolver::Observer....

net/base/host_resolver.h

 // 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.
 
 #ifndef NET_BASE_HOST_RESOLVER_H_
 #define NET_BASE_HOST_RESOLVER_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/lock.h"
 #include "base/ref_counted.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/completion_callback.h"
 #include "net/base/host_cache.h"
 
 class MessageLoop;
 
 namespace net {
 
 class AddressList;
-class DnsResolutionObserver;
 class HostMapper;
 
 // This class represents the task of resolving hostnames (or IP address
 // literal) to an AddressList object.
 //
 // HostResolver handles multiple requests at a time, so when cancelling a
 // request the Request* handle that was returned by Resolve() needs to be
 // given.  A simpler alternative for consumers that only have 1 outstanding
 // request at a time is to create a SingleRequestHostResolver wrapper around
 // HostResolver (which will automatically cancel the single request when it
@@ skipping 59 matching lines @@
     bool allow_cached_response_;
 
     // Whether this request was started by the DNS prefetcher.
     bool is_speculative_;
 
     // Optional data for consumption by observers. This is the URL of the
     // page that lead us to the navigation, for DNS prefetcher's benefit.
     GURL referrer_;
   };
 
+  // Interface for observing the requests that flow through a HostResolver.
+  class Observer {
+   public:
+    virtual ~Observer() {}
+
+    // Called at the start of HostResolver::Resolve(). |id| is a unique number
+    // given to the request, so it can be matched up with a corresponding call
+    // to OnFinishResolutionWithStatus().
+    virtual void OnStartResolution(int id, const RequestInfo& info) = 0;
+
+    // Called on completion of request |id|. Note that if the request was
+    // cancelled, OnFinishResolutionWithStatus() will not be called.
+    virtual void OnFinishResolutionWithStatus(int id, bool was_resolved,
+                                              const RequestInfo& info) = 0;
+  };
+
   // Creates a HostResolver that caches up to |max_cache_entries| for
   // |cache_duration_ms| milliseconds.
   //
   // TODO(eroman): Get rid of the default parameters as it violate google
   // style. This is temporary to help with refactoring.
   HostResolver(int max_cache_entries = 100, int cache_duration_ms = 60000);
 
   // If any completion callbacks are pending when the resolver is destroyed,
   // the host resolutions are cancelled, and the completion callbacks will not
   // be called.
@@ skipping 17 matching lines @@
   int Resolve(const RequestInfo& info, AddressList* addresses,
               CompletionCallback* callback, Request** req);
 
   // Cancels the specified request. |req| is the handle returned by Resolve().
   // After a request is cancelled, its completion callback will not be called.
   void CancelRequest(Request* req);
 
   // Adds an observer to this resolver. The observer will be notified of the
   // start and completion of all requests (excluding cancellation). |observer|
   // must remain valid for the duration of this HostResolver's lifetime.
-  void AddObserver(DnsResolutionObserver* observer);
+  void AddObserver(Observer* observer);
 
   // Unregisters an observer previously added by AddObserver().
-  void RemoveObserver(DnsResolutionObserver* observer);
+  void RemoveObserver(Observer* observer);
 
  private:
   class Job;
   typedef std::vector<Request*> RequestsList;
   typedef base::hash_map<std::string, scoped_refptr<Job> > JobMap;
-  typedef std::vector<DnsResolutionObserver*> ObserversList;
+  typedef std::vector<Observer*> ObserversList;
 
   // Adds a job to outstanding jobs list.
   void AddOutstandingJob(Job* job);
 
   // Returns the outstanding job for |hostname|, or NULL if there is none.
   Job* FindOutstandingJob(const std::string& hostname);
 
   // Removes |job| from the outstanding jobs list.
   void RemoveOutstandingJob(Job* job);
 
@@ skipping 101 matching lines @@
 //
 // NOTE: In most cases, you should use ScopedHostMapper instead, which is
 // defined in host_resolver_unittest.h
 //
 HostMapper* SetHostMapper(HostMapper* host_mapper);
 #endif
 
 }  // namespace net
 
 #endif  // NET_BASE_HOST_RESOLVER_H_