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

net/proxy/multi_threaded_proxy_resolver_unittest.cc

 // Copyright (c) 2012 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/multi_threaded_proxy_resolver.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
@@ skipping 35 matching lines @@
 //       - returns a single-item proxy list with the query's host.
 class MockProxyResolver : public ProxyResolver {
  public:
   MockProxyResolver()
       : worker_loop_(base::MessageLoop::current()), request_count_(0) {}
 
   // ProxyResolver implementation.
   int GetProxyForURL(const GURL& query_url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
-                     RequestHandle* request,
+                     std::unique_ptr<Request>* request,
                      const NetLogWithSource& net_log) override {
     if (!resolve_latency_.is_zero())
       base::PlatformThread::Sleep(resolve_latency_);
 
     CheckIsOnWorkerThread();
 
     EXPECT_TRUE(callback.is_null());
     EXPECT_TRUE(request == NULL);
 
     // Write something into |net_log| (doesn't really have any meaning.)
     net_log.BeginEvent(NetLogEventType::PAC_JAVASCRIPT_ALERT);
 
     results->UseNamedProxy(query_url.host());
 
     // Return a success code which represents the request's order.
     return request_count_++;
   }
 
-  void CancelRequest(RequestHandle request) override { NOTREACHED(); }
-
-  LoadState GetLoadState(RequestHandle request) const override {
-    NOTREACHED();
-    return LOAD_STATE_IDLE;
-  }
-
   int request_count() const { return request_count_; }
 
   void SetResolveLatency(base::TimeDelta latency) {
     resolve_latency_ = latency;
   }
 
  private:
   void CheckIsOnWorkerThread() {
     EXPECT_EQ(base::MessageLoop::current(), worker_loop_);
   }
@@ skipping 29 matching lines @@
     unblocked_.Signal();
   }
 
   void WaitUntilBlocked() {
     blocked_.Wait();
   }
 
   int GetProxyForURL(const GURL& query_url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
-                     RequestHandle* request,
+                     std::unique_ptr<Request>* request,
                      const NetLogWithSource& net_log) override {
     if (should_block_) {
       blocked_.Signal();
       unblocked_.Wait();
     }
 
     return MockProxyResolver::GetProxyForURL(
         query_url, results, callback, request, net_log);
   }
 
@@ skipping 170 matching lines @@
        SingleThread_UpdatesNetLogWithThreadWait) {
   const size_t kNumThreads = 1u;
   ASSERT_NO_FATAL_FAILURE(Init(kNumThreads));
 
   int rv;
 
   // Block the proxy resolver, so no request can complete.
   factory().resolvers()[0]->Block();
 
   // Start request 0.
-  ProxyResolver::RequestHandle request0;
+  std::unique_ptr<ProxyResolver::Request> request0;
   TestCompletionCallback callback0;
   ProxyInfo results0;
   BoundTestNetLog log0;
   rv = resolver().GetProxyForURL(GURL("http://request0"), &results0,
                                  callback0.callback(), &request0, log0.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Start 2 more requests (request1 and request2).
 
   TestCompletionCallback callback1;
   ProxyInfo results1;
   BoundTestNetLog log1;
   rv = resolver().GetProxyForURL(GURL("http://request1"), &results1,
                                  callback1.callback(), NULL, log1.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
-  ProxyResolver::RequestHandle request2;
+  std::unique_ptr<ProxyResolver::Request> request2;
   TestCompletionCallback callback2;
   ProxyInfo results2;
   BoundTestNetLog log2;
   rv = resolver().GetProxyForURL(GURL("http://request2"), &results2,
                                  callback2.callback(), &request2, log2.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Unblock the worker thread so the requests can continue running.
   factory().resolvers()[0]->WaitUntilBlocked();
   factory().resolvers()[0]->Unblock();
@@ skipping 42 matching lines @@
 TEST_F(MultiThreadedProxyResolverTest, SingleThread_CancelRequest) {
   const size_t kNumThreads = 1u;
   ASSERT_NO_FATAL_FAILURE(Init(kNumThreads));
 
   int rv;
 
   // Block the proxy resolver, so no request can complete.
   factory().resolvers()[0]->Block();
 
   // Start request 0.
-  ProxyResolver::RequestHandle request0;
+  std::unique_ptr<ProxyResolver::Request> request0;
   TestCompletionCallback callback0;
   ProxyInfo results0;
   rv = resolver().GetProxyForURL(GURL("http://request0"), &results0,
                                  callback0.callback(), &request0,
                                  NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Wait until requests 0 reaches the worker thread.
   factory().resolvers()[0]->WaitUntilBlocked();
 
   // Start 3 more requests (request1 : request3).
 
   TestCompletionCallback callback1;
   ProxyInfo results1;
   rv =
       resolver().GetProxyForURL(GURL("http://request1"), &results1,
                                 callback1.callback(), NULL, NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
-  ProxyResolver::RequestHandle request2;
+  std::unique_ptr<ProxyResolver::Request> request2;
   TestCompletionCallback callback2;
   ProxyInfo results2;
   rv = resolver().GetProxyForURL(GURL("http://request2"), &results2,
                                  callback2.callback(), &request2,
                                  NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   TestCompletionCallback callback3;
   ProxyInfo results3;
   rv =
       resolver().GetProxyForURL(GURL("http://request3"), &results3,
                                 callback3.callback(), NULL, NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Cancel request0 (inprogress) and request2 (pending).
-  resolver().CancelRequest(request0);
-  resolver().CancelRequest(request2);
+  request0.reset();
+  request2.reset();
 
   // Unblock the worker thread so the requests can continue running.
   factory().resolvers()[0]->Unblock();
 
   // Wait for requests 1 and 3 to finish.
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(1, rv);
   EXPECT_EQ("PROXY request1:80", results1.ToPacString());
 
@@ skipping 76 matching lines @@
   ASSERT_NO_FATAL_FAILURE(Init(kNumThreads));
 
   // Verify that it reaches the synchronous resolver.
   // One thread has been provisioned (i.e. one ProxyResolver was created).
   ASSERT_EQ(1u, factory().resolvers().size());
 
   const int kNumRequests = 8;
   int rv;
   TestCompletionCallback callback[kNumRequests];
   ProxyInfo results[kNumRequests];
-  ProxyResolver::RequestHandle request[kNumRequests];
+  std::unique_ptr<ProxyResolver::Request> request[kNumRequests];
 
   // Start request 0 -- this should run on thread 0 as there is nothing else
   // going on right now.
   rv = resolver().GetProxyForURL(GURL("http://request0"), &results[0],
                                  callback[0].callback(), &request[0],
                                  NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Wait for request 0 to finish.
   rv = callback[0].WaitForResult();
@@ skipping 54 matching lines @@
                                  NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = resolver().GetProxyForURL(GURL("http://request6"), &results[6],
                                  callback[6].callback(), &request[6],
                                  NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   rv = resolver().GetProxyForURL(GURL("http://request7"), &results[7],
                                  callback[7].callback(), &request[7],
                                  NetLogWithSource());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
-  resolver().CancelRequest(request[5]);
-  resolver().CancelRequest(request[6]);
+  request[5].reset();
+  request[6].reset();
 
   EXPECT_EQ(2, callback[7].WaitForResult());
 
   // Check that the cancelled requests never invoked their callback.
   EXPECT_FALSE(callback[5].have_result());
   EXPECT_FALSE(callback[6].have_result());
 
   // Unblock the first two threads and wait for their requests to complete.
   factory().resolvers()[0]->Unblock();
   factory().resolvers()[1]->Unblock();
@@ skipping 15 matching lines @@
   int rv;
 
   // One thread has been provisioned (i.e. one ProxyResolver was created).
   ASSERT_EQ(1u, factory().resolvers().size());
   EXPECT_EQ(ASCIIToUTF16("pac script bytes"),
             factory().script_data()[0]->utf16());
 
   const int kNumRequests = 4;
   TestCompletionCallback callback[kNumRequests];
   ProxyInfo results[kNumRequests];
-  ProxyResolver::RequestHandle request[kNumRequests];
+  std::unique_ptr<ProxyResolver::Request> request[kNumRequests];
 
   // Start a request that will block the first thread.
 
   factory().resolvers()[0]->Block();
 
   rv = resolver().GetProxyForURL(GURL("http://request0"), &results[0],
                                  callback[0].callback(), &request[0],
                                  NetLogWithSource());
 
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
@@ skipping 124 matching lines @@
   }
   // The factory destructor will block until the worker thread stops, but it may
   // post tasks to the origin message loop which are still pending. Run them
   // now to ensure it works as expected.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace
 
 }  // namespace net