Revert of Change ProxyResolver::GetProxyForURL() to take a scoped_ptr<Request>* rather than a RequestHandle* (patchset #11 id:200001 of https://codereview.chromium.org/1439053002/ )

Reason for revert:
Top crasher on Canary has PAC script cancellation on callstack. Very likely a bug or interaction with this CL.

Reverting until I have a chance to fully investigate.

Original issue's description:
> Change ProxyResolver::GetProxyForURL() to take a scoped_ptr<Request>* rather than a RequestHandle*
>
> * ProxyResolver::GetProxyForURL() fills a |scoped_pointer<Request>*|
>   rather than a |void*|
> * ProxyResolver::CancelRequest(void*) has been removed. Requests
>   are instead cancelled by resetting the scoped_ptr<Request>.
>
> This makes for less error prone code as cancellation of
> requests is automatic when the
> scoped_ptr<Request> goes out of scope.
> ProxyResolver::GetLoadState() is removed and replaced
> by Request::GetLoadState().
>
> Also made some renaming, as there were similar class
> named Job or Request. Now they are all Job and this new thing
> is Request.
>
> Referencing by address to object in vector was not wise in net/proxy/mojo_proxy_resolver_impl_unittest.cc which is now fixed by using scoped_ptrs in that vector.
>
> BUG=478934
>
> Committed: https://crrev.com/a750e126346aa42df1b0cbc2ae6a58abbe7a5069
> Cr-Commit-Position: refs/heads/master@{#377856}

TBR=davidben@chromium.org,olli.raula@intel.com
# Not skipping CQ checks because original CL landed more than 1 days ago.
BUG=478934

Review URL: https://codereview.chromium.org/1745133002

Cr-Commit-Position: refs/heads/master@{#378274}

23 files changed, 721 insertions, 696 deletions

diff --git a/content/browser/resolve_proxy_msg_helper_unittest.cc b/content/browser/resolve_proxy_msg_helper_unittest.cc
index 7ecd784..5e3dd0d 100644
--- a/content/browser/resolve_proxy_msg_helper_unittest.cc
+++ b/content/browser/resolve_proxy_msg_helper_unittest.cc
@@ -126,10 +126,10 @@ TEST_F(ResolveProxyMsgHelperTest, Sequential) {
   resolver_factory_->pending_requests()[0]->CompleteNowWithForwarder(
       net::OK, &resolver_);
 
-  ASSERT_EQ(1u, resolver_.pending_jobs().size());
-  EXPECT_EQ(url1, resolver_.pending_jobs()[0]->url());
-  resolver_.pending_jobs()[0]->results()->UseNamedProxy("result1:80");
-  resolver_.pending_jobs()[0]->CompleteNow(net::OK);
+  ASSERT_EQ(1u, resolver_.pending_requests().size());
+  EXPECT_EQ(url1, resolver_.pending_requests()[0]->url());
+  resolver_.pending_requests()[0]->results()->UseNamedProxy("result1:80");
+  resolver_.pending_requests()[0]->CompleteNow(net::OK);
 
   // Check result.
   EXPECT_EQ(true, pending_result()->result);
@@ -138,10 +138,10 @@ TEST_F(ResolveProxyMsgHelperTest, Sequential) {
 
   helper_->OnResolveProxy(url2, msg2);
 
-  ASSERT_EQ(1u, resolver_.pending_jobs().size());
-  EXPECT_EQ(url2, resolver_.pending_jobs()[0]->url());
-  resolver_.pending_jobs()[0]->results()->UseNamedProxy("result2:80");
-  resolver_.pending_jobs()[0]->CompleteNow(net::OK);
+  ASSERT_EQ(1u, resolver_.pending_requests().size());
+  EXPECT_EQ(url2, resolver_.pending_requests()[0]->url());
+  resolver_.pending_requests()[0]->results()->UseNamedProxy("result2:80");
+  resolver_.pending_requests()[0]->CompleteNow(net::OK);
 
   // Check result.
   EXPECT_EQ(true, pending_result()->result);
@@ -150,10 +150,10 @@ TEST_F(ResolveProxyMsgHelperTest, Sequential) {
 
   helper_->OnResolveProxy(url3, msg3);
 
-  ASSERT_EQ(1u, resolver_.pending_jobs().size());
-  EXPECT_EQ(url3, resolver_.pending_jobs()[0]->url());
-  resolver_.pending_jobs()[0]->results()->UseNamedProxy("result3:80");
-  resolver_.pending_jobs()[0]->CompleteNow(net::OK);
+  ASSERT_EQ(1u, resolver_.pending_requests().size());
+  EXPECT_EQ(url3, resolver_.pending_requests()[0]->url());
+  resolver_.pending_requests()[0]->results()->UseNamedProxy("result3:80");
+  resolver_.pending_requests()[0]->CompleteNow(net::OK);
 
   // Check result.
   EXPECT_EQ(true, pending_result()->result);
@@ -186,33 +186,33 @@ TEST_F(ResolveProxyMsgHelperTest, QueueRequests) {
 
   // ResolveProxyHelper only keeps 1 request outstanding in ProxyService
   // at a time.
-  ASSERT_EQ(1u, resolver_.pending_jobs().size());
-  EXPECT_EQ(url1, resolver_.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver_.pending_requests().size());
+  EXPECT_EQ(url1, resolver_.pending_requests()[0]->url());
 
-  resolver_.pending_jobs()[0]->results()->UseNamedProxy("result1:80");
-  resolver_.pending_jobs()[0]->CompleteNow(net::OK);
+  resolver_.pending_requests()[0]->results()->UseNamedProxy("result1:80");
+  resolver_.pending_requests()[0]->CompleteNow(net::OK);
 
   // Check result.
   EXPECT_EQ(true, pending_result()->result);
   EXPECT_EQ("PROXY result1:80", pending_result()->proxy_list);
   clear_pending_result();
 
-  ASSERT_EQ(1u, resolver_.pending_jobs().size());
-  EXPECT_EQ(url2, resolver_.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver_.pending_requests().size());
+  EXPECT_EQ(url2, resolver_.pending_requests()[0]->url());
 
-  resolver_.pending_jobs()[0]->results()->UseNamedProxy("result2:80");
-  resolver_.pending_jobs()[0]->CompleteNow(net::OK);
+  resolver_.pending_requests()[0]->results()->UseNamedProxy("result2:80");
+  resolver_.pending_requests()[0]->CompleteNow(net::OK);
 
   // Check result.
   EXPECT_EQ(true, pending_result()->result);
   EXPECT_EQ("PROXY result2:80", pending_result()->proxy_list);
   clear_pending_result();
 
-  ASSERT_EQ(1u, resolver_.pending_jobs().size());
-  EXPECT_EQ(url3, resolver_.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver_.pending_requests().size());
+  EXPECT_EQ(url3, resolver_.pending_requests()[0]->url());
 
-  resolver_.pending_jobs()[0]->results()->UseNamedProxy("result3:80");
-  resolver_.pending_jobs()[0]->CompleteNow(net::OK);
+  resolver_.pending_requests()[0]->results()->UseNamedProxy("result3:80");
+  resolver_.pending_requests()[0]->CompleteNow(net::OK);
 
   // Check result.
   EXPECT_EQ(true, pending_result()->result);
@@ -246,8 +246,8 @@ TEST_F(ResolveProxyMsgHelperTest, CancelPendingRequests) {
 
   // ResolveProxyHelper only keeps 1 request outstanding in ProxyService
   // at a time.
-  ASSERT_EQ(1u, resolver_.pending_jobs().size());
-  EXPECT_EQ(url1, resolver_.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver_.pending_requests().size());
+  EXPECT_EQ(url1, resolver_.pending_requests()[0]->url());
 
   // Delete the underlying ResolveProxyMsgHelper -- this should cancel all
   // the requests which are outstanding.
@@ -255,7 +255,7 @@ TEST_F(ResolveProxyMsgHelperTest, CancelPendingRequests) {
 
   // The pending requests sent to the proxy resolver should have been cancelled.
 
-  EXPECT_EQ(0u, resolver_.pending_jobs().size());
+  EXPECT_EQ(0u, resolver_.pending_requests().size());
 
   EXPECT_TRUE(pending_result() == NULL);
 
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index 3465f76..bc7f7b3 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -10954,7 +10954,7 @@ class CapturingProxyResolver : public ProxyResolver {
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
-                     scoped_ptr<Request>* request,
+                     RequestHandle* request,
                      const BoundNetLog& net_log) override {
     ProxyServer proxy_server(ProxyServer::SCHEME_HTTP,
                              HostPortPair("myproxy", 80));
@@ -10963,6 +10963,13 @@ class CapturingProxyResolver : public ProxyResolver {
     return OK;
   }
 
+  void CancelRequest(RequestHandle request) override { NOTREACHED(); }
+
+  LoadState GetLoadState(RequestHandle request) const override {
+    NOTREACHED();
+    return LOAD_STATE_IDLE;
+  }
+
   const std::vector<GURL>& resolved() const { return resolved_; }
 
  private:
diff --git a/net/proxy/mock_proxy_resolver.cc b/net/proxy/mock_proxy_resolver.cc
index e263552..21cac00 100644
--- a/net/proxy/mock_proxy_resolver.cc
+++ b/net/proxy/mock_proxy_resolver.cc
@@ -11,74 +11,61 @@
 
 namespace net {
 
-MockAsyncProxyResolver::RequestImpl::RequestImpl(scoped_ptr<Job> job)
-    : job_(std::move(job)) {
-  DCHECK(job_);
-}
-
-MockAsyncProxyResolver::RequestImpl::~RequestImpl() {
-  MockAsyncProxyResolver* resolver = job_->Resolver();
-  // AddCancelledJob will check if request is already cancelled
-  resolver->AddCancelledJob(std::move(job_));
-}
-
-LoadState MockAsyncProxyResolver::RequestImpl::GetLoadState() {
-  return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
-}
-
-MockAsyncProxyResolver::Job::Job(MockAsyncProxyResolver* resolver,
-                                 const GURL& url,
-                                 ProxyInfo* results,
-                                 const CompletionCallback& callback)
+MockAsyncProxyResolver::Request::Request(MockAsyncProxyResolver* resolver,
+                                         const GURL& url,
+                                         ProxyInfo* results,
+                                         const CompletionCallback& callback)
     : resolver_(resolver),
       url_(url),
       results_(results),
       callback_(callback),
-      origin_loop_(base::MessageLoop::current()) {}
-
-MockAsyncProxyResolver::Job::~Job() {}
+      origin_loop_(base::MessageLoop::current()) {
+}
 
-void MockAsyncProxyResolver::Job::CompleteNow(int rv) {
+void MockAsyncProxyResolver::Request::CompleteNow(int rv) {
   CompletionCallback callback = callback_;
 
-  resolver_->RemovePendingJob(this);
+  // May delete |this|.
+  resolver_->RemovePendingRequest(this);
 
   callback.Run(rv);
 }
 
+MockAsyncProxyResolver::Request::~Request() {}
+
 MockAsyncProxyResolver::~MockAsyncProxyResolver() {}
 
 int MockAsyncProxyResolver::GetProxyForURL(const GURL& url,
                                            ProxyInfo* results,
                                            const CompletionCallback& callback,
-                                           scoped_ptr<Request>* request,
+                                           RequestHandle* request_handle,
                                            const BoundNetLog& /*net_log*/) {
-  scoped_ptr<Job> job(new Job(this, url, results, callback));
+  scoped_refptr<Request> request = new Request(this, url, results, callback);
+  pending_requests_.push_back(request);
 
-  pending_jobs_.push_back(job.get());
-  request->reset(new RequestImpl(std::move(job)));
+  if (request_handle)
+    *request_handle = reinterpret_cast<RequestHandle>(request.get());
 
-  // Test code completes the request by calling job->CompleteNow().
+  // Test code completes the request by calling request->CompleteNow().
   return ERR_IO_PENDING;
 }
 
-void MockAsyncProxyResolver::AddCancelledJob(scoped_ptr<Job> job) {
-  std::vector<Job*>::iterator it =
-      std::find(pending_jobs_.begin(), pending_jobs_.end(), job.get());
-  // Because this is called always when RequestImpl is destructed,
-  // we need to check if it is still in pending jobs.
-  if (it != pending_jobs_.end()) {
-    cancelled_jobs_.push_back(std::move(job));
-    pending_jobs_.erase(it);
-  }
+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::RemovePendingJob(Job* job) {
-  DCHECK(job);
-  std::vector<Job*>::iterator it =
-      std::find(pending_jobs_.begin(), pending_jobs_.end(), job);
-  DCHECK(it != pending_jobs_.end());
-  pending_jobs_.erase(it);
+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);
 }
 
 MockAsyncProxyResolver::MockAsyncProxyResolver() {
@@ -178,9 +165,17 @@ ForwardingProxyResolver::ForwardingProxyResolver(ProxyResolver* impl)
 int ForwardingProxyResolver::GetProxyForURL(const GURL& query_url,
                                             ProxyInfo* results,
                                             const CompletionCallback& callback,
-                                            scoped_ptr<Request>* request,
+                                            RequestHandle* 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
diff --git a/net/proxy/mock_proxy_resolver.h b/net/proxy/mock_proxy_resolver.h
index 71ca2b24..9ed3348 100644
--- a/net/proxy/mock_proxy_resolver.h
+++ b/net/proxy/mock_proxy_resolver.h
@@ -21,26 +21,27 @@ 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>;
+
+    virtual ~Request();
+
     MockAsyncProxyResolver* resolver_;
     const GURL url_;
     ProxyInfo* results_;
@@ -48,17 +49,7 @@ class MockAsyncProxyResolver : public ProxyResolver {
     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;
@@ -67,20 +58,23 @@ class MockAsyncProxyResolver : public ProxyResolver {
   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_; }
+  void CancelRequest(RequestHandle request_handle) override;
+  LoadState GetLoadState(RequestHandle request_handle) const override;
+  const RequestsList& pending_requests() const {
+    return pending_requests_;
+  }
 
-  const std::vector<scoped_ptr<Job>>& cancelled_jobs() const {
-    return cancelled_jobs_;
+  const RequestsList& cancelled_requests() const {
+    return cancelled_requests_;
   }
 
-  void AddCancelledJob(scoped_ptr<Job> job);
-  void RemovePendingJob(Job* job);
+  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
@@ -157,8 +151,10 @@ class ForwardingProxyResolver : public ProxyResolver {
   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_;
diff --git a/net/proxy/mojo_proxy_resolver_factory_impl_unittest.cc b/net/proxy/mojo_proxy_resolver_factory_impl_unittest.cc
index 149cdc0..c7fb51b 100644
--- a/net/proxy/mojo_proxy_resolver_factory_impl_unittest.cc
+++ b/net/proxy/mojo_proxy_resolver_factory_impl_unittest.cc
@@ -31,9 +31,15 @@ class FakeProxyResolver : public ProxyResolverV8Tracing {
   void GetProxyForURL(const GURL& url,
                       ProxyInfo* results,
                       const CompletionCallback& callback,
-                      scoped_ptr<ProxyResolver::Request>* request,
+                      ProxyResolver::RequestHandle* request,
                       scoped_ptr<Bindings> bindings) override {}
 
+  void CancelRequest(ProxyResolver::RequestHandle request) override {}
+
+  LoadState GetLoadState(ProxyResolver::RequestHandle request) const override {
+    return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
+  }
+
   const base::Closure on_destruction_;
 };
 
diff --git a/net/proxy/mojo_proxy_resolver_impl.cc b/net/proxy/mojo_proxy_resolver_impl.cc
index 46b91a4..bbac2e72 100644
--- a/net/proxy/mojo_proxy_resolver_impl.cc
+++ b/net/proxy/mojo_proxy_resolver_impl.cc
@@ -40,7 +40,7 @@ class MojoProxyResolverImpl::Job {
   interfaces::ProxyResolverRequestClientPtr client_;
   ProxyInfo result_;
   GURL url_;
-  scoped_ptr<net::ProxyResolver::Request> request_;
+  net::ProxyResolver::RequestHandle request_handle_;
   bool done_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
@@ -77,14 +77,18 @@ MojoProxyResolverImpl::Job::Job(
     : resolver_(resolver),
       client_(std::move(client)),
       url_(url),
+      request_handle_(nullptr),
       done_(false) {}
 
-MojoProxyResolverImpl::Job::~Job() {}
+MojoProxyResolverImpl::Job::~Job() {
+  if (request_handle_ && !done_)
+    resolver_->resolver_->CancelRequest(request_handle_);
+}
 
 void MojoProxyResolverImpl::Job::Start() {
   resolver_->resolver_->GetProxyForURL(
       url_, &result_, base::Bind(&Job::GetProxyDone, base::Unretained(this)),
-      &request_,
+      &request_handle_,
       make_scoped_ptr(new MojoProxyResolverV8TracingBindings<
                       interfaces::ProxyResolverRequestClient>(client_.get())));
   client_.set_connection_error_handler(base::Bind(
diff --git a/net/proxy/mojo_proxy_resolver_impl_unittest.cc b/net/proxy/mojo_proxy_resolver_impl_unittest.cc
index fb722c0..b045b27 100644
--- a/net/proxy/mojo_proxy_resolver_impl_unittest.cc
+++ b/net/proxy/mojo_proxy_resolver_impl_unittest.cc
@@ -102,87 +102,68 @@ void TestRequestClient::OnConnectionError() {
 
 class MockProxyResolverV8Tracing : public ProxyResolverV8Tracing {
  public:
-  struct Job {
+  struct Request {
     GURL url;
     ProxyInfo* results;
+    CompletionCallback callback;
     bool cancelled = false;
-    void Complete(int result) {
-      DCHECK(!callback_.is_null());
-      callback_.Run(result);
-      callback_.Reset();
-    }
-
-    bool WasCompleted() { return callback_.is_null(); }
-
-    void SetCallback(CompletionCallback callback) { callback_ = callback; }
-
-   private:
-    CompletionCallback callback_;
-  };
-
-  class RequestImpl : public ProxyResolver::Request {
-   public:
-    RequestImpl(Job* job, MockProxyResolverV8Tracing* resolver)
-        : job_(job), resolver_(resolver) {}
-
-    ~RequestImpl() override {
-      if (job_->WasCompleted())
-        return;
-      job_->cancelled = true;
-      if (!resolver_->cancel_callback_.is_null()) {
-        resolver_->cancel_callback_.Run();
-        resolver_->cancel_callback_.Reset();
-      }
-    }
-
-    LoadState GetLoadState() override {
-      return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
-    }
-
-   private:
-    Job* job_;
-    MockProxyResolverV8Tracing* resolver_;
   };
-
   MockProxyResolverV8Tracing() {}
 
   // ProxyResolverV8Tracing overrides.
   void GetProxyForURL(const GURL& url,
                       ProxyInfo* results,
                       const CompletionCallback& callback,
-                      scoped_ptr<ProxyResolver::Request>* request,
+                      ProxyResolver::RequestHandle* request,
                       scoped_ptr<Bindings> bindings) override;
+  void CancelRequest(ProxyResolver::RequestHandle request_handle) override;
+  LoadState GetLoadState(ProxyResolver::RequestHandle request) const override;
 
-  // Wait until the request are cancelled.
+  // Wait until the mock resolver has received a CancelRequest call.
   void WaitForCancel();
 
-  const std::vector<scoped_ptr<Job>>& pending_jobs() { return pending_jobs_; }
+  const std::vector<Request>& pending_requests() { return pending_requests_; }
 
  private:
   base::Closure cancel_callback_;
-  std::vector<scoped_ptr<Job>> pending_jobs_;
+  std::vector<Request> pending_requests_;
 };
 
 void MockProxyResolverV8Tracing::GetProxyForURL(
     const GURL& url,
     ProxyInfo* results,
     const CompletionCallback& callback,
-    scoped_ptr<ProxyResolver::Request>* request,
+    ProxyResolver::RequestHandle* request,
     scoped_ptr<Bindings> bindings) {
-  pending_jobs_.push_back(make_scoped_ptr(new Job()));
-  auto pending_job = pending_jobs_.back().get();
-  pending_job->url = url;
-  pending_job->results = results;
-  pending_job->SetCallback(callback);
-  request->reset(new RequestImpl(pending_job, this));
+  pending_requests_.push_back(Request());
+  auto& pending_request = pending_requests_.back();
+  pending_request.url = url;
+  pending_request.results = results;
+  pending_request.callback = callback;
+  *request =
+      reinterpret_cast<ProxyResolver::RequestHandle>(pending_requests_.size());
 }
 
+void MockProxyResolverV8Tracing::CancelRequest(
+    ProxyResolver::RequestHandle request_handle) {
+  size_t id = reinterpret_cast<size_t>(request_handle) - 1;
+  pending_requests_[id].cancelled = true;
+  if (!cancel_callback_.is_null()) {
+    cancel_callback_.Run();
+    cancel_callback_.Reset();
+  }
+}
+
+LoadState MockProxyResolverV8Tracing::GetLoadState(
+    ProxyResolver::RequestHandle request) const {
+  return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
+}
 
 void MockProxyResolverV8Tracing::WaitForCancel() {
-  while (std::find_if(pending_jobs_.begin(), pending_jobs_.end(),
-                      [](const scoped_ptr<Job>& job) {
-                        return job->cancelled;
-                      }) != pending_jobs_.end()) {
+  while (std::find_if(pending_requests_.begin(), pending_requests_.end(),
+                      [](const Request& request) {
+                        return request.cancelled;
+                      }) != pending_requests_.end()) {
     base::RunLoop run_loop;
     cancel_callback_ = run_loop.QuitClosure();
     run_loop.Run();
@@ -212,19 +193,19 @@ TEST_F(MojoProxyResolverImplTest, GetProxyForUrl) {
   TestRequestClient client(mojo::GetProxy(&client_ptr));
 
   resolver_->GetProxyForUrl("http://example.com", std::move(client_ptr));
-  ASSERT_EQ(1u, mock_proxy_resolver_->pending_jobs().size());
-  MockProxyResolverV8Tracing::Job* job =
-      mock_proxy_resolver_->pending_jobs()[0].get();
-  EXPECT_EQ(GURL("http://example.com"), job->url);
+  ASSERT_EQ(1u, mock_proxy_resolver_->pending_requests().size());
+  const MockProxyResolverV8Tracing::Request& request =
+      mock_proxy_resolver_->pending_requests()[0];
+  EXPECT_EQ(GURL("http://example.com"), request.url);
 
-  job->results->UsePacString(
+  request.results->UsePacString(
       "PROXY proxy.example.com:1; "
       "SOCKS4 socks4.example.com:2; "
       "SOCKS5 socks5.example.com:3; "
       "HTTPS https.example.com:4; "
       "QUIC quic.example.com:65000; "
       "DIRECT");
-  job->Complete(OK);
+  request.callback.Run(OK);
   client.WaitForResult();
 
   EXPECT_EQ(OK, client.error());
@@ -259,11 +240,11 @@ TEST_F(MojoProxyResolverImplTest, GetProxyForUrlFailure) {
   TestRequestClient client(mojo::GetProxy(&client_ptr));
 
   resolver_->GetProxyForUrl("http://example.com", std::move(client_ptr));
-  ASSERT_EQ(1u, mock_proxy_resolver_->pending_jobs().size());
-  MockProxyResolverV8Tracing::Job* job =
-      mock_proxy_resolver_->pending_jobs()[0].get();
-  EXPECT_EQ(GURL("http://example.com"), job->url);
-  job->Complete(ERR_FAILED);
+  ASSERT_EQ(1u, mock_proxy_resolver_->pending_requests().size());
+  const MockProxyResolverV8Tracing::Request& request =
+      mock_proxy_resolver_->pending_requests()[0];
+  EXPECT_EQ(GURL("http://example.com"), request.url);
+  request.callback.Run(ERR_FAILED);
   client.WaitForResult();
 
   EXPECT_EQ(ERR_FAILED, client.error());
@@ -280,17 +261,17 @@ TEST_F(MojoProxyResolverImplTest, GetProxyForUrlMultiple) {
 
   resolver_->GetProxyForUrl("http://example.com", std::move(client_ptr1));
   resolver_->GetProxyForUrl("https://example.com", std::move(client_ptr2));
-  ASSERT_EQ(2u, mock_proxy_resolver_->pending_jobs().size());
-  MockProxyResolverV8Tracing::Job* job1 =
-      mock_proxy_resolver_->pending_jobs()[0].get();
-  EXPECT_EQ(GURL("http://example.com"), job1->url);
-  MockProxyResolverV8Tracing::Job* job2 =
-      mock_proxy_resolver_->pending_jobs()[1].get();
-  EXPECT_EQ(GURL("https://example.com"), job2->url);
-  job1->results->UsePacString("HTTPS proxy.example.com:12345");
-  job1->Complete(OK);
-  job2->results->UsePacString("SOCKS5 another-proxy.example.com:6789");
-  job2->Complete(OK);
+  ASSERT_EQ(2u, mock_proxy_resolver_->pending_requests().size());
+  const MockProxyResolverV8Tracing::Request& request1 =
+      mock_proxy_resolver_->pending_requests()[0];
+  EXPECT_EQ(GURL("http://example.com"), request1.url);
+  const MockProxyResolverV8Tracing::Request& request2 =
+      mock_proxy_resolver_->pending_requests()[1];
+  EXPECT_EQ(GURL("https://example.com"), request2.url);
+  request1.results->UsePacString("HTTPS proxy.example.com:12345");
+  request1.callback.Run(OK);
+  request2.results->UsePacString("SOCKS5 another-proxy.example.com:6789");
+  request2.callback.Run(OK);
   client1.WaitForResult();
   client2.WaitForResult();
 
@@ -319,11 +300,11 @@ TEST_F(MojoProxyResolverImplTest, DestroyClient) {
       new TestRequestClient(mojo::GetProxy(&client_ptr)));
 
   resolver_->GetProxyForUrl("http://example.com", std::move(client_ptr));
-  ASSERT_EQ(1u, mock_proxy_resolver_->pending_jobs().size());
-  const MockProxyResolverV8Tracing::Job* job =
-      mock_proxy_resolver_->pending_jobs()[0].get();
-  EXPECT_EQ(GURL("http://example.com"), job->url);
-  job->results->UsePacString("PROXY proxy.example.com:8080");
+  ASSERT_EQ(1u, mock_proxy_resolver_->pending_requests().size());
+  const MockProxyResolverV8Tracing::Request& request =
+      mock_proxy_resolver_->pending_requests()[0];
+  EXPECT_EQ(GURL("http://example.com"), request.url);
+  request.results->UsePacString("PROXY proxy.example.com:8080");
   client.reset();
   mock_proxy_resolver_->WaitForCancel();
 }
@@ -333,7 +314,7 @@ TEST_F(MojoProxyResolverImplTest, DestroyService) {
   TestRequestClient client(mojo::GetProxy(&client_ptr));
 
   resolver_->GetProxyForUrl("http://example.com", std::move(client_ptr));
-  ASSERT_EQ(1u, mock_proxy_resolver_->pending_jobs().size());
+  ASSERT_EQ(1u, mock_proxy_resolver_->pending_requests().size());
   resolver_impl_.reset();
   client.event_waiter().WaitForEvent(TestRequestClient::CONNECTION_ERROR);
 }
diff --git a/net/proxy/multi_threaded_proxy_resolver.cc b/net/proxy/multi_threaded_proxy_resolver.cc
index 9845593..5eae4f7 100644
--- a/net/proxy/multi_threaded_proxy_resolver.cc
+++ b/net/proxy/multi_threaded_proxy_resolver.cc
@@ -117,12 +117,13 @@ class MultiThreadedProxyResolver : public ProxyResolver,
   int GetProxyForURL(const GURL& 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:
   class GetProxyForURLJob;
-  class RequestImpl;
   // FIFO queue of pending jobs waiting to be started.
   // TODO(eroman): Make this priority queue.
   typedef std::deque<scoped_refptr<Job>> PendingJobsQueue;
@@ -230,20 +231,6 @@ class Job : public base::RefCountedThreadSafe<Job> {
   bool was_cancelled_;
 };
 
-class MultiThreadedProxyResolver::RequestImpl : public ProxyResolver::Request {
- public:
-  explicit RequestImpl(scoped_refptr<Job> job) : job_(std::move(job)) {}
-
-  ~RequestImpl() override { job_->Cancel(); }
-
-  LoadState GetLoadState() override {
-    return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
-  }
-
- private:
-  scoped_refptr<Job> job_;
-};
-
 // CreateResolverJob -----------------------------------------------------------
 
 // Runs on the worker thread to call ProxyResolverFactory::CreateProxyResolver.
@@ -455,11 +442,8 @@ MultiThreadedProxyResolver::~MultiThreadedProxyResolver() {
 }
 
 int MultiThreadedProxyResolver::GetProxyForURL(
-    const GURL& url,
-    ProxyInfo* results,
-    const CompletionCallback& callback,
-    scoped_ptr<Request>* request,
-    const BoundNetLog& net_log) {
+    const GURL& url, ProxyInfo* results, const CompletionCallback& callback,
+    RequestHandle* request, const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
 
@@ -469,7 +453,7 @@ int MultiThreadedProxyResolver::GetProxyForURL(
   // Completion will be notified through |callback|, unless the caller cancels
   // the request using |request|.
   if (request)
-    request->reset(new RequestImpl(job));
+    *request = reinterpret_cast<RequestHandle>(job.get());
 
   // If there is an executor that is ready to run this request, submit it!
   Executor* executor = FindIdleExecutor();
@@ -492,6 +476,31 @@ int MultiThreadedProxyResolver::GetProxyForURL(
   return ERR_IO_PENDING;
 }
 
+void MultiThreadedProxyResolver::CancelRequest(RequestHandle req) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(req);
+
+  Job* job = reinterpret_cast<Job*>(req);
+  DCHECK_EQ(Job::TYPE_GET_PROXY_FOR_URL, job->type());
+
+  if (job->executor()) {
+    // If the job was already submitted to the executor, just mark it
+    // as cancelled so the user callback isn't run on completion.
+    job->Cancel();
+  } else {
+    // Otherwise the job is just sitting in a queue.
+    PendingJobsQueue::iterator it =
+        std::find(pending_jobs_.begin(), pending_jobs_.end(), job);
+    DCHECK(it != pending_jobs_.end());
+    pending_jobs_.erase(it);
+  }
+}
+
+LoadState MultiThreadedProxyResolver::GetLoadState(RequestHandle req) const {
+  DCHECK(CalledOnValidThread());
+  DCHECK(req);
+  return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
+}
 
 Executor* MultiThreadedProxyResolver::FindIdleExecutor() {
   DCHECK(CalledOnValidThread());
@@ -517,14 +526,14 @@ void MultiThreadedProxyResolver::AddNewExecutor() {
 
 void MultiThreadedProxyResolver::OnExecutorReady(Executor* executor) {
   DCHECK(CalledOnValidThread());
-  while (!pending_jobs_.empty()) {
-    scoped_refptr<Job> job = pending_jobs_.front();
-    pending_jobs_.pop_front();
-    if (!job->was_cancelled()) {
-      executor->StartJob(job.get());
-      return;
-    }
-  }
+  if (pending_jobs_.empty())
+    return;
+
+  // Get the next job to process (FIFO). Transfer it from the pending queue
+  // to the executor.
+  scoped_refptr<Job> job = pending_jobs_.front();
+  pending_jobs_.pop_front();
+  executor->StartJob(job.get());
 }
 
 }  // namespace
diff --git a/net/proxy/multi_threaded_proxy_resolver_unittest.cc b/net/proxy/multi_threaded_proxy_resolver_unittest.cc
index 1eaed5f..5c29864 100644
--- a/net/proxy/multi_threaded_proxy_resolver_unittest.cc
+++ b/net/proxy/multi_threaded_proxy_resolver_unittest.cc
@@ -46,7 +46,7 @@ class MockProxyResolver : public ProxyResolver {
   int GetProxyForURL(const GURL& query_url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
-                     scoped_ptr<Request>* request,
+                     RequestHandle* request,
                      const BoundNetLog& net_log) override {
     if (resolve_latency_ != base::TimeDelta())
       base::PlatformThread::Sleep(resolve_latency_);
@@ -65,6 +65,13 @@ class MockProxyResolver : public ProxyResolver {
     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) {
@@ -113,7 +120,7 @@ class BlockableProxyResolver : public MockProxyResolver {
   int GetProxyForURL(const GURL& query_url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
-                     scoped_ptr<Request>* request,
+                     RequestHandle* request,
                      const BoundNetLog& net_log) override {
     if (should_block_) {
       blocked_.Signal();
@@ -301,7 +308,7 @@ TEST_F(MultiThreadedProxyResolverTest,
   factory().resolvers()[0]->Block();
 
   // Start request 0.
-  scoped_ptr<ProxyResolver::Request> request0;
+  ProxyResolver::RequestHandle request0;
   TestCompletionCallback callback0;
   ProxyInfo results0;
   BoundTestNetLog log0;
@@ -318,7 +325,7 @@ TEST_F(MultiThreadedProxyResolverTest,
                                  callback1.callback(), NULL, log1.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  scoped_ptr<ProxyResolver::Request> request2;
+  ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback2;
   ProxyInfo results2;
   BoundTestNetLog log2;
@@ -386,7 +393,7 @@ TEST_F(MultiThreadedProxyResolverTest, SingleThread_CancelRequest) {
   factory().resolvers()[0]->Block();
 
   // Start request 0.
-  scoped_ptr<ProxyResolver::Request> request0;
+  ProxyResolver::RequestHandle request0;
   TestCompletionCallback callback0;
   ProxyInfo results0;
   rv =
@@ -405,7 +412,7 @@ TEST_F(MultiThreadedProxyResolverTest, SingleThread_CancelRequest) {
                                  callback1.callback(), NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  scoped_ptr<ProxyResolver::Request> request2;
+  ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback2;
   ProxyInfo results2;
   rv =
@@ -420,8 +427,8 @@ TEST_F(MultiThreadedProxyResolverTest, SingleThread_CancelRequest) {
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Cancel request0 (inprogress) and request2 (pending).
-  request0.reset();
-  request2.reset();
+  resolver().CancelRequest(request0);
+  resolver().CancelRequest(request2);
 
   // Unblock the worker thread so the requests can continue running.
   factory().resolvers()[0]->Unblock();
@@ -515,7 +522,7 @@ TEST_F(MultiThreadedProxyResolverTest, ThreeThreads_Basic) {
   int rv;
   TestCompletionCallback callback[kNumRequests];
   ProxyInfo results[kNumRequests];
-  scoped_ptr<ProxyResolver::Request> request[kNumRequests];
+  ProxyResolver::RequestHandle request[kNumRequests];
 
   // Start request 0 -- this should run on thread 0 as there is nothing else
   // going on right now.
@@ -590,8 +597,8 @@ TEST_F(MultiThreadedProxyResolverTest, ThreeThreads_Basic) {
                                  callback[7].callback(), &request[7],
                                  BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  request[5].reset();
-  request[6].reset();
+  resolver().CancelRequest(request[5]);
+  resolver().CancelRequest(request[6]);
 
   EXPECT_EQ(2, callback[7].WaitForResult());
 
@@ -627,7 +634,7 @@ TEST_F(MultiThreadedProxyResolverTest, OneThreadBlocked) {
   const int kNumRequests = 4;
   TestCompletionCallback callback[kNumRequests];
   ProxyInfo results[kNumRequests];
-  scoped_ptr<ProxyResolver::Request> request[kNumRequests];
+  ProxyResolver::RequestHandle request[kNumRequests];
 
   // Start a request that will block the first thread.
 
diff --git a/net/proxy/proxy_resolver.h b/net/proxy/proxy_resolver.h
index 0a85f60..81efe05 100644
--- a/net/proxy/proxy_resolver.h
+++ b/net/proxy/proxy_resolver.h
@@ -27,11 +27,8 @@ class ProxyInfo;
 // requests at a time.
 class NET_EXPORT_PRIVATE ProxyResolver {
  public:
-  class Request {
-   public:
-    virtual ~Request() {}  // Cancels the request
-    virtual LoadState GetLoadState() = 0;
-  };
+  // Opaque pointer type, to return a handle to cancel outstanding requests.
+  typedef void* RequestHandle;
 
   ProxyResolver() {}
 
@@ -42,14 +39,19 @@ class NET_EXPORT_PRIVATE ProxyResolver {
   // by running |callback|.  If the result code is OK then
   // the request was successful and |results| contains the proxy
   // resolution information.  In the case of asynchronous completion
-  // |*request| is written to. Call request->reset() to cancel. The
-  // scoped_ptr<Request> must not outlive the ProxyResolver that assigned it.
+  // |*request| is written to, and can be passed to CancelRequest().
   virtual int GetProxyForURL(const GURL& url,
                              ProxyInfo* results,
                              const CompletionCallback& callback,
-                             scoped_ptr<Request>* request,
+                             RequestHandle* request,
                              const BoundNetLog& net_log) = 0;
 
+  // Cancels |request|.
+  virtual void CancelRequest(RequestHandle request) = 0;
+
+  // Gets the LoadState for |request|.
+  virtual LoadState GetLoadState(RequestHandle request) const = 0;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ProxyResolver);
 };
diff --git a/net/proxy/proxy_resolver_factory_mojo.cc b/net/proxy/proxy_resolver_factory_mojo.cc
index 0412217..2070cf9 100644
--- a/net/proxy/proxy_resolver_factory_mojo.cc
+++ b/net/proxy/proxy_resolver_factory_mojo.cc
@@ -118,14 +118,13 @@ class ProxyResolverMojo : public ProxyResolver {
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const net::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:
   class Job;
-  class RequestImpl;
-
-  base::ThreadChecker thread_checker_;
 
   // Mojo error handler.
   void OnConnectionError();
@@ -143,24 +142,13 @@ class ProxyResolverMojo : public ProxyResolver {
 
   std::set<Job*> pending_jobs_;
 
+  base::ThreadChecker thread_checker_;
 
   scoped_ptr<base::ScopedClosureRunner> on_delete_callback_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyResolverMojo);
 };
 
-class ProxyResolverMojo::RequestImpl : public ProxyResolver::Request {
- public:
-  explicit RequestImpl(scoped_ptr<Job> job);
-
-  ~RequestImpl() override;
-
-  LoadState GetLoadState() override;
-
- private:
-  scoped_ptr<Job> job_;
-};
-
 class ProxyResolverMojo::Job
     : public ClientMixin<interfaces::ProxyResolverRequestClient> {
  public:
@@ -171,15 +159,13 @@ class ProxyResolverMojo::Job
       const BoundNetLog& net_log);
   ~Job() override;
 
+  // Cancels the job and prevents the callback from being run.
+  void Cancel();
+
   // Returns the LoadState of this job.
   LoadState GetLoadState();
 
-  ProxyResolverMojo* resolver();
-
-  void CompleteRequest(int result);
-
  private:
-  friend class base::RefCounted<Job>;
   // Mojo error handler.
   void OnConnectionError();
 
@@ -197,18 +183,6 @@ class ProxyResolverMojo::Job
   mojo::Binding<interfaces::ProxyResolverRequestClient> binding_;
 };
 
-ProxyResolverMojo::RequestImpl::RequestImpl(scoped_ptr<Job> job)
-    : job_(std::move(job)) {}
-
-ProxyResolverMojo::RequestImpl::~RequestImpl() {
-  job_->CompleteRequest(ERR_PAC_SCRIPT_TERMINATED);
-}
-
-LoadState ProxyResolverMojo::RequestImpl::GetLoadState() {
-  CHECK_EQ(1u, job_->resolver()->pending_jobs_.count(job_.get()));
-  return job_->GetLoadState();
-}
-
 ProxyResolverMojo::Job::Job(ProxyResolverMojo* resolver,
                             const GURL& url,
                             ProxyInfo* results,
@@ -230,31 +204,27 @@ ProxyResolverMojo::Job::Job(ProxyResolverMojo* resolver,
       &ProxyResolverMojo::Job::OnConnectionError, base::Unretained(this)));
 }
 
-ProxyResolverMojo::Job::~Job() {}
+ProxyResolverMojo::Job::~Job() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!callback_.is_null())
+    callback_.Run(ERR_PAC_SCRIPT_TERMINATED);
+}
+
+void ProxyResolverMojo::Job::Cancel() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!callback_.is_null());
+  callback_.Reset();
+}
 
 LoadState ProxyResolverMojo::Job::GetLoadState() {
   return dns_request_in_progress() ? LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT
                                    : LOAD_STATE_RESOLVING_PROXY_FOR_URL;
 }
 
-ProxyResolverMojo* ProxyResolverMojo::Job::resolver() {
-  return resolver_;
-};
-
 void ProxyResolverMojo::Job::OnConnectionError() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "ProxyResolverMojo::Job::OnConnectionError";
-  CompleteRequest(ERR_PAC_SCRIPT_TERMINATED);
-}
-
-void ProxyResolverMojo::Job::CompleteRequest(int result) {
-  CompletionCallback callback = callback_;
-  callback_.Reset();
-  if (resolver_)
-    resolver_->RemoveJob(this);
-  resolver_ = nullptr;
-  if (!callback.is_null())
-    callback.Run(result);
+  resolver_->RemoveJob(this);
 }
 
 void ProxyResolverMojo::Job::ReportResult(
@@ -268,7 +238,10 @@ void ProxyResolverMojo::Job::ReportResult(
     DVLOG(1) << "Servers: " << results_->ToPacString();
   }
 
-  CompleteRequest(error);
+  CompletionCallback callback = callback_;
+  callback_.Reset();
+  resolver_->RemoveJob(this);
+  callback.Run(error);
 }
 
 ProxyResolverMojo::ProxyResolverMojo(
@@ -302,28 +275,42 @@ void ProxyResolverMojo::OnConnectionError() {
 
 void ProxyResolverMojo::RemoveJob(Job* job) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  pending_jobs_.erase(job);
+  size_t num_erased = pending_jobs_.erase(job);
+  DCHECK(num_erased);
+  delete job;
 }
 
 int ProxyResolverMojo::GetProxyForURL(const GURL& url,
                                       ProxyInfo* results,
                                       const CompletionCallback& callback,
-                                      scoped_ptr<Request>* request,
+                                      RequestHandle* request,
                                       const BoundNetLog& net_log) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!mojo_proxy_resolver_ptr_)
     return ERR_PAC_SCRIPT_TERMINATED;
 
-  scoped_ptr<Job> job(new Job(this, url, results, callback, net_log));
-  bool inserted = pending_jobs_.insert(job.get()).second;
+  Job* job = new Job(this, url, results, callback, net_log);
+  bool inserted = pending_jobs_.insert(job).second;
   DCHECK(inserted);
-  request->reset(new RequestImpl(std::move(job)));
+  *request = job;
 
   return ERR_IO_PENDING;
 }
 
+void ProxyResolverMojo::CancelRequest(RequestHandle request) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  Job* job = static_cast<Job*>(request);
+  DCHECK(job);
+  job->Cancel();
+  RemoveJob(job);
+}
 
+LoadState ProxyResolverMojo::GetLoadState(RequestHandle request) const {
+  Job* job = static_cast<Job*>(request);
+  CHECK_EQ(1u, pending_jobs_.count(job));
+  return job->GetLoadState();
+}
 
 }  // namespace
 
diff --git a/net/proxy/proxy_resolver_factory_mojo_unittest.cc b/net/proxy/proxy_resolver_factory_mojo_unittest.cc
index 0830609..9fa4ef5 100644
--- a/net/proxy/proxy_resolver_factory_mojo_unittest.cc
+++ b/net/proxy/proxy_resolver_factory_mojo_unittest.cc
@@ -294,14 +294,14 @@ class Request {
   int WaitForResult();
 
   const ProxyInfo& results() const { return results_; }
-  LoadState load_state() { return request_->GetLoadState(); }
+  LoadState load_state() { return resolver_->GetLoadState(handle_); }
   BoundTestNetLog& net_log() { return net_log_; }
 
  private:
   ProxyResolver* resolver_;
   const GURL url_;
   ProxyInfo results_;
-  scoped_ptr<ProxyResolver::Request> request_;
+  ProxyResolver::RequestHandle handle_;
   int error_;
   TestCompletionCallback callback_;
   BoundTestNetLog net_log_;
@@ -313,12 +313,12 @@ Request::Request(ProxyResolver* resolver, const GURL& url)
 
 int Request::Resolve() {
   error_ = resolver_->GetProxyForURL(url_, &results_, callback_.callback(),
-                                     &request_, net_log_.bound());
+                                     &handle_, net_log_.bound());
   return error_;
 }
 
 void Request::Cancel() {
-  request_.reset();
+  resolver_->CancelRequest(handle_);
 }
 
 int Request::WaitForResult() {
@@ -841,7 +841,7 @@ TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_DeleteInCallback) {
 
   ProxyInfo results;
   TestCompletionCallback callback;
-  scoped_ptr<ProxyResolver::Request> request;
+  ProxyResolver::RequestHandle handle;
   BoundNetLog net_log;
   EXPECT_EQ(
       OK,
@@ -849,7 +849,7 @@ TEST_F(ProxyResolverFactoryMojoTest, GetProxyForURL_DeleteInCallback) {
           GURL(kExampleUrl), &results,
           base::Bind(&ProxyResolverFactoryMojoTest::DeleteProxyResolverCallback,
                      base::Unretained(this), callback.callback()),
-          &request, net_log)));
+          &handle, net_log)));
   on_delete_callback_.WaitForResult();
 }
 
@@ -861,7 +861,7 @@ TEST_F(ProxyResolverFactoryMojoTest,
 
   ProxyInfo results;
   TestCompletionCallback callback;
-  scoped_ptr<ProxyResolver::Request> request;
+  ProxyResolver::RequestHandle handle;
   BoundNetLog net_log;
   EXPECT_EQ(
       ERR_PAC_SCRIPT_TERMINATED,
@@ -869,7 +869,7 @@ TEST_F(ProxyResolverFactoryMojoTest,
           GURL(kExampleUrl), &results,
           base::Bind(&ProxyResolverFactoryMojoTest::DeleteProxyResolverCallback,
                      base::Unretained(this), callback.callback()),
-          &request, net_log)));
+          &handle, net_log)));
   on_delete_callback_.WaitForResult();
 }
 
diff --git a/net/proxy/proxy_resolver_mac.cc b/net/proxy/proxy_resolver_mac.cc
index c3d86b1..d4f4119 100644
--- a/net/proxy/proxy_resolver_mac.cc
+++ b/net/proxy/proxy_resolver_mac.cc
@@ -73,9 +73,13 @@ class ProxyResolverMac : public ProxyResolver {
   int GetProxyForURL(const GURL& 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:
   const scoped_refptr<ProxyResolverScriptData> script_data_;
 };
@@ -92,7 +96,7 @@ ProxyResolverMac::~ProxyResolverMac() {}
 int ProxyResolverMac::GetProxyForURL(const GURL& query_url,
                                      ProxyInfo* results,
                                      const CompletionCallback& /*callback*/,
-                                     scoped_ptr<Request>* /*request*/,
+                                     RequestHandle* /*request*/,
                                      const BoundNetLog& net_log) {
   base::ScopedCFTypeRef<CFStringRef> query_ref(
       base::SysUTF8ToCFStringRef(query_url.spec()));
@@ -199,6 +203,15 @@ int ProxyResolverMac::GetProxyForURL(const GURL& query_url,
   return OK;
 }
 
+void ProxyResolverMac::CancelRequest(RequestHandle request) {
+  NOTREACHED();
+}
+
+LoadState ProxyResolverMac::GetLoadState(RequestHandle request) const {
+  NOTREACHED();
+  return LOAD_STATE_IDLE;
+}
+
 }  // namespace
 
 ProxyResolverFactoryMac::ProxyResolverFactoryMac()
diff --git a/net/proxy/proxy_resolver_perftest.cc b/net/proxy/proxy_resolver_perftest.cc
index ae5e25d..7aae5b2 100644
--- a/net/proxy/proxy_resolver_perftest.cc
+++ b/net/proxy/proxy_resolver_perftest.cc
@@ -234,11 +234,18 @@ class ProxyResolverV8Wrapper : public ProxyResolver {
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const CompletionCallback& /*callback*/,
-                     scoped_ptr<Request>* /*request*/,
+                     RequestHandle* /*request*/,
                      const BoundNetLog& net_log) override {
     return resolver_->GetProxyForURL(url, results, bindings_.get());
   }
 
+  void CancelRequest(RequestHandle request) override { NOTREACHED(); }
+
+  LoadState GetLoadState(RequestHandle request) const override {
+    NOTREACHED();
+    return LOAD_STATE_IDLE;
+  }
+
  private:
   scoped_ptr<ProxyResolverV8> resolver_;
   scoped_ptr<MockJSBindings> bindings_;
diff --git a/net/proxy/proxy_resolver_v8_tracing.cc b/net/proxy/proxy_resolver_v8_tracing.cc
index 9375969..dd2fe40 100644
--- a/net/proxy/proxy_resolver_v8_tracing.cc
+++ b/net/proxy/proxy_resolver_v8_tracing.cc
@@ -311,18 +311,10 @@ class ProxyResolverV8TracingImpl : public ProxyResolverV8Tracing,
   void GetProxyForURL(const GURL& url,
                       ProxyInfo* results,
                       const CompletionCallback& callback,
-                      scoped_ptr<ProxyResolver::Request>* request,
+                      ProxyResolver::RequestHandle* request,
                       scoped_ptr<Bindings> bindings) override;
-
-  class RequestImpl : public ProxyResolver::Request {
-   public:
-    explicit RequestImpl(scoped_refptr<Job> job);
-    ~RequestImpl() override;
-    LoadState GetLoadState() override;
-
-   private:
-    scoped_refptr<Job> job_;
-  };
+  void CancelRequest(ProxyResolver::RequestHandle request) override;
+  LoadState GetLoadState(ProxyResolver::RequestHandle request) const override;
 
  private:
   // The worker thread on which the ProxyResolverV8 will be run.
@@ -391,16 +383,10 @@ void Job::Cancel() {
   //     posted after the DNS dependency was resolved and saved to local cache.
   // (f) The script execution completed entirely, and posted a task to the
   //     origin thread to notify the caller.
-  // (g) The job is already completed.
   //
   // |cancelled_| is read on both the origin thread and worker thread. The
   // code that runs on the worker thread is littered with checks on
   // |cancelled_| to break out early.
-
-  // If the job already completed, there is nothing to be cancelled.
-  if (callback_.is_null())
-    return;
-
   cancelled_.Set();
 
   ReleaseCallback();
@@ -948,33 +934,34 @@ ProxyResolverV8TracingImpl::~ProxyResolverV8TracingImpl() {
   thread_.reset();
 }
 
-ProxyResolverV8TracingImpl::RequestImpl::RequestImpl(scoped_refptr<Job> job)
-    : job_(std::move(job)) {}
-
-ProxyResolverV8TracingImpl::RequestImpl::~RequestImpl() {
-  job_->Cancel();
-}
-
-LoadState ProxyResolverV8TracingImpl::RequestImpl::GetLoadState() {
-  return job_->GetLoadState();
-}
-
 void ProxyResolverV8TracingImpl::GetProxyForURL(
     const GURL& url,
     ProxyInfo* results,
     const CompletionCallback& callback,
-    scoped_ptr<ProxyResolver::Request>* request,
+    ProxyResolver::RequestHandle* request,
     scoped_ptr<Bindings> bindings) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
 
   scoped_refptr<Job> job = new Job(job_params_.get(), std::move(bindings));
 
-  request->reset(new RequestImpl(job));
+  if (request)
+    *request = job.get();
 
   job->StartGetProxyForURL(url, results, callback);
 }
 
+void ProxyResolverV8TracingImpl::CancelRequest(
+    ProxyResolver::RequestHandle request) {
+  Job* job = reinterpret_cast<Job*>(request);
+  job->Cancel();
+}
+
+LoadState ProxyResolverV8TracingImpl::GetLoadState(
+    ProxyResolver::RequestHandle request) const {
+  Job* job = reinterpret_cast<Job*>(request);
+  return job->GetLoadState();
+}
 
 class ProxyResolverV8TracingFactoryImpl : public ProxyResolverV8TracingFactory {
  public:
diff --git a/net/proxy/proxy_resolver_v8_tracing.h b/net/proxy/proxy_resolver_v8_tracing.h
index ecb1a76..f5f66cf 100644
--- a/net/proxy/proxy_resolver_v8_tracing.h
+++ b/net/proxy/proxy_resolver_v8_tracing.h
@@ -50,13 +50,20 @@ class NET_EXPORT ProxyResolverV8Tracing {
   // Gets a list of proxy servers to use for |url|. This request always
   // runs asynchronously and notifies the result by running |callback|. If the
   // result code is OK then the request was successful and |results| contains
-  // the proxy resolution information.  Request can be cancelled by resetting
-  // |*request|.
+  // the proxy resolution information. If |request| is non-null, |*request| is
+  // written to, and can be passed to CancelRequest().
   virtual void GetProxyForURL(const GURL& url,
                               ProxyInfo* results,
                               const CompletionCallback& callback,
-                              scoped_ptr<ProxyResolver::Request>* request,
+                              ProxyResolver::RequestHandle* request,
                               scoped_ptr<Bindings> bindings) = 0;
+
+  // Cancels |request|.
+  virtual void CancelRequest(ProxyResolver::RequestHandle request) = 0;
+
+  // Gets the LoadState for |request|.
+  virtual LoadState GetLoadState(
+      ProxyResolver::RequestHandle request) const = 0;
 };
 
 // A factory for ProxyResolverV8Tracing instances. The default implementation,
diff --git a/net/proxy/proxy_resolver_v8_tracing_unittest.cc b/net/proxy/proxy_resolver_v8_tracing_unittest.cc
index b8a9daf..888dd18 100644
--- a/net/proxy/proxy_resolver_v8_tracing_unittest.cc
+++ b/net/proxy/proxy_resolver_v8_tracing_unittest.cc
@@ -159,10 +159,9 @@ TEST_F(ProxyResolverV8TracingTest, Simple) {
 
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
-  scoped_ptr<ProxyResolver::Request> req;
 
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), &req,
+                           callback.callback(), NULL,
                            mock_bindings.CreateBindings());
 
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -186,9 +185,8 @@ TEST_F(ProxyResolverV8TracingTest, JavascriptError) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://throw-an-error/"), &proxy_info,
-                           callback.callback(), &req,
+                           callback.callback(), NULL,
                            mock_bindings.CreateBindings());
 
   EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, callback.WaitForResult());
@@ -214,9 +212,8 @@ TEST_F(ProxyResolverV8TracingTest, TooManyAlerts) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), &req,
+                           callback.callback(), NULL,
                            mock_bindings.CreateBindings());
 
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -251,9 +248,8 @@ TEST_F(ProxyResolverV8TracingTest, TooManyEmptyAlerts) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), &req,
+                           callback.callback(), NULL,
                            mock_bindings.CreateBindings());
 
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -298,9 +294,8 @@ TEST_F(ProxyResolverV8TracingTest, Dns) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), &req,
+                           callback.callback(), NULL,
                            mock_bindings.CreateBindings());
 
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -351,9 +346,8 @@ TEST_F(ProxyResolverV8TracingTest, DnsChecksCache) {
   TestCompletionCallback callback2;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foopy/req1"), &proxy_info,
-                           callback1.callback(), &req,
+                           callback1.callback(), NULL,
                            mock_bindings.CreateBindings());
 
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ -364,9 +358,8 @@ TEST_F(ProxyResolverV8TracingTest, DnsChecksCache) {
   // The first request took 2 restarts, hence on g_iteration=3.
   EXPECT_EQ("166.155.144.11:3", proxy_info.proxy_server().ToURI());
 
-  scoped_ptr<ProxyResolver::Request> req2;
   resolver->GetProxyForURL(GURL("http://foopy/req2"), &proxy_info,
-                           callback2.callback(), &req2,
+                           callback2.callback(), NULL,
                            mock_bindings.CreateBindings());
 
   EXPECT_EQ(OK, callback2.WaitForResult());
@@ -398,9 +391,8 @@ TEST_F(ProxyResolverV8TracingTest, FallBackToSynchronous1) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), &req,
+                           callback.callback(), NULL,
                            mock_bindings.CreateBindings());
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ -438,9 +430,8 @@ TEST_F(ProxyResolverV8TracingTest, FallBackToSynchronous2) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), &req,
+                           callback.callback(), NULL,
                            mock_bindings.CreateBindings());
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ -470,9 +461,8 @@ TEST_F(ProxyResolverV8TracingTest, InfiniteDNSSequence) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), &req,
+                           callback.callback(), NULL,
                            mock_bindings.CreateBindings());
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ -511,9 +501,8 @@ TEST_F(ProxyResolverV8TracingTest, InfiniteDNSSequence2) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), &req,
+                           callback.callback(), NULL,
                            mock_bindings.CreateBindings());
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ -552,9 +541,8 @@ void DnsDuringInitHelper(bool synchronous_host_resolver) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                           callback.callback(), &req,
+                           callback.callback(), NULL,
                            mock_bindings.CreateBindings());
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ -599,7 +587,7 @@ TEST_F(ProxyResolverV8TracingTest, CancelAll) {
 
   const size_t kNumRequests = 5;
   ProxyInfo proxy_info[kNumRequests];
-  scoped_ptr<ProxyResolver::Request> request[kNumRequests];
+  ProxyResolver::RequestHandle request[kNumRequests];
 
   for (size_t i = 0; i < kNumRequests; ++i) {
     resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info[i],
@@ -608,7 +596,7 @@ TEST_F(ProxyResolverV8TracingTest, CancelAll) {
   }
 
   for (size_t i = 0; i < kNumRequests; ++i) {
-    request[i].reset();
+    resolver->CancelRequest(request[i]);
   }
 }
 
@@ -626,8 +614,8 @@ TEST_F(ProxyResolverV8TracingTest, CancelSome) {
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
-  scoped_ptr<ProxyResolver::Request> request1;
-  scoped_ptr<ProxyResolver::Request> request2;
+  ProxyResolver::RequestHandle request1;
+  ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback;
 
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info1,
@@ -637,7 +625,7 @@ TEST_F(ProxyResolverV8TracingTest, CancelSome) {
                            callback.callback(), &request2,
                            mock_bindings.CreateBindings());
 
-  request1.reset();
+  resolver->CancelRequest(request1);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 }
@@ -655,8 +643,8 @@ TEST_F(ProxyResolverV8TracingTest, CancelWhilePendingCompletionTask) {
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
-  scoped_ptr<ProxyResolver::Request> request1;
-  scoped_ptr<ProxyResolver::Request> request2;
+  ProxyResolver::RequestHandle request1;
+  ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback;
 
   resolver->GetProxyForURL(GURL("http://throw-an-error/"), &proxy_info1,
@@ -665,10 +653,10 @@ TEST_F(ProxyResolverV8TracingTest, CancelWhilePendingCompletionTask) {
 
   // Wait until the first request has finished running on the worker thread.
   // Cancel the first request, while it is running its completion task on
-  // the origin thread. Reset deletes Request opject which cancels the request.
-  mock_bindings.RunOnError(
-      base::Bind(&scoped_ptr<ProxyResolver::Request>::reset,
-                 base::Unretained(&request1), nullptr));
+  // the origin thread.
+  mock_bindings.RunOnError(base::Bind(&ProxyResolverV8Tracing::CancelRequest,
+                                      base::Unretained(resolver.get()),
+                                      request1));
 
   // Start another request, to make sure it is able to complete.
   resolver->GetProxyForURL(GURL("http://i-have-no-idea-what-im-doing/"),
@@ -758,8 +746,8 @@ TEST_F(ProxyResolverV8TracingTest, CancelWhileOutstandingNonBlockingDns) {
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
-  scoped_ptr<ProxyResolver::Request> request1;
-  scoped_ptr<ProxyResolver::Request> request2;
+  ProxyResolver::RequestHandle request1;
+  ProxyResolver::RequestHandle request2;
 
   resolver->GetProxyForURL(GURL("http://foo/req1"), &proxy_info1,
                            base::Bind(&CrashCallback), &request1,
@@ -773,8 +761,8 @@ TEST_F(ProxyResolverV8TracingTest, CancelWhileOutstandingNonBlockingDns) {
 
   host_resolver.WaitUntilRequestIsReceived();
 
-  request1.reset();
-  request2.reset();
+  resolver->CancelRequest(request1);
+  resolver->CancelRequest(request2);
 
   EXPECT_EQ(2, host_resolver.num_cancelled_requests());
 
@@ -783,8 +771,9 @@ TEST_F(ProxyResolverV8TracingTest, CancelWhileOutstandingNonBlockingDns) {
   // should have been cancelled.
 }
 
-void CancelRequestAndPause(scoped_ptr<ProxyResolver::Request>* request) {
-  request->reset();
+void CancelRequestAndPause(ProxyResolverV8Tracing* resolver,
+                           ProxyResolver::RequestHandle request) {
+  resolver->CancelRequest(request);
 
   // 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
@@ -803,13 +792,14 @@ TEST_F(ProxyResolverV8TracingTest, CancelWhileBlockedInNonBlockingDns) {
       CreateResolver(mock_bindings.CreateBindings(), "dns.js");
 
   ProxyInfo proxy_info;
-  scoped_ptr<ProxyResolver::Request> request;
+  ProxyResolver::RequestHandle request;
 
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                            base::Bind(&CrashCallback), &request,
                            mock_bindings.CreateBindings());
 
-  host_resolver.SetAction(base::Bind(CancelRequestAndPause, &request));
+  host_resolver.SetAction(
+      base::Bind(CancelRequestAndPause, resolver.get(), request));
 
   host_resolver.WaitUntilRequestIsReceived();
 }
@@ -824,7 +814,7 @@ TEST_F(ProxyResolverV8TracingTest, CancelWhileBlockedInNonBlockingDns2) {
       CreateResolver(mock_bindings.CreateBindings(), "dns.js");
 
   ProxyInfo proxy_info;
-  scoped_ptr<ProxyResolver::Request> request;
+  ProxyResolver::RequestHandle request;
 
   resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                            base::Bind(&CrashCallback), &request,
@@ -834,7 +824,7 @@ TEST_F(ProxyResolverV8TracingTest, CancelWhileBlockedInNonBlockingDns2) {
   // 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));
-  request.reset();
+  resolver->CancelRequest(request);
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 }
@@ -908,9 +898,8 @@ TEST_F(ProxyResolverV8TracingTest, Terminate) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   resolver->GetProxyForURL(GURL("http://foopy/req1"), &proxy_info,
-                           callback.callback(), &req,
+                           callback.callback(), NULL,
                            mock_bindings.CreateBindings());
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ -982,14 +971,13 @@ TEST_F(ProxyResolverV8TracingTest, MultipleResolvers) {
   const size_t kNumResults = kNumResolvers * kNumIterations;
   TestCompletionCallback callback[kNumResults];
   ProxyInfo proxy_info[kNumResults];
-  scoped_ptr<ProxyResolver::Request> request[kNumResults];
 
   for (size_t i = 0; i < kNumResults; ++i) {
     size_t resolver_i = i % kNumResolvers;
     resolver[resolver_i]->GetProxyForURL(
-        GURL("http://foo/"), &proxy_info[i], callback[i].callback(),
-        &request[i], resolver_i == 3 ? mock_bindings3.CreateBindings()
-                                     : mock_bindings0.CreateBindings());
+        GURL("http://foo/"), &proxy_info[i], callback[i].callback(), NULL,
+        resolver_i == 3 ? mock_bindings3.CreateBindings()
+                        : mock_bindings0.CreateBindings());
   }
 
   // ------------------------
diff --git a/net/proxy/proxy_resolver_v8_tracing_wrapper.cc b/net/proxy/proxy_resolver_v8_tracing_wrapper.cc
index 767087c..25144b6 100644
--- a/net/proxy/proxy_resolver_v8_tracing_wrapper.cc
+++ b/net/proxy/proxy_resolver_v8_tracing_wrapper.cc
@@ -88,9 +88,13 @@ class ProxyResolverV8TracingWrapper : public ProxyResolver {
   int GetProxyForURL(const GURL& 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:
   scoped_ptr<ProxyResolverV8Tracing> resolver_impl_;
   NetLog* net_log_;
@@ -114,7 +118,7 @@ int ProxyResolverV8TracingWrapper::GetProxyForURL(
     const GURL& url,
     ProxyInfo* results,
     const CompletionCallback& callback,
-    scoped_ptr<Request>* request,
+    RequestHandle* request,
     const BoundNetLog& net_log) {
   resolver_impl_->GetProxyForURL(
       url, results, callback, request,
@@ -123,6 +127,15 @@ int ProxyResolverV8TracingWrapper::GetProxyForURL(
   return ERR_IO_PENDING;
 }
 
+void ProxyResolverV8TracingWrapper::CancelRequest(RequestHandle request) {
+  resolver_impl_->CancelRequest(request);
+}
+
+LoadState ProxyResolverV8TracingWrapper::GetLoadState(
+    RequestHandle request) const {
+  return resolver_impl_->GetLoadState(request);
+}
+
 }  // namespace
 
 ProxyResolverFactoryV8TracingWrapper::ProxyResolverFactoryV8TracingWrapper(
diff --git a/net/proxy/proxy_resolver_v8_tracing_wrapper_unittest.cc b/net/proxy/proxy_resolver_v8_tracing_wrapper_unittest.cc
index 66fdc9e..946d4bf 100644
--- a/net/proxy/proxy_resolver_v8_tracing_wrapper_unittest.cc
+++ b/net/proxy/proxy_resolver_v8_tracing_wrapper_unittest.cc
@@ -128,10 +128,9 @@ TEST_F(ProxyResolverV8TracingWrapperTest, Simple) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                               callback.callback(), &req, request_log.bound());
+                               callback.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -160,10 +159,9 @@ TEST_F(ProxyResolverV8TracingWrapperTest, JavascriptError) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   int rv =
       resolver->GetProxyForURL(GURL("http://throw-an-error/"), &proxy_info,
-                               callback.callback(), &req, request_log.bound());
+                               callback.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(ERR_PAC_SCRIPT_FAILED, callback.WaitForResult());
@@ -210,10 +208,9 @@ TEST_F(ProxyResolverV8TracingWrapperTest, TooManyAlerts) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                               callback.callback(), &req, request_log.bound());
+                               callback.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -259,10 +256,9 @@ TEST_F(ProxyResolverV8TracingWrapperTest, TooManyEmptyAlerts) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                               callback.callback(), &req, request_log.bound());
+                               callback.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -317,10 +313,9 @@ TEST_F(ProxyResolverV8TracingWrapperTest, Dns) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                               callback.callback(), &req, request_log.bound());
+                               callback.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -383,10 +378,9 @@ TEST_F(ProxyResolverV8TracingWrapperTest, DnsChecksCache) {
   TestCompletionCallback callback2;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   int rv =
       resolver->GetProxyForURL(GURL("http://foopy/req1"), &proxy_info,
-                               callback1.callback(), &req, request_log.bound());
+                               callback1.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ -397,10 +391,9 @@ TEST_F(ProxyResolverV8TracingWrapperTest, DnsChecksCache) {
   // The first request took 2 restarts, hence on g_iteration=3.
   EXPECT_EQ("166.155.144.11:3", proxy_info.proxy_server().ToURI());
 
-  scoped_ptr<ProxyResolver::Request> req2;
-  rv = resolver->GetProxyForURL(GURL("http://foopy/req2"), &proxy_info,
-                                callback2.callback(), &req2,
-                                request_log.bound());
+  rv =
+      resolver->GetProxyForURL(GURL("http://foopy/req2"), &proxy_info,
+                               callback2.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback2.WaitForResult());
@@ -437,10 +430,9 @@ TEST_F(ProxyResolverV8TracingWrapperTest, FallBackToSynchronous1) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                               callback.callback(), &req, request_log.bound());
+                               callback.callback(), NULL, request_log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ -492,10 +484,9 @@ TEST_F(ProxyResolverV8TracingWrapperTest, FallBackToSynchronous2) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                               callback.callback(), &req, request_log.bound());
+                               callback.callback(), NULL, request_log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ -531,10 +522,9 @@ TEST_F(ProxyResolverV8TracingWrapperTest, InfiniteDNSSequence) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                               callback.callback(), &req, request_log.bound());
+                               callback.callback(), NULL, request_log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ -577,10 +567,9 @@ TEST_F(ProxyResolverV8TracingWrapperTest, InfiniteDNSSequence2) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                               callback.callback(), &req, request_log.bound());
+                               callback.callback(), NULL, request_log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ -622,10 +611,9 @@ void DnsDuringInitHelper(bool synchronous_host_resolver) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   int rv =
       resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
-                               callback.callback(), &req, request_log.bound());
+                               callback.callback(), NULL, request_log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ -679,7 +667,7 @@ TEST_F(ProxyResolverV8TracingWrapperTest, CancelAll) {
 
   const size_t kNumRequests = 5;
   ProxyInfo proxy_info[kNumRequests];
-  scoped_ptr<ProxyResolver::Request> request[kNumRequests];
+  ProxyResolver::RequestHandle request[kNumRequests];
 
   for (size_t i = 0; i < kNumRequests; ++i) {
     int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info[i],
@@ -689,7 +677,7 @@ TEST_F(ProxyResolverV8TracingWrapperTest, CancelAll) {
   }
 
   for (size_t i = 0; i < kNumRequests; ++i) {
-    request[i].reset();
+    resolver->CancelRequest(request[i]);
   }
 }
 
@@ -707,8 +695,8 @@ TEST_F(ProxyResolverV8TracingWrapperTest, CancelSome) {
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
-  scoped_ptr<ProxyResolver::Request> request1;
-  scoped_ptr<ProxyResolver::Request> request2;
+  ProxyResolver::RequestHandle request1;
+  ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info1,
@@ -720,7 +708,7 @@ TEST_F(ProxyResolverV8TracingWrapperTest, CancelSome) {
                                 callback.callback(), &request2, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  request1.reset();
+  resolver->CancelRequest(request1);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 }
@@ -738,8 +726,8 @@ TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhilePendingCompletionTask) {
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
-  scoped_ptr<ProxyResolver::Request> request1;
-  scoped_ptr<ProxyResolver::Request> request2;
+  ProxyResolver::RequestHandle request1;
+  ProxyResolver::RequestHandle request2;
   TestCompletionCallback callback;
 
   int rv = resolver->GetProxyForURL(GURL("http://throw-an-error/"),
@@ -749,10 +737,10 @@ TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhilePendingCompletionTask) {
 
   // 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. Reset deletes Request object which cancels the request.
-  error_observer->RunOnError(
-      base::Bind(&scoped_ptr<ProxyResolver::Request>::reset,
-                 base::Unretained(&request1), nullptr));
+  // the origin thread.
+  error_observer->RunOnError(base::Bind(&ProxyResolver::CancelRequest,
+                                        base::Unretained(resolver.get()),
+                                        request1));
 
   // Start another request, to make sure it is able to complete.
   rv = resolver->GetProxyForURL(GURL("http://i-have-no-idea-what-im-doing/"),
@@ -840,8 +828,8 @@ TEST_F(ProxyResolverV8TracingWrapperTest,
 
   ProxyInfo proxy_info1;
   ProxyInfo proxy_info2;
-  scoped_ptr<ProxyResolver::Request> request1;
-  scoped_ptr<ProxyResolver::Request> request2;
+  ProxyResolver::RequestHandle request1;
+  ProxyResolver::RequestHandle request2;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/req1"), &proxy_info1,
                                     base::Bind(&CrashCallback), &request1,
@@ -859,8 +847,8 @@ TEST_F(ProxyResolverV8TracingWrapperTest,
 
   host_resolver.WaitUntilRequestIsReceived();
 
-  request1.reset();
-  request2.reset();
+  resolver->CancelRequest(request1);
+  resolver->CancelRequest(request2);
 
   EXPECT_EQ(2, host_resolver.num_cancelled_requests());
 
@@ -869,8 +857,9 @@ TEST_F(ProxyResolverV8TracingWrapperTest,
   // should have been cancelled.
 }
 
-void CancelRequestAndPause(scoped_ptr<ProxyResolver::Request>* request) {
-  request->reset();
+void CancelRequestAndPause(ProxyResolver* resolver,
+                           ProxyResolver::RequestHandle request) {
+  resolver->CancelRequest(request);
 
   // 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
@@ -889,7 +878,7 @@ TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhileBlockedInNonBlockingDns) {
       nullptr, &host_resolver, make_scoped_ptr(error_observer), "dns.js");
 
   ProxyInfo proxy_info;
-  scoped_ptr<ProxyResolver::Request> request;
+  ProxyResolver::RequestHandle request;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                     base::Bind(&CrashCallback), &request,
@@ -897,7 +886,8 @@ TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhileBlockedInNonBlockingDns) {
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  host_resolver.SetAction(base::Bind(CancelRequestAndPause, &request));
+  host_resolver.SetAction(
+      base::Bind(CancelRequestAndPause, resolver.get(), request));
 
   host_resolver.WaitUntilRequestIsReceived();
 }
@@ -912,7 +902,7 @@ TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhileBlockedInNonBlockingDns2) {
       nullptr, &host_resolver, make_scoped_ptr(error_observer), "dns.js");
 
   ProxyInfo proxy_info;
-  scoped_ptr<ProxyResolver::Request> request;
+  ProxyResolver::RequestHandle request;
 
   int rv = resolver->GetProxyForURL(GURL("http://foo/"), &proxy_info,
                                     base::Bind(&CrashCallback), &request,
@@ -924,7 +914,7 @@ TEST_F(ProxyResolverV8TracingWrapperTest, CancelWhileBlockedInNonBlockingDns2) {
   // 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));
-  request.reset();
+  resolver->CancelRequest(request);
 
   EXPECT_EQ(0u, host_resolver.num_resolve());
 }
@@ -1011,10 +1001,9 @@ TEST_F(ProxyResolverV8TracingWrapperTest, Terminate) {
   TestCompletionCallback callback;
   ProxyInfo proxy_info;
 
-  scoped_ptr<ProxyResolver::Request> req;
   int rv =
       resolver->GetProxyForURL(GURL("http://foopy/req1"), &proxy_info,
-                               callback.callback(), &req, request_log.bound());
+                               callback.callback(), NULL, request_log.bound());
 
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -1092,13 +1081,12 @@ TEST_F(ProxyResolverV8TracingWrapperTest, MultipleResolvers) {
   const size_t kNumResults = kNumResolvers * kNumIterations;
   TestCompletionCallback callback[kNumResults];
   ProxyInfo proxy_info[kNumResults];
-  scoped_ptr<ProxyResolver::Request> request[kNumResults];
 
   for (size_t i = 0; i < kNumResults; ++i) {
     size_t resolver_i = i % kNumResolvers;
     int rv = resolver[resolver_i]->GetProxyForURL(
-        GURL("http://foo/"), &proxy_info[i], callback[i].callback(),
-        &request[i], BoundNetLog());
+        GURL("http://foo/"), &proxy_info[i], callback[i].callback(), NULL,
+        BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
diff --git a/net/proxy/proxy_resolver_winhttp.cc b/net/proxy/proxy_resolver_winhttp.cc
index a2b50d2..7dccbf0 100644
--- a/net/proxy/proxy_resolver_winhttp.cc
+++ b/net/proxy/proxy_resolver_winhttp.cc
@@ -62,8 +62,11 @@ class ProxyResolverWinHttp : public ProxyResolver {
   int GetProxyForURL(const GURL& 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:
   bool OpenWinHttpSession();
@@ -92,7 +95,7 @@ ProxyResolverWinHttp::~ProxyResolverWinHttp() {
 int ProxyResolverWinHttp::GetProxyForURL(const GURL& query_url,
                                          ProxyInfo* results,
                                          const CompletionCallback& /*callback*/,
-                                         scoped_ptr<Request>* /*request*/,
+                                         RequestHandle* /*request*/,
                                          const BoundNetLog& /*net_log*/) {
   // If we don't have a WinHTTP session, then create a new one.
   if (!session_handle_ && !OpenWinHttpSession())
@@ -172,6 +175,16 @@ int ProxyResolverWinHttp::GetProxyForURL(const GURL& query_url,
   return rv;
 }
 
+void ProxyResolverWinHttp::CancelRequest(RequestHandle request) {
+  // This is a synchronous ProxyResolver; no possibility for async requests.
+  NOTREACHED();
+}
+
+LoadState ProxyResolverWinHttp::GetLoadState(RequestHandle request) const {
+  NOTREACHED();
+  return LOAD_STATE_IDLE;
+}
+
 bool ProxyResolverWinHttp::OpenWinHttpSession() {
   DCHECK(!session_handle_);
   session_handle_ = WinHttpOpen(NULL,
diff --git a/net/proxy/proxy_service.cc b/net/proxy/proxy_service.cc
index 615403d..d6d410c 100644
--- a/net/proxy/proxy_service.cc
+++ b/net/proxy/proxy_service.cc
@@ -185,10 +185,18 @@ class ProxyResolverNull : public ProxyResolver {
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
-                     scoped_ptr<Request>* request,
+                     RequestHandle* request,
                      const BoundNetLog& net_log) override {
     return ERR_NOT_IMPLEMENTED;
   }
+
+  void CancelRequest(RequestHandle request) override { NOTREACHED(); }
+
+  LoadState GetLoadState(RequestHandle request) const override {
+    NOTREACHED();
+    return LOAD_STATE_IDLE;
+  }
+
 };
 
 // ProxyResolver that simulates a PAC script which returns
@@ -201,12 +209,19 @@ class ProxyResolverFromPacString : public ProxyResolver {
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
-                     scoped_ptr<Request>* request,
+                     RequestHandle* request,
                      const BoundNetLog& net_log) override {
     results->UsePacString(pac_string_);
     return OK;
   }
 
+  void CancelRequest(RequestHandle request) override { NOTREACHED(); }
+
+  LoadState GetLoadState(RequestHandle request) const override {
+    NOTREACHED();
+    return LOAD_STATE_IDLE;
+  }
+
  private:
   const std::string pac_string_;
 };
@@ -763,6 +778,7 @@ class ProxyService::PacRequest
         url_(url),
         load_flags_(load_flags),
         proxy_delegate_(proxy_delegate),
+        resolve_job_(NULL),
         config_id_(ProxyConfig::kInvalidConfigID),
         config_source_(PROXY_CONFIG_SOURCE_UNKNOWN),
         net_log_(net_log),
@@ -788,7 +804,7 @@ class ProxyService::PacRequest
 
   bool is_started() const {
     // Note that !! casts to bool. (VS gives a warning otherwise).
-    return !!resolve_job_.get();
+    return !!resolve_job_;
   }
 
   void StartAndCompleteCheckingForSynchronous() {
@@ -803,7 +819,8 @@ class ProxyService::PacRequest
   void CancelResolveJob() {
     DCHECK(is_started());
     // The request may already be running in the resolver.
-    resolve_job_.reset();
+    resolver()->CancelRequest(resolve_job_);
+    resolve_job_ = NULL;
     DCHECK(!is_started());
   }
 
@@ -831,12 +848,12 @@ class ProxyService::PacRequest
   int QueryDidComplete(int result_code) {
     DCHECK(!was_cancelled());
 
-    // This state is cleared when resolve_job_ is reset below.
+    // This state is cleared when resolve_job_ is set to nullptr below.
     bool script_executed = is_started();
 
     // Clear |resolve_job_| so is_started() returns false while
     // DidFinishResolvingProxy() runs.
-    resolve_job_.reset();
+    resolve_job_ = nullptr;
 
     // Note that DidFinishResolvingProxy might modify |results_|.
     int rv = service_->DidFinishResolvingProxy(
@@ -862,7 +879,7 @@ class ProxyService::PacRequest
 
   LoadState GetLoadState() const {
     if (is_started())
-      return resolve_job_->GetLoadState();
+      return resolver()->GetLoadState(resolve_job_);
     return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
   }
 
@@ -895,7 +912,7 @@ class ProxyService::PacRequest
   GURL url_;
   int load_flags_;
   ProxyDelegate* proxy_delegate_;
-  scoped_ptr<ProxyResolver::Request> resolve_job_;
+  ProxyResolver::RequestHandle resolve_job_;
   ProxyConfig::ID config_id_;  // The config id when the resolve was started.
   ProxyConfigSource config_source_;  // The source of proxy settings.
   BoundNetLog net_log_;
diff --git a/net/proxy/proxy_service_unittest.cc b/net/proxy/proxy_service_unittest.cc
index 96e2d2e..a9cb9ed 100644
--- a/net/proxy/proxy_service_unittest.cc
+++ b/net/proxy/proxy_service_unittest.cc
@@ -274,14 +274,25 @@ class TestProxyFallbackProxyDelegate : public ProxyDelegate {
   int proxy_fallback_net_error_;
 };
 
-using JobMap = std::map<GURL, MockAsyncProxyResolver::Job*>;
-
-// Given a jobmap and a list of target URLs |urls|, asserts that the set of URLs
-// of the jobs appearing in |list| is exactly the set of URLs in |urls|.
-JobMap GetJobsForURLs(const JobMap& map, const std::vector<GURL>& urls) {
-  size_t a = urls.size();
-  size_t b = map.size();
-  if (a != b) {
+using RequestMap =
+    std::map<GURL, scoped_refptr<MockAsyncProxyResolver::Request>>;
+
+// Given a list of requests |list| from a MockAsyncProxyResolver and a list of
+// target URLs |_urls|, asserts that the set of URLs of the requests appearing
+// in |list| is exactly the set of URLs in |_urls|, and produces a RequestMap in
+// |*map| containing the requests corresponding to those target |_urls|.
+//
+// Note that this function must return void to allow use of gtest's ASSERT_*
+// macros inside it.
+RequestMap GetRequestsForURLs(
+    const MockAsyncProxyResolver::RequestsList& requests,
+    const std::vector<GURL>& urls) {
+  RequestMap map;
+
+  for (const auto& it : requests)
+    map[it->url()] = it;
+
+  if (urls.size() != map.size()) {
     ADD_FAILURE() << "map size (" << map.size() << ") != urls size ("
                   << urls.size() << ")";
     return map;
@@ -297,11 +308,11 @@ JobMap GetJobsForURLs(const JobMap& map, const std::vector<GURL>& urls) {
 
 // Given a MockAsyncProxyResolver |resolver| and some GURLs, validates that the
 // set of pending request URLs for |resolver| is exactly the supplied list of
-// URLs and returns a map from URLs to the corresponding pending jobs.
-JobMap GetPendingJobsForURLs(const MockAsyncProxyResolver& resolver,
-                             const GURL& url1 = GURL(),
-                             const GURL& url2 = GURL(),
-                             const GURL& url3 = GURL()) {
+// URLs and returns a map from URLs to the corresponding pending requests.
+RequestMap GetPendingRequestsForURLs(const MockAsyncProxyResolver& resolver,
+                                     const GURL& url1 = GURL(),
+                                     const GURL& url2 = GURL(),
+                                     const GURL& url3 = GURL()) {
   std::vector<GURL> urls;
   if (!url1.is_empty())
     urls.push_back(url1);
@@ -309,23 +320,16 @@ JobMap GetPendingJobsForURLs(const MockAsyncProxyResolver& resolver,
     urls.push_back(url2);
   if (!url3.is_empty())
     urls.push_back(url3);
-
-  JobMap map;
-  for (MockAsyncProxyResolver::Job* it : resolver.pending_jobs()) {
-    DCHECK(it);
-    map[it->url()] = it;
-  }
-
-  return GetJobsForURLs(map, urls);
+  return GetRequestsForURLs(resolver.pending_requests(), urls);
 }
 
 // Given a MockAsyncProxyResolver |resolver| and some GURLs, validates that the
 // set of cancelled request URLs for |resolver| is exactly the supplied list of
-// URLs and returns a map from URLs to the corresponding cancelled jobs.
-JobMap GetCancelledJobsForURLs(const MockAsyncProxyResolver& resolver,
-                               const GURL& url1 = GURL(),
-                               const GURL& url2 = GURL(),
-                               const GURL& url3 = GURL()) {
+// URLs and returns a map from URLs to the corresponding cancelled requests.
+RequestMap GetCancelledRequestsForURLs(const MockAsyncProxyResolver& resolver,
+                                       const GURL& url1 = GURL(),
+                                       const GURL& url2 = GURL(),
+                                       const GURL& url3 = GURL()) {
   std::vector<GURL> urls;
   if (!url1.is_empty())
     urls.push_back(url1);
@@ -333,15 +337,7 @@ JobMap GetCancelledJobsForURLs(const MockAsyncProxyResolver& resolver,
     urls.push_back(url2);
   if (!url3.is_empty())
     urls.push_back(url3);
-
-  JobMap map;
-  for (const scoped_ptr<MockAsyncProxyResolver::Job>& it :
-       resolver.cancelled_jobs()) {
-    DCHECK(it);
-    map[it->url()] = it.get();
-  }
-
-  return GetJobsForURLs(map, urls);
+  return GetRequestsForURLs(resolver.cancelled_requests(), urls);
 }
 
 }  // namespace
@@ -411,7 +407,7 @@ TEST_F(ProxyServiceTest, OnResolveProxyCallbackAddProxy) {
 
   // Verify that the ProxyDelegate's behavior is stateless across
   // invocations of ResolveProxy. Start by having the callback add a proxy
-  // and checking that subsequent jobs are not affected.
+  // and checking that subsequent requests are not affected.
   delegate.set_add_proxy(true);
 
   // Callback should interpose:
@@ -507,12 +503,12 @@ TEST_F(ProxyServiceTest, PAC) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("foopy");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("foopy");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_FALSE(info.is_direct());
@@ -563,10 +559,10 @@ TEST_F(ProxyServiceTest, PAC_NoIdentityOrHash) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
   // The URL should have been simplified, stripping the username/password/hash.
   EXPECT_EQ(GURL("http://www.google.com/?ref"),
-            resolver.pending_jobs()[0]->url());
+            resolver.pending_requests()[0]->url());
 
   // We end here without ever completing the request -- destruction of
   // ProxyService will cancel the outstanding request.
@@ -594,12 +590,12 @@ TEST_F(ProxyServiceTest, PAC_FailoverWithoutDirect) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("foopy:8080");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("foopy:8080");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
@@ -648,11 +644,11 @@ TEST_F(ProxyServiceTest, PAC_RuntimeError) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Simulate a failure in the PAC executor.
-  resolver.pending_jobs()[0]->CompleteNow(ERR_PAC_SCRIPT_FAILED);
+  resolver.pending_requests()[0]->CompleteNow(ERR_PAC_SCRIPT_FAILED);
 
   EXPECT_EQ(OK, callback1.WaitForResult());
 
@@ -706,13 +702,13 @@ TEST_F(ProxyServiceTest, PAC_FailoverAfterDirect) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
-  resolver.pending_jobs()[0]->results()->UsePacString(
+  resolver.pending_requests()[0]->results()->UsePacString(
       "DIRECT ; PROXY foobar:10 ; DIRECT ; PROXY foobar:20");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_TRUE(info.is_direct());
@@ -778,11 +774,11 @@ TEST_F(ProxyServiceTest, PAC_ConfigSourcePropagates) {
                                 NULL, NULL, BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
 
   // Set the result in proxy resolver.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("foopy");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("foopy");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
@@ -820,11 +816,11 @@ TEST_F(ProxyServiceTest, ProxyResolverFails) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Fail the first resolve request in MockAsyncProxyResolver.
-  resolver.pending_jobs()[0]->CompleteNow(ERR_FAILED);
+  resolver.pending_requests()[0]->CompleteNow(ERR_FAILED);
 
   // Although the proxy resolver failed the request, ProxyService implicitly
   // falls-back to DIRECT.
@@ -843,13 +839,13 @@ TEST_F(ProxyServiceTest, ProxyResolverFails) {
                             NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // This time we will have the resolver succeed (perhaps the PAC script has
   // a dependency on the current time).
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("foopy_valid:8080");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("foopy_valid:8080");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(info.is_direct());
@@ -884,11 +880,11 @@ TEST_F(ProxyServiceTest, ProxyResolverTerminatedDuringRequest) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Fail the first resolve request in MockAsyncProxyResolver.
-  resolver.pending_jobs()[0]->CompleteNow(ERR_PAC_SCRIPT_TERMINATED);
+  resolver.pending_requests()[0]->CompleteNow(ERR_PAC_SCRIPT_TERMINATED);
 
   // Although the proxy resolver failed the request, ProxyService implicitly
   // falls-back to DIRECT.
@@ -914,12 +910,12 @@ TEST_F(ProxyServiceTest, ProxyResolverTerminatedDuringRequest) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // This time we will have the resolver succeed.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("foopy_valid:8080");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("foopy_valid:8080");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(info.is_direct());
@@ -960,10 +956,10 @@ TEST_F(ProxyServiceTest,
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  JobMap jobs = GetPendingJobsForURLs(resolver, url1, url2);
+  RequestMap requests = GetPendingRequestsForURLs(resolver, url1, url2);
 
   // Fail the first resolve request in MockAsyncProxyResolver.
-  jobs[url1]->CompleteNow(ERR_PAC_SCRIPT_TERMINATED);
+  requests[url1]->CompleteNow(ERR_PAC_SCRIPT_TERMINATED);
 
   // Although the proxy resolver failed the request, ProxyService implicitly
   // falls-back to DIRECT.
@@ -976,7 +972,7 @@ TEST_F(ProxyServiceTest,
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
 
   // The second request is cancelled when the proxy resolver terminates.
-  jobs = GetCancelledJobsForURLs(resolver, url2);
+  requests = GetCancelledRequestsForURLs(resolver, url2);
 
   // Since a second request was in progress, the ProxyService starts
   // initializating a new ProxyResolver.
@@ -985,11 +981,11 @@ TEST_F(ProxyServiceTest,
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  jobs = GetPendingJobsForURLs(resolver, url2);
+  requests = GetPendingRequestsForURLs(resolver, url2);
 
   // This request succeeds.
-  jobs[url2]->results()->UseNamedProxy("foopy_valid:8080");
-  jobs[url2]->CompleteNow(OK);
+  requests[url2]->results()->UseNamedProxy("foopy_valid:8080");
+  requests[url2]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(info.is_direct());
@@ -1119,11 +1115,11 @@ TEST_F(ProxyServiceTest, ProxyResolverFailsInJavaScriptMandatoryPac) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Fail the first resolve request in MockAsyncProxyResolver.
-  resolver.pending_jobs()[0]->CompleteNow(ERR_FAILED);
+  resolver.pending_requests()[0]->CompleteNow(ERR_FAILED);
 
   // As the proxy resolver failed the request and is configured for a mandatory
   // PAC script, ProxyService must not implicitly fall-back to DIRECT.
@@ -1138,13 +1134,13 @@ TEST_F(ProxyServiceTest, ProxyResolverFailsInJavaScriptMandatoryPac) {
                             NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // This time we will have the resolver succeed (perhaps the PAC script has
   // a dependency on the current time).
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("foopy_valid:8080");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("foopy_valid:8080");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(info.is_direct());
@@ -1178,13 +1174,13 @@ TEST_F(ProxyServiceTest, ProxyFallback) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy(
+  resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // The first item is valid.
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ -1223,14 +1219,14 @@ TEST_F(ProxyServiceTest, ProxyFallback) {
                             NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Set the result in proxy resolver -- the second result is already known
   // to be bad, so we will not try to use it initially.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy(
+  resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy3:7070;foopy1:8080;foopy2:9090");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback3.WaitForResult());
   EXPECT_FALSE(info.is_direct());
@@ -1282,14 +1278,14 @@ TEST_F(ProxyServiceTest, ProxyFallback) {
                             NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // This time, the first 3 results have been found to be bad, but only the
   // first proxy has been confirmed ...
-  resolver.pending_jobs()[0]->results()->UseNamedProxy(
+  resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy3:7070;foopy2:9090;foopy4:9091");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // ... therefore, we should see the second proxy first.
   EXPECT_EQ(OK, callback7.WaitForResult());
@@ -1328,13 +1324,13 @@ TEST_F(ProxyServiceTest, ProxyFallbackToDirect) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
-  resolver.pending_jobs()[0]->results()->UsePacString(
+  resolver.pending_requests()[0]->results()->UsePacString(
       "PROXY foopy1:8080; PROXY foopy2:9090; DIRECT");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Get the first result.
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ -1401,13 +1397,13 @@ TEST_F(ProxyServiceTest, ProxyFallback_NewSettings) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // Set the result in proxy resolver.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy(
+  resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // The first item is valid.
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ -1428,12 +1424,12 @@ TEST_F(ProxyServiceTest, ProxyFallback_NewSettings) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
-  resolver.pending_jobs()[0]->results()->UseNamedProxy(
+  resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // The first proxy is still there since the configuration changed.
   EXPECT_EQ(OK, callback2.WaitForResult());
@@ -1463,12 +1459,12 @@ TEST_F(ProxyServiceTest, ProxyFallback_NewSettings) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
-  resolver.pending_jobs()[0]->results()->UseNamedProxy(
+  resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback4.WaitForResult());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
@@ -1503,12 +1499,12 @@ TEST_F(ProxyServiceTest, ProxyFallback_BadConfig) {
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
-  resolver.pending_jobs()[0]->results()->UseNamedProxy(
+  resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // The first item is valid.
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ -1533,11 +1529,11 @@ TEST_F(ProxyServiceTest, ProxyFallback_BadConfig) {
                             NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // This simulates a javascript runtime error in the PAC script.
-  resolver.pending_jobs()[0]->CompleteNow(ERR_FAILED);
+  resolver.pending_requests()[0]->CompleteNow(ERR_FAILED);
 
   // Although the resolver failed, the ProxyService will implicitly fall-back
   // to a DIRECT connection.
@@ -1555,12 +1551,12 @@ TEST_F(ProxyServiceTest, ProxyFallback_BadConfig) {
       callback4.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
-  resolver.pending_jobs()[0]->results()->UseNamedProxy(
+  resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // The first proxy is not there since the it was added to the bad proxies
   // list by the earlier ReconsiderProxyAfterError().
@@ -1601,12 +1597,12 @@ TEST_F(ProxyServiceTest, ProxyFallback_BadConfigMandatory) {
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
-  resolver.pending_jobs()[0]->results()->UseNamedProxy(
+  resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // The first item is valid.
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ -1631,11 +1627,11 @@ TEST_F(ProxyServiceTest, ProxyFallback_BadConfigMandatory) {
                             NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
   // This simulates a javascript runtime error in the PAC script.
-  resolver.pending_jobs()[0]->CompleteNow(ERR_FAILED);
+  resolver.pending_requests()[0]->CompleteNow(ERR_FAILED);
 
   // Although the resolver failed, the ProxyService will NOT fall-back
   // to a DIRECT connection as it is configured as mandatory.
@@ -1654,12 +1650,12 @@ TEST_F(ProxyServiceTest, ProxyFallback_BadConfigMandatory) {
       callback4.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
 
-  resolver.pending_jobs()[0]->results()->UseNamedProxy(
+  resolver.pending_requests()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // The first proxy is not there since the it was added to the bad proxies
   // list by the earlier ReconsiderProxyAfterError().
@@ -1936,7 +1932,7 @@ TEST_F(ProxyServiceTest, CancelInProgressRequest) {
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  GetPendingJobsForURLs(resolver, url1);
+  GetPendingRequestsForURLs(resolver, url1);
 
   ProxyInfo info2;
   TestCompletionCallback callback2;
@@ -1945,34 +1941,34 @@ TEST_F(ProxyServiceTest, CancelInProgressRequest) {
                             &request2, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  GetPendingJobsForURLs(resolver, url1, url2);
+  GetPendingRequestsForURLs(resolver, url1, url2);
 
   ProxyInfo info3;
   TestCompletionCallback callback3;
   rv = service.ResolveProxy(url3, LOAD_NORMAL, &info3, callback3.callback(),
                             NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
-  GetPendingJobsForURLs(resolver, url1, url2, url3);
+  GetPendingRequestsForURLs(resolver, url1, url2, url3);
 
   // Cancel the second request
   service.CancelPacRequest(request2);
 
-  JobMap jobs = GetPendingJobsForURLs(resolver, url1, url3);
+  RequestMap requests = GetPendingRequestsForURLs(resolver, url1, url3);
 
-  // Complete the two un-cancelled jobs.
+  // Complete the two un-cancelled requests.
   // We complete the last one first, just to mix it up a bit.
-  jobs[url3]->results()->UseNamedProxy("request3:80");
-  jobs[url3]->CompleteNow(OK);  // dsaadsasd
+  requests[url3]->results()->UseNamedProxy("request3:80");
+  requests[url3]->CompleteNow(OK);
 
-  jobs[url1]->results()->UseNamedProxy("request1:80");
-  jobs[url1]->CompleteNow(OK);
+  requests[url1]->results()->UseNamedProxy("request1:80");
+  requests[url1]->CompleteNow(OK);
 
-  // Complete and verify that jobs ran as expected.
+  // Complete and verify that requests ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   EXPECT_FALSE(callback2.have_result());  // Cancelled.
-  GetCancelledJobsForURLs(resolver, url2);
+  GetCancelledRequestsForURLs(resolver, url2);
 
   EXPECT_EQ(OK, callback3.WaitForResult());
   EXPECT_EQ("request3:80", info3.proxy_server().ToURI());
@@ -2045,24 +2041,24 @@ TEST_F(ProxyServiceTest, InitialPACScriptDownload) {
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  JobMap jobs = GetPendingJobsForURLs(resolver, url1, url2, url3);
+  RequestMap requests = GetPendingRequestsForURLs(resolver, url1, url2, url3);
 
   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, service.GetLoadState(request1));
   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, service.GetLoadState(request2));
   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, service.GetLoadState(request3));
 
-  // Complete all the jobs (in some order).
+  // Complete all the requests (in some order).
 
-  jobs[url3]->results()->UseNamedProxy("request3:80");
-  jobs[url3]->CompleteNow(OK);
+  requests[url3]->results()->UseNamedProxy("request3:80");
+  requests[url3]->CompleteNow(OK);
 
-  jobs[url1]->results()->UseNamedProxy("request1:80");
-  jobs[url1]->CompleteNow(OK);
+  requests[url1]->results()->UseNamedProxy("request1:80");
+  requests[url1]->CompleteNow(OK);
 
-  jobs[url2]->results()->UseNamedProxy("request2:80");
-  jobs[url2]->CompleteNow(OK);
+  requests[url2]->results()->UseNamedProxy("request2:80");
+  requests[url2]->CompleteNow(OK);
 
-  // Complete and verify that jobs ran as expected.
+  // Complete and verify that requests ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
   EXPECT_FALSE(info1.proxy_resolve_start_time().is_null());
@@ -2100,7 +2096,7 @@ TEST_F(ProxyServiceTest, ChangeScriptFetcherWhilePACDownloadInProgress) {
   service.SetProxyScriptFetchers(
       fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
 
-  // Start 2 jobs.
+  // Start 2 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
@@ -2140,7 +2136,7 @@ TEST_F(ProxyServiceTest, ChangeScriptFetcherWhilePACDownloadInProgress) {
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  GetPendingJobsForURLs(resolver, url1, url2);
+  GetPendingRequestsForURLs(resolver, url1, url2);
 }
 
 // Test cancellation of a request, while the PAC script is being fetched.
@@ -2190,7 +2186,7 @@ TEST_F(ProxyServiceTest, CancelWhilePACFetching) {
   // Nothing has been sent to the factory yet.
   EXPECT_TRUE(factory->pending_requests().empty());
 
-  // Cancel the first 2 jobs.
+  // Cancel the first 2 requests.
   service.CancelPacRequest(request1);
   service.CancelPacRequest(request2);
 
@@ -2205,17 +2201,17 @@ TEST_F(ProxyServiceTest, CancelWhilePACFetching) {
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(GURL("http://request3"), resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(GURL("http://request3"), resolver.pending_requests()[0]->url());
 
-  // Complete all the jobs.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("request3:80");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  // Complete all the requests.
+  resolver.pending_requests()[0]->results()->UseNamedProxy("request3:80");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback3.WaitForResult());
   EXPECT_EQ("request3:80", info3.proxy_server().ToURI());
 
-  EXPECT_TRUE(resolver.cancelled_jobs().empty());
+  EXPECT_TRUE(resolver.cancelled_requests().empty());
 
   EXPECT_FALSE(callback1.have_result());  // Cancelled.
   EXPECT_FALSE(callback2.have_result());  // Cancelled.
@@ -2290,18 +2286,18 @@ TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomPac) {
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  // Now finally, the pending jobs should have been sent to the resolver
+  // Now finally, the pending requests should have been sent to the resolver
   // (which was initialized with custom PAC script).
 
-  JobMap jobs = GetPendingJobsForURLs(resolver, url1, url2);
+  RequestMap requests = GetPendingRequestsForURLs(resolver, url1, url2);
 
-  // Complete the pending jobs.
-  jobs[url2]->results()->UseNamedProxy("request2:80");
-  jobs[url2]->CompleteNow(OK);
-  jobs[url1]->results()->UseNamedProxy("request1:80");
-  jobs[url1]->CompleteNow(OK);
+  // Complete the pending requests.
+  requests[url2]->results()->UseNamedProxy("request2:80");
+  requests[url2]->CompleteNow(OK);
+  requests[url1]->results()->UseNamedProxy("request1:80");
+  requests[url1]->CompleteNow(OK);
 
-  // Verify that jobs ran as expected.
+  // Verify that requests ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
   EXPECT_FALSE(info1.proxy_resolve_start_time().is_null());
@@ -2371,18 +2367,18 @@ TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomPac2) {
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  // Now finally, the pending jobs should have been sent to the resolver
+  // Now finally, the pending requests should have been sent to the resolver
   // (which was initialized with custom PAC script).
 
-  JobMap jobs = GetPendingJobsForURLs(resolver, url1, url2);
+  RequestMap requests = GetPendingRequestsForURLs(resolver, url1, url2);
 
-  // Complete the pending jobs.
-  jobs[url2]->results()->UseNamedProxy("request2:80");
-  jobs[url2]->CompleteNow(OK);
-  jobs[url1]->results()->UseNamedProxy("request1:80");
-  jobs[url1]->CompleteNow(OK);
+  // Complete the pending requests.
+  requests[url2]->results()->UseNamedProxy("request2:80");
+  requests[url2]->CompleteNow(OK);
+  requests[url1]->results()->UseNamedProxy("request1:80");
+  requests[url1]->CompleteNow(OK);
 
-  // Verify that jobs ran as expected.
+  // Verify that requests ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
@@ -2408,7 +2404,7 @@ TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomToManual) {
   service.SetProxyScriptFetchers(
       fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
 
-  // Start 2 jobs.
+  // Start 2 requests.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
@@ -2442,7 +2438,7 @@ TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomToManual) {
   // sent to it.
   ASSERT_EQ(0u, factory->pending_requests().size());
 
-  // Verify that jobs ran as expected -- they should have fallen back to
+  // Verify that requests ran as expected -- they should have fallen back to
   // the manual proxy configuration for HTTP urls.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("foopy:80", info1.proxy_server().ToURI());
@@ -2491,12 +2487,13 @@ TEST_F(ProxyServiceTest, BypassDoesntApplyToPac) {
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(GURL("http://www.google.com"), resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(GURL("http://www.google.com"),
+            resolver.pending_requests()[0]->url());
 
   // Complete the pending request.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("request1:80");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Verify that request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ -2509,12 +2506,13 @@ TEST_F(ProxyServiceTest, BypassDoesntApplyToPac) {
                             callback2.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(GURL("http://www.google.com"), resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(GURL("http://www.google.com"),
+            resolver.pending_requests()[0]->url());
 
   // Complete the pending request.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("request2:80");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
@@ -2636,9 +2634,9 @@ TEST_F(ProxyServiceTest, UpdateConfigFromPACToDirect) {
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   // Complete the pending request.
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("request1:80");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Verify that request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ -2648,7 +2646,7 @@ TEST_F(ProxyServiceTest, UpdateConfigFromPACToDirect) {
   // (Even though the configuration isn't old/bad).
   //
   // This new configuration no longer has auto_detect set, so
-  // jobs should complete synchronously now as direct-connect.
+  // requests should complete synchronously now as direct-connect.
   config_service->SetConfig(ProxyConfig::CreateDirect());
 
   // Start another request -- the effective configuration has changed.
@@ -2709,12 +2707,12 @@ TEST_F(ProxyServiceTest, NetworkChangeTriggersPacRefetch) {
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(GURL("http://request1"), resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
 
   // Complete the pending request.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("request1:80");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ -2751,12 +2749,12 @@ TEST_F(ProxyServiceTest, NetworkChangeTriggersPacRefetch) {
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(GURL("http://request2"), resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[0]->url());
 
   // Complete the pending second request.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("request2:80");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback2.WaitForResult());
@@ -2869,12 +2867,12 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterFailure) {
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that it was sent to the resolver.
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(GURL("http://request2"), resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[0]->url());
 
   // Complete the pending second request.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("request2:80");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback2.WaitForResult());
@@ -2932,12 +2930,12 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentChange) {
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(GURL("http://request1"), resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
 
   // Complete the pending request.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("request1:80");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ -2953,7 +2951,7 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentChange) {
   fetcher->WaitUntilFetch();
 
   ASSERT_TRUE(factory->pending_requests().empty());
-  ASSERT_TRUE(resolver.pending_jobs().empty());
+  ASSERT_TRUE(resolver.pending_requests().empty());
 
   // Make sure that our background checker is trying to download the expected
   // PAC script (same one as before). This time we will simulate a successful
@@ -2981,12 +2979,12 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentChange) {
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that it was sent to the resolver.
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(GURL("http://request2"), resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[0]->url());
 
   // Complete the pending second request.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("request2:80");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback2.WaitForResult());
@@ -3044,12 +3042,12 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentUnchanged) {
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(GURL("http://request1"), resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
 
   // Complete the pending request.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("request1:80");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ -3065,7 +3063,7 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentUnchanged) {
   fetcher->WaitUntilFetch();
 
   ASSERT_TRUE(factory->pending_requests().empty());
-  ASSERT_TRUE(resolver.pending_jobs().empty());
+  ASSERT_TRUE(resolver.pending_requests().empty());
 
   // Make sure that our background checker is trying to download the expected
   // PAC script (same one as before). We will simulate the same response as
@@ -3077,7 +3075,7 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentUnchanged) {
   base::MessageLoop::current()->RunUntilIdle();
 
   ASSERT_TRUE(factory->pending_requests().empty());
-  ASSERT_TRUE(resolver.pending_jobs().empty());
+  ASSERT_TRUE(resolver.pending_requests().empty());
 
   // At this point the ProxyService is still running the same PAC script as
   // before.
@@ -3090,12 +3088,12 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterContentUnchanged) {
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that it was sent to the resolver.
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(GURL("http://request2"), resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[0]->url());
 
   // Complete the pending second request.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("request2:80");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback2.WaitForResult());
@@ -3153,12 +3151,12 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterSuccess) {
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(GURL("http://request1"), resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
 
   // Complete the pending request.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("request1:80");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ -3174,7 +3172,7 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterSuccess) {
   fetcher->WaitUntilFetch();
 
   ASSERT_TRUE(factory->pending_requests().empty());
-  ASSERT_TRUE(resolver.pending_jobs().empty());
+  ASSERT_TRUE(resolver.pending_requests().empty());
 
   // Make sure that our background checker is trying to download the expected
   // PAC script (same one as before). This time we will simulate a failure
@@ -3307,12 +3305,12 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterActivity) {
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(GURL("http://request1"), resolver.pending_jobs()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
 
   // Complete the pending request.
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("request1:80");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
@@ -3324,7 +3322,7 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterActivity) {
 
   ASSERT_FALSE(fetcher->has_pending_request());
   ASSERT_TRUE(factory->pending_requests().empty());
-  ASSERT_TRUE(resolver.pending_jobs().empty());
+  ASSERT_TRUE(resolver.pending_requests().empty());
 
   // Start a second request.
   ProxyInfo info2;
@@ -3334,10 +3332,10 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterActivity) {
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // This request should have sent work to the resolver; complete it.
-  ASSERT_EQ(1u, resolver.pending_jobs().size());
-  EXPECT_EQ(GURL("http://request2"), resolver.pending_jobs()[0]->url());
-  resolver.pending_jobs()[0]->results()->UseNamedProxy("request2:80");
-  resolver.pending_jobs()[0]->CompleteNow(OK);
+  ASSERT_EQ(1u, resolver.pending_requests().size());
+  EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[0]->url());
+  resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
+  resolver.pending_requests()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
diff --git a/net/url_request/url_request_ftp_job_unittest.cc b/net/url_request/url_request_ftp_job_unittest.cc
index 7ca6754..cb31ecf 100644
--- a/net/url_request/url_request_ftp_job_unittest.cc
+++ b/net/url_request/url_request_ftp_job_unittest.cc
@@ -332,13 +332,13 @@ TEST_F(URLRequestFtpJobTest, FtpProxyRequestOrphanJob) {
   // Verify PAC request is in progress.
   EXPECT_EQ(net::LoadState::LOAD_STATE_RESOLVING_PROXY_FOR_URL,
             url_request->GetLoadState().state);
-  EXPECT_EQ(1u, resolver_factory->resolver()->pending_jobs().size());
-  EXPECT_EQ(0u, resolver_factory->resolver()->cancelled_jobs().size());
+  EXPECT_EQ(1u, resolver_factory->resolver()->pending_requests().size());
+  EXPECT_EQ(0u, resolver_factory->resolver()->cancelled_requests().size());
 
   // Destroying the request should cancel the PAC request.
   url_request.reset();
-  EXPECT_EQ(0u, resolver_factory->resolver()->pending_jobs().size());
-  EXPECT_EQ(1u, resolver_factory->resolver()->cancelled_jobs().size());
+  EXPECT_EQ(0u, resolver_factory->resolver()->pending_requests().size());
+  EXPECT_EQ(1u, resolver_factory->resolver()->cancelled_requests().size());
 }
 
 // Make sure PAC requests are cancelled on request cancellation.  Requests can
@@ -363,14 +363,14 @@ TEST_F(URLRequestFtpJobTest, FtpProxyRequestCancelRequest) {
   url_request->Start();
   EXPECT_EQ(net::LoadState::LOAD_STATE_RESOLVING_PROXY_FOR_URL,
             url_request->GetLoadState().state);
-  EXPECT_EQ(1u, resolver_factory->resolver()->pending_jobs().size());
-  EXPECT_EQ(0u, resolver_factory->resolver()->cancelled_jobs().size());
+  EXPECT_EQ(1u, resolver_factory->resolver()->pending_requests().size());
+  EXPECT_EQ(0u, resolver_factory->resolver()->cancelled_requests().size());
 
   // Cancelling the request should cancel the PAC request.
   url_request->Cancel();
   EXPECT_EQ(net::LoadState::LOAD_STATE_IDLE, url_request->GetLoadState().state);
-  EXPECT_EQ(0u, resolver_factory->resolver()->pending_jobs().size());
-  EXPECT_EQ(1u, resolver_factory->resolver()->cancelled_jobs().size());
+  EXPECT_EQ(0u, resolver_factory->resolver()->pending_requests().size());
+  EXPECT_EQ(1u, resolver_factory->resolver()->cancelled_requests().size());
 }
 
 TEST_F(URLRequestFtpJobTest, FtpProxyRequestNeedProxyAuthNoCredentials) {