WIP: Prototype OOP V8 PAC.

net/proxy/proxy_resolver_mojo.cc

+// Copyright 2015 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/proxy/proxy_resolver_mojo.h"
+
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/strings/string16.h"
+#include "base/strings/utf_string_conversions.h"
+#include "mojo/public/cpp/bindings/interface_ptr.h"
+#include "net/base/address_list.h"
+#include "net/base/completion_callback.h"
+#include "net/base/load_states.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_export.h"
+#include "net/base/net_log.h"
+#include "net/dns/single_request_host_resolver.h"
+#include "net/proxy/proxy_info.h"
+#include "net/proxy/proxy_resolver_script_data.h"
+#include "url/gurl.h"
+
+namespace net {
+
+namespace {
+
+class Job : public mojo::InterfaceImpl<proxy::ResolveRequestClient> {
+ public:
+  Job(ProxyInfo* results,
+      const CompletionCallback& callback,
+      const BoundNetLog& net_log,
+      HostResolver* host_resolver);
+  ~Job() override;
+
+  LoadState GetLoadState() const;
+
+ private:
+  void ReportResult(const mojo::String& pac_string) override;
+  void ReportError(int32_t error) override;
+  void UpdateLoadState(int32_t load_state) override;
+
+  void OnConnectionError() override;
+
+  void ResolveHostDone(int32_t result);
+  ProxyInfo* results_;
+  CompletionCallback callback_;
+  BoundNetLog net_log_;
+
+  SingleRequestHostResolver host_resolver_;
+
+  bool host_resolve_in_progress_;
+  AddressList host_resolve_result_;
+  LoadState load_state_ = LOAD_STATE_RESOLVING_PROXY_FOR_URL;
+  mojo::Callback<void(int32_t, mojo::Array<mojo::String>)>
+      host_resolve_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(Job);
+};
+
+Job::Job(ProxyInfo* results,
+         const CompletionCallback& callback,
+         const BoundNetLog& net_log,
+         HostResolver* host_resolver)
+    : results_(results),
+      callback_(callback),
+      net_log_(net_log),
+      host_resolver_(host_resolver) {
+}
+
+Job::~Job() = default;
+
+LoadState Job::GetLoadState() const {
+  return load_state_;
+}
+
+void Job::ReportResult(const mojo::String& pac_string) {
+  VLOG(1) << pac_string.To<std::string>();
+  results_->UsePacString(pac_string);
+  ReportError(0);
+}
+
+void Job::ReportError(int32_t error) {
+  callback_.Run(error);
+  delete this;
+}
+
+void Job::UpdateLoadState(int32_t load_state) {
+  load_state_ = static_cast<LoadState>(load_state);
+}
+
+void Job::OnConnectionError() {
+  callback_.Run(ERR_FAILED);
+  delete this;
+}
+
+void Job::ResolveHostDone(int32_t result) {
+  host_resolve_in_progress_ = false;
+  if (result != 0) {
+    host_resolve_callback_.Run(result, mojo::Array<mojo::String>());
+    return;
+  }
+}
+
+}  // namespace
+
+class ProxyResolverMojo::SetPacScriptJob
+    : public mojo::InterfaceImpl<proxy::SetPacScriptClient> {
+ public:
+  explicit SetPacScriptJob(const CompletionCallback& callback);
+  ~SetPacScriptJob() override;
+
+  base::WeakPtr<SetPacScriptJob> GetWeakPtr();
+
+ private:
+  void ReportResult(int32_t error) override;
+
+  void OnConnectionError() override;
+
+  CompletionCallback callback_;
+
+  base::WeakPtrFactory<SetPacScriptJob> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(SetPacScriptJob);
+};
+
+ProxyResolverMojo::ProxyResolverMojo(
+    mojo::InterfacePtr<proxy::Resolver> resolver,
+    HostResolver* host_resolver)
+    : ProxyResolver(true),
+      resolver_(resolver.Pass()),
+      host_resolver_(host_resolver) {
+  // XXX: Call SetResolver().
+}
+
+ProxyResolverMojo::~ProxyResolverMojo() = default;
+
+int ProxyResolverMojo::GetProxyForURL(const GURL& url,
+                                      ProxyInfo* results,
+                                      const CompletionCallback& callback,
+                                      RequestHandle* request,
+                                      const BoundNetLog& net_log) {
+  VLOG(1) << "GetProxyForURL " << url;
+  mojo::InterfacePtr<proxy::ResolveRequestClient> handle;
+  *request = mojo::WeakBindToProxy(
+      new Job(results, callback, net_log, host_resolver_), &handle);
+  resolver_->GetProxyForUrl(url.spec(), handle.Pass());
+  return ERR_IO_PENDING;
+}
+
+void ProxyResolverMojo::CancelRequest(RequestHandle request) {
+  delete static_cast<Job*>(request);
+}
+
+LoadState ProxyResolverMojo::GetLoadState(RequestHandle request) const {
+  return static_cast<Job*>(request)->GetLoadState();
+}
+
+void ProxyResolverMojo::CancelSetPacScript() {
+  if (set_pac_script_job_)
+    delete set_pac_script_job_.get();
+}
+
+int ProxyResolverMojo::SetPacScript(
+    const scoped_refptr<ProxyResolverScriptData>& pac_script,
+    const CompletionCallback& callback) {
+  proxy::SetPacScriptClientPtr handle;
+  set_pac_script_job_ = mojo::WeakBindToProxy(new SetPacScriptJob(callback),
+                                              &handle)->GetWeakPtr();
+  VLOG(1) << "SetPacScript";
+  // XXX: Try to avoid converting between utf16 and utf8 and back to utf16.
+  resolver_->SetPacScript(base::UTF16ToUTF8(pac_script->utf16()),
+                          handle.Pass());
+  return ERR_IO_PENDING;
+}
+
+ProxyResolverMojo::SetPacScriptJob::SetPacScriptJob(
+    const CompletionCallback& callback)
+    : callback_(callback), weak_factory_(this) {
+}
+
+ProxyResolverMojo::SetPacScriptJob::~SetPacScriptJob() = default;
+
+base::WeakPtr<ProxyResolverMojo::SetPacScriptJob>
+ProxyResolverMojo::SetPacScriptJob::GetWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
+void ProxyResolverMojo::SetPacScriptJob::ReportResult(int32_t error) {
+  callback_.Run(error);
+  delete this;
+}
+
+void ProxyResolverMojo::SetPacScriptJob::OnConnectionError() {
+  callback_.Run(ERR_FAILED);
+  delete this;
+}
+
+}  // namespace net