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/url_type_converters.h"
   9 #include "net/base/net_errors.h"
  10 #include "net/log/net_log.h"
  11 #include "net/proxy/load_state_change_coalescer.h"
  12 #include "net/proxy/mojo_proxy_type_converters.h"
  13 #include "net/proxy/proxy_info.h"
  14 #include "net/proxy/proxy_resolver_script_data.h"
  15
  16 namespace net {
  17 namespace {
  18 const int kLoadStateChangeCoalesceTimeoutMilliseconds = 10;
  19 }
  20
  21 class MojoProxyResolverImpl::Job : public mojo::ErrorHandler {
  22  public:
  23   Job(interfaces::ProxyResolverRequestClientPtr client,
  24       MojoProxyResolverImpl* resolver,
  25       const GURL& url);
  26   ~Job() override;
  27
  28   void Start();
  29
  30   // Invoked when the LoadState for this job changes.
  31   void LoadStateChanged(LoadState load_state);
  32
  33   net::ProxyResolver::RequestHandle request_handle() { return request_handle_; }
  34
  35  private:
  36   // mojo::ErrorHandler override.
  37   // This is invoked in response to the client disconnecting, indicating
  38   // cancellation.
  39   void OnConnectionError() override;
  40
  41   void GetProxyDone(int error);
  42
  43   void SendLoadStateChanged(LoadState load_state);
  44
  45   MojoProxyResolverImpl* resolver_;
  46
  47   interfaces::ProxyResolverRequestClientPtr client_;
  48   ProxyInfo result_;
  49   GURL url_;
  50   net::ProxyResolver::RequestHandle request_handle_;
  51   bool done_;
  52   LoadStateChangeCoalescer load_state_change_coalescer_;
  53
  54   DISALLOW_COPY_AND_ASSIGN(Job);
  55 };
  56
  57 MojoProxyResolverImpl::MojoProxyResolverImpl(
  58     scoped_ptr<net::ProxyResolver> resolver)
  59     : resolver_(resolver.Pass()) {
  60   DCHECK(resolver_->expects_pac_bytes());
  61 }
  62
  63 MojoProxyResolverImpl::~MojoProxyResolverImpl() {
  64   if (!set_pac_script_requests_.empty())
  65     resolver_->CancelSetPacScript();
  66   STLDeleteElements(&resolve_jobs_);
  67 }
  68
  69 void MojoProxyResolverImpl::LoadStateChanged(
  70     net::ProxyResolver::RequestHandle handle,
  71     LoadState load_state) {
  72   auto it = request_handle_to_job_.find(handle);
  73   DCHECK(it != request_handle_to_job_.end());
  74   it->second->LoadStateChanged(load_state);
  75 }
  76
  77 void MojoProxyResolverImpl::SetPacScript(
  78     const mojo::String& data,
  79     const mojo::Callback<void(int32_t)>& callback) {
  80   DVLOG(1) << "SetPacScript(" << data << ")";
  81   set_pac_script_requests_.push(
  82       SetPacScriptRequest(ProxyResolverScriptData::FromUTF8(data), callback));
  83   if (set_pac_script_requests_.size() == 1)
  84     StartSetPacScript();
  85 }
  86
  87 void MojoProxyResolverImpl::GetProxyForUrl(
  88     const mojo::String& url,
  89     interfaces::ProxyResolverRequestClientPtr client) {
  90   DVLOG(1) << "GetProxyForUrl(" << url << ")";
  91   Job* job = new Job(client.Pass(), this, url.To<GURL>());
  92   bool inserted = resolve_jobs_.insert(job).second;
  93   DCHECK(inserted);
  94   job->Start();
  95 }
  96
  97 void MojoProxyResolverImpl::DeleteJob(Job* job) {
  98   if (job->request_handle())
  99     request_handle_to_job_.erase(job->request_handle());
 100
 101   size_t num_erased = resolve_jobs_.erase(job);
 102   DCHECK(num_erased);
 103   delete job;
 104 }
 105
 106 void MojoProxyResolverImpl::StartSetPacScript() {
 107   DCHECK(!set_pac_script_requests_.empty());
 108   int result = resolver_->SetPacScript(
 109       set_pac_script_requests_.front().script_data,
 110       base::Bind(&MojoProxyResolverImpl::SetPacScriptDone,
 111                  base::Unretained(this)));
 112   if (result != ERR_IO_PENDING)
 113     SetPacScriptDone(result);
 114 }
 115
 116 void MojoProxyResolverImpl::SetPacScriptDone(int result) {
 117   DVLOG(1) << "SetPacScript finished with error " << result;
 118   DCHECK(!set_pac_script_requests_.empty());
 119   set_pac_script_requests_.front().callback.Run(result);
 120   set_pac_script_requests_.pop();
 121   if (!set_pac_script_requests_.empty())
 122     StartSetPacScript();
 123 }
 124
 125 MojoProxyResolverImpl::Job::Job(
 126     interfaces::ProxyResolverRequestClientPtr client,
 127     MojoProxyResolverImpl* resolver,
 128     const GURL& url)
 129     : resolver_(resolver),
 130       client_(client.Pass()),
 131       url_(url),
 132       request_handle_(nullptr),
 133       done_(false),
 134       load_state_change_coalescer_(
 135           base::Bind(&MojoProxyResolverImpl::Job::SendLoadStateChanged,
 136                      base::Unretained(this)),
 137           base::TimeDelta::FromMilliseconds(
 138               kLoadStateChangeCoalesceTimeoutMilliseconds),
 139           LOAD_STATE_RESOLVING_PROXY_FOR_URL) {
 140 }
 141
 142 MojoProxyResolverImpl::Job::~Job() {
 143   if (request_handle_ && !done_)
 144     resolver_->resolver_->CancelRequest(request_handle_);
 145 }
 146
 147 void MojoProxyResolverImpl::Job::Start() {
 148   int result = resolver_->resolver_->GetProxyForURL(
 149       url_, &result_, base::Bind(&Job::GetProxyDone, base::Unretained(this)),
 150       &request_handle_, BoundNetLog());
 151   if (result != ERR_IO_PENDING) {
 152     GetProxyDone(result);
 153     return;
 154   }
 155   client_.set_error_handler(this);
 156   resolver_->request_handle_to_job_.insert(
 157       std::make_pair(request_handle_, this));
 158 }
 159
 160 void MojoProxyResolverImpl::Job::LoadStateChanged(LoadState load_state) {
 161   load_state_change_coalescer_.LoadStateChanged(load_state);
 162 }
 163
 164 void MojoProxyResolverImpl::Job::GetProxyDone(int error) {
 165   done_ = true;
 166   DVLOG(1) << "GetProxyForUrl(" << url_ << ") finished with error " << error
 167            << ". " << result_.proxy_list().size() << " Proxies returned:";
 168   for (const auto& proxy : result_.proxy_list().GetAll()) {
 169     DVLOG(1) << proxy.ToURI();
 170   }
 171   mojo::Array<interfaces::ProxyServerPtr> result;
 172   if (error == OK) {
 173     result = mojo::Array<interfaces::ProxyServerPtr>::From(
 174         result_.proxy_list().GetAll());
 175   }
 176   client_->ReportResult(error, result.Pass());
 177   resolver_->DeleteJob(this);
 178 }
 179
 180 void MojoProxyResolverImpl::Job::OnConnectionError() {
 181   resolver_->DeleteJob(this);
 182 }
 183
 184 void MojoProxyResolverImpl::Job::SendLoadStateChanged(LoadState load_state) {
 185   client_->LoadStateChanged(load_state);
 186 }
 187
 188 MojoProxyResolverImpl::SetPacScriptRequest::SetPacScriptRequest(
 189     const scoped_refptr<ProxyResolverScriptData>& script_data,
 190     const mojo::Callback<void(int32_t)>& callback)
 191     : script_data(script_data), callback(callback) {
 192 }
 193
 194 MojoProxyResolverImpl::SetPacScriptRequest::~SetPacScriptRequest() = default;
 195
 196 }  // namespace net