Shut down proxy resolver utility processes when no longer needed.

net/proxy/proxy_service_mojo.cc

Index: net/proxy/proxy_service_mojo.cc
diff --git a/net/proxy/proxy_service_mojo.cc b/net/proxy/proxy_service_mojo.cc
index b714f03efcb5a1f572a11ea3625daf5c6a2f9997..c8e94b2ebc614edd719845ccbe9a8205197217d8 100644
--- a/net/proxy/proxy_service_mojo.cc
+++ b/net/proxy/proxy_service_mojo.cc
@@ -4,8 +4,9 @@
 
 #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"
@@ -17,6 +18,40 @@
 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(
@@ -28,8 +63,16 @@ class ProxyResolverFactoryForMojoResolver : public ProxyResolverFactory {
 
   // 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: