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

net/proxy/mock_proxy_resolver.h

Index: net/proxy/mock_proxy_resolver.h
diff --git a/net/proxy/mock_proxy_resolver.h b/net/proxy/mock_proxy_resolver.h
index aec843227b95e034bb4104ef49ea4d8f8c5f85a7..391c7f671a1fbd97abb31be1bbfdc148f2f7dd2e 100644
--- a/net/proxy/mock_proxy_resolver.h
+++ b/net/proxy/mock_proxy_resolver.h
@@ -20,15 +20,15 @@ class MessageLoop;
 namespace net {
 
 // Asynchronous mock proxy resolver. All requests complete asynchronously,
-// user must call Request::CompleteNow() on a pending request to signal it.
+// user must call Job::CompleteNow() on a pending request to signal it.
 class MockAsyncProxyResolver : public ProxyResolver {
  public:
-  class Request : public base::RefCounted<Request> {
+  class Job : public base::RefCounted<Job> {
    public:
-    Request(MockAsyncProxyResolver* resolver,
-            const GURL& url,
-            ProxyInfo* results,
-            const CompletionCallback& callback);
+    Job(MockAsyncProxyResolver* resolver,
+        const GURL& url,
+        ProxyInfo* results,
+        const CompletionCallback& callback);
 
     const GURL& url() const { return url_; }
     ProxyInfo* results() const { return results_; }
@@ -37,9 +37,9 @@ class MockAsyncProxyResolver : public ProxyResolver {
     void CompleteNow(int rv);
 
    private:
-    friend class base::RefCounted<Request>;
+    friend class base::RefCounted<Job>;
 
-    virtual ~Request();
+    virtual ~Job();
 
     MockAsyncProxyResolver* resolver_;
     const GURL url_;
@@ -48,7 +48,20 @@ class MockAsyncProxyResolver : public ProxyResolver {
     base::MessageLoop* origin_loop_;
   };
 
-  typedef std::vector<scoped_refptr<Request> > RequestsList;
+  class RequestImpl : public ProxyResolver::Request {
+   public:
+    RequestImpl(Job* job, MockAsyncProxyResolver* resolver);
+
+    ~RequestImpl() override;
+
+    LoadState GetLoadState() override;
+
+   private:
+    scoped_refptr<Job> job_;
+    MockAsyncProxyResolver* resolver_;
+  };
+
+  typedef std::vector<scoped_refptr<Job>> JobsList;
 
   MockAsyncProxyResolver();
   ~MockAsyncProxyResolver() override;
@@ -57,23 +70,18 @@ class MockAsyncProxyResolver : public ProxyResolver {
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
-                     RequestHandle* request_handle,
+                     scoped_ptr<Request>* request,
                      const BoundNetLog& /*net_log*/) override;
-  void CancelRequest(RequestHandle request_handle) override;
-  LoadState GetLoadState(RequestHandle request_handle) const override;
-  const RequestsList& pending_requests() const {
-    return pending_requests_;
-  }
+  const JobsList& pending_jobs() const { return pending_jobs_; }
 
-  const RequestsList& cancelled_requests() const {
-    return cancelled_requests_;
-  }
+  const JobsList& cancelled_jobs() const { return cancelled_jobs_; }
 
-  void RemovePendingRequest(Request* request);
+  void AddCancelledJob(scoped_refptr<Job> job);
+  void RemovePendingJob(Job* job);
 
  private:
-  RequestsList pending_requests_;
-  RequestsList cancelled_requests_;
+  JobsList pending_jobs_;
+  JobsList cancelled_jobs_;
 };
 
 // Asynchronous mock proxy resolver factory . All requests complete
@@ -150,10 +158,8 @@ class ForwardingProxyResolver : public ProxyResolver {
   int GetProxyForURL(const GURL& query_url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
-                     RequestHandle* request,
+                     scoped_ptr<Request>* request,
                      const BoundNetLog& net_log) override;
-  void CancelRequest(RequestHandle request) override;
-  LoadState GetLoadState(RequestHandle request) const override;
 
  private:
   ProxyResolver* impl_;