Remove unused HostResolver::Observer.

net/base/mock_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_MOCK_HOST_RESOLVER_H_
 #define NET_BASE_MOCK_HOST_RESOLVER_H_
 #pragma once
 
 #include <list>
 #include <map>
 
 #include "base/memory/weak_ptr.h"
-#include "base/observer_list.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/non_thread_safe.h"
 #include "net/base/host_resolver.h"
 #include "net/base/host_resolver_proc.h"
 
 namespace net {
 
 class HostCache;
 class RuleBasedHostResolverProc;
 
@@ skipping 32 matching lines @@
  public:
   virtual ~MockHostResolverBase();
 
   RuleBasedHostResolverProc* rules() { return rules_; }
 
   // Controls whether resolutions complete synchronously or asynchronously.
   void set_synchronous_mode(bool is_synchronous) {
     synchronous_mode_ = is_synchronous;
   }
 
-  // Resets the mock.
-  void Reset(HostResolverProc* interceptor);
-
   // HostResolver methods:
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
                       OldCompletionCallback* callback,
                       RequestHandle* out_req,
                       const BoundNetLog& net_log) OVERRIDE;
   virtual int ResolveFromCache(const RequestInfo& info,
                                AddressList* addresses,
                                const BoundNetLog& net_log) OVERRIDE;
   virtual void CancelRequest(RequestHandle req) OVERRIDE;
-  virtual void AddObserver(Observer* observer) OVERRIDE;
-  virtual void RemoveObserver(Observer* observer) OVERRIDE;
   virtual HostCache* GetHostCache() OVERRIDE;
 
  protected:
   explicit MockHostResolverBase(bool use_caching);
 
  private:
   struct Request;
   typedef std::map<size_t, Request*> RequestMap;
 
   // Resolve as IP or from |cache_| return cached error or
   // DNS_CACHE_MISS if failed.
   int ResolveFromIPLiteralOrCache(const RequestInfo& info,
                                   AddressList* addresses);
   // Resolve via |proc_|.
   int ResolveProc(size_t id, const RequestInfo& info, AddressList* addresses);
   // Resolve request stored in |requests_|. Pass rv to callback.
   void ResolveNow(size_t id);
 
   bool synchronous_mode_;
-  ObserverList<Observer> observers_;
   scoped_refptr<RuleBasedHostResolverProc> rules_;
   scoped_refptr<HostResolverProc> proc_;
   scoped_ptr<HostCache> cache_;
   RequestMap requests_;
   size_t next_request_id_;
 
   DISALLOW_COPY_AND_ASSIGN(MockHostResolverBase);
 };
 
 class MockHostResolver : public MockHostResolverBase {
@@ skipping 75 matching lines @@
  public:
   virtual int Resolve(const RequestInfo& info,
                       AddressList* addresses,
                       OldCompletionCallback* callback,
                       RequestHandle* out_req,
                       const BoundNetLog& net_log) OVERRIDE;
   virtual int ResolveFromCache(const RequestInfo& info,
                                AddressList* addresses,
                                const BoundNetLog& net_log) OVERRIDE;
   virtual void CancelRequest(RequestHandle req) OVERRIDE {}
-  virtual void AddObserver(Observer* observer) OVERRIDE {}
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {}
 };
 
 // This class sets the default HostResolverProc for a particular scope.  The
 // chain of resolver procs starting at |proc| is placed in front of any existing
 // default resolver proc(s).  This means that if multiple
 // ScopedDefaultHostResolverProcs are declared, then resolving will start with
 // the procs given to the last-allocated one, then fall back to the procs given
 // to the previously-allocated one, and so forth.
 //
 // NOTE: Only use this as a catch-all safety net. Individual tests should use
 // MockHostResolver.
 class ScopedDefaultHostResolverProc {
  public:
   ScopedDefaultHostResolverProc();
   explicit ScopedDefaultHostResolverProc(HostResolverProc* proc);
 
   ~ScopedDefaultHostResolverProc();
 
   void Init(HostResolverProc* proc);
 
  private:
   scoped_refptr<HostResolverProc> current_proc_;
   scoped_refptr<HostResolverProc> previous_proc_;
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_MOCK_HOST_RESOLVER_H_