Shut down proxy resolver utility processes when no longer needed.

net/proxy/proxy_service_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_service_mojo.h"
 
+#include "base/callback_helpers.h"
 #include "base/logging.h"
-#include "net/dns/host_resolver_mojo.h"
+#include "net/dns/mojo_host_resolver_impl.h"
 #include "net/interfaces/proxy_resolver_service.mojom.h"
 #include "net/proxy/in_process_mojo_proxy_resolver_factory.h"
 #include "net/proxy/mojo_proxy_resolver_impl.h"
 #include "net/proxy/proxy_resolver_factory.h"
 #include "net/proxy/proxy_resolver_mojo.h"
 #include "net/proxy/proxy_resolver_v8_tracing.h"
 #include "net/proxy/proxy_service.h"
 
 namespace net {
 namespace {
 
+class MojoHostResolverHolder {
+ public:
+  // Connects |host_resolver_request| to |host_resolver| using a
+  // MojoHostResolverImpl that will remain until the returned
+  // base::ScopedClosureRunner is destroyed. |runner| is destroyed when the
+  // returned base::ScopedClosureRunner is destroyed.
+  static scoped_ptr<base::ScopedClosureRunner> Create(

[eroman, 2015/04/15 00:46:44]

This code is hard to read and the ownerships hard to follow.

[Sam McNally, 2015/04/15 06:04:22]

Moved ownership of the MojoHostResolverImpl back into ProxyResolverMojo.

+      HostResolver* host_resolver,
+      mojo::InterfaceRequest<interfaces::HostResolver> host_resolver_request,
+      scoped_ptr<base::ScopedClosureRunner> runner) {
+    return make_scoped_ptr(new base::ScopedClosureRunner(base::Bind(
+        &MojoHostResolverHolder::Delete,
+        base::Passed(make_scoped_ptr(new MojoHostResolverHolder(
+            host_resolver, host_resolver_request.Pass(), runner.Pass()))))));
+  }
+
+ private:
+  MojoHostResolverHolder(
+      HostResolver* host_resolver,
+      mojo::InterfaceRequest<interfaces::HostResolver> host_resolver_request,
+      scoped_ptr<base::ScopedClosureRunner> runner)
+      : mojo_host_resolver_(host_resolver),
+        mojo_host_resolver_binding_(&mojo_host_resolver_,
+                                    host_resolver_request.Pass()),
+        runner_(runner.Pass()) {}
+
+  // Implicitly delete when |holder| falls out of scope.
+  static void Delete(scoped_ptr<MojoHostResolverHolder> holder) {}
+
+  MojoHostResolverImpl mojo_host_resolver_;
+  mojo::Binding<interfaces::HostResolver> mojo_host_resolver_binding_;
+  scoped_ptr<base::ScopedClosureRunner> runner_;
+};
+
 class ProxyResolverFactoryForMojoResolver : public ProxyResolverFactory {
  public:
   ProxyResolverFactoryForMojoResolver(
       MojoProxyResolverFactory* mojo_proxy_factory,
       HostResolver* host_resolver)
       : ProxyResolverFactory(true),
         mojo_proxy_factory_(mojo_proxy_factory),
         host_resolver_(host_resolver) {}
 
   // ProxyResolverFactory override.
   scoped_ptr<ProxyResolver> CreateProxyResolver() override {
+    interfaces::HostResolverPtr mojo_host_resolver_ptr;
+    interfaces::ProxyResolverPtr mojo_proxy_resolver_ptr;
+    auto host_resolver_request = mojo::GetProxy(&mojo_host_resolver_ptr);
+    scoped_ptr<base::ScopedClosureRunner> runner(
+        mojo_proxy_factory_->Create(mojo::GetProxy(&mojo_proxy_resolver_ptr),
+                                    mojo_host_resolver_ptr.Pass()));
+    runner = MojoHostResolverHolder::Create(
+        host_resolver_, host_resolver_request.Pass(), runner.Pass());
     return make_scoped_ptr(
-        new ProxyResolverMojo(mojo_proxy_factory_, host_resolver_));
+        new ProxyResolverMojo(mojo_proxy_resolver_ptr.Pass(), runner.Pass()));
   }
 
  private:
   MojoProxyResolverFactory* const mojo_proxy_factory_;
   HostResolver* const host_resolver_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyResolverFactoryForMojoResolver);
 };
 
 }  // namespace
@@ skipping 31 matching lines @@
     HostResolver* host_resolver,
     NetLog* net_log,
     NetworkDelegate* network_delegate) {
   return CreateProxyServiceUsingMojoFactory(
       InProcessMojoProxyResolverFactory::GetInstance(), proxy_config_service,
       proxy_script_fetcher, dhcp_proxy_script_fetcher, host_resolver, net_log,
       network_delegate);
 }
 
 }  // namespace net