Implement utility-side host resolver Mojo client.

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..59177f3d5f7c0db7a8de33271d6bc5a5704431f7
--- /dev/null
+++ b/net/dns/host_resolver_mojo.cc
@@ -0,0 +1,98 @@
+// 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"
+#include "net/base/net_log.h"
+#include "net/dns/type_converters.h"
+#include "third_party/mojo/src/mojo/public/cpp/bindings/binding.h"
+#include "third_party/mojo/src/mojo/public/cpp/bindings/error_handler.h"
+
+namespace net {
+
+class HostResolverMojo::Job : public interfaces::HostResolverRequestClient,
+                              public mojo::ErrorHandler {
+ public:
+  Job(AddressList* addresses,
+      const CompletionCallback& callback,
+      mojo::InterfaceRequest<interfaces::HostResolverRequestClient> request);
+
+ private:
+  // interfaces::HostResolverRequestClient override.
+  void ReportResult(int32_t error,
+                    interfaces::AddressListPtr address_list) override;
+
+  // mojo::ErrorHandler override.
+  void OnConnectionError() override;
+
+  AddressList* addresses_;
+  CompletionCallback callback_;
+  mojo::Binding<interfaces::HostResolverRequestClient> binding_;
+};
+
+HostResolverMojo::HostResolverMojo(interfaces::HostResolverPtr resolver,
+                                   mojo::ErrorHandler* error_handler)
+    : resolver_(resolver.Pass()) {
+  if (error_handler)
+    resolver_.set_error_handler(error_handler);
+}
+
+HostResolverMojo::~HostResolverMojo() = default;
+
+int HostResolverMojo::Resolve(const RequestInfo& info,
+                              RequestPriority priority,
+                              AddressList* addresses,
+                              const CompletionCallback& callback,
+                              RequestHandle* request_handle,
+                              const BoundNetLog& source_net_log) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DVLOG(1) << "Resolve " << info.host_port_pair().ToString();
+  mojo::InterfacePtr<interfaces::HostResolverRequestClient> handle;

[Anand Mistry (off Chromium), 2015/02/16 06:32:44]

This is interfaces::HostResolverRequestClientPtr right? Which one should we be
using consistently?

[Sam McNally, 2015/02/16 07:24:44]

interfaces::HostResolverRequestClientPtr.

+  *request_handle = new Job(addresses, callback, mojo::GetProxy(&handle));
+  resolver_->Resolve(interfaces::HostResolverRequestInfo::From(info),
+                     handle.Pass());
+  return ERR_IO_PENDING;
+}
+
+int HostResolverMojo::ResolveFromCache(const RequestInfo& info,
+                                       AddressList* addresses,
+                                       const BoundNetLog& source_net_log) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DVLOG(1) << "ResolveFromCache " << info.host_port_pair().ToString();
+  // TODO(sammc): Support caching.
+  return ERR_DNS_CACHE_MISS;
+}
+
+void HostResolverMojo::CancelRequest(RequestHandle req) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  // Deleting the Job closes the HostResolverRequestClient connection,
+  // signalling cancellation of the request.
+  delete static_cast<Job*>(req);
+}
+
+HostResolverMojo::Job::Job(
+    AddressList* addresses,
+    const CompletionCallback& callback,
+    mojo::InterfaceRequest<interfaces::HostResolverRequestClient> request)
+    : addresses_(addresses),
+      callback_(callback),
+      binding_(this, request.Pass()) {
+  binding_.set_error_handler(this);
+}
+
+void HostResolverMojo::Job::ReportResult(
+    int32_t error,
+    interfaces::AddressListPtr address_list) {
+  if (error == OK && address_list)
+    *addresses_ = address_list->To<AddressList>();
+  callback_.Run(error);
+  delete this;
+}
+
+void HostResolverMojo::Job::OnConnectionError() {
+  ReportResult(ERR_FAILED, interfaces::AddressListPtr());
+}
+
+}  // namespace net