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

net/proxy/proxy_service_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/proxy/proxy_service.h"
 
 #include <cstdarg>
 #include <vector>
 
 #include "base/format_macros.h"
@@ skipping 223 matching lines @@
   int proxy_fallback_net_error() const {
     return proxy_fallback_net_error_;
   }
 
  private:
   bool on_proxy_fallback_called_;
   ProxyServer proxy_server_;
   int proxy_fallback_net_error_;
 };
 
-using RequestMap =
-    std::map<GURL, scoped_refptr<MockAsyncProxyResolver::Request>>;
+using JobMap = std::map<GURL, base::WeakPtr<MockAsyncProxyResolver::Job>>;
 
-// 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|.
+// Given a list of jobs |list| from a MockAsyncProxyResolver 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|, and produces a JobMap in
+// |*map| containing the jobs 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;
+// Note that it is important that this function do not make permanent copy from
+// RefPtr in JobsList.
+JobMap GetJobsForURLs(const MockAsyncProxyResolver::JobsList jobs,
+                      const std::vector<GURL>& urls) {
+  JobMap map;
+  for (const auto& it : jobs) {
+    DCHECK(it);
+    map[it->url()] = it->AsWeakPtr();
+  }
 
-  for (const auto& it : requests)
-    map[it->url()] = it;
-
-  if (urls.size() != map.size()) {
+  int a = urls.size();
+  int b = map.size();
+  if (a != b) {
     ADD_FAILURE() << "map size (" << map.size() << ") != urls size ("
                   << urls.size() << ")";
     return map;
   }
   for (const auto& it : urls) {
     if (map.count(it) != 1U) {
       ADD_FAILURE() << "url not in map: " << it.spec();
       break;
     }
   }
   return map;
 }
 
 // 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 requests.
-RequestMap GetPendingRequestsForURLs(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 jobs.
+JobMap GetPendingJobsForURLs(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);
   if (!url2.is_empty())
     urls.push_back(url2);
   if (!url3.is_empty())
     urls.push_back(url3);
-  return GetRequestsForURLs(resolver.pending_requests(), urls);
+  return GetJobsForURLs(resolver.pending_jobs(), 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 requests.
-RequestMap GetCancelledRequestsForURLs(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 jobs.
+JobMap GetCancelledJobsForURLs(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);
   if (!url2.is_empty())
     urls.push_back(url2);
   if (!url3.is_empty())
     urls.push_back(url3);
-  return GetRequestsForURLs(resolver.cancelled_requests(), urls);
+  return GetJobsForURLs(resolver.cancelled_jobs(), urls);
 }
 
 }  // namespace
 
 TEST_F(ProxyServiceTest, Direct) {
   MockAsyncProxyResolverFactory* factory =
       new MockAsyncProxyResolverFactory(false);
   ProxyService service(
       make_scoped_ptr(new MockProxyConfigService(ProxyConfig::CreateDirect())),
       make_scoped_ptr(factory), NULL);
@@ skipping 49 matching lines @@
 
   // Verify that network delegate is invoked.
   TestResolveProxyNetworkDelegate delegate;
   rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(), NULL,
                             &delegate, log.bound());
   EXPECT_TRUE(delegate.on_resolve_proxy_called());
   EXPECT_EQ(&service, delegate.proxy_service());
 
   // Verify that the NetworkDelegate's behavior is stateless across
   // invocations of ResolveProxy. Start by having the callback add a proxy
-  // and checking that subsequent requests are not affected.
+  // and checking that subsequent jobs are not affected.
   delegate.set_add_proxy(true);
 
   // Callback should interpose:
   rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(), NULL,
                             &delegate, log.bound());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ(info.proxy_server().host_port_pair().host(), "delegate_proxy.com");
   delegate.set_add_proxy(false);
 
   // Check non-bypassed URL:
@@ skipping 75 matching lines @@
                                 &request, NULL, log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(LOAD_STATE_RESOLVING_PROXY_FOR_URL, service.GetLoadState(request));
 
   ASSERT_EQ(1u, factory->pending_requests().size());
   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_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // Set the result in proxy resolver.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("foopy");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("foopy");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy:80", info.proxy_server().ToURI());
   EXPECT_TRUE(info.did_use_pac_script());
 
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
 
@@ skipping 30 matching lines @@
   ProxyInfo info;
   TestCompletionCallback callback;
   int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(),
                                 NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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_requests().size());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
   // The URL should have been simplified, stripping the username/password/hash.
   EXPECT_EQ(GURL("http://www.google.com/?ref"),
-            resolver.pending_requests()[0]->url());
+            resolver.pending_jobs()[0]->url());
 
   // We end here without ever completing the request -- destruction of
   // ProxyService will cancel the outstanding request.
 }
 
 TEST_F(ProxyServiceTest, PAC_FailoverWithoutDirect) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
   MockAsyncProxyResolver resolver;
   MockAsyncProxyResolverFactory* factory =
       new MockAsyncProxyResolverFactory(false);
 
   ProxyService service(make_scoped_ptr(config_service),
                        make_scoped_ptr(factory), NULL);
 
   GURL url("http://www.google.com/");
 
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
                                 NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // Set the result in proxy resolver.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("foopy:8080");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("foopy:8080");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy:8080", info.proxy_server().ToURI());
   EXPECT_TRUE(info.did_use_pac_script());
 
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
 
