Implement browser-side host resolver Mojo service.

BUG=11746

Review URL: https://codereview.chromium.org/892393005

Cr-Commit-Position: refs/heads/master@{#316160}

net/BUILD.gn

@@ -790,6 +790,35 @@ if (use_v8_in_net) {
   }
 }
 
+if (use_v8_in_net && !is_android) {
+  source_set("net_browser_services") {
+    sources = [
+      "dns/mojo_host_resolver_impl.cc",
+      "dns/mojo_host_resolver_impl.h",
+    ]
+
+    public_deps = [
+      ":mojo_type_converters",
+      ":net",
+      "//net/interfaces",
+      "//third_party/mojo/src/mojo/public/cpp/bindings",
+    ]
+  }
+
+  source_set("mojo_type_converters") {
+    sources = [
+      "dns/mojo_type_converters.cc",
+      "dns/mojo_type_converters.h",
+    ]
+
+    public_deps = [
+      ":net",
+      "//net/interfaces",
+      "//third_party/mojo/src/mojo/public/cpp/bindings",
+    ]
+  }
+}
+
 if (!is_ios && !is_android) {
   executable("crash_cache") {
     testonly = true
@@ -1319,6 +1348,16 @@ if (!is_android && !is_win && !is_mac) {
       ]
     }
 
+    if (use_v8_in_net && !is_android) {
+      deps += [
+        ":net_browser_services",
+        "//mojo/environment:chromium",
+        "//third_party/mojo/src/mojo/edk/system",
+      ]
+    } else {
+      sources -= [ "dns/mojo_host_resolver_impl_unittest.cc" ]
+    }
+
     if (!enable_mdns) {
       sources -= [
         "dns/mdns_cache_unittest.cc",

net/DEPS

@@ -4,6 +4,7 @@ include_rules = [
   "+jni",
   "+third_party/apple_apsl",
   "+third_party/libevent",
+  "+third_party/mojo/src/mojo/public",
   "+third_party/nss",
   "+third_party/zlib",
   "+sdch/open-vcdiff",
@@ -50,6 +51,10 @@ specific_include_rules = {
   "ftp_directory_listing_parser\.cc": [
     "+base/i18n",
   ],
+
+  "run_all_unittests\.cc": [
+    "+third_party/mojo/src/mojo/edk",
+  ],
 }
 
 skip_child_includes = [

net/dns/mojo_host_resolver_impl.cc

@@ -0,0 +1,130 @@
+// 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/mojo_host_resolver_impl.h"
+
+#include "base/basictypes.h"
+#include "base/stl_util.h"
+#include "net/base/address_list.h"
+#include "net/base/net_errors.h"
+#include "net/dns/host_resolver.h"
+#include "net/dns/mojo_type_converters.h"
+
+namespace net {
+
+// Handles host resolution for a single request and sends a response when done.
+// Also detects connection errors for HostResolverRequestClient and cancels the
+// outstanding resolve request. Owned by MojoHostResolverImpl.
+class MojoHostResolverImpl::Job : public mojo::ErrorHandler {
+ public:
+  Job(MojoHostResolverImpl* resolver_service,
+      net::HostResolver* resolver,
+      const net::HostResolver::RequestInfo& request_info,
+      interfaces::HostResolverRequestClientPtr client);
+  ~Job() override;
+
+  void Start();
+
+ private:
+  // Completion callback for the HostResolver::Resolve request.
+  void OnResolveDone(int result);
+
+  // Overridden from mojo::ErrorHandler:
+  void OnConnectionError() override;
+
+  MojoHostResolverImpl* resolver_service_;
+  net::HostResolver* resolver_;
+  net::HostResolver::RequestInfo request_info_;
+  interfaces::HostResolverRequestClientPtr client_;
+  net::HostResolver::RequestHandle handle_;
+  AddressList result_;
+  base::ThreadChecker thread_checker_;
+};
+
+MojoHostResolverImpl::MojoHostResolverImpl(net::HostResolver* resolver)
+    : resolver_(resolver) {
+}
+
+MojoHostResolverImpl::~MojoHostResolverImpl() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  STLDeleteElements(&pending_jobs_);
+}
+
+void MojoHostResolverImpl::Resolve(
+    interfaces::HostResolverRequestInfoPtr request_info,
+    interfaces::HostResolverRequestClientPtr client) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  Job* job = new Job(this, resolver_,
+                     request_info->To<net::HostResolver::RequestInfo>(),
+                     client.Pass());
+  pending_jobs_.insert(job);
+  job->Start();
+}
+
+void MojoHostResolverImpl::DeleteJob(Job* job) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  size_t num_erased = pending_jobs_.erase(job);
+  DCHECK(num_erased);
+  delete job;
+}
+
+MojoHostResolverImpl::Job::Job(
+    MojoHostResolverImpl* resolver_service,
+    net::HostResolver* resolver,
+    const net::HostResolver::RequestInfo& request_info,
+    interfaces::HostResolverRequestClientPtr client)
+    : resolver_service_(resolver_service),
+      resolver_(resolver),
+      request_info_(request_info),
+      client_(client.Pass()),
+      handle_(nullptr) {
+  client_.set_error_handler(this);
+}
+
+void MojoHostResolverImpl::Job::Start() {
+  DVLOG(1) << "Resolve " << request_info_.host_port_pair().ToString();
+  BoundNetLog net_log;
+  int result =
+      resolver_->Resolve(request_info_, DEFAULT_PRIORITY, &result_,
+                         base::Bind(&MojoHostResolverImpl::Job::OnResolveDone,
+                                    base::Unretained(this)),
+                         &handle_, net_log);
+
+  if (result != ERR_IO_PENDING)
+    OnResolveDone(result);
+}
+
+MojoHostResolverImpl::Job::~Job() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (handle_)
+    resolver_->CancelRequest(handle_);
+}
+
+void MojoHostResolverImpl::Job::OnResolveDone(int result) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  handle_ = nullptr;
+  DVLOG(1) << "Resolved " << request_info_.host_port_pair().ToString()
+           << " with error " << result << " and " << result_.size()
+           << " results!";
+  for (const auto& address : result_) {
+    DVLOG(1) << address.ToString();
+  }
+  if (result == OK)
+    client_->ReportResult(result, interfaces::AddressList::From(result_));
+  else
+    client_->ReportResult(result, nullptr);
+
+  resolver_service_->DeleteJob(this);
+}
+
+void MojoHostResolverImpl::Job::OnConnectionError() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  // |resolver_service_| should always outlive us.
+  DCHECK(resolver_service_);
+  DVLOG(1) << "Connection error on request for "
+           << request_info_.host_port_pair().ToString();
+  resolver_service_->DeleteJob(this);
+}
+
+}  // namespace net

