Shut down proxy resolver utility processes when no longer needed.

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/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/common/url_type_converters.h"
 #include "net/base/net_errors.h"
 #include "net/dns/mojo_host_resolver_impl.h"
-#include "net/proxy/mojo_proxy_resolver_factory.h"
 #include "net/proxy/mojo_proxy_type_converters.h"
 #include "net/proxy/proxy_info.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 ProxyResolverMojo::Job : public interfaces::ProxyResolverRequestClient,
                                public mojo::ErrorHandler {
  public:
@@ skipping 79 matching lines @@
   callback_.Reset();
   resolver_->RemoveJob(this);
   callback.Run(error);
 }
 
 void ProxyResolverMojo::Job::LoadStateChanged(int32_t load_state) {
   load_state_ = static_cast<LoadState>(load_state);
 }
 
 ProxyResolverMojo::ProxyResolverMojo(
-    MojoProxyResolverFactory* mojo_proxy_resolver_factory,
-    HostResolver* host_resolver)
+    interfaces::ProxyResolverPtr mojo_proxy_resolver,
+    HostResolver* host_resolver,
+    mojo::InterfaceRequest<interfaces::HostResolver> host_resolver_request,
+    scoped_ptr<base::ScopedClosureRunner> runner)
     : ProxyResolver(true /* |expects_pac_bytes| */),
-      mojo_proxy_resolver_factory_(mojo_proxy_resolver_factory),
-      host_resolver_(host_resolver) {
+      mojo_proxy_resolver_ptr_(mojo_proxy_resolver.Pass()),
+      host_resolver_(host_resolver),
+      host_resolver_binding_(&host_resolver_, host_resolver_request.Pass()),
+      runner_(runner.Pass()) {
+  mojo_proxy_resolver_ptr_.set_error_handler(this);
 }
 
 ProxyResolverMojo::~ProxyResolverMojo() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // All pending requests should have been cancelled.
   DCHECK(pending_jobs_.empty());
   DCHECK(set_pac_script_callback_.IsCancelled());
 }
 
 void ProxyResolverMojo::CancelSetPacScript() {
@@ skipping 11 matching lines @@
       pac_script->utf16().empty()) {
     return ERR_PAC_SCRIPT_FAILED;
   }
 
   DVLOG(1) << "ProxyResolverMojo::SetPacScript: " << pac_script->utf16();
   set_pac_script_callback_.Reset(
       base::Bind(&ProxyResolverMojo::OnSetPacScriptDone, base::Unretained(this),
                  pac_script, callback));
 
   if (!mojo_proxy_resolver_ptr_)
-    SetUpServices();
+    return ERR_PAC_SCRIPT_TERMINATED;
 
   mojo_proxy_resolver_ptr_->SetPacScript(
       mojo::String::From(pac_script->utf16()),
       set_pac_script_callback_.callback());
 
   return ERR_IO_PENDING;
 }
 
 void ProxyResolverMojo::OnSetPacScriptDone(
     const scoped_refptr<ProxyResolverScriptData>& pac_script,
     const net::CompletionCallback& callback,
     int32_t result) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!set_pac_script_callback_.IsCancelled());
   DVLOG(1) << "ProxyResolverMojo::OnSetPacScriptDone: " << result;
 
   // |callback| is owned by |set_pac_script_callback_|, so make a copy before
   // cancelling.
   auto callback_copy = callback;
   set_pac_script_callback_.Cancel();
   callback_copy.Run(result);
 }
 
-void ProxyResolverMojo::SetUpServices() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  // A Mojo service implementation must outlive its binding.
-  mojo_host_resolver_binding_.reset();
-
-  interfaces::HostResolverPtr mojo_host_resolver_ptr;
-  mojo_host_resolver_.reset(new MojoHostResolverImpl(host_resolver_));
-  mojo_host_resolver_binding_.reset(new mojo::Binding<interfaces::HostResolver>(
-      mojo_host_resolver_.get(), mojo::GetProxy(&mojo_host_resolver_ptr)));
-  mojo_proxy_resolver_ptr_.reset();
-  mojo_proxy_resolver_factory_->Create(
-      mojo::GetProxy(&mojo_proxy_resolver_ptr_), mojo_host_resolver_ptr.Pass());
-  mojo_proxy_resolver_ptr_.set_error_handler(this);
-}
-
 void ProxyResolverMojo::OnConnectionError() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "ProxyResolverMojo::OnConnectionError";
 
   // Disconnect from the Mojo proxy resolver service. An attempt to reconnect
   // will happen on the next |SetPacScript()| request.
   mojo_proxy_resolver_ptr_.reset();
 
   // This callback may call |SetPacScript()| and re-create the connection. So
   // disconnect from the Mojo service (above) before aborting the pending
   // request.
   if (!set_pac_script_callback_.IsCancelled())
     set_pac_script_callback_.callback().Run(ERR_PAC_SCRIPT_TERMINATED);
 }
 
 void ProxyResolverMojo::RemoveJob(Job* job) {
   DCHECK(thread_checker_.CalledOnValidThread());
   size_t num_erased = pending_jobs_.erase(job);
   DCHECK(num_erased);
   delete job;
 }
 
 int ProxyResolverMojo::GetProxyForURL(const GURL& url,
                                       ProxyInfo* results,
                                       const net::CompletionCallback& callback,
                                       RequestHandle* request,
                                       const BoundNetLog& net_log) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // If the Mojo service is not connected, fail. The Mojo service is connected
-  // when the script is set, which must be done after construction and after a
-  // previous request returns ERR_PAC_SCRIPT_TERMINATED due to the Mojo proxy
-  // resolver process crashing.
-  if (!mojo_proxy_resolver_ptr_) {
-    DVLOG(1) << "ProxyResolverMojo::GetProxyForURL: Mojo not connected";
+  if (!mojo_proxy_resolver_ptr_)
     return ERR_PAC_SCRIPT_TERMINATED;
-  }
 
   Job* job = new Job(this, url, results, callback);
   bool inserted = pending_jobs_.insert(job).second;
   DCHECK(inserted);
   *request = job;
 
   return ERR_IO_PENDING;
 }
 
 void ProxyResolverMojo::CancelRequest(RequestHandle request) {
   DCHECK(thread_checker_.CalledOnValidThread());
   Job* job = static_cast<Job*>(request);
   DCHECK(job);
   job->Cancel();
   RemoveJob(job);
 }
 
 LoadState ProxyResolverMojo::GetLoadState(RequestHandle request) const {
   Job* job = static_cast<Job*>(request);
   CHECK_EQ(1u, pending_jobs_.count(job));
   return job->load_state();
 }
 
 }  // namespace net