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

net/proxy/mock_proxy_resolver.h

 // 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.
 
 #ifndef NET_PROXY_MOCK_PROXY_RESOLVER_H_
 #define NET_PROXY_MOCK_PROXY_RESOLVER_H_
 
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_resolver_factory.h"
 #include "url/gurl.h"
 
 namespace base {
 class MessageLoop;
 }
 
 namespace net {
 
 // Asynchronous mock proxy resolver. All requests complete asynchronously,
-// user must call Job::CompleteNow() on a pending request to signal it.
+// user must call Request::CompleteNow() on a pending request to signal it.
 class MockAsyncProxyResolver : public ProxyResolver {
  public:
-  class Job {
+  class Request : public base::RefCounted<Request> {
    public:
-    Job(MockAsyncProxyResolver* resolver,
-        const GURL& url,
-        ProxyInfo* results,
-        const CompletionCallback& callback);
+    Request(MockAsyncProxyResolver* resolver,
+            const GURL& url,
+            ProxyInfo* results,
+            const CompletionCallback& callback);
 
     const GURL& url() const { return url_; }
     ProxyInfo* results() const { return results_; }
     const CompletionCallback& callback() const { return callback_; }
-    MockAsyncProxyResolver* Resolver() const { return resolver_; };
 
     void CompleteNow(int rv);
 
-    ~Job();
+   private:
+    friend class base::RefCounted<Request>;
 
-   private:
+    virtual ~Request();
+
     MockAsyncProxyResolver* resolver_;
     const GURL url_;
     ProxyInfo* results_;
     CompletionCallback callback_;
     base::MessageLoop* origin_loop_;
   };
 
-  class RequestImpl : public ProxyResolver::Request {
-   public:
-    explicit RequestImpl(scoped_ptr<Job> job);
-
-    ~RequestImpl() override;
-
-    LoadState GetLoadState() override;
-
-   private:
-    scoped_ptr<Job> job_;
-  };
+  typedef std::vector<scoped_refptr<Request> > RequestsList;
 
   MockAsyncProxyResolver();
   ~MockAsyncProxyResolver() override;
 
   // ProxyResolver implementation.
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
-                     scoped_ptr<Request>* request,
+                     RequestHandle* request_handle,
                      const BoundNetLog& /*net_log*/) override;
-  const std::vector<Job*>& pending_jobs() const { return pending_jobs_; }
-
-  const std::vector<scoped_ptr<Job>>& cancelled_jobs() const {
-    return cancelled_jobs_;
+  void CancelRequest(RequestHandle request_handle) override;
+  LoadState GetLoadState(RequestHandle request_handle) const override;
+  const RequestsList& pending_requests() const {
+    return pending_requests_;
   }
 
-  void AddCancelledJob(scoped_ptr<Job> job);
-  void RemovePendingJob(Job* job);
+  const RequestsList& cancelled_requests() const {
+    return cancelled_requests_;
+  }
+
+  void RemovePendingRequest(Request* request);
 
  private:
-  std::vector<Job*> pending_jobs_;
-  std::vector<scoped_ptr<Job>> cancelled_jobs_;
+  RequestsList pending_requests_;
+  RequestsList cancelled_requests_;
 };
 
 // Asynchronous mock proxy resolver factory . All requests complete
 // asynchronously; the user must call Request::CompleteNow() on a pending
 // request to signal it.
 class MockAsyncProxyResolverFactory : public ProxyResolverFactory {
  public:
   class Request;
   using RequestsList = std::vector<scoped_refptr<Request>>;
 
@@ skipping 56 matching lines @@
 // ForwardingProxyResolver forwards all requests to |impl|. |impl| must remain
 // so long as this remains in use.
 class ForwardingProxyResolver : public ProxyResolver {
  public:
   explicit ForwardingProxyResolver(ProxyResolver* impl);
 
   // ProxyResolver overrides.
   int GetProxyForURL(const GURL& query_url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
-                     scoped_ptr<Request>* request,
+                     RequestHandle* request,
                      const BoundNetLog& net_log) override;
+  void CancelRequest(RequestHandle request) override;
+  LoadState GetLoadState(RequestHandle request) const override;
 
  private:
   ProxyResolver* impl_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardingProxyResolver);
 };
 
 }  // namespace net
 
 #endif  // NET_PROXY_MOCK_PROXY_RESOLVER_H_