Refactoring: ProtocolHandler::MaybeCreateJob takes NetworkDelegate as argument

webkit/appcache/appcache_request_handler_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 <stack>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 56 matching lines @@
   // exercise fallback code paths.
 
   class MockURLRequestDelegate : public net::URLRequest::Delegate {
     virtual void OnResponseStarted(net::URLRequest* request) {}
     virtual void OnReadCompleted(net::URLRequest* request, int bytes_read) {}
   };
 
   class MockURLRequestJob : public net::URLRequestJob {
    public:
     MockURLRequestJob(net::URLRequest* request,
+                      net::NetworkDelegate* network_delegate,
                       int response_code)
-        : net::URLRequestJob(request, request->context()->network_delegate()),
+        : net::URLRequestJob(request, network_delegate),
           response_code_(response_code),
           has_response_info_(false) {}
     MockURLRequestJob(net::URLRequest* request,
+                      net::NetworkDelegate* network_delegate,
                       const net::HttpResponseInfo& info)
-        : net::URLRequestJob(request,
-                             request->context()->network_delegate()),
+        : net::URLRequestJob(request, network_delegate),
           response_code_(info.headers->response_code()),
           has_response_info_(true),
           response_info_(info) {}
 
   protected:
     virtual ~MockURLRequestJob() {}
     virtual void Start() OVERRIDE {
       NotifyHeadersComplete();
     }
     virtual int GetResponseCode() const OVERRIDE {
@@ skipping 12 matching lines @@
     net::HttpResponseInfo response_info_;
   };
 
   class MockURLRequest : public net::URLRequest {
    public:
     explicit MockURLRequest(const GURL& url, net::URLRequestContext* context) :
         net::URLRequest(url, NULL, context) {
     }
 
     void SimulateResponseCode(int http_response_code) {
-      mock_factory_job_ = new MockURLRequestJob(this, http_response_code);
+      mock_factory_job_ = new MockURLRequestJob(
+          this, context()->network_delegate(), http_response_code);
       Start();
       DCHECK(!mock_factory_job_);
       // All our simulation needs  to satisfy are the following two DCHECKs
       DCHECK(status().is_success());
       DCHECK_EQ(http_response_code, GetResponseCode());
     }
 
     void SimulateResponseInfo(const net::HttpResponseInfo& info) {
-      mock_factory_job_ = new MockURLRequestJob(this, info);
+      mock_factory_job_ = new MockURLRequestJob(
+          this, context()->network_delegate(), info);
       set_delegate(&delegate_);  // needed to get the info back out
       Start();
       DCHECK(!mock_factory_job_);
     }
 
     MockURLRequestDelegate delegate_;
   };
 
-  static net::URLRequestJob* MockHttpJobFactory(net::URLRequest* request,
-                                                const std::string& scheme) {
+  static net::URLRequestJob* MockHttpJobFactory(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate,
+      const std::string& scheme) {
     if (mock_factory_job_) {
       net::URLRequestJob* temp = mock_factory_job_;
       mock_factory_job_ = NULL;
       return temp;
     } else {
       // Some of these tests trigger UpdateJobs which start URLRequests.
       // We short circuit those be returning error jobs.
       return new net::URLRequestErrorJob(request,
+                                         network_delegate,
                                          net::ERR_INTERNET_DISCONNECTED);
     }
   }
 
   static void SetUpTestCase() {
     io_thread_.reset(new base::Thread("AppCacheRequestHandlerTest Thread"));
     base::Thread::Options options(MessageLoop::TYPE_IO, 0);
     io_thread_->StartWithOptions(options);
   }
 
@@ skipping 84 matching lines @@
   void MainResource_Miss() {
     PushNextTask(
         base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Miss,
                    base::Unretained(this)));
 
     request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(request_.get(),
+                                       empty_context_.network_delegate());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     // We have to wait for completion of storage->FindResponseForMainRequest.
     ScheduleNextTask();
   }
 
   void Verify_MainResource_Miss() {
     EXPECT_FALSE(job_->is_waiting());
     EXPECT_TRUE(job_->is_delivering_network_response());
 
     int64 cache_id = kNoCacheId;
     GURL manifest_url;
     handler_->GetExtraResponseInfo(&cache_id, &manifest_url);
     EXPECT_EQ(kNoCacheId, cache_id);
     EXPECT_EQ(GURL(), manifest_url);
     EXPECT_EQ(0, handler_->found_group_id_);
 
     AppCacheURLRequestJob* fallback_job;
     fallback_job = handler_->MaybeLoadFallbackForRedirect(
-        request_.get(), GURL("http://blah/redirect"));
+        request_.get(),
+        request_->context()->network_delegate(),
+        GURL("http://blah/redirect"));
     EXPECT_FALSE(fallback_job);
-    fallback_job = handler_->MaybeLoadFallbackForResponse(request_.get());
+    fallback_job = handler_->MaybeLoadFallbackForResponse(
+        request_.get(), request_->context()->network_delegate());
     EXPECT_FALSE(fallback_job);
 
     EXPECT_TRUE(host_->preferred_manifest_url().is_empty());
 
     TestFinished();
   }
 
   // MainResource_Hit --------------------------------------------------
 
   void MainResource_Hit() {
     PushNextTask(
         base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Hit,
                    base::Unretained(this)));
 
     request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         GURL(), AppCacheEntry(),
         1, 2, GURL("http://blah/manifest/"));
 
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(request_.get(),
+                                       empty_context_.network_delegate());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     // We have to wait for completion of storage->FindResponseForMainRequest.
     ScheduleNextTask();
   }
 
   void Verify_MainResource_Hit() {
     EXPECT_FALSE(job_->is_waiting());
     EXPECT_TRUE(job_->is_delivering_appcache_response());
 
     int64 cache_id = kNoCacheId;
     GURL manifest_url;
     handler_->GetExtraResponseInfo(&cache_id, &manifest_url);
     EXPECT_EQ(1, cache_id);
     EXPECT_EQ(GURL("http://blah/manifest/"), manifest_url);
     EXPECT_EQ(2, handler_->found_group_id_);
 
     AppCacheURLRequestJob* fallback_job;
-    fallback_job = handler_->MaybeLoadFallbackForResponse(request_.get());
+    fallback_job = handler_->MaybeLoadFallbackForResponse(
+        request_.get(), request_->context()->network_delegate());
     EXPECT_FALSE(fallback_job);
 
     EXPECT_EQ(GURL("http://blah/manifest/"),
               host_->preferred_manifest_url());
 
     TestFinished();
   }
 
   // MainResource_Fallback --------------------------------------------------
 
   void MainResource_Fallback() {
     PushNextTask(
         base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Fallback,
                    base::Unretained(this)));
 
     request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(),
         GURL("http://blah/fallbackurl"),
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         1, 2, GURL("http://blah/manifest/"));
 
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(request_.get(),
+                                       empty_context_.network_delegate());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     // We have to wait for completion of storage->FindResponseForMainRequest.
     ScheduleNextTask();
   }
 
   void Verify_MainResource_Fallback() {
     EXPECT_FALSE(job_->is_waiting());
     EXPECT_TRUE(job_->is_delivering_network_response());
 
     // When the request is restarted, the existing job is dropped so a
     // real network job gets created. We expect NULL here which will cause
     // the net library to create a real job.
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(request_.get(),
+                                       empty_context_.network_delegate());
     EXPECT_FALSE(job_);
 
     // Simulate an http error of the real network job.
     request_->SimulateResponseCode(500);
 
-    job_ = handler_->MaybeLoadFallbackForResponse(request_.get());
+    job_ = handler_->MaybeLoadFallbackForResponse(
+        request_.get(), request_->context()->network_delegate());
     EXPECT_TRUE(job_);
     EXPECT_TRUE(job_->is_delivering_appcache_response());
 
     int64 cache_id = kNoCacheId;
     GURL manifest_url;
     handler_->GetExtraResponseInfo(&cache_id, &manifest_url);
     EXPECT_EQ(1, cache_id);
     EXPECT_EQ(GURL("http://blah/manifest/"), manifest_url);
     EXPECT_TRUE(host_->main_resource_was_namespace_entry_);
     EXPECT_EQ(GURL("http://blah/fallbackurl"), host_->namespace_entry_url_);
@@ skipping 16 matching lines @@
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(),
         GURL("http://blah/fallbackurl"),
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         1, 2, GURL("http://blah/manifest/"));
 
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(request_.get(),
+                                       empty_context_.network_delegate());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     // We have to wait for completion of storage->FindResponseForMainRequest.
     ScheduleNextTask();
   }
 
   void Verify_MainResource_FallbackOverride() {
     EXPECT_FALSE(job_->is_waiting());
     EXPECT_TRUE(job_->is_delivering_network_response());
 
     // When the request is restarted, the existing job is dropped so a
     // real network job gets created. We expect NULL here which will cause
     // the net library to create a real job.
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(request_.get(),
+                                       empty_context_.network_delegate());
     EXPECT_FALSE(job_);
 
     // Simulate an http error of the real network job, but with custom
     // headers that override the fallback behavior.
     const char kOverrideHeaders[] =
         "HTTP/1.1 404 BOO HOO\0"
         "x-chromium-appcache-fallback-override: disallow-fallback\0"
         "\0";
     net::HttpResponseInfo info;
     info.headers = new net::HttpResponseHeaders(
         std::string(kOverrideHeaders, arraysize(kOverrideHeaders)));
     request_->SimulateResponseInfo(info);
 
-    job_ = handler_->MaybeLoadFallbackForResponse(request_.get());
+    job_ = handler_->MaybeLoadFallbackForResponse(
+        request_.get(), request_->context()->network_delegate());
     EXPECT_FALSE(job_);
 
     TestFinished();
   }
 
   // SubResource_Miss_WithNoCacheSelected ----------------------------------
 
   void SubResource_Miss_WithNoCacheSelected() {
     request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
@@ skipping 11 matching lines @@
   void SubResource_Miss_WithCacheSelected() {
     // A sub-resource load where the resource is not in an appcache, or
     // in a network or fallback namespace, should result in a failed request.
     host_->AssociateCompleteCache(MakeNewCache());
 
     request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
 
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(request_.get(),
+                                       empty_context_.network_delegate());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_delivering_error_response());
 
     AppCacheURLRequestJob* fallback_job;
     fallback_job = handler_->MaybeLoadFallbackForRedirect(
-        request_.get(), GURL("http://blah/redirect"));
+        request_.get(),
+        empty_context_.network_delegate(),
+        GURL("http://blah/redirect"));
     EXPECT_FALSE(fallback_job);
-    fallback_job = handler_->MaybeLoadFallbackForResponse(request_.get());
+    fallback_job = handler_->MaybeLoadFallbackForResponse(
+        request_.get(), empty_context_.network_delegate());
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // SubResource_Miss_WithWaitForCacheSelection -----------------------------
 
   void SubResource_Miss_WithWaitForCacheSelection() {
     // Precondition, the host is waiting on cache selection.
     scoped_refptr<AppCache> cache(MakeNewCache());
     host_->pending_selected_cache_id_ = cache->cache_id();
     host_->set_preferred_manifest_url(cache->owning_group()->manifest_url());
 
     request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(request_.get(),
+                                       empty_context_.network_delegate());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     host_->FinishCacheSelection(cache, NULL);
     EXPECT_FALSE(job_->is_waiting());
     EXPECT_TRUE(job_->is_delivering_error_response());
 
     AppCacheURLRequestJob* fallback_job;
     fallback_job = handler_->MaybeLoadFallbackForRedirect(
-        request_.get(), GURL("http://blah/redirect"));
+        request_.get(),
+        empty_context_.network_delegate(),
+        GURL("http://blah/redirect"));
     EXPECT_FALSE(fallback_job);
-    fallback_job = handler_->MaybeLoadFallbackForResponse(request_.get());
+    fallback_job = handler_->MaybeLoadFallbackForResponse(
+        request_.get(), empty_context_.network_delegate());
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // SubResource_Hit -----------------------------
 
   void SubResource_Hit() {
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1), AppCacheEntry(), false);
 
     request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(request_.get(),
+                                       empty_context_.network_delegate());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_delivering_appcache_response());
 
     AppCacheURLRequestJob* fallback_job;
     fallback_job = handler_->MaybeLoadFallbackForRedirect(
-        request_.get(), GURL("http://blah/redirect"));
+        request_.get(),
+        empty_context_.network_delegate(),
+        GURL("http://blah/redirect"));
     EXPECT_FALSE(fallback_job);
-    fallback_job = handler_->MaybeLoadFallbackForResponse(request_.get());
+    fallback_job = handler_->MaybeLoadFallbackForResponse(
+        request_.get(), empty_context_.network_delegate());
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // SubResource_RedirectFallback -----------------------------
 
   void SubResource_RedirectFallback() {
     // Redirects to resources in the a different origin are subject to
     // fallback namespaces.
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(), AppCacheEntry(AppCacheEntry::EXPLICIT, 1), false);
 
     request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(request_.get(),
+                                       empty_context_.network_delegate());
     EXPECT_FALSE(job_.get());
 
     job_ = handler_->MaybeLoadFallbackForRedirect(
-        request_.get(), GURL("http://not_blah/redirect"));
+        request_.get(),
+        empty_context_.network_delegate(),
+        GURL("http://not_blah/redirect"));
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_delivering_appcache_response());
 
     AppCacheURLRequestJob* fallback_job;
-    fallback_job = handler_->MaybeLoadFallbackForResponse(request_.get());
+    fallback_job = handler_->MaybeLoadFallbackForResponse(
+        request_.get(), empty_context_.network_delegate());
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // SubResource_NoRedirectFallback -----------------------------
 
   void SubResource_NoRedirectFallback() {
     // Redirects to resources in the same-origin are not subject to
     // fallback namespaces.
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(), AppCacheEntry(AppCacheEntry::EXPLICIT, 1), false);
 
     request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(request_.get(),
+                                       empty_context_.network_delegate());
     EXPECT_FALSE(job_.get());
 
     AppCacheURLRequestJob* fallback_job;
     fallback_job = handler_->MaybeLoadFallbackForRedirect(
-        request_.get(), GURL("http://blah/redirect"));
+        request_.get(),
+        empty_context_.network_delegate(),
+        GURL("http://blah/redirect"));
     EXPECT_FALSE(fallback_job);
 
     request_->SimulateResponseCode(200);
-    fallback_job = handler_->MaybeLoadFallbackForResponse(request_.get());
+    fallback_job = handler_->MaybeLoadFallbackForResponse(
+        request_.get(), empty_context_.network_delegate());
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // SubResource_Network -----------------------------
 
   void SubResource_Network() {
     // A sub-resource load where the resource is in a network namespace,
     // should result in the system using a 'real' job to do the network
     // retrieval.
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(), AppCacheEntry(), true);
 
     request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(request_.get(),
+                                       empty_context_.network_delegate());
     EXPECT_FALSE(job_.get());
 
     AppCacheURLRequestJob* fallback_job;
     fallback_job = handler_->MaybeLoadFallbackForRedirect(
-        request_.get(), GURL("http://blah/redirect"));
+        request_.get(),
+        empty_context_.network_delegate(),
+        GURL("http://blah/redirect"));
     EXPECT_FALSE(fallback_job);
-    fallback_job = handler_->MaybeLoadFallbackForResponse(request_.get());
+    fallback_job = handler_->MaybeLoadFallbackForResponse(
+        request_.get(), empty_context_.network_delegate());
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // DestroyedHost -----------------------------
 
   void DestroyedHost() {
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1), AppCacheEntry(), false);
 
     request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
 
     backend_impl_->UnregisterHost(1);
     host_ = NULL;
 
-    EXPECT_FALSE(handler_->MaybeLoadResource(request_.get()));
+    EXPECT_FALSE(handler_->MaybeLoadResource(
+        request_.get(), empty_context_.network_delegate()));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect(
-        request_.get(), GURL("http://blah/redirect")));
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(request_.get()));
+        request_.get(),
+        empty_context_.network_delegate(),
+        GURL("http://blah/redirect")));
+    EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(
+        request_.get(), empty_context_.network_delegate()));
 
     TestFinished();
   }
 
   // DestroyedHostWithWaitingJob -----------------------------
 
   void DestroyedHostWithWaitingJob() {
     // Precondition, the host is waiting on cache selection.
     host_->pending_selected_cache_id_ = 1;
 
     request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
 
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(
+        request_.get(), empty_context_.network_delegate());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     backend_impl_->UnregisterHost(1);
     host_ = NULL;
     EXPECT_TRUE(job_->has_been_killed());
 
-    EXPECT_FALSE(handler_->MaybeLoadResource(request_.get()));
+    EXPECT_FALSE(handler_->MaybeLoadResource(
+        request_.get(), empty_context_.network_delegate()));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect(
-        request_.get(), GURL("http://blah/redirect")));
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(request_.get()));
+        request_.get(),
+        empty_context_.network_delegate(),
+        GURL("http://blah/redirect")));
+    EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(
+        request_.get(), empty_context_.network_delegate()));
 
     TestFinished();
   }
 
   // UnsupportedScheme -----------------------------
 
   void UnsupportedScheme() {
     // Precondition, the host is waiting on cache selection.
     host_->pending_selected_cache_id_ = 1;
 
     request_.reset(new MockURLRequest(GURL("ftp://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());  // we could redirect to http (conceivably)
 
-    EXPECT_FALSE(handler_->MaybeLoadResource(request_.get()));
+    EXPECT_FALSE(handler_->MaybeLoadResource(
+        request_.get(), empty_context_.network_delegate()));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect(
-        request_.get(), GURL("ftp://blah/redirect")));
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(request_.get()));
+        request_.get(),
+        empty_context_.network_delegate(),
+        GURL("ftp://blah/redirect")));
+    EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(
+        request_.get(), empty_context_.network_delegate()));
 
     TestFinished();
   }
 
   // CanceledRequest -----------------------------
 
   void CanceledRequest() {
     request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(request_.get(),
+                                       empty_context_.network_delegate());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
     EXPECT_FALSE(job_->has_been_started());
 
     mock_factory_job_ = job_.get();
     request_->Start();
     EXPECT_TRUE(job_->has_been_started());
 
     request_->Cancel();
     EXPECT_TRUE(job_->has_been_killed());
 
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(request_.get()));
+    EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(
+        request_.get(), empty_context_.network_delegate()));
 
     TestFinished();
   }
 
   // WorkerRequest -----------------------------
 
   void WorkerRequest() {
     EXPECT_TRUE(AppCacheRequestHandler::IsMainResourceType(
         ResourceType::MAIN_FRAME));
     EXPECT_TRUE(AppCacheRequestHandler::IsMainResourceType(
@@ skipping 44 matching lines @@
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_policy_->can_load_return_value_ = false;
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         GURL(), AppCacheEntry(),
         1, 2, GURL("http://blah/manifest/"));
 
-    job_ = handler_->MaybeLoadResource(request_.get());
+    job_ = handler_->MaybeLoadResource(request_.get(),
+                                       empty_context_.network_delegate());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     // We have to wait for completion of storage->FindResponseForMainRequest.
     ScheduleNextTask();
   }
 
   void Verify_MainResource_Blocked() {
     EXPECT_FALSE(job_->is_waiting());
     EXPECT_FALSE(job_->is_delivering_appcache_response());
@@ skipping 116 matching lines @@
 
 TEST_F(AppCacheRequestHandlerTest, WorkerRequest) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::WorkerRequest);
 }
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Blocked) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Blocked);
 }
 
 }  // namespace appcache