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

net/proxy/mock_proxy_resolver.cc

Index: net/proxy/mock_proxy_resolver.cc
diff --git a/net/proxy/mock_proxy_resolver.cc b/net/proxy/mock_proxy_resolver.cc
index 3bf5314ca2627842468575ab9dd2d4696f478b40..ad8d73e488f3f556d44bf96e20cbb42c32a736c0 100644
--- a/net/proxy/mock_proxy_resolver.cc
+++ b/net/proxy/mock_proxy_resolver.cc
@@ -9,61 +9,72 @@
 
 namespace net {
 
-MockAsyncProxyResolver::Request::Request(MockAsyncProxyResolver* resolver,
-                                         const GURL& url,
-                                         ProxyInfo* results,
-                                         const CompletionCallback& callback)
+MockAsyncProxyResolver::RequestImpl::RequestImpl(
+    Job* job,
+    MockAsyncProxyResolver* resolver)

[eroman, 2015/11/24 01:20:59]

Doesn't the job already contain the resolver? (In which case not necessary to
have that parameter here).

+    : job_(job), resolver_(resolver) {
+  DCHECK(resolver_);
+  DCHECK(job_);
+}
+
+MockAsyncProxyResolver::RequestImpl::~RequestImpl() {
+  DCHECK(resolver_);
+  DCHECK(job_);
+  resolver_->AddCancelledJob(job_);
+  resolver_->RemovePendingJob(job_.get());
+}
+
+LoadState MockAsyncProxyResolver::RequestImpl::GetLoadState() {
+  return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
+}
+
+MockAsyncProxyResolver::Job::Job(MockAsyncProxyResolver* resolver,
+                                 const GURL& url,
+                                 ProxyInfo* results,
+                                 const CompletionCallback& callback)
     : resolver_(resolver),
       url_(url),
       results_(results),
       callback_(callback),
-      origin_loop_(base::MessageLoop::current()) {
-}
+      origin_loop_(base::MessageLoop::current()) {}
 
-void MockAsyncProxyResolver::Request::CompleteNow(int rv) {
+void MockAsyncProxyResolver::Job::CompleteNow(int rv) {
   CompletionCallback callback = callback_;
 
   // May delete |this|.
-  resolver_->RemovePendingRequest(this);
+  resolver_->RemovePendingJob(this);
 
   callback.Run(rv);
 }
 
-MockAsyncProxyResolver::Request::~Request() {}
+MockAsyncProxyResolver::Job::~Job() {}
 
 MockAsyncProxyResolver::~MockAsyncProxyResolver() {}
 
 int MockAsyncProxyResolver::GetProxyForURL(const GURL& url,
                                            ProxyInfo* results,
                                            const CompletionCallback& callback,
-                                           RequestHandle* request_handle,
+                                           scoped_ptr<Request>* request,
                                            const BoundNetLog& /*net_log*/) {
-  scoped_refptr<Request> request = new Request(this, url, results, callback);
-  pending_requests_.push_back(request);
+  scoped_refptr<Job> job = new Job(this, url, results, callback);
+  pending_jobs_.push_back(job);
 
-  if (request_handle)
-    *request_handle = reinterpret_cast<RequestHandle>(request.get());
+  if (request)
+    request->reset(new RequestImpl(job.get(), this));
 
   // Test code completes the request by calling request->CompleteNow().
   return ERR_IO_PENDING;
 }
 
-void MockAsyncProxyResolver::CancelRequest(RequestHandle request_handle) {
-  scoped_refptr<Request> request = reinterpret_cast<Request*>(request_handle);
-  cancelled_requests_.push_back(request);
-  RemovePendingRequest(request.get());
+void MockAsyncProxyResolver::AddCancelledJob(scoped_refptr<Job> job) {
+  cancelled_jobs_.push_back(job);
 }
 
-LoadState MockAsyncProxyResolver::GetLoadState(
-    RequestHandle request_handle) const {
-  return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
-}
-
-void MockAsyncProxyResolver::RemovePendingRequest(Request* request) {
-  RequestsList::iterator it = std::find(
-      pending_requests_.begin(), pending_requests_.end(), request);
-  DCHECK(it != pending_requests_.end());
-  pending_requests_.erase(it);
+void MockAsyncProxyResolver::RemovePendingJob(Job* job) {
+  JobsList::iterator it =
+      std::find(pending_jobs_.begin(), pending_jobs_.end(), job);
+  DCHECK(it != pending_jobs_.end());
+  pending_jobs_.erase(it);
 }
 
 MockAsyncProxyResolver::MockAsyncProxyResolver() {
@@ -163,17 +174,9 @@ ForwardingProxyResolver::ForwardingProxyResolver(ProxyResolver* impl)
 int ForwardingProxyResolver::GetProxyForURL(const GURL& query_url,
                                             ProxyInfo* results,
                                             const CompletionCallback& callback,
-                                            RequestHandle* request,
+                                            scoped_ptr<Request>* request,
                                             const BoundNetLog& net_log) {
   return impl_->GetProxyForURL(query_url, results, callback, request, net_log);
 }
 
-void ForwardingProxyResolver::CancelRequest(RequestHandle request) {
-  impl_->CancelRequest(request);
-}
-
-LoadState ForwardingProxyResolver::GetLoadState(RequestHandle request) const {
-  return impl_->GetLoadState(request);
-}
-
 }  // namespace net