@@ skipping 28 matching lines @@
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
                                 NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // Simulate a failure in the PAC executor.
-  resolver.pending_requests()[0]->CompleteNow(ERR_PAC_SCRIPT_FAILED);
+  resolver.pending_jobs()[0]->CompleteNow(ERR_PAC_SCRIPT_FAILED);
 
   EXPECT_EQ(OK, callback1.WaitForResult());
 
   // Since the PAC script was non-mandatory, we should have fallen-back to
   // DIRECT.
   EXPECT_TRUE(info.is_direct());
   EXPECT_TRUE(info.did_use_pac_script());
   EXPECT_EQ(1, info.config_id());
 
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
@@ skipping 33 matching lines @@
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
                                 NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // Set the result in proxy resolver.
-  resolver.pending_requests()[0]->results()->UsePacString(
+  resolver.pending_jobs()[0]->results()->UsePacString(
       "DIRECT ; PROXY foobar:10 ; DIRECT ; PROXY foobar:20");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_TRUE(info.is_direct());
 
   // Fallback 1.
   TestCompletionCallback callback2;
   rv = service.ReconsiderProxyAfterError(
       url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
       callback2.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
@@ skipping 45 matching lines @@
                        make_scoped_ptr(factory), NULL);
 
   // Resolve something.
   GURL url("http://www.google.com/");
   ProxyInfo info;
   TestCompletionCallback callback;
   int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback.callback(),
                                 NULL, NULL, BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
-  ASSERT_EQ(1u, resolver.pending_requests().size());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
 
   // Set the result in proxy resolver.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("foopy");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("foopy");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_EQ(PROXY_CONFIG_SOURCE_TEST, info.config_source());
   EXPECT_TRUE(info.did_use_pac_script());
 
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
 }
 
@@ skipping 17 matching lines @@
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
                                 NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // Fail the first resolve request in MockAsyncProxyResolver.
-  resolver.pending_requests()[0]->CompleteNow(ERR_FAILED);
+  resolver.pending_jobs()[0]->CompleteNow(ERR_FAILED);
 
   // Although the proxy resolver failed the request, ProxyService implicitly
   // falls-back to DIRECT.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_TRUE(info.is_direct());
 
   // Failed PAC executions still have proxy resolution times.
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
 
   // The second resolve request will try to run through the proxy resolver,
   // regardless of whether the first request failed in it.
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback2.callback(), NULL,
                             NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // This time we will have the resolver succeed (perhaps the PAC script has
   // a dependency on the current time).
