Change ProxyResolver::GetProxyForURL() to take a scoped_ptr<Request>* rather than a RequestHandle*

net/proxy/proxy_resolver_v8_tracing_wrapper_unittest.cc

 // Copyright (c) 2013 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_v8_tracing_wrapper.h"
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 649 matching lines @@
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
   scoped_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, make_scoped_ptr(error_observer), "dns.js");
 
   const size_t kNumRequests = 5;
   ProxyInfo proxy_info[kNumRequests];
-  ProxyResolver::RequestHandle request[kNumRequests];
+  scoped_ptr<ProxyResolver::Request> request[kNumRequests];
 
   for (size_t i = 0; i < kNumRequests; ++i) {
     int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info[i],
                                       base::Bind(&CrashCallback), &request[i],
                                       BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
   for (size_t i = 0; i < kNumRequests; ++i) {
-    resolver->CancelRequest(request[i]);
+    request[i].reset();
   }
 }
 
 // Note the execution order for this test can vary. Since multiple
 // threads are involved, the cancellation may be received a different
 // times.
 TEST_F(ProxyResolverV8TracingWrapperTest, CancelSome) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
   scoped_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, make_scoped_ptr(error_observer), "dns.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
-  ProxyResolver::RequestHandle request1;
-  ProxyResolver::RequestHandle request2;
+  scoped_ptr<ProxyResolver::Request> request1;
+  scoped_ptr<ProxyResolver::Request> request2;
   TestCompletionCallback callback;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info1,
                                     base::Bind(&CrashCallback), &request1,
                                     BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info2,
                                 callback.callback(), &request2, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  resolver->CancelRequest(request1);
+  request1.reset();
 
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Cancel a request after it has finished running on the worker thread, and has
 // posted a task the completion task back to origin thread.
 TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhilePendingCompletionTask) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   host_resolver.rules()->AddSimulatedFailure("*");
 
   scoped_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, make_scoped_ptr(error_observer), "error.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
-  ProxyResolver::RequestHandle request1;
-  ProxyResolver::RequestHandle request2;
+  scoped_ptr<ProxyResolver::Request> request1;
+  scoped_ptr<ProxyResolver::Request> request2;
   TestCompletionCallback callback;
 
   int rv = resolver->GetProxyForURL(GURL("http://throw-an-error/"),
                                     &proxy_info1, base::Bind(&CrashCallback),
                                     &request1, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait until the first request has finished running on the worker thread.
   // Cancel the first request, while it has a pending completion task on
-  // the origin thread.
-  error_observer->RunOnError(base::Bind(&ProxyResolver::CancelRequest,
-                                        base::Unretained(resolver.get()),
-                                        request1));
+  // the origin thread. Reset deletes Request object which cancels the request.
+  error_observer->RunOnError(
+      base::Bind(&scoped_ptr<ProxyResolver::Request>::reset,
+                 base::Unretained(&request1), nullptr));
 
   // Start another request, to make sure it is able to complete.
   rv = resolver->GetProxyForURL(GURL("http://i-have-no-idea-what-im-doing/"),
                                 &proxy_info2, callback.callback(), &request2,
                                 BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_EQ("i-approve-this-message:42", proxy_info2.proxy_server().ToURI());
@@ skipping 67 matching lines @@
 TEST_F(ProxyResolverV8TracingWrapperTest,
        CancelWhileOutstandingNonBlockingDns) {
   BlockableHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   scoped_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, make_scoped_ptr(error_observer), "dns.js");
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
-  ProxyResolver::RequestHandle request1;
-  ProxyResolver::RequestHandle request2;
+  scoped_ptr<ProxyResolver::Request> request1;
+  scoped_ptr<ProxyResolver::Request> request2;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/req1"), &proxy_info1,
                                     base::Bind(&CrashCallback), &request1,
                                     BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   host_resolver.WaitUntilRequestIsReceived();
 
   rv = resolver->GetProxyForURL(GURL("http://foo/req2"), &proxy_info2,
                                 base::Bind(&CrashCallback), &request2,
                                 BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   host_resolver.WaitUntilRequestIsReceived();
 
-  resolver->CancelRequest(request1);
-  resolver->CancelRequest(request2);
+  request1.reset();
+  request2.reset();
 
   EXPECT_EQ(2, host_resolver.num_cancelled_requests());
 
   // After leaving this scope, the ProxyResolver is destroyed.
   // This should not cause any problems, as the outstanding work
   // should have been cancelled.
 }
 
-void CancelRequestAndPause(ProxyResolver* resolver,
-                           ProxyResolver::RequestHandle request) {
-  resolver->CancelRequest(request);
+void CancelRequestAndPause(scoped_ptr<ProxyResolver::Request>* request) {
+  request->reset();
 
   // Sleep for a little bit. This makes it more likely for the worker
   // thread to have returned from its call, and serves as a regression
   // test for http://crbug.com/173373.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(30));
 }
 
 // In non-blocking mode, the worker thread actually does block for
 // a short time to see if the result is in the DNS cache. Test
 // cancellation while the worker thread is waiting on this event.
 TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhileBlockedInNonBlockingDns) {
   BlockableHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   scoped_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, make_scoped_ptr(error_observer), "dns.js");
 
   ProxyInfo proxy_info;
-  ProxyResolver::RequestHandle request;
+  scoped_ptr<ProxyResolver::Request> request;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                     base::Bind(&CrashCallback), &request,
                                     BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  host_resolver.SetAction(
-      base::Bind(CancelRequestAndPause, resolver.get(), request));
+  host_resolver.SetAction(base::Bind(CancelRequestAndPause, &request));
 
   host_resolver.WaitUntilRequestIsReceived();
 }
 
 // Cancel the request while there is a pending DNS request, however before
 // the request is sent to the host resolver.
 TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhileBlockedInNonBlockingDns2) {
   MockCachingHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   scoped_ptr<ProxyResolver> resolver = CreateResolver(
       nullptr, &host_resolver, make_scoped_ptr(error_observer), "dns.js");
 
   ProxyInfo proxy_info;
-  ProxyResolver::RequestHandle request;
+  scoped_ptr<ProxyResolver::Request> request;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                     base::Bind(&CrashCallback), &request,
                                     BoundNetLog());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Wait a bit, so the DNS task has hopefully been posted. The test will
   // work whatever the delay is here, but it is most useful if the delay
   // is large enough to allow a task to be posted back.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
-  resolver->CancelRequest(request);
+  request.reset();
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 }
 
 TEST_F(ProxyResolverV8TracingWrapperTest,
        CancelCreateResolverWhileOutstandingBlockingDns) {
   BlockableHostResolver host_resolver;
   MockErrorObserver* error_observer = new MockErrorObserver;
 
   ProxyResolverFactoryV8TracingWrapper factory(
@@ skipping 197 matching lines @@
                 proxy_uri.substr(0, proxy_uri.find(':') + 1));
     } else {
       NOTREACHED();
     }
   }
 }
 
 }  // namespace
 
 }  // namespace net