net/dns/mojo_host_resolver_impl.h

@@ -0,0 +1,53 @@
+// 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.
+
+#ifndef NET_DNS_MOJO_HOST_RESOLVER_IMPL_H_
+#define NET_DNS_MOJO_HOST_RESOLVER_IMPL_H_
+
+#include <set>
+
+#include "base/macros.h"
+#include "base/threading/thread_checker.h"
+#include "net/interfaces/host_resolver_service.mojom.h"
+
+namespace net {
+
+class HostResolver;
+
+// This is the implementation of the HostResolver Mojo interface.
+// Inbound Mojo requests are sent to the HostResolver passed into the
+// constructor. When destroyed, any outstanding resolver requests are cancelled.
+// If a request's HostResolverRequestClient is shut down, the associated
+// resolver request is cancelled.
+class MojoHostResolverImpl : public interfaces::HostResolver {
+ public:
+  // |resolver| is expected to outlive |this|.
+  explicit MojoHostResolverImpl(net::HostResolver* resolver);
+  ~MojoHostResolverImpl() override;
+
+ private:
+  class Job;
+
+  // Removes |job| from the set of pending jobs, and deletes it.
+  void DeleteJob(Job* job);
+
+  // Overridden from net::interfaces::HostResolver:
+  void Resolve(interfaces::HostResolverRequestInfoPtr request_info,
+               interfaces::HostResolverRequestClientPtr client) override;
+
+  // Resolver for resolving incoming requests. Not owned.
+  net::HostResolver* resolver_;
+
+  // All pending jobs, so they can be cancelled when this service is destroyed.
+  // Owns all jobs.
+  std::set<Job*> pending_jobs_;
+
+  base::ThreadChecker thread_checker_;
+
+  DISALLOW_COPY_AND_ASSIGN(MojoHostResolverImpl);
+};
+
+}  // namespace net
+
+#endif  // NET_DNS_MOJO_HOST_RESOLVER_IMPL_H_