Remove unused HostResolver::Observer.

net/base/host_resolver.h

 // Copyright (c) 2011 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_
 #pragma once
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
-#include "googleurl/src/gurl.h"
 #include "net/base/address_family.h"
 #include "net/base/completion_callback.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_export.h"
 #include "net/base/net_util.h"
 #include "net/base/request_priority.h"
 
 namespace net {
 
 class AddressList;
@@ skipping 41 matching lines @@
 
     bool allow_cached_response() const { return allow_cached_response_; }
     void set_allow_cached_response(bool b) { allow_cached_response_ = b; }
 
     bool is_speculative() const { return is_speculative_; }
     void set_is_speculative(bool b) { is_speculative_ = b; }
 
     RequestPriority priority() const { return priority_; }
     void set_priority(RequestPriority priority) { priority_ = priority; }
 
-    const GURL& referrer() const { return referrer_; }
-    void set_referrer(const GURL& referrer) { referrer_ = referrer; }
-
    private:
     // The hostname to resolve, and the port to use in resulting sockaddrs.
     HostPortPair host_port_pair_;
 
     // The address family to restrict results to.
     AddressFamily address_family_;
 
     // Flags to use when resolving this request.
     HostResolverFlags host_resolver_flags_;
 
     // Whether it is ok to return a result from the host cache.
     bool allow_cached_response_;
 
     // Whether this request was started by the DNS prefetcher.
     bool is_speculative_;
 
     // The priority for the request.
     RequestPriority priority_;
-
-    // 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() or OnCancelResolution().
-    virtual void OnStartResolution(int id, const RequestInfo& info) = 0;
-
-    // Called on completion of request |id|. Note that if the request was
-    // cancelled, OnCancelResolution() will be called instead.
-    virtual void OnFinishResolutionWithStatus(int id, bool was_resolved,
-                                              const RequestInfo& info) = 0;
-
-    // Called when request |id| has been cancelled. A request is "cancelled"
-    // if either the HostResolver is destroyed while a resolution is in
-    // progress, or HostResolver::CancelRequest() is called.
-    virtual void OnCancelResolution(int id, const RequestInfo& info) = 0;
   };
 
   // Opaque type used to cancel a request.
   typedef void* RequestHandle;
 
   // This value can be passed into CreateSystemHostResolver as the
   // |max_concurrent_resolves| parameter. It will select a default level of
   // concurrency.
   static const size_t kDefaultParallelism = 0;
 
@@ skipping 33 matching lines @@
 
   // Resolves the given hostname (or IP address literal) out of cache
   // only.  This is guaranteed to complete synchronously.  This acts like
   // |Resolve()| if the hostname is IP literal or cached value exists.
   // Otherwise, ERR_DNS_CACHE_MISS is returned.
   virtual int ResolveFromCache(const RequestInfo& info,
                                AddressList* addresses,
                                const BoundNetLog& net_log) = 0;
 
   // Cancels the specified request. |req| is the handle returned by Resolve().
-  // After a request is cancelled, its completion callback will not be called.
+  // After a request is canceled, its completion callback will not be called.
+  // CancelRequest must NOT be called after the request's completion callback
+  // has already run or the request was canceled.
   virtual void CancelRequest(RequestHandle req) = 0;
 
-  // 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.
-  virtual void AddObserver(Observer* observer) = 0;
-
-  // Unregisters an observer previously added by AddObserver().
-  virtual void RemoveObserver(Observer* observer) = 0;
-
   // Sets the default AddressFamily to use when requests have left it
   // unspecified. For example, this could be used to restrict resolution
   // results to AF_INET by passing in ADDRESS_FAMILY_IPV4, or to
   // AF_INET6 by passing in ADDRESS_FAMILY_IPV6.
   virtual void SetDefaultAddressFamily(AddressFamily address_family) {}
   virtual AddressFamily GetDefaultAddressFamily() const;
 
   // Continuously observe whether IPv6 is supported, and set the allowable
   // address family to IPv4 iff IPv6 is not supported.
   virtual void ProbeIPv6Support();
@@ skipping 24 matching lines @@
     NetLog* net_log);
 
 // Creates a HostResolver implementation that sends actual DNS queries to
 // the specified DNS server and parses response and returns results.
 NET_EXPORT HostResolver* CreateAsyncHostResolver(size_t max_concurrent_resolves,
                                                  const IPAddressNumber& dns_ip,
                                                  NetLog* net_log);
 }  // namespace net
 
 #endif  // NET_BASE_HOST_RESOLVER_H_