-  resolver.pending_requests()[0]->results()->UseNamedProxy("foopy_valid:8080");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("foopy_valid:8080");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy_valid:8080", info.proxy_server().ToURI());
 }
 
 TEST_F(ProxyServiceTest, ProxyResolverTerminatedDuringRequest) {
   // Test what happens when the ProxyResolver fails with a fatal error while
   // a GetProxyForURL() call is in progress.
 
@@ skipping 14 matching lines @@
   int rv =
       service.ResolveProxy(url, net::LOAD_NORMAL, &info, callback1.callback(),
                            nullptr, nullptr, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ASSERT_EQ(1u, factory->pending_requests().size());
   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_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // Fail the first resolve request in MockAsyncProxyResolver.
-  resolver.pending_requests()[0]->CompleteNow(ERR_PAC_SCRIPT_TERMINATED);
+  resolver.pending_jobs()[0]->CompleteNow(ERR_PAC_SCRIPT_TERMINATED);
 
   // Although the proxy resolver failed the request, ProxyService implicitly
   // falls-back to DIRECT.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_TRUE(info.is_direct());
 
   // Failed PAC executions still have proxy resolution times.
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
 
   // With no other requests, the ProxyService waits for a new request before
   // initializing a new ProxyResolver.
   EXPECT_TRUE(factory->pending_requests().empty());
 
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(url, net::LOAD_NORMAL, &info, callback2.callback(),
                             nullptr, nullptr, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ASSERT_EQ(1u, factory->pending_requests().size());
   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_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // This time we will have the resolver succeed.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("foopy_valid:8080");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("foopy_valid:8080");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy_valid:8080", info.proxy_server().ToURI());
 }
 
 TEST_F(ProxyServiceTest,
        ProxyResolverTerminatedDuringRequestWithConcurrentRequest) {
   // Test what happens when the ProxyResolver fails with a fatal error while
   // a GetProxyForURL() call is in progress.
@@ skipping 20 matching lines @@
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(url2, net::LOAD_NORMAL, &info, callback2.callback(),
                             nullptr, nullptr, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ASSERT_EQ(1u, factory->pending_requests().size());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  RequestMap requests = GetPendingRequestsForURLs(resolver, url1, url2);
+  JobMap jobs = GetPendingJobsForURLs(resolver, url1, url2);
 
   // Fail the first resolve request in MockAsyncProxyResolver.
-  requests[url1]->CompleteNow(ERR_PAC_SCRIPT_TERMINATED);
+  jobs[url1]->CompleteNow(ERR_PAC_SCRIPT_TERMINATED);
 
   // Although the proxy resolver failed the request, ProxyService implicitly
   // falls-back to DIRECT.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_TRUE(info.is_direct());
 
   // Failed PAC executions still have proxy resolution times.
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
 
   // The second request is cancelled when the proxy resolver terminates.
-  requests = GetCancelledRequestsForURLs(resolver, url2);
+  jobs = GetCancelledJobsForURLs(resolver, url2);
 
   // Since a second request was in progress, the ProxyService starts
   // initializating a new ProxyResolver.
   ASSERT_EQ(1u, factory->pending_requests().size());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  requests = GetPendingRequestsForURLs(resolver, url2);
+  jobs = GetPendingJobsForURLs(resolver, url2);
 
   // This request succeeds.
-  requests[url2]->results()->UseNamedProxy("foopy_valid:8080");
-  requests[url2]->CompleteNow(OK);
+  jobs[url2]->results()->UseNamedProxy("foopy_valid:8080");
+  jobs[url2]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy_valid:8080", info.proxy_server().ToURI());
 }
 
 TEST_F(ProxyServiceTest, ProxyScriptFetcherFailsDownloadingMandatoryPac) {
   // Test what happens when the ProxyScriptResolver fails to download a
   // mandatory PAC script.
 
@@ skipping 109 matching lines @@
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
                                 NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // Fail the first resolve request in MockAsyncProxyResolver.
-  resolver.pending_requests()[0]->CompleteNow(ERR_FAILED);
+  resolver.pending_jobs()[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.
   EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED,
             callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
 
   // The second resolve request will try to run through the proxy resolver,
   // regardless of whether the first request failed in it.
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback2.callback(), NULL,
                             NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // This time we will have the resolver succeed (perhaps the PAC script has
   // a dependency on the current time).
-  resolver.pending_requests()[0]->results()->UseNamedProxy("foopy_valid:8080");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("foopy_valid:8080");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy_valid:8080", info.proxy_server().ToURI());
 }
 
 TEST_F(ProxyServiceTest, ProxyFallback) {
   // Test what happens when we specify multiple proxy servers and some of them
   // are bad.
 
@@ skipping 13 matching lines @@
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
                                 NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // Set the result in proxy resolver.
-  resolver.pending_requests()[0]->results()->UseNamedProxy(
+  resolver.pending_jobs()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // The first item is valid.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
   base::TimeTicks proxy_resolve_start_time = info.proxy_resolve_start_time();
@@ skipping 18 matching lines @@
   service.ReportSuccess(info, &test_delegate);
   EXPECT_EQ("foopy1:8080", test_delegate.proxy_server().ToURI());
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED,
             test_delegate.proxy_fallback_net_error());
 
   TestCompletionCallback callback3;
   rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback3.callback(), NULL,
                             NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[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_requests()[0]->results()->UseNamedProxy(
+  resolver.pending_jobs()[0]->results()->UseNamedProxy(
       "foopy3:7070;foopy1:8080;foopy2:9090");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback3.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy3:7070", info.proxy_server().ToURI());
 
   // Proxy times should have been updated, so get them again.
   EXPECT_LE(proxy_resolve_end_time, info.proxy_resolve_start_time());
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
@@ skipping 31 matching lines @@
   // Proxy times should not have been modified by fallback.
   EXPECT_EQ(proxy_resolve_start_time, info.proxy_resolve_start_time());
   EXPECT_EQ(proxy_resolve_end_time, info.proxy_resolve_end_time());
 
   // Look up proxies again
   TestCompletionCallback callback7;
   rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback7.callback(), NULL,
                             NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // This time, the first 3 results have been found to be bad, but only the
   // first proxy has been confirmed ...
-  resolver.pending_requests()[0]->results()->UseNamedProxy(
+  resolver.pending_jobs()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy3:7070;foopy2:9090;foopy4:9091");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // ... therefore, we should see the second proxy first.
   EXPECT_EQ(OK, callback7.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy3:7070", info.proxy_server().ToURI());
 
   EXPECT_LE(proxy_resolve_end_time, info.proxy_resolve_start_time());
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   // TODO(nsylvain): Test that the proxy can be retried after the delay.
@@ skipping 18 matching lines @@
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
                                 NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // Set the result in proxy resolver.
-  resolver.pending_requests()[0]->results()->UsePacString(
+  resolver.pending_jobs()[0]->results()->UsePacString(
       "PROXY foopy1:8080; PROXY foopy2:9090; DIRECT");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // Get the first result.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake an error on the proxy.
   TestCompletionCallback callback2;
   rv = service.ReconsiderProxyAfterError(
       url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
@@ skipping 46 matching lines @@
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
                                 NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // Set the result in proxy resolver.
-  resolver.pending_requests()[0]->results()->UseNamedProxy(
+  resolver.pending_jobs()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // The first item is valid.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake an error on the proxy, and also a new configuration on the proxy.
   config_service->SetConfig(
       ProxyConfig::CreateFromCustomPacURL(GURL("http://foopy-new/proxy.pac")));
 
   TestCompletionCallback callback2;
   rv = service.ReconsiderProxyAfterError(
       url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
       callback2.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy-new/proxy.pac"),
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
-  resolver.pending_requests()[0]->results()->UseNamedProxy(
+  resolver.pending_jobs()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // The first proxy is still there since the configuration changed.
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // We fake another error. It should now ignore the first one.
   TestCompletionCallback callback3;
   rv = service.ReconsiderProxyAfterError(
       url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
       callback3.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
 
   // We simulate a new configuration.
   config_service->SetConfig(
       ProxyConfig::CreateFromCustomPacURL(
           GURL("http://foopy-new2/proxy.pac")));
 
   // We fake another error. It should go back to the first proxy.
   TestCompletionCallback callback4;
   rv = service.ReconsiderProxyAfterError(
       url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
       callback4.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(GURL("http://foopy-new2/proxy.pac"),
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
-  resolver.pending_requests()[0]->results()->UseNamedProxy(
+  resolver.pending_jobs()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback4.WaitForResult());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
 }
 
 TEST_F(ProxyServiceTest, ProxyFallback_BadConfig) {
@@ skipping 14 matching lines @@
   // Get the proxy information.
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
                                 NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
-  resolver.pending_requests()[0]->results()->UseNamedProxy(
+  resolver.pending_jobs()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // The first item is valid.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake a proxy error.
   TestCompletionCallback callback2;
   rv = service.ReconsiderProxyAfterError(
       url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
       callback2.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   // The first proxy is ignored, and the second one is selected.
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
 
   // Fake a PAC failure.
   ProxyInfo info2;
   TestCompletionCallback callback3;
   rv = service.ResolveProxy(url, LOAD_NORMAL, &info2, callback3.callback(),
                             NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // This simulates a javascript runtime error in the PAC script.
-  resolver.pending_requests()[0]->CompleteNow(ERR_FAILED);
+  resolver.pending_jobs()[0]->CompleteNow(ERR_FAILED);
 
   // Although the resolver failed, the ProxyService will implicitly fall-back
   // to a DIRECT connection.
   EXPECT_EQ(OK, callback3.WaitForResult());
   EXPECT_TRUE(info2.is_direct());
   EXPECT_FALSE(info2.is_empty());
 
   // The PAC script will work properly next time and successfully return a
   // proxy list. Since we have not marked the configuration as bad, it should
   // "just work" the next time we call it.
   ProxyInfo info3;
   TestCompletionCallback callback4;
   rv = service.ReconsiderProxyAfterError(
       url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info3,
       callback4.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
-  resolver.pending_requests()[0]->results()->UseNamedProxy(
+  resolver.pending_jobs()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // The first proxy is not there since the it was added to the bad proxies
   // list by the earlier ReconsiderProxyAfterError().
   EXPECT_EQ(OK, callback4.WaitForResult());
   EXPECT_FALSE(info3.is_direct());
   EXPECT_EQ("foopy1:8080", info3.proxy_server().ToURI());
 
   EXPECT_FALSE(info.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info.proxy_resolve_end_time().is_null());
   EXPECT_LE(info.proxy_resolve_start_time(), info.proxy_resolve_end_time());
@@ skipping 20 matching lines @@
   // Get the proxy information.
   ProxyInfo info;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(url, LOAD_NORMAL, &info, callback1.callback(),
                                 NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
-  resolver.pending_requests()[0]->results()->UseNamedProxy(
+  resolver.pending_jobs()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // The first item is valid.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1:8080", info.proxy_server().ToURI());
 
   // Fake a proxy error.
   TestCompletionCallback callback2;
   rv = service.ReconsiderProxyAfterError(
       url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info,
       callback2.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   // The first proxy is ignored, and the second one is selected.
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy2:9090", info.proxy_server().ToURI());
 
   // Fake a PAC failure.
   ProxyInfo info2;
   TestCompletionCallback callback3;
   rv = service.ResolveProxy(url, LOAD_NORMAL, &info2, callback3.callback(),
                             NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
   // This simulates a javascript runtime error in the PAC script.
-  resolver.pending_requests()[0]->CompleteNow(ERR_FAILED);
+  resolver.pending_jobs()[0]->CompleteNow(ERR_FAILED);
 
   // Although the resolver failed, the ProxyService will NOT fall-back
   // to a DIRECT connection as it is configured as mandatory.
   EXPECT_EQ(ERR_MANDATORY_PROXY_CONFIGURATION_FAILED,
             callback3.WaitForResult());
   EXPECT_FALSE(info2.is_direct());
   EXPECT_TRUE(info2.is_empty());
 
   // The PAC script will work properly next time and successfully return a
   // proxy list. Since we have not marked the configuration as bad, it should
   // "just work" the next time we call it.
   ProxyInfo info3;
   TestCompletionCallback callback4;
   rv = service.ReconsiderProxyAfterError(
       url, LOAD_NORMAL, ERR_PROXY_CONNECTION_FAILED, &info3,
       callback4.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(url, resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(url, resolver.pending_jobs()[0]->url());
 
-  resolver.pending_requests()[0]->results()->UseNamedProxy(
+  resolver.pending_jobs()[0]->results()->UseNamedProxy(
       "foopy1:8080;foopy2:9090");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // The first proxy is not there since the it was added to the bad proxies
   // list by the earlier ReconsiderProxyAfterError().
   EXPECT_EQ(OK, callback4.WaitForResult());
   EXPECT_FALSE(info3.is_direct());
   EXPECT_EQ("foopy1:8080", info3.proxy_server().ToURI());
 }
 
 TEST_F(ProxyServiceTest, ProxyBypassList) {
   // Test that the proxy bypass rules are consulted.
@@ skipping 256 matching lines @@
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(url1, LOAD_NORMAL, &info1, callback1.callback(),
                                 NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Successfully initialize the PAC script.
   EXPECT_EQ(GURL("http://foopy/proxy.pac"),
             factory->pending_requests()[0]->script_data()->url());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  GetPendingRequestsForURLs(resolver, url1);
+  GetPendingJobsForURLs(resolver, url1);
 
   ProxyInfo info2;
   TestCompletionCallback callback2;
   ProxyService::PacRequest* request2;
   rv = service.ResolveProxy(url2, LOAD_NORMAL, &info2, callback2.callback(),
                             &request2, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  GetPendingRequestsForURLs(resolver, url1, url2);
+  GetPendingJobsForURLs(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);
-  GetPendingRequestsForURLs(resolver, url1, url2, url3);
+  GetPendingJobsForURLs(resolver, url1, url2, url3);
 
   // Cancel the second request
   service.CancelPacRequest(request2);
 
-  RequestMap requests = GetPendingRequestsForURLs(resolver, url1, url3);
+  JobMap jobs = GetPendingJobsForURLs(resolver, url1, url3);
 
-  // Complete the two un-cancelled requests.
+  // Complete the two un-cancelled jobs.
   // We complete the last one first, just to mix it up a bit.
-  requests[url3]->results()->UseNamedProxy("request3:80");
-  requests[url3]->CompleteNow(OK);
+  jobs[url3]->results()->UseNamedProxy("request3:80");
+  jobs[url3]->CompleteNow(OK);  // dsaadsasd
 
-  requests[url1]->results()->UseNamedProxy("request1:80");
-  requests[url1]->CompleteNow(OK);
+  jobs[url1]->results()->UseNamedProxy("request1:80");
+  jobs[url1]->CompleteNow(OK);
 
-  // Complete and verify that requests ran as expected.
+  // Complete and verify that jobs ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   EXPECT_FALSE(callback2.have_result());  // Cancelled.
-  GetCancelledRequestsForURLs(resolver, url2);
+  GetCancelledJobsForURLs(resolver, url2);
 
   EXPECT_EQ(OK, callback3.WaitForResult());
   EXPECT_EQ("request3:80", info3.proxy_server().ToURI());
 }
 
 // Test the initial PAC download for resolver that expects bytes.
 TEST_F(ProxyServiceTest, InitialPACScriptDownload) {
   const GURL url1("http://request1");
   const GURL url2("http://request2");
   const GURL url3("http://request3");
@@ skipping 52 matching lines @@
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, it will have been sent to the proxy
   // resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  RequestMap requests = GetPendingRequestsForURLs(resolver, url1, url2, url3);
+  JobMap jobs = GetPendingJobsForURLs(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 requests (in some order).
+  // Complete all the jobs (in some order).
 
-  requests[url3]->results()->UseNamedProxy("request3:80");
-  requests[url3]->CompleteNow(OK);
+  jobs[url3]->results()->UseNamedProxy("request3:80");
+  jobs[url3]->CompleteNow(OK);
 
-  requests[url1]->results()->UseNamedProxy("request1:80");
-  requests[url1]->CompleteNow(OK);
+  jobs[url1]->results()->UseNamedProxy("request1:80");
+  jobs[url1]->CompleteNow(OK);
 
-  requests[url2]->results()->UseNamedProxy("request2:80");
-  requests[url2]->CompleteNow(OK);
+  jobs[url2]->results()->UseNamedProxy("request2:80");
+  jobs[url2]->CompleteNow(OK);
 
-  // Complete and verify that requests ran as expected.
+  // Complete and verify that jobs 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());
   EXPECT_FALSE(info1.proxy_resolve_end_time().is_null());
   EXPECT_LE(info1.proxy_resolve_start_time(), info1.proxy_resolve_end_time());
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
   EXPECT_FALSE(info2.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info2.proxy_resolve_end_time().is_null());
@@ skipping 17 matching lines @@
   MockAsyncProxyResolverFactory* factory =
       new MockAsyncProxyResolverFactory(true);
 
   ProxyService service(make_scoped_ptr(config_service),
                        make_scoped_ptr(factory), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(
       fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
 
-  // Start 2 requests.
+  // Start 2 jobs.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv = service.ResolveProxy(url1, LOAD_NORMAL, &info1, callback1.callback(),
                                 NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The first request should have triggered download of PAC script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
@@ skipping 19 matching lines @@
   EXPECT_TRUE(factory->pending_requests().empty());
 
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, it will have been sent to the proxy
   // resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  GetPendingRequestsForURLs(resolver, url1, url2);
+  GetPendingJobsForURLs(resolver, url1, url2);
 }
 
 // Test cancellation of a request, while the PAC script is being fetched.
 TEST_F(ProxyServiceTest, CancelWhilePACFetching) {
   MockProxyConfigService* config_service =
       new MockProxyConfigService("http://foopy/proxy.pac");
 
   MockAsyncProxyResolver resolver;
   MockAsyncProxyResolverFactory* factory =
       new MockAsyncProxyResolverFactory(true);
@@ skipping 29 matching lines @@
 
   ProxyInfo info3;
   TestCompletionCallback callback3;
   rv = service.ResolveProxy(GURL("http://request3"), LOAD_NORMAL, &info3,
                             callback3.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Nothing has been sent to the factory yet.
   EXPECT_TRUE(factory->pending_requests().empty());
 
-  // Cancel the first 2 requests.
+  // Cancel the first 2 jobs.
   service.CancelPacRequest(request1);
   service.CancelPacRequest(request2);
 
   // At this point the ProxyService should be waiting for the
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, it will have been sent to the
   // proxy resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(GURL("http://request3"), resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(GURL("http://request3"), resolver.pending_jobs()[0]->url());
 
-  // Complete all the requests.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("request3:80");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  // Complete all the jobs.
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("request3:80");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback3.WaitForResult());
   EXPECT_EQ("request3:80", info3.proxy_server().ToURI());
 
-  EXPECT_TRUE(resolver.cancelled_requests().empty());
+  EXPECT_TRUE(resolver.cancelled_jobs().empty());
 
   EXPECT_FALSE(callback1.have_result());  // Cancelled.
   EXPECT_FALSE(callback2.have_result());  // Cancelled.
 
   TestNetLogEntry::List entries1;
   log1.GetEntries(&entries1);
 
   // Check the NetLog for request 1 (which was cancelled) got filled properly.
   EXPECT_EQ(4u, entries1.size());
   EXPECT_TRUE(LogContainsBeginEvent(
@@ skipping 54 matching lines @@
 
   // Next it should be trying the custom PAC url.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  // Now finally, the pending requests should have been sent to the resolver
+  // Now finally, the pending jobs should have been sent to the resolver
   // (which was initialized with custom PAC script).
 
-  RequestMap requests = GetPendingRequestsForURLs(resolver, url1, url2);
+  JobMap jobs = GetPendingJobsForURLs(resolver, url1, url2);
 
-  // Complete the pending requests.
-  requests[url2]->results()->UseNamedProxy("request2:80");
-  requests[url2]->CompleteNow(OK);
-  requests[url1]->results()->UseNamedProxy("request1:80");
-  requests[url1]->CompleteNow(OK);
+  // Complete the pending jobs.
+  jobs[url2]->results()->UseNamedProxy("request2:80");
+  jobs[url2]->CompleteNow(OK);
+  jobs[url1]->results()->UseNamedProxy("request1:80");
+  jobs[url1]->CompleteNow(OK);
 
-  // Verify that requests ran as expected.
+  // Verify that jobs 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());
   EXPECT_FALSE(info1.proxy_resolve_end_time().is_null());
   EXPECT_LE(info1.proxy_resolve_start_time(), info1.proxy_resolve_end_time());
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
   EXPECT_FALSE(info2.proxy_resolve_start_time().is_null());
   EXPECT_FALSE(info2.proxy_resolve_end_time().is_null());
@@ skipping 49 matching lines @@
 
   // Next it should be trying the custom PAC url.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  // Now finally, the pending requests should have been sent to the resolver
+  // Now finally, the pending jobs should have been sent to the resolver
   // (which was initialized with custom PAC script).
 
-  RequestMap requests = GetPendingRequestsForURLs(resolver, url1, url2);
+  JobMap jobs = GetPendingJobsForURLs(resolver, url1, url2);
 
-  // Complete the pending requests.
-  requests[url2]->results()->UseNamedProxy("request2:80");
-  requests[url2]->CompleteNow(OK);
-  requests[url1]->results()->UseNamedProxy("request1:80");
-  requests[url1]->CompleteNow(OK);
+  // Complete the pending jobs.
+  jobs[url2]->results()->UseNamedProxy("request2:80");
+  jobs[url2]->CompleteNow(OK);
+  jobs[url1]->results()->UseNamedProxy("request1:80");
+  jobs[url1]->CompleteNow(OK);
 
-  // Verify that requests ran as expected.
+  // Verify that jobs ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
 }
 
 // Test that if all of auto-detect, a custom PAC script, and manual settings
 // are given, then we will try them in that order.
 TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomToManual) {
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://foopy/proxy.pac"));
   config.proxy_rules().ParseFromString("http=foopy:80");
 
   MockProxyConfigService* config_service = new MockProxyConfigService(config);
   MockAsyncProxyResolverFactory* factory =
       new MockAsyncProxyResolverFactory(true);
   ProxyService service(make_scoped_ptr(config_service),
                        make_scoped_ptr(factory), NULL);
 
   MockProxyScriptFetcher* fetcher = new MockProxyScriptFetcher;
   service.SetProxyScriptFetchers(
       fetcher, make_scoped_ptr(new DoNothingDhcpProxyScriptFetcher()));
 
-  // Start 2 requests.
+  // Start 2 jobs.
 
   ProxyInfo info1;
   TestCompletionCallback callback1;
   int rv =
       service.ResolveProxy(GURL("http://request1"), LOAD_NORMAL, &info1,
                            callback1.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   ProxyInfo info2;
   TestCompletionCallback callback2;
@@ skipping 13 matching lines @@
 
   // Next it should be trying the custom PAC url -- fail the download.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
 
   // Since we never managed to initialize a resolver, nothing should have been
   // sent to it.
   ASSERT_EQ(0u, factory->pending_requests().size());
 
-  // Verify that requests ran as expected -- they should have fallen back to
+  // Verify that jobs 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());
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("foopy:80", info2.proxy_server().ToURI());
 }
 
 // Test that the bypass rules are NOT applied when using autodetect.
 TEST_F(ProxyServiceTest, BypassDoesntApplyToPac) {
@@ skipping 28 matching lines @@
 
   // It should be trying to auto-detect first -- succeed the download.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(GURL("http://www.google.com"),
-            resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(GURL("http://www.google.com"), resolver.pending_jobs()[0]->url());
 
   // Complete the pending request.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("request1:80");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // Verify that request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // Start another request, it should pickup the bypass item.
   ProxyInfo info2;
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(GURL("http://www.google.com"), LOAD_NORMAL, &info2,
                             callback2.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(GURL("http://www.google.com"),
-            resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(GURL("http://www.google.com"), resolver.pending_jobs()[0]->url());
 
   // Complete the pending request.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("request2:80");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
 }
 
 // Delete the ProxyService while InitProxyResolver has an outstanding
 // request to the script fetcher. When run under valgrind, should not
 // have any memory errors (used to be that the ProxyScriptFetcher was
 // being deleted prior to the InitProxyResolver).
 TEST_F(ProxyServiceTest, DeleteWhileInitProxyResolverHasOutstandingFetch) {
@@ skipping 101 matching lines @@
       service.ResolveProxy(GURL("http://www.google.com"), LOAD_NORMAL, &info1,
                            callback1.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Successfully set the autodetect script.
   EXPECT_EQ(ProxyResolverScriptData::TYPE_AUTO_DETECT,
             factory->pending_requests()[0]->script_data()->type());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   // Complete the pending request.
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("request1:80");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // Verify that request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // Force the ProxyService to pull down a new proxy configuration.
   // (Even though the configuration isn't old/bad).
   //
   // This new configuration no longer has auto_detect set, so
-  // requests should complete synchronously now as direct-connect.
+  // jobs should complete synchronously now as direct-connect.
   config_service->SetConfig(ProxyConfig::CreateDirect());
 
   // Start another request -- the effective configuration has changed.
   ProxyInfo info2;
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(GURL("http://www.google.com"), LOAD_NORMAL, &info2,
                             callback2.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(info2.is_direct());
@@ skipping 40 matching lines @@
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, the request will have been sent to
   // the proxy resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(GURL("http://request1"), resolver.pending_jobs()[0]->url());
 
   // Complete the pending request.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("request1:80");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // Now simluate a change in the network. The ProxyConfigService is still
   // going to return the same PAC URL as before, but this URL needs to be
   // refetched on the new network.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
@@ skipping 16 matching lines @@
   // Simulate the PAC script fetch as having completed (this time with
   // different data).
   fetcher->NotifyFetchCompletion(OK, kValidPacScript2);
 
   // Now that the PAC script is downloaded, the second request will have been
   // sent to the proxy resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript2),
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(GURL("http://request2"), resolver.pending_jobs()[0]->url());
 
   // Complete the pending second request.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("request2:80");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
 
   // Check that the expected events were output to the log stream. In particular
   // PROXY_CONFIG_CHANGED should have only been emitted once (for the initial
   // setup), and NOT a second time when the IP address changed.
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
@@ skipping 92 matching lines @@
   // DIRECT.
 
   // Start a second request.
   ProxyInfo info2;
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(GURL("http://request2"), LOAD_NORMAL, &info2,
                             callback2.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that it was sent to the resolver.
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(GURL("http://request2"), resolver.pending_jobs()[0]->url());
 
   // Complete the pending second request.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("request2:80");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
 }
 
 // This test verifies that the PAC script specified by the settings is
 // periodically polled for changes. Specifically, if the initial fetch succeeds,
 // however at a later time its *contents* change, we will eventually
 // re-configure the service to use the new script.
@@ skipping 37 matching lines @@
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, the request will have been sent to
   // the proxy resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(GURL("http://request1"), resolver.pending_jobs()[0]->url());
 
   // Complete the pending request.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("request1:80");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // At this point we have initialized the proxy service using a PAC script.
   //
   // A background task to periodically re-check the PAC script for validity will
   // have been started. We will now wait for the next download attempt to start.
   //
   // Note that we shouldn't have to wait long here, since our test enables a
   // special unit-test mode.
   fetcher->WaitUntilFetch();
 
   ASSERT_TRUE(factory->pending_requests().empty());
-  ASSERT_TRUE(resolver.pending_requests().empty());
+  ASSERT_TRUE(resolver.pending_jobs().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
   // download of a DIFFERENT script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, kValidPacScript2);
 
   base::MessageLoop::current()->RunUntilIdle();
 
   // Now that the PAC script is downloaded, it should be used to initialize the
   // ProxyResolver. Simulate a successful parse.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript2),
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
   // At this point the ProxyService should have re-configured itself to use the
   // new PAC script.
 
   // Start a second request.
   ProxyInfo info2;
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(GURL("http://request2"), LOAD_NORMAL, &info2,
                             callback2.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that it was sent to the resolver.
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(GURL("http://request2"), resolver.pending_jobs()[0]->url());
 
   // Complete the pending second request.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("request2:80");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
 }
 
 // This test verifies that the PAC script specified by the settings is
 // periodically polled for changes. Specifically, if the initial fetch succeeds
 // and so does the next poll, however the contents of the downloaded script
 // have NOT changed, then we do not bother to re-initialize the proxy resolver.
@@ skipping 37 matching lines @@
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, the request will have been sent to
   // the proxy resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(GURL("http://request1"), resolver.pending_jobs()[0]->url());
 
   // Complete the pending request.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("request1:80");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // At this point we have initialized the proxy service using a PAC script.
   //
   // A background task to periodically re-check the PAC script for validity will
   // have been started. We will now wait for the next download attempt to start.
   //
   // Note that we shouldn't have to wait long here, since our test enables a
   // special unit-test mode.
   fetcher->WaitUntilFetch();
 
   ASSERT_TRUE(factory->pending_requests().empty());
-  ASSERT_TRUE(resolver.pending_requests().empty());
+  ASSERT_TRUE(resolver.pending_jobs().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
   // last time (i.e. the script is unchanged).
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   base::MessageLoop::current()->RunUntilIdle();
 
   ASSERT_TRUE(factory->pending_requests().empty());
-  ASSERT_TRUE(resolver.pending_requests().empty());
+  ASSERT_TRUE(resolver.pending_jobs().empty());
 
   // At this point the ProxyService is still running the same PAC script as
   // before.
 
   // Start a second request.
   ProxyInfo info2;
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(GURL("http://request2"), LOAD_NORMAL, &info2,
                             callback2.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Check that it was sent to the resolver.
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(GURL("http://request2"), resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(GURL("http://request2"), resolver.pending_jobs()[0]->url());
 
   // Complete the pending second request.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("request2:80");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("request2:80");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
 }
 
 // This test verifies that the PAC script specified by the settings is
 // periodically polled for changes. Specifically, if the initial fetch succeeds,
 // however at a later time it starts to fail, we should re-configure the
 // ProxyService to stop using that PAC script.
@@ skipping 37 matching lines @@
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, the request will have been sent to
   // the proxy resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(GURL("http://request1"), resolver.pending_jobs()[0]->url());
 
   // Complete the pending request.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("request1:80");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // At this point we have initialized the proxy service using a PAC script.
   //
   // A background task to periodically re-check the PAC script for validity will
   // have been started. We will now wait for the next download attempt to start.
   //
   // Note that we shouldn't have to wait long here, since our test enables a
   // special unit-test mode.
   fetcher->WaitUntilFetch();
 
   ASSERT_TRUE(factory->pending_requests().empty());
-  ASSERT_TRUE(resolver.pending_requests().empty());
+  ASSERT_TRUE(resolver.pending_jobs().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
   // to download the script.
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
   fetcher->NotifyFetchCompletion(ERR_FAILED, std::string());
 
   base::MessageLoop::current()->RunUntilIdle();
 
@@ skipping 112 matching lines @@
   // ProxyScriptFetcher to invoke its completion callback, notifying it of
   // PAC script download completion.
   fetcher->NotifyFetchCompletion(OK, kValidPacScript1);
 
   // Now that the PAC script is downloaded, the request will have been sent to
   // the proxy resolver.
   EXPECT_EQ(ASCIIToUTF16(kValidPacScript1),
             factory->pending_requests()[0]->script_data()->utf16());
   factory->pending_requests()[0]->CompleteNowWithForwarder(OK, &resolver);
 
-  ASSERT_EQ(1u, resolver.pending_requests().size());
-  EXPECT_EQ(GURL("http://request1"), resolver.pending_requests()[0]->url());
+  ASSERT_EQ(1u, resolver.pending_jobs().size());
+  EXPECT_EQ(GURL("http://request1"), resolver.pending_jobs()[0]->url());
 
   // Complete the pending request.
-  resolver.pending_requests()[0]->results()->UseNamedProxy("request1:80");
-  resolver.pending_requests()[0]->CompleteNow(OK);
+  resolver.pending_jobs()[0]->results()->UseNamedProxy("request1:80");
+  resolver.pending_jobs()[0]->CompleteNow(OK);
 
   // Wait for completion callback, and verify that the request ran as expected.
   EXPECT_EQ(OK, callback1.WaitForResult());
   EXPECT_EQ("request1:80", info1.proxy_server().ToURI());
 
   // At this point we have initialized the proxy service using a PAC script.
   // Our PAC poller is set to update ONLY in response to network activity,
   // (i.e. another call to ResolveProxy()).
 
   ASSERT_FALSE(fetcher->has_pending_request());
   ASSERT_TRUE(factory->pending_requests().empty());
-  ASSERT_TRUE(resolver.pending_requests().empty());
+  ASSERT_TRUE(resolver.pending_jobs().empty());
 
   // Start a second request.
   ProxyInfo info2;
   TestCompletionCallback callback2;
   rv = service.ResolveProxy(GURL("http://request2"), LOAD_NORMAL, &info2,
                             callback2.callback(), NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // This request should have sent work to the resolver; complete it.
-  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);
+  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);
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_EQ("request2:80", info2.proxy_server().ToURI());
 
   // In response to getting that resolve request, the poller should have
   // started the next poll, and made it as far as to request the download.
 
   EXPECT_TRUE(fetcher->has_pending_request());
   EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url());
 
@@ skipping 61 matching lines @@
       url, LOAD_NORMAL, &info, NULL, log.bound());
   EXPECT_TRUE(synchronous_success);
   EXPECT_FALSE(info.is_direct());
   EXPECT_EQ("foopy1", info.proxy_server().host_port_pair().host());
 
   // No request should have been queued.
   EXPECT_EQ(0u, factory->pending_requests().size());
 }
 
 }  // namespace net