Shut down proxy resolver utility processes when no longer needed.

net/proxy/proxy_resolver_mojo_unittest.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 <list>
 #include <map>
 #include <queue>
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "mojo/common/common_type_converters.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/log/net_log.h"
+#include "net/proxy/mojo_proxy_resolver_factory.h"
 #include "net/proxy/mojo_proxy_type_converters.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_resolver_script_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/binding.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/error_handler.h"
 #include "url/gurl.h"
 
 namespace net {
 
@@ skipping 364 matching lines @@
       break;
     case CreateProxyResolverAction::WAIT_FOR_CLIENT_DISCONNECT:
       ASSERT_FALSE(client.WaitForIncomingMethodCall());
       break;
   }
   WakeWaiter();
 }
 
 }  // namespace
 
-class ProxyResolverMojoTest : public testing::Test {
+class ProxyResolverMojoTest : public testing::Test,
+                              public MojoProxyResolverFactory {
  public:
   void SetUp() override {
     mock_proxy_resolver_factory_.reset(new MockMojoProxyResolverFactory(
         &mock_proxy_resolver_, mojo::GetProxy(&factory_ptr_)));
     proxy_resolver_factory_mojo_.reset(
-        new ProxyResolverFactoryMojo(factory_ptr_.get(), nullptr));
+        new ProxyResolverFactoryMojo(this, nullptr));
   }
 
   scoped_ptr<Request> MakeRequest(const GURL& url) {
     return make_scoped_ptr(new Request(proxy_resolver_mojo_.get(), url));
   }
 
+  scoped_ptr<base::ScopedClosureRunner> CreateResolver(
+      const mojo::String& pac_script,
+      mojo::InterfaceRequest<interfaces::ProxyResolver> req,
+      interfaces::HostResolverPtr host_resolver,
+      interfaces::ProxyResolverFactoryRequestClientPtr client) override {
+    factory_ptr_->CreateResolver(pac_script, req.Pass(), host_resolver.Pass(),
+                                 client.Pass());
+    return make_scoped_ptr(
+        new base::ScopedClosureRunner(on_delete_callback_.closure()));
+  }
+
   mojo::Array<interfaces::ProxyServerPtr> ProxyServersFromPacString(
       const std::string& pac_string) {
     ProxyInfo proxy_info;
     proxy_info.UsePacString(pac_string);
 
     return mojo::Array<interfaces::ProxyServerPtr>::From(
         proxy_info.proxy_list().GetAll());
   }
 
   void CreateProxyResolver() {
     mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
         CreateProxyResolverAction::ReturnResult(kScriptData, OK));
     TestCompletionCallback callback;
     scoped_refptr<ProxyResolverScriptData> pac_script(
         ProxyResolverScriptData::FromUTF8(kScriptData));
     scoped_ptr<ProxyResolverFactory::Request> request;
     ASSERT_EQ(
         OK,
         callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
             pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
     EXPECT_TRUE(request);
     ASSERT_TRUE(proxy_resolver_mojo_);
   }
 
+  void DeleteProxyResolverCallback(const CompletionCallback& callback,
+                                   int result) {
+    proxy_resolver_mojo_.reset();
+    callback.Run(result);
+  }
+
   scoped_ptr<MockMojoProxyResolverFactory> mock_proxy_resolver_factory_;
   interfaces::ProxyResolverFactoryPtr factory_ptr_;
   scoped_ptr<ProxyResolverFactory> proxy_resolver_factory_mojo_;
 
   MockMojoProxyResolver mock_proxy_resolver_;
   scoped_ptr<ProxyResolver> proxy_resolver_mojo_;
+  TestClosure on_delete_callback_;
 };
 
 TEST_F(ProxyResolverMojoTest, CreateProxyResolver) {
   CreateProxyResolver();
 }
 
 TEST_F(ProxyResolverMojoTest, CreateProxyResolver_Empty) {
   TestCompletionCallback callback;
   scoped_refptr<ProxyResolverScriptData> pac_script(
       ProxyResolverScriptData::FromUTF8(""));
@@ skipping 24 matching lines @@
 
   TestCompletionCallback callback;
   scoped_refptr<ProxyResolverScriptData> pac_script(
       ProxyResolverScriptData::FromUTF8(kScriptData));
   scoped_ptr<ProxyResolverFactory::Request> request;
   EXPECT_EQ(
       ERR_PAC_STATUS_NOT_OK,
       callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
           pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
   EXPECT_TRUE(request);
+  on_delete_callback_.WaitForResult();
 
   // A second attempt succeeds.
   CreateProxyResolver();
 }
 
 TEST_F(ProxyResolverMojoTest, CreateProxyResolver_BothDisconnected) {
   mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
       CreateProxyResolverAction::DropBoth(kScriptData));
 
   scoped_refptr<ProxyResolverScriptData> pac_script(
@@ skipping 28 matching lines @@
 
   scoped_refptr<ProxyResolverScriptData> pac_script(
       ProxyResolverScriptData::FromUTF8(kScriptData));
   scoped_ptr<ProxyResolverFactory::Request> request;
   TestCompletionCallback callback;
   EXPECT_EQ(
       ERR_PAC_SCRIPT_TERMINATED,
       callback.GetResult(proxy_resolver_factory_mojo_->CreateProxyResolver(
           pac_script, &proxy_resolver_mojo_, callback.callback(), &request)));
   EXPECT_TRUE(request);
+  on_delete_callback_.WaitForResult();
 }
 
 TEST_F(ProxyResolverMojoTest, CreateProxyResolver_Cancel) {
   mock_proxy_resolver_factory_->AddCreateProxyResolverAction(
       CreateProxyResolverAction::WaitForClientDisconnect(kScriptData));
 
   scoped_refptr<ProxyResolverScriptData> pac_script(
       ProxyResolverScriptData::FromUTF8(kScriptData));
   scoped_ptr<ProxyResolverFactory::Request> request;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, proxy_resolver_factory_mojo_->CreateProxyResolver(
                                 pac_script, &proxy_resolver_mojo_,
                                 callback.callback(), &request));
   ASSERT_TRUE(request);
   request.reset();
 
   // The Mojo request is still made.
   mock_proxy_resolver_factory_->WaitForNextRequest();
+  on_delete_callback_.WaitForResult();
 }
 
 TEST_F(ProxyResolverMojoTest, GetProxyForURL) {
   mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
       GURL(kExampleUrl), ProxyServersFromPacString("DIRECT")));
   CreateProxyResolver();
 
   scoped_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
   EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
   EXPECT_EQ(OK, request->WaitForResult());
@@ skipping 98 matching lines @@
   mock_proxy_resolver_.AddGetProxyAction(
       GetProxyForUrlAction::DropRequest(GURL(kExampleUrl)));
   CreateProxyResolver();
 
   scoped_ptr<Request> request1(MakeRequest(GURL(kExampleUrl)));
   EXPECT_EQ(ERR_IO_PENDING, request1->Resolve());
 
   EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED, request1->WaitForResult());
 }
 
+TEST_F(ProxyResolverMojoTest, GetProxyForURL_DeleteInCallback) {
+  mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
+      GURL(kExampleUrl), ProxyServersFromPacString("DIRECT")));
+  CreateProxyResolver();
+
+  ProxyInfo results;
+  TestCompletionCallback callback;
+  ProxyResolver::RequestHandle handle;
+  BoundNetLog net_log;
+  EXPECT_EQ(OK,
+            callback.GetResult(proxy_resolver_mojo_->GetProxyForURL(
+                GURL(kExampleUrl), &results,
+                base::Bind(&ProxyResolverMojoTest::DeleteProxyResolverCallback,
+                           base::Unretained(this), callback.callback()),
+                &handle, net_log)));
+  on_delete_callback_.WaitForResult();
+}
+
+TEST_F(ProxyResolverMojoTest, GetProxyForURL_DeleteInCallbackFromDisconnect) {
+  mock_proxy_resolver_.AddGetProxyAction(
+      GetProxyForUrlAction::Disconnect(GURL(kExampleUrl)));
+  CreateProxyResolver();
+
+  ProxyInfo results;
+  TestCompletionCallback callback;
+  ProxyResolver::RequestHandle handle;
+  BoundNetLog net_log;
+  EXPECT_EQ(ERR_PAC_SCRIPT_TERMINATED,
+            callback.GetResult(proxy_resolver_mojo_->GetProxyForURL(
+                GURL(kExampleUrl), &results,
+                base::Bind(&ProxyResolverMojoTest::DeleteProxyResolverCallback,
+                           base::Unretained(this), callback.callback()),
+                &handle, net_log)));
+  on_delete_callback_.WaitForResult();
+}
+
+TEST_F(ProxyResolverMojoTest, DeleteResolver) {
+  CreateProxyResolver();
+  proxy_resolver_mojo_.reset();
+  on_delete_callback_.WaitForResult();
+}
 }  // namespace net