Reland "Change ProxyResolver::GetProxyForURL() to take a unique_ptr<Request>* "

net/proxy/proxy_resolver_factory_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_factory_mojo.h"
 
 #include <list>
 #include <map>
 #include <memory>
 #include <queue>
@@ skipping 281 matching lines @@
 
 class Request {
  public:
   Request(ProxyResolver* resolver, const GURL& url);
 
   int Resolve();
   void Cancel();
   int WaitForResult();
 
   const ProxyInfo& results() const { return results_; }
-  LoadState load_state() { return resolver_->GetLoadState(handle_); }
+  LoadState load_state() { return request_->GetLoadState(); }
   BoundTestNetLog& net_log() { return net_log_; }
+  const TestCompletionCallback& callback() const { return callback_; }
 
  private:
   ProxyResolver* resolver_;
   const GURL url_;
   ProxyInfo results_;
-  ProxyResolver::RequestHandle handle_;
+  std::unique_ptr<ProxyResolver::Request> request_;
   int error_;
   TestCompletionCallback callback_;
   BoundTestNetLog net_log_;
 };
 
 Request::Request(ProxyResolver* resolver, const GURL& url)
     : resolver_(resolver), url_(url), error_(0) {
 }
 
 int Request::Resolve() {
   error_ = resolver_->GetProxyForURL(url_, &results_, callback_.callback(),
-                                     &handle_, net_log_.bound());
+                                     &request_, net_log_.bound());
   return error_;
 }
 
 void Request::Cancel() {
-  resolver_->CancelRequest(handle_);
+  request_.reset();
 }
 
 int Request::WaitForResult() {
   error_ = callback_.WaitForResult();
   return error_;
 }
 
 class MockMojoProxyResolverFactory : public interfaces::ProxyResolverFactory {
  public:
   MockMojoProxyResolverFactory(
@@ skipping 444 matching lines @@
 }
 
 TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_Cancel) {
   mock_proxy_resolver_.AddGetProxyAction(
       GetProxyForUrlAction::WaitForClientDisconnect(GURL(kExampleUrl)));
   CreateProxyResolver();
 
   std::unique_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
   EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING));
   request->Cancel();
+  EXPECT_FALSE(request->callback().have_result());
 
   // The Mojo request is still made.
   mock_proxy_resolver_.WaitForNextRequest();
 }
 
 TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_MultipleRequests) {
   mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
       GURL(kExampleUrl), ProxyServersFromPacString("DIRECT")));
   mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
       GURL("https://www.chromium.org"),
@@ skipping 42 matching lines @@
   EXPECT_THAT(request1->WaitForResult(), IsError(ERR_PAC_SCRIPT_TERMINATED));
 }
 
 TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_DeleteInCallback) {
   mock_proxy_resolver_.AddGetProxyAction(GetProxyForUrlAction::ReturnServers(
       GURL(kExampleUrl), ProxyServersFromPacString("DIRECT")));
   CreateProxyResolver();
 
   ProxyInfo results;
   TestCompletionCallback callback;
-  ProxyResolver::RequestHandle handle;
+  std::unique_ptr<ProxyResolver::Request> request;
   NetLogWithSource net_log;
   EXPECT_EQ(
       OK,
       callback.GetResult(proxy_resolver_mojo_->GetProxyForURL(
           GURL(kExampleUrl), &results,
           base::Bind(&ProxyResolverFactoryMojoTest::DeleteProxyResolverCallback,
                      base::Unretained(this), callback.callback()),
-          &handle, net_log)));
+          &request, net_log)));
   on_delete_callback_.WaitForResult();
 }
 
 TEST_F(ProxyResolverFactoryMojoTest,
        GetProxyForURL_DeleteInCallbackFromDisconnect) {
   mock_proxy_resolver_.AddGetProxyAction(
       GetProxyForUrlAction::Disconnect(GURL(kExampleUrl)));
   CreateProxyResolver();
 
   ProxyInfo results;
   TestCompletionCallback callback;
-  ProxyResolver::RequestHandle handle;
+  std::unique_ptr<ProxyResolver::Request> request;
   NetLogWithSource net_log;
   EXPECT_EQ(
       ERR_PAC_SCRIPT_TERMINATED,
       callback.GetResult(proxy_resolver_mojo_->GetProxyForURL(
           GURL(kExampleUrl), &results,
           base::Bind(&ProxyResolverFactoryMojoTest::DeleteProxyResolverCallback,
                      base::Unretained(this), callback.callback()),
-          &handle, net_log)));
+          &request, net_log)));
   on_delete_callback_.WaitForResult();
 }
 
 TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_DnsRequest) {
   mock_proxy_resolver_.AddGetProxyAction(
       GetProxyForUrlAction::MakeDnsRequest(GURL(kExampleUrl)));
   CreateProxyResolver();
 
   std::unique_ptr<Request> request(MakeRequest(GURL(kExampleUrl)));
   EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING));
   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, request->load_state());
 
   host_resolver_.waiter().WaitForEvent(MockHostResolver::DNS_REQUEST);
   EXPECT_EQ(LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT, request->load_state());
   mock_proxy_resolver_.ClearBlockedClients();
   request->WaitForResult();
 }
 
 TEST_F(ProxyResolverFactoryMojoTest, DeleteResolver) {
   CreateProxyResolver();
   proxy_resolver_mojo_.reset();
   on_delete_callback_.WaitForResult();
 }
 }  // namespace net