Remove unused HostResolver::Observer.

net/dns/async_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/dns/async_host_resolver.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 66 matching lines @@
 // cancelled, which can be either through specific CancelRequest call or by
 // the destruction of AsyncHostResolver, which would destruct pending or
 // in-progress requests, causing them to be cancelled.  Synchronous
 // resolution sets |callback_| to NULL, thus, if in the destructor we still
 // have a non-NULL |callback_|, we are being cancelled.
 class AsyncHostResolver::Request {
  public:
   Request(AsyncHostResolver* resolver,
           const BoundNetLog& source_net_log,
           const BoundNetLog& request_net_log,
-          int id,
           const HostResolver::RequestInfo& info,
           OldCompletionCallback* callback,
           AddressList* addresses)
       : resolver_(resolver),
         source_net_log_(source_net_log),
         request_net_log_(request_net_log),
-        id_(id),
         info_(info),
         callback_(callback),
         addresses_(addresses),
         result_(ERR_UNEXPECTED) {
     DCHECK(addresses_);
     DCHECK(resolver_);
     resolver_->OnStart(this);
     std::string dns_name;
     if (DNSDomainFromDot(info.hostname(), &dns_name))
       key_ = Key(dns_name, QueryTypeFromAddressFamily(info.address_family()));
   }
 
   ~Request() {
     if (callback_)
       resolver_->OnCancel(this);
   }
 
-  int id() const { return id_; }
   int result() const { return result_; }
   const Key& key() const {
     DCHECK(IsValid());
     return key_;
   }
   const HostResolver::RequestInfo& info() const { return info_; }
   RequestPriority priority() const { return info_.priority(); }
   const BoundNetLog& source_net_log() const { return source_net_log_; }
   const BoundNetLog& request_net_log() const { return request_net_log_; }
 
@@ skipping 58 matching lines @@
 
   // Returns true if request has a validly formed hostname.
   bool IsValid() const {
     return !info_.hostname().empty() && !key_.first.empty();
   }
 
  private:
   AsyncHostResolver* resolver_;
   BoundNetLog source_net_log_;
   BoundNetLog request_net_log_;
-  const int id_;
   const HostResolver::RequestInfo info_;
   Key key_;
   OldCompletionCallback* callback_;
   AddressList* addresses_;
   int result_;
 };
 
 //-----------------------------------------------------------------------------
 AsyncHostResolver::AsyncHostResolver(const IPEndPoint& dns_server,
                                      size_t max_transactions,
                                      size_t max_pending_requests,
                                      const RandIntCallback& rand_int_cb,
                                      HostCache* cache,
                                      ClientSocketFactory* factory,
                                      NetLog* net_log)
     : max_transactions_(max_transactions),
       max_pending_requests_(max_pending_requests),
       dns_server_(dns_server),
       rand_int_cb_(rand_int_cb),
       cache_(cache),
       factory_(factory),
-      next_request_id_(0),
       net_log_(net_log) {
 }
 
 AsyncHostResolver::~AsyncHostResolver() {
   // Destroy request lists.
   for (KeyRequestListMap::iterator it = requestlist_map_.begin();
        it != requestlist_map_.end(); ++it)
     STLDeleteElements(&it->second);
 
   // Destroy transactions.
@@ skipping 56 matching lines @@
   DCHECK(request);
 
   request->source_net_log().BeginEvent(
       NetLog::TYPE_ASYNC_HOST_RESOLVER,
       make_scoped_refptr(new NetLogSourceParameter(
           "source_dependency", request->request_net_log().source())));
   request->request_net_log().BeginEvent(
       NetLog::TYPE_ASYNC_HOST_RESOLVER_REQUEST,
       make_scoped_refptr(new RequestParameters(
           request->info(), request->source_net_log().source())));
-
-  FOR_EACH_OBSERVER(
-      HostResolver::Observer, observers_,
-      OnStartResolution(request->id(), request->info()));
 }
 
 void AsyncHostResolver::OnFinish(Request* request, int result) {
   DCHECK(request);
-  bool was_resolved = result == OK;
-
-  FOR_EACH_OBSERVER(
-      HostResolver::Observer, observers_,
-      OnFinishResolutionWithStatus(
-          request->id(), was_resolved, request->info()));
-
   request->request_net_log().EndEventWithNetErrorCode(
       NetLog::TYPE_ASYNC_HOST_RESOLVER_REQUEST, result);
   request->source_net_log().EndEvent(
       NetLog::TYPE_ASYNC_HOST_RESOLVER, NULL);
 }
 
 void AsyncHostResolver::OnCancel(Request* request) {
   DCHECK(request);
 
-  FOR_EACH_OBSERVER(
-      HostResolver::Observer, observers_,
-      OnCancelResolution(request->id(), request->info()));
-
   request->request_net_log().AddEvent(
       NetLog::TYPE_CANCELLED, NULL);
   request->request_net_log().EndEvent(
       NetLog::TYPE_ASYNC_HOST_RESOLVER_REQUEST, NULL);
   request->source_net_log().EndEvent(
       NetLog::TYPE_ASYNC_HOST_RESOLVER, NULL);
 }
 
 void AsyncHostResolver::CancelRequest(RequestHandle req_handle) {
   scoped_ptr<Request> request(reinterpret_cast<Request*>(req_handle));
   DCHECK(request.get());
 
   KeyRequestListMap::iterator it = requestlist_map_.find(request->key());
   if (it != requestlist_map_.end())
     it->second.remove(request.get());
   else
     pending_requests_[request->priority()].remove(request.get());
 }
 
-void AsyncHostResolver::AddObserver(HostResolver::Observer* observer) {
-  observers_.AddObserver(observer);
-}
-
-void AsyncHostResolver::RemoveObserver(HostResolver::Observer* observer) {
-  observers_.RemoveObserver(observer);
-}
-
 void AsyncHostResolver::SetDefaultAddressFamily(
     AddressFamily address_family) {
   NOTIMPLEMENTED();
 }
 
 AddressFamily AsyncHostResolver::GetDefaultAddressFamily() const {
   return ADDRESS_FAMILY_IPV4;
 }
 
 HostCache* AsyncHostResolver::GetHostCache() {
@@ skipping 53 matching lines @@
   ProcessPending();
 }
 
 AsyncHostResolver::Request* AsyncHostResolver::CreateNewRequest(
     const RequestInfo& info,
     OldCompletionCallback* callback,
     AddressList* addresses,
     const BoundNetLog& source_net_log) {
   BoundNetLog request_net_log = BoundNetLog::Make(net_log_,
       NetLog::SOURCE_ASYNC_HOST_RESOLVER_REQUEST);
-  int id = next_request_id_++;
   return new Request(
-      this, source_net_log, request_net_log, id, info, callback, addresses);
+      this, source_net_log, request_net_log, info, callback, addresses);
 }
 
 bool AsyncHostResolver::AttachToRequestList(Request* request) {
   KeyRequestListMap::iterator it = requestlist_map_.find(request->key());
   if (it == requestlist_map_.end())
     return false;
   it->second.push_back(request);
   return true;
 }
 
@@ skipping 85 matching lines @@
         it = requests.erase(it);
       } else {
         ++it;
       }
     }
   }
   StartNewTransactionFor(request);
 }
 
 }  // namespace net