net/dns/mojo_host_resolver_impl.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/dns/mojo_host_resolver_impl.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/stl_util.h"
   9 #include "net/base/address_list.h"
  10 #include "net/base/net_errors.h"
  11 #include "net/dns/host_resolver.h"
  12 #include "net/dns/mojo_host_type_converters.h"
  13
  14 namespace net {
  15
  16 // Handles host resolution for a single request and sends a response when done.
  17 // Also detects connection errors for HostResolverRequestClient and cancels the
  18 // outstanding resolve request. Owned by MojoHostResolverImpl.
  19 class MojoHostResolverImpl::Job {
  20  public:
  21   Job(MojoHostResolverImpl* resolver_service,
  22       net::HostResolver* resolver,
  23       const net::HostResolver::RequestInfo& request_info,
  24       const BoundNetLog& net_log,
  25       interfaces::HostResolverRequestClientPtr client);
  26   ~Job();
  27
  28   void Start();
  29
  30  private:
  31   // Completion callback for the HostResolver::Resolve request.
  32   void OnResolveDone(int result);
  33
  34   // Mojo error handler.
  35   void OnConnectionError();
  36
  37   MojoHostResolverImpl* resolver_service_;
  38   net::HostResolver* resolver_;
  39   net::HostResolver::RequestInfo request_info_;
  40   const BoundNetLog net_log_;
  41   interfaces::HostResolverRequestClientPtr client_;
  42   net::HostResolver::RequestHandle handle_;
  43   AddressList result_;
  44   base::ThreadChecker thread_checker_;
  45 };
  46
  47 MojoHostResolverImpl::MojoHostResolverImpl(net::HostResolver* resolver,
  48                                            const BoundNetLog& net_log)
  49     : resolver_(resolver), net_log_(net_log) {
  50 }
  51
  52 MojoHostResolverImpl::~MojoHostResolverImpl() {
  53   DCHECK(thread_checker_.CalledOnValidThread());
  54   STLDeleteElements(&pending_jobs_);
  55 }
  56
  57 void MojoHostResolverImpl::Resolve(
  58     interfaces::HostResolverRequestInfoPtr request_info,
  59     interfaces::HostResolverRequestClientPtr client) {
  60   DCHECK(thread_checker_.CalledOnValidThread());
  61   Job* job = new Job(this, resolver_,
  62                      request_info->To<net::HostResolver::RequestInfo>(),
  63                      net_log_, client.Pass());
  64   pending_jobs_.insert(job);
  65   job->Start();
  66 }
  67
  68 void MojoHostResolverImpl::DeleteJob(Job* job) {
  69   DCHECK(thread_checker_.CalledOnValidThread());
  70   size_t num_erased = pending_jobs_.erase(job);
  71   DCHECK(num_erased);
  72   delete job;
  73 }
  74
  75 MojoHostResolverImpl::Job::Job(
  76     MojoHostResolverImpl* resolver_service,
  77     net::HostResolver* resolver,
  78     const net::HostResolver::RequestInfo& request_info,
  79     const BoundNetLog& net_log,
  80     interfaces::HostResolverRequestClientPtr client)
  81     : resolver_service_(resolver_service),
  82       resolver_(resolver),
  83       request_info_(request_info),
  84       net_log_(net_log),
  85       client_(client.Pass()),
  86       handle_(nullptr) {
  87   client_.set_connection_error_handler(base::Bind(
  88       &MojoHostResolverImpl::Job::OnConnectionError, base::Unretained(this)));
  89 }
  90
  91 void MojoHostResolverImpl::Job::Start() {
  92   DVLOG(1) << "Resolve " << request_info_.host_port_pair().ToString();
  93   int result =
  94       resolver_->Resolve(request_info_, DEFAULT_PRIORITY, &result_,
  95                          base::Bind(&MojoHostResolverImpl::Job::OnResolveDone,
  96                                     base::Unretained(this)),
  97                          &handle_, net_log_);
  98
  99   if (result != ERR_IO_PENDING)
 100     OnResolveDone(result);
 101 }
 102
 103 MojoHostResolverImpl::Job::~Job() {
 104   DCHECK(thread_checker_.CalledOnValidThread());
 105   if (handle_)
 106     resolver_->CancelRequest(handle_);
 107 }
 108
 109 void MojoHostResolverImpl::Job::OnResolveDone(int result) {
 110   DCHECK(thread_checker_.CalledOnValidThread());
 111   handle_ = nullptr;
 112   DVLOG(1) << "Resolved " << request_info_.host_port_pair().ToString()
 113            << " with error " << result << " and " << result_.size()
 114            << " results!";
 115   for (const auto& address : result_) {
 116     DVLOG(1) << address.ToString();
 117   }
 118   if (result == OK)
 119     client_->ReportResult(result, interfaces::AddressList::From(result_));
 120   else
 121     client_->ReportResult(result, nullptr);
 122
 123   resolver_service_->DeleteJob(this);
 124 }
 125
 126 void MojoHostResolverImpl::Job::OnConnectionError() {
 127   DCHECK(thread_checker_.CalledOnValidThread());
 128   // |resolver_service_| should always outlive us.
 129   DCHECK(resolver_service_);
 130   DVLOG(1) << "Connection error on request for "
 131            << request_info_.host_port_pair().ToString();
 132   resolver_service_->DeleteJob(this);
 133 }
 134
 135 }  // namespace net