WIP: Prototype OOP V8 PAC.

net/dns/host_resolver_mojo.cc

Index: net/dns/host_resolver_mojo.cc
diff --git a/net/dns/host_resolver_mojo.cc b/net/dns/host_resolver_mojo.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1f43ad7dfed639b8509506135bc821b8de3b2acd
--- /dev/null
+++ b/net/dns/host_resolver_mojo.cc
@@ -0,0 +1,108 @@
+// 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/dns/host_resolver_mojo.h"
+
+#include "net/base/net_errors.h"
+
+namespace net {
+
+class HostResolverMojo::Job
+    : public mojo::InterfaceImpl<dns::ResolveRequestClient> {
+ public:
+  Job(AddressList* addresses, const CompletionCallback& callback);
+
+ private:
+  void ReportResult(dns::AddressListPtr address_list) override;
+  void ReportError(int32_t error) override;
+
+  void OnConnectionError() override;
+
+  AddressList* addresses_;
+  CompletionCallback callback_;
+};
+
+HostResolverMojo::HostResolverMojo(dns::ResolverPtr resolver)
+    : resolver_(resolver.Pass()) {
+}
+
+HostResolverMojo::~HostResolverMojo() = default;
+
+int HostResolverMojo::Resolve(const RequestInfo& info,
+                              RequestPriority priority,
+                              AddressList* addresses,
+                              const CompletionCallback& callback,
+                              RequestHandle* out_req,
+                              const BoundNetLog& source_net_log) {
+  VLOG(1) << "Resolve " << info.host_port_pair().ToString();
+  mojo::InterfacePtr<dns::ResolveRequestClient> handle;
+  *out_req = mojo::WeakBindToProxy(new Job(addresses, callback), &handle);
+  resolver_->Resolve(dns::RequestInfo::From(info), handle.Pass());
+  return ERR_IO_PENDING;
+}
+
+int HostResolverMojo::ResolveFromCache(const RequestInfo& info,
+                                       AddressList* addresses,
+                                       const BoundNetLog& source_net_log) {
+  VLOG(1) << "ResolveFromCache " << info.host_port_pair().ToString();
+  return ERR_FAILED;
+}
+
+void HostResolverMojo::CancelRequest(RequestHandle req) {
+  delete static_cast<Job*>(req);
+}
+
+HostResolverMojo::Job::Job(AddressList* addresses,
+                           const CompletionCallback& callback)
+    : addresses_(addresses), callback_(callback) {
+}
+
+void HostResolverMojo::Job::ReportResult(dns::AddressListPtr address_list) {
+  *addresses_ = address_list->To<AddressList>();
+  ReportError(0);
+}
+
+void HostResolverMojo::Job::ReportError(int32_t error) {
+  callback_.Run(error);
+  delete this;
+}
+
+void HostResolverMojo::Job::OnConnectionError() {
+  ReportError(ERR_FAILED);
+}
+
+}  // namespace net
+
+namespace mojo {
+
+// static
+net::dns::RequestInfoPtr
+TypeConverter<net::dns::RequestInfoPtr, net::HostResolver::RequestInfo>::
+    Convert(const net::HostResolver::RequestInfo& obj) {
+  net::dns::RequestInfoPtr result(net::dns::RequestInfo::New());
+  result->host_port_pair = obj.host_port_pair().ToString();
+  result->address_family = obj.address_family();
+
+  return result.Pass();
+}
+
+// static
+net::AddressList
+TypeConverter<net::AddressList, net::dns::AddressList>::Convert(
+    const net::dns::AddressList& obj) {
+  net::IPAddressList addresses;
+  addresses.resize(obj.addresses.size());
+  for (size_t i = 0; i < obj.addresses.size(); i++) {
+    const auto& serialized_address = obj.addresses[i];
+    net::IPAddressNumber& address = addresses[i];
+    address.resize(serialized_address.size());
+    std::copy(&serialized_address[0],
+              &serialized_address[serialized_address.size() - 1],
+              address.begin());
+  }
+  return net::AddressList::CreateFromIPAddressList(addresses,
+                                                   obj.canonical_name);
+}
+
+}  // namespace mojo