Implement browser-side host resolver Mojo service.

net/dns/host_resolver_service_impl.cc

Index: net/dns/host_resolver_service_impl.cc
diff --git a/net/dns/host_resolver_service_impl.cc b/net/dns/host_resolver_service_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..30441ac40e78a52b8ec350ce935a98302a3db0bf
--- /dev/null
+++ b/net/dns/host_resolver_service_impl.cc
@@ -0,0 +1,135 @@
+// 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_service_impl.h"
+
+#include "base/basictypes.h"
+#include "net/base/address_list.h"
+#include "net/base/net_errors.h"
+#include "net/dns/host_resolver.h"
+#include "net/dns/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 HostResolverServiceImpl.
+class HostResolverServiceImpl::Job : public mojo::ErrorHandler {
+ public:
+  Job(HostResolverServiceImpl* resolver_service,
+      HostResolver* resolver,
+      const HostResolver::RequestInfo& request_info,
+      interfaces::HostResolverRequestClientPtr client);
+
+  void Start();

[Sam McNally, 2015/02/05 23:58:36]

I'd prefer to not have a way to create a Job without starting it.

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

Done.

+  void Cancel();
+
+ private:
+  // Completion callback for the HostResolver::Resolve request.
+  void OnResolveDone(int32_t result);
+
+  // Overridden from mojo::ErrorHandler:
+  void OnConnectionError() override;
+
+  HostResolverServiceImpl* resolver_service_;
+  HostResolver* resolver_;
+  HostResolver::RequestInfo request_info_;
+  interfaces::HostResolverRequestClientPtr client_;
+  HostResolver::RequestHandle handle_;
+  AddressList result_;
+  BoundNetLog net_log_;

[eroman, 2015/02/05 19:51:11]

This is not actually initialized. Rather may want to leave this out and pass the
dependency in where used.

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

Done.

+  base::ThreadChecker thread_checker_;
+};
+
+HostResolverServiceImpl::HostResolverServiceImpl(HostResolver* resolver)
+    : resolver_(resolver) {
+}
+
+HostResolverServiceImpl::~HostResolverServiceImpl() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  for (Job* job : pending_jobs_) {

[eroman, 2015/02/05 19:51:11]

How about having cancellation be done as part of deletion?

Then STLDeleteElements(&pending_jobs_) would be sufficient, and explicit job
cancel method not needed

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

Done.

+    job->Cancel();
+    delete job;
+  }
+}
+
+size_t HostResolverServiceImpl::OutstandingRequestsForTesting() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return pending_jobs_.size();
+}
+
+void HostResolverServiceImpl::Resolve(
+    interfaces::HostResolverRequestInfoPtr request_info,
+    interfaces::HostResolverRequestClientPtr client) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  Job* job =
+      new Job(this, resolver_, request_info->To<HostResolver::RequestInfo>(),
+              client.Pass());
+  pending_jobs_.insert(job);
+  job->Start();
+}
+
+void HostResolverServiceImpl::DeleteJob(Job* job) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  size_t num_erased = pending_jobs_.erase(job);
+  DCHECK(num_erased);
+  delete job;
+}
+
+HostResolverServiceImpl::Job::Job(
+    HostResolverServiceImpl* resolver_service,
+    HostResolver* resolver,
+    const 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 HostResolverServiceImpl::Job::Start() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DVLOG(1) << "Resolve " << request_info_.host_port_pair().ToString();
+  int32_t result = resolver_->Resolve(

[eroman, 2015/02/05 19:51:11]

"int" is what the net stack uses, I suggest you stick to the same type here.
Even though in practice we compile with 32-bit ints on all platforms at the
moment.

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

Oops. Was stuck in the Mojo mentality of fixed-size types.

+      request_info_, DEFAULT_PRIORITY, &result_,
+      base::Bind(&HostResolverServiceImpl::Job::OnResolveDone,
+                 base::Unretained(this)),
+      &handle_, net_log_);
+
+  if (result != ERR_IO_PENDING)
+    OnResolveDone(result);
+}
+
+void HostResolverServiceImpl::Job::Cancel() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  resolver_->CancelRequest(handle_);
+}
+
+void HostResolverServiceImpl::Job::OnResolveDone(int32_t result) {

[eroman, 2015/02/05 19:51:11]

why int32_t? The //net code defines error as "int"

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

Fixed.

+  DCHECK(thread_checker_.CalledOnValidThread());
+  DVLOG(1) << "Resolved " << request_info_.host_port_pair().ToString()
+           << " with error " << result << " and " << result_.size()
+           << " results!";
+  for (const auto& address : result_) {
+    VLOG(1) << address.ToString();
+  }
+  if (result)
+    client_->ReportResult(result, nullptr);
+  else
+    client_->ReportResult(0, interfaces::AddressList::From(result_));
+
+  resolver_service_->DeleteJob(this);
+}
+
+void HostResolverServiceImpl::Job::OnConnectionError() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DVLOG(1) << "Connection error on request for "
+           << request_info_.host_port_pair().ToString();
+  Cancel();
+  resolver_service_->DeleteJob(this);
+}
+
+}  // namespace net