Remove unused HostResolver::Observer.

net/base/host_resolver_impl.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/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
@@ skipping 243 matching lines @@
   const std::string host_;
   const NetLog::Source source_;
 };
 
 //-----------------------------------------------------------------------------
 
 class HostResolverImpl::Request {
  public:
   Request(const BoundNetLog& source_net_log,
           const BoundNetLog& request_net_log,
-          int id,
           const RequestInfo& info,
           OldCompletionCallback* callback,
           AddressList* addresses)
       : source_net_log_(source_net_log),
         request_net_log_(request_net_log),
-        id_(id),
         info_(info),
         job_(NULL),
         callback_(callback),
         addresses_(addresses) {
   }
 
   // Mark the request as cancelled.
   void MarkAsCancelled() {
     job_ = NULL;
     callback_ = NULL;
@@ skipping 27 matching lines @@
   }
 
   const BoundNetLog& source_net_log() {
     return source_net_log_;
   }
 
   const BoundNetLog& request_net_log() {
     return request_net_log_;
   }
 
-  int id() const {
-    return id_;
-  }
-
   const RequestInfo& info() const {
     return info_;
   }
 
  private:
   BoundNetLog source_net_log_;
   BoundNetLog request_net_log_;
 
-  // Unique ID for this request. Used by observers to identify requests.
-  int id_;
-
   // The request info that started the request.
   RequestInfo info_;
 
   // The resolve job (running in worker pool) that this request is dependent on.
   Job* job_;
 
   // The user's callback to invoke when the request completes.
   OldCompletionCallback* callback_;
 
   // The address list to save result into.
@@ skipping 713 matching lines @@
     HostResolverProc* resolver_proc,
     HostCache* cache,
     size_t max_jobs,
     size_t max_retry_attempts,
     NetLog* net_log)
     : cache_(cache),
       max_jobs_(max_jobs),
       max_retry_attempts_(max_retry_attempts),
       unresponsive_delay_(base::TimeDelta::FromMilliseconds(6000)),
       retry_factor_(2),
-      next_request_id_(0),
       next_job_id_(0),
       resolver_proc_(resolver_proc),
       default_address_family_(ADDRESS_FAMILY_UNSPECIFIED),
       ipv6_probe_monitoring_(false),
       additional_resolver_flags_(0),
       net_log_(net_log) {
   DCHECK_GT(max_jobs, 0u);
 
   // Maximum of 4 retry attempts for host resolution.
   static const size_t kDefaultMaxRetryAttempts = 4u;
@@ skipping 53 matching lines @@
 
 int HostResolverImpl::Resolve(const RequestInfo& info,
                               AddressList* addresses,
                               OldCompletionCallback* callback,
                               RequestHandle* out_req,
                               const BoundNetLog& source_net_log) {
   DCHECK(addresses);
   DCHECK(callback);
   DCHECK(CalledOnValidThread());
 
-  // Choose a unique ID number for observers to see.
-  int request_id = next_request_id_++;
-
   // Make a log item for the request.
   BoundNetLog request_net_log = BoundNetLog::Make(net_log_,
       NetLog::SOURCE_HOST_RESOLVER_IMPL_REQUEST);
 
   // Update the net log and notify registered observers.
-  OnStartRequest(source_net_log, request_net_log, request_id, info);
+  OnStartRequest(source_net_log, request_net_log, info);
 
   // Build a key that identifies the request in the cache and in the
   // outstanding jobs map.
   Key key = GetEffectiveKeyForRequest(info);
 
-  int rv = ResolveHelper(request_id, key, info, addresses, request_net_log);
+  int rv = ResolveHelper(key, info, addresses, request_net_log);
   if (rv != ERR_DNS_CACHE_MISS) {
-    OnFinishRequest(source_net_log, request_net_log, request_id, info,
+    OnFinishRequest(source_net_log, request_net_log, info,
                     rv,
                     0  /* os_error (unknown since from cache) */);
     return rv;
   }
 
    // Create a handle for this request, and pass it back to the user if they
   // asked for it (out_req != NULL).
-  Request* req = new Request(source_net_log, request_net_log, request_id, info,
+  Request* req = new Request(source_net_log, request_net_log, info,
                              callback, addresses);
   if (out_req)
     *out_req = reinterpret_cast<RequestHandle>(req);
 
   // Next we need to attach our request to a "job". This job is responsible for
   // calling "getaddrinfo(hostname)" on a worker thread.
   scoped_refptr<Job> job;
 
   // If there is already an outstanding job to resolve |key|, use
   // it. This prevents starting concurrent resolves for the same hostname.
   job = FindOutstandingJob(key);
   if (job) {
     job->AddRequest(req);
   } else {
     JobPool* pool = GetPoolForRequest(req);
     if (CanCreateJobForPool(*pool)) {
       CreateAndStartJob(req);
     } else {
       return EnqueueRequest(pool, req);
     }
   }
 
   // Completion happens during OnJobComplete(Job*).
   return ERR_IO_PENDING;
 }
 
-int HostResolverImpl::ResolveHelper(int request_id,
-                                    const Key& key,
+int HostResolverImpl::ResolveHelper(const Key& key,
                                     const RequestInfo& info,
                                     AddressList* addresses,
                                     const BoundNetLog& request_net_log) {
   // The result of |getaddrinfo| for empty hosts is inconsistent across systems.
   // On Windows it gives the default interface's address, whereas on Linux it
   // gives an error. We will make it fail on all platforms for consistency.
   if (info.hostname().empty() || info.hostname().size() > kMaxHostLength)
     return ERR_NAME_NOT_RESOLVED;
 
   int net_error = ERR_UNEXPECTED;
   if (ResolveAsIP(key, info, &net_error, addresses))
     return net_error;
   net_error = ERR_DNS_CACHE_MISS;
   ServeFromCache(key, info, request_net_log, &net_error, addresses);
   return net_error;
 }
 
 int HostResolverImpl::ResolveFromCache(const RequestInfo& info,
                                        AddressList* addresses,
                                        const BoundNetLog& source_net_log) {
   DCHECK(CalledOnValidThread());
   DCHECK(addresses);
 
-  // Choose a unique ID number for observers to see.
-  int request_id = next_request_id_++;
-
   // Make a log item for the request.
   BoundNetLog request_net_log = BoundNetLog::Make(net_log_,
       NetLog::SOURCE_HOST_RESOLVER_IMPL_REQUEST);
 
   // Update the net log and notify registered observers.
-  OnStartRequest(source_net_log, request_net_log, request_id, info);
+  OnStartRequest(source_net_log, request_net_log, info);
 
   // Build a key that identifies the request in the cache and in the
   // outstanding jobs map.
   Key key = GetEffectiveKeyForRequest(info);
 
-  int rv = ResolveHelper(request_id, key, info, addresses, request_net_log);
-  OnFinishRequest(source_net_log, request_net_log, request_id, info,
+  int rv = ResolveHelper(key, info, addresses, request_net_log);
+  OnFinishRequest(source_net_log, request_net_log, info,
                   rv,
                   0  /* os_error (unknown since from cache) */);
   return rv;
 }
 
 // See OnJobComplete(Job*) for why it is important not to clean out
 // cancelled requests from Job::requests_.
 void HostResolverImpl::CancelRequest(RequestHandle req_handle) {
   DCHECK(CalledOnValidThread());
   Request* req = reinterpret_cast<Request*>(req_handle);
   DCHECK(req);
 
   scoped_ptr<Request> request_deleter;  // Frees at end of function.
 
   if (!req->job()) {
     // If the request was not attached to a job yet, it must have been
     // enqueued into a pool. Remove it from that pool's queue.
     // Otherwise if it was attached to a job, the job is responsible for
     // deleting it.
     JobPool* pool = GetPoolForRequest(req);
     pool->RemovePendingRequest(req);
     request_deleter.reset(req);
   } else {
     req->request_net_log().EndEvent(
         NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_ATTACH, NULL);
   }
 
   // NULL out the fields of req, to mark it as cancelled.
   req->MarkAsCancelled();
-  OnCancelRequest(req->source_net_log(), req->request_net_log(), req->id(),
-                  req->info());
-}
-
-void HostResolverImpl::AddObserver(HostResolver::Observer* observer) {
-  DCHECK(CalledOnValidThread());
-  observers_.push_back(observer);
-}
-
-void HostResolverImpl::RemoveObserver(HostResolver::Observer* observer) {
-  DCHECK(CalledOnValidThread());
-  ObserversList::iterator it =
-      std::find(observers_.begin(), observers_.end(), observer);
-
-  // Observer must exist.
-  DCHECK(it != observers_.end());
-
-  observers_.erase(it);
+  OnCancelRequest(req->source_net_log(), req->request_net_log(), req->info());
 }
 
 void HostResolverImpl::SetDefaultAddressFamily(AddressFamily address_family) {
   DCHECK(CalledOnValidThread());
   ipv6_probe_monitoring_ = false;
   DiscardIPv6ProbeJob();
   default_address_family_ = address_family;
 }
 
 AddressFamily HostResolverImpl::GetDefaultAddressFamily() const {
@@ skipping 119 matching lines @@
   // Complete all of the requests that were attached to the job.
   for (RequestsList::const_iterator it = job->requests().begin();
        it != job->requests().end(); ++it) {
     Request* req = *it;
     if (!req->was_cancelled()) {
       DCHECK_EQ(job, req->job());
       req->request_net_log().EndEvent(
           NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_ATTACH, NULL);
 
       // Update the net log and notify registered observers.
-      OnFinishRequest(req->source_net_log(), req->request_net_log(), req->id(),
+      OnFinishRequest(req->source_net_log(), req->request_net_log(),
                       req->info(), net_error, os_error);
 
       req->OnComplete(net_error, addrlist);
 
       // Check if the job was cancelled as a result of running the callback.
       // (Meaning that |this| was deleted).
       if (job->was_cancelled())
         return;
     }
   }
 
   cur_completing_job_ = NULL;
 }
 
 void HostResolverImpl::OnStartRequest(const BoundNetLog& source_net_log,
                                       const BoundNetLog& request_net_log,
-                                      int request_id,
                                       const RequestInfo& info) {
   source_net_log.BeginEvent(
       NetLog::TYPE_HOST_RESOLVER_IMPL,
       make_scoped_refptr(new NetLogSourceParameter(
           "source_dependency", request_net_log.source())));
 
   request_net_log.BeginEvent(
       NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST,
       make_scoped_refptr(new RequestInfoParameters(
           info, source_net_log.source())));
-
-  // Notify the observers of the start.
-  if (!observers_.empty()) {
-    for (ObserversList::iterator it = observers_.begin();
-         it != observers_.end(); ++it) {
-      (*it)->OnStartResolution(request_id, info);
-    }
-  }
 }
 
 void HostResolverImpl::OnFinishRequest(const BoundNetLog& source_net_log,
                                        const BoundNetLog& request_net_log,
-                                       int request_id,
                                        const RequestInfo& info,
                                        int net_error,
                                        int os_error) {
   bool was_resolved = net_error == OK;
 
-  // Notify the observers of the completion.
-  if (!observers_.empty()) {
-    for (ObserversList::iterator it = observers_.begin();
-         it != observers_.end(); ++it) {
-      (*it)->OnFinishResolutionWithStatus(request_id, was_resolved, info);
-    }
-  }
-
   // Log some extra parameters on failure for synchronous requests.
   scoped_refptr<NetLog::EventParameters> params;
   if (!was_resolved) {
     params = new HostResolveFailedParams(0, net_error, os_error);
   }
 
   request_net_log.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST, params);
   source_net_log.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL, NULL);
 }
 
 void HostResolverImpl::OnCancelRequest(const BoundNetLog& source_net_log,
                                        const BoundNetLog& request_net_log,
-                                       int request_id,
                                        const RequestInfo& info) {
   request_net_log.AddEvent(NetLog::TYPE_CANCELLED, NULL);
-
-  // Notify the observers of the cancellation.
-  if (!observers_.empty()) {
-    for (ObserversList::iterator it = observers_.begin();
-         it != observers_.end(); ++it) {
-      (*it)->OnCancelResolution(request_id, info);
-    }
-  }
-
   request_net_log.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST, NULL);
   source_net_log.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL, NULL);
 }
 
 void HostResolverImpl::DiscardIPv6ProbeJob() {
   if (ipv6_probe_job_.get()) {
     ipv6_probe_job_->Cancel();
     ipv6_probe_job_ = NULL;
   }
 }
@@ skipping 84 matching lines @@
 
 int HostResolverImpl::EnqueueRequest(JobPool* pool, Request* req) {
   scoped_ptr<Request> req_evicted_from_queue(
       pool->InsertPendingRequest(req));
 
   // If the queue has become too large, we need to kick something out.
   if (req_evicted_from_queue.get()) {
     Request* r = req_evicted_from_queue.get();
     int error = ERR_HOST_RESOLVER_QUEUE_TOO_LARGE;
 
-    OnFinishRequest(r->source_net_log(), r->request_net_log(), r->id(),
-                    r->info(), error,
+    OnFinishRequest(r->source_net_log(), r->request_net_log(), r->info(), error,
                     0  /* os_error (not applicable) */);
 
     if (r == req)
       return error;
 
     r->OnComplete(error, AddressList());
   }
 
   return ERR_IO_PENDING;
 }
@@ skipping 42 matching lines @@
   // resolv.conf changes so we don't need to do anything to clear that cache.
   if (cache_.get())
     cache_->clear();
   // Existing jobs will have been sent to the original server so they need to
   // be aborted. TODO(Craig): Should these jobs be restarted?
   AbortAllInProgressJobs();
   // |this| may be deleted inside AbortAllInProgressJobs().
 }
 
 }  // namespace net