net/proxy/mojo_proxy_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/proxy/mojo_proxy_resolver_impl.h"
   6
   7 #include "base/stl_util.h"
   8 #include "mojo/common/common_type_converters.h"
   9 #include "net/base/net_errors.h"
  10 #include "net/base/net_log.h"
  11 #include "net/proxy/mojo_proxy_type_converters.h"
  12 #include "net/proxy/proxy_info.h"
  13 #include "net/proxy/proxy_resolver.h"
  14 #include "net/proxy/proxy_resolver_script_data.h"
  15
  16 namespace net {
  17
  18 class MojoProxyResolverImpl::Job : public mojo::ErrorHandler {
  19  public:
  20   Job(interfaces::ProxyResolverRequestClientPtr client,
  21       MojoProxyResolverImpl* resolver,
  22       const GURL& url);
  23   ~Job() override;
  24
  25   void Start();
  26
  27  private:
  28   // mojo::ErrorHandler override.
  29   // This is invoked in response to the client disconnecting, indicating
  30   // cancellation.
  31   void OnConnectionError() override;
  32
  33   void GetProxyDone(int error);
  34
  35   MojoProxyResolverImpl* resolver_;
  36
  37   interfaces::ProxyResolverRequestClientPtr client_;
  38   ProxyInfo result_;
  39   GURL url_;
  40   net::ProxyResolver::RequestHandle request_handle_;
  41
  42   DISALLOW_COPY_AND_ASSIGN(Job);
  43 };
  44
  45 MojoProxyResolverImpl::MojoProxyResolverImpl(
  46     scoped_ptr<net::ProxyResolver> resolver)
  47     : resolver_(resolver.Pass()) {
  48   DCHECK(resolver_->expects_pac_bytes());
  49 }
  50
  51 MojoProxyResolverImpl::~MojoProxyResolverImpl() {
  52   if (!set_pac_script_requests_.empty())
  53     resolver_->CancelSetPacScript();
  54   STLDeleteElements(&resolve_jobs_);
  55 }
  56
  57 void MojoProxyResolverImpl::SetPacScript(
  58     const mojo::String& data,
  59     const mojo::Callback<void(int32_t)>& callback) {
  60   DVLOG(1) << "SetPacScript(" << data << ")";
  61   set_pac_script_requests_.push(
  62       SetPacScriptRequest(ProxyResolverScriptData::FromUTF8(data), callback));
  63   if (set_pac_script_requests_.size() == 1)
  64     StartSetPacScript();
  65 }
  66
  67 void MojoProxyResolverImpl::GetProxyForUrl(
  68     const mojo::String& url,
  69     interfaces::ProxyResolverRequestClientPtr client) {
  70   DVLOG(1) << "GetProxyForUrl(" << url << ")";
  71   Job* job = new Job(client.Pass(), this, url.To<GURL>());
  72   bool inserted = resolve_jobs_.insert(job).second;
  73   DCHECK(inserted);
  74   job->Start();
  75 }
  76
  77 void MojoProxyResolverImpl::DeleteJob(Job* job) {
  78   size_t num_erased = resolve_jobs_.erase(job);
  79   DCHECK(num_erased);
  80   delete job;
  81 }
  82
  83 void MojoProxyResolverImpl::StartSetPacScript() {
  84   DCHECK(!set_pac_script_requests_.empty());
  85   int result = resolver_->SetPacScript(
  86       set_pac_script_requests_.front().script_data,
  87       base::Bind(&MojoProxyResolverImpl::SetPacScriptDone,
  88                  base::Unretained(this)));
  89   if (result != ERR_IO_PENDING)
  90     SetPacScriptDone(result);
  91 }
  92
  93 void MojoProxyResolverImpl::SetPacScriptDone(int result) {
  94   DVLOG(1) << "SetPacScript finished with error " << result;
  95   DCHECK(!set_pac_script_requests_.empty());
  96   set_pac_script_requests_.front().callback.Run(result);
  97   set_pac_script_requests_.pop();
  98   if (!set_pac_script_requests_.empty())
  99     StartSetPacScript();
 100 }
 101
 102 MojoProxyResolverImpl::Job::Job(
 103     interfaces::ProxyResolverRequestClientPtr client,
 104     MojoProxyResolverImpl* resolver,
 105     const GURL& url)
 106     : resolver_(resolver),
 107       client_(client.Pass()),
 108       url_(url),
 109       request_handle_(nullptr) {
 110 }
 111
 112 MojoProxyResolverImpl::Job::~Job() {
 113   if (request_handle_)
 114     resolver_->resolver_->CancelRequest(request_handle_);
 115 }
 116
 117 void MojoProxyResolverImpl::Job::Start() {
 118   int result = resolver_->resolver_->GetProxyForURL(
 119       url_, &result_, base::Bind(&Job::GetProxyDone, base::Unretained(this)),
 120       &request_handle_, BoundNetLog());
 121   if (result != ERR_IO_PENDING) {
 122     GetProxyDone(result);
 123     return;
 124   }
 125   client_.set_error_handler(this);
 126 }
 127
 128 void MojoProxyResolverImpl::Job::GetProxyDone(int error) {
 129   request_handle_ = nullptr;
 130   DVLOG(1) << "GetProxyForUrl(" << url_ << ") finished with error " << error
 131            << ". " << result_.proxy_list().size() << " Proxies returned:";
 132   for (const auto& proxy : result_.proxy_list().GetAll()) {
 133     DVLOG(1) << proxy.ToURI();
 134   }
 135   mojo::Array<interfaces::ProxyServerPtr> result;
 136   if (error == OK) {
 137     result = mojo::Array<interfaces::ProxyServerPtr>::From(
 138         result_.proxy_list().GetAll());
 139   }
 140   client_->ReportResult(error, result.Pass());
 141   resolver_->DeleteJob(this);
 142 }
 143
 144 void MojoProxyResolverImpl::Job::OnConnectionError() {
 145   resolver_->DeleteJob(this);
 146 }
 147
 148 MojoProxyResolverImpl::SetPacScriptRequest::SetPacScriptRequest(
 149     const scoped_refptr<ProxyResolverScriptData>& script_data,
 150     const mojo::Callback<void(int32_t)>& callback)
 151     : script_data(script_data), callback(callback) {
 152 }
 153
 154 MojoProxyResolverImpl::SetPacScriptRequest::~SetPacScriptRequest() = default;
 155
 156 }  // namespace net