Remove unused HostResolver::Observer.

net/base/mock_host_resolver.cc

 // 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.
 
 #include "net/base/mock_host_resolver.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
@@ skipping 60 matching lines @@
   STLDeleteValues(&requests_);
 }
 
 int MockHostResolverBase::Resolve(const RequestInfo& info,
                                   AddressList* addresses,
                                   OldCompletionCallback* callback,
                                   RequestHandle* handle,
                                   const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   size_t id = next_request_id_++;
-  FOR_EACH_OBSERVER(Observer, observers_, OnStartResolution(id, info));
   int rv = ResolveFromIPLiteralOrCache(info, addresses);
   if (rv != ERR_DNS_CACHE_MISS) {
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      OnFinishResolutionWithStatus(id, rv == OK, info));
     return rv;
   }
   if (synchronous_mode_) {
     return ResolveProc(id, info, addresses);
   }
   // Store the request for asynchronous resolution
   Request* req = new Request(info, addresses, callback);
   requests_[id] = req;
   if (handle)
     *handle = reinterpret_cast<RequestHandle>(id);
   MessageLoop::current()->PostTask(FROM_HERE,
                                    base::Bind(&MockHostResolverBase::ResolveNow,
                                               AsWeakPtr(),
                                               id));
   return ERR_IO_PENDING;
 }
 
 int MockHostResolverBase::ResolveFromCache(const RequestInfo& info,
                                            AddressList* addresses,
                                            const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
-  size_t id = next_request_id_++;
-  FOR_EACH_OBSERVER(Observer, observers_, OnStartResolution(id, info));
+  next_request_id_++;
   int rv = ResolveFromIPLiteralOrCache(info, addresses);
-  FOR_EACH_OBSERVER(Observer, observers_,
-                    OnFinishResolutionWithStatus(id, rv == OK, info));
   return rv;
 }
 
 void MockHostResolverBase::CancelRequest(RequestHandle handle) {
   DCHECK(CalledOnValidThread());
   size_t id = reinterpret_cast<size_t>(handle);
   RequestMap::iterator it = requests_.find(id);
   if (it != requests_.end()) {
     scoped_ptr<Request> req(it->second);
     requests_.erase(it);
-    FOR_EACH_OBSERVER(Observer, observers_, OnCancelResolution(id, req->info));
+  } else {
+    NOTREACHED() << "CancelRequest must NOT be called after request is "
+        "complete or canceled.";
   }
 }
 
-void MockHostResolverBase::AddObserver(Observer* observer) {
-  DCHECK(CalledOnValidThread());
-  observers_.AddObserver(observer);
-}
-
-void MockHostResolverBase::RemoveObserver(Observer* observer) {
-  DCHECK(CalledOnValidThread());
-  observers_.RemoveObserver(observer);
-}
-
 HostCache* MockHostResolverBase::GetHostCache() {
   return cache_.get();
 }
 
 // start id from 1 to distinguish from NULL RequestHandle
 MockHostResolverBase::MockHostResolverBase(bool use_caching)
     : synchronous_mode_(false), next_request_id_(1) {
   rules_ = CreateCatchAllHostResolverProc();
   proc_ = rules_;
 
   if (use_caching) {
     cache_.reset(new HostCache(
         100,  // max entries.
         base::TimeDelta::FromMinutes(1),
         base::TimeDelta::FromSeconds(0)));
   }
-  STLDeleteValues(&requests_);
 }
 
 int MockHostResolverBase::ResolveFromIPLiteralOrCache(const RequestInfo& info,
                                                       AddressList* addresses) {
   IPAddressNumber ip;
   if (ParseIPLiteralToNumber(info.hostname(), &ip)) {
     *addresses = AddressList::CreateFromIPAddressWithCname(
         ip, info.port(), info.host_resolver_flags() & HOST_RESOLVER_CANONNAME);
     return OK;
   }
@@ skipping 22 matching lines @@
                           &addr,
                           NULL);
   if (cache_.get()) {
     HostCache::Key key(info.hostname(),
                        info.address_family(),
                        info.host_resolver_flags());
     cache_->Set(key, rv, addr, base::TimeTicks::Now());
   }
   if (rv == OK)
     *addresses = CreateAddressListUsingPort(addr, info.port());
-  FOR_EACH_OBSERVER(Observer, observers_,
-                    OnFinishResolutionWithStatus(id, rv == OK, info));
   return rv;
 }
 
 void MockHostResolverBase::ResolveNow(size_t id) {
   RequestMap::iterator it = requests_.find(id);
   if (it == requests_.end())
     return;  // was canceled
 
   scoped_ptr<Request> req(it->second);
   requests_.erase(it);
@@ skipping 201 matching lines @@
   CHECK_EQ(old_proc, current_proc_);
 }
 
 void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) {
   current_proc_ = proc;
   previous_proc_ = HostResolverProc::SetDefault(current_proc_);
   current_proc_->SetLastProc(previous_proc_);
 }
 
 }  // namespace net