Add an abstraction for a job in the AppCacheRequestHandler class.

content/browser/appcache/appcache_request_handler_unittest.cc

 // Copyright 2014 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 "content/browser/appcache/appcache_request_handler.h"
 
 #include <stdint.h>
 
 #include <stack>
 #include <string>
@@ skipping 259 matching lines @@
         base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Miss,
                    base::Unretained(this)));
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_MAIN_FRAME, false);
     EXPECT_TRUE(handler_.get());
 
-    job_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())
+            ->AsURLRequestJob()));
     EXPECT_TRUE(job_.get());
-    EXPECT_TRUE(job_->is_waiting());
+    EXPECT_TRUE(job_->IsWaiting());
 
     // 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());
+    EXPECT_FALSE(job_->IsWaiting());
+    EXPECT_TRUE(job_->IsDeliveringNetworkResponse());
 
     int64_t cache_id = kAppCacheNoCacheId;
     GURL manifest_url;
     handler_->GetExtraResponseInfo(&cache_id, &manifest_url);
     EXPECT_EQ(kAppCacheNoCacheId, cache_id);
     EXPECT_EQ(GURL(), manifest_url);
     EXPECT_EQ(0, handler_->found_group_id_);
 
     std::unique_ptr<AppCacheURLRequestJob> fallback_job(
-        handler_->MaybeLoadFallbackForRedirect(
-            request_->context()->network_delegate(),
-            GURL("http://blah/redirect")));
+        static_cast<AppCacheURLRequestJob*>(
+            handler_->MaybeLoadFallbackForRedirect(
+                request_->context()->network_delegate(),
+                GURL("http://blah/redirect"))));
     EXPECT_FALSE(fallback_job);
-    fallback_job.reset(handler_->MaybeLoadFallbackForResponse(
-        request_->context()->network_delegate()));
+    fallback_job.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForResponse(
+            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_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_MAIN_FRAME, false);
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         GURL(), AppCacheEntry(),
         1, 2, GURL("http://blah/manifest/"));
 
-    job_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_TRUE(job_.get());
-    EXPECT_TRUE(job_->is_waiting());
+    EXPECT_TRUE(job_->IsWaiting());
 
     // 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());
+    EXPECT_FALSE(job_->IsWaiting());
+    EXPECT_TRUE(job_->IsDeliveringAppCacheResponse());
 
     int64_t cache_id = kAppCacheNoCacheId;
     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_);
 
     std::unique_ptr<AppCacheURLRequestJob> fallback_job(
-        handler_->MaybeLoadFallbackForResponse(
-            request_->context()->network_delegate()));
+        static_cast<AppCacheURLRequestJob*>(
+            handler_->MaybeLoadFallbackForResponse(
+                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_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_MAIN_FRAME, false);
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(),
         GURL("http://blah/fallbackurl"),
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         1, 2, GURL("http://blah/manifest/"));
 
-    job_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_TRUE(job_.get());
-    EXPECT_TRUE(job_->is_waiting());
+    EXPECT_TRUE(job_->IsWaiting());
 
     // We have to wait for completion of storage->FindResponseForMainRequest.
     ScheduleNextTask();
   }
 
   void SimulateResponseCode(int response_code) {
     net::HttpResponseInfo info;
     std::string headers =
         base::StringPrintf("HTTP/1.1 %i Muffin\r\n\r\n", response_code);
     info.headers = new net::HttpResponseHeaders(
         net::HttpUtil::AssembleRawHeaders(headers.c_str(), headers.length()));
 
     job_factory_->SetJob(base::MakeUnique<MockURLRequestJob>(
         request_.get(), request_->context()->network_delegate(), info));
     request_->Start();
     // All our simulation needs to satisfy are the following two DCHECKs.
     DCHECK_EQ(net::OK, delegate_.request_status());
     DCHECK_EQ(response_code, request_->GetResponseCode());
   }
 
   void SimulateResponseInfo(const net::HttpResponseInfo& info) {
     job_factory_->SetJob(base::MakeUnique<MockURLRequestJob>(
         request_.get(), request_->context()->network_delegate(), info));
     request_->Start();
   }
 
   void Verify_MainResource_Fallback() {
-    EXPECT_FALSE(job_->is_waiting());
-    EXPECT_TRUE(job_->is_delivering_network_response());
+    EXPECT_FALSE(job_->IsWaiting());
+    EXPECT_TRUE(job_->IsDeliveringNetworkResponse());
 
     // The handler expects to the job to tell it that the request is going to
     // be restarted before it sees the next request.
     handler_->OnPrepareToRestart();
 
     // 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_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_FALSE(job_.get());
 
     // Simulate an http error of the real network job.
     SimulateResponseCode(500);
 
-    job_.reset(handler_->MaybeLoadFallbackForResponse(
-        request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForResponse(
+            request_->context()->network_delegate())));
     EXPECT_TRUE(job_.get());
-    EXPECT_TRUE(job_->is_delivering_appcache_response());
+    EXPECT_TRUE(job_->IsDeliveringAppCacheResponse());
 
     int64_t cache_id = kAppCacheNoCacheId;
     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_);
 
     EXPECT_EQ(GURL("http://blah/manifest/"),
@@ skipping 16 matching lines @@
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_MAIN_FRAME, false);
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(),
         GURL("http://blah/fallbackurl"),
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         1, 2, GURL("http://blah/manifest/"));
 
-    job_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_TRUE(job_.get());
-    EXPECT_TRUE(job_->is_waiting());
+    EXPECT_TRUE(job_->IsWaiting());
 
     // 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());
+    EXPECT_FALSE(job_->IsWaiting());
+    EXPECT_TRUE(job_->IsDeliveringNetworkResponse());
 
     // The handler expects to the job to tell it that the request is going to
     // be restarted before it sees the next request.
     handler_->OnPrepareToRestart();
 
     // 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_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_FALSE(job_.get());
 
     // 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)));
     SimulateResponseInfo(info);
 
-    job_.reset(handler_->MaybeLoadFallbackForResponse(
-        request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForResponse(
+            request_->context()->network_delegate())));
     EXPECT_FALSE(job_.get());
 
     // GetExtraResponseInfo should return no information.
     int64_t cache_id = kAppCacheNoCacheId;
     GURL manifest_url;
     handler_->GetExtraResponseInfo(&cache_id, &manifest_url);
     EXPECT_EQ(kAppCacheNoCacheId, cache_id);
     EXPECT_TRUE(manifest_url.is_empty());
 
     TestFinished();
@@ skipping 22 matching lines @@
     // in a network or fallback namespace, should result in a failed request.
     host_->AssociateCompleteCache(MakeNewCache());
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
 
-    job_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_TRUE(job_.get());
-    EXPECT_TRUE(job_->is_delivering_error_response());
+    EXPECT_TRUE(job_->IsDeliveringErrorResponse());
 
     std::unique_ptr<AppCacheURLRequestJob> fallback_job(
-        handler_->MaybeLoadFallbackForRedirect(
-            request_->context()->network_delegate(),
-            GURL("http://blah/redirect")));
+        static_cast<AppCacheURLRequestJob*>(
+            handler_->MaybeLoadFallbackForRedirect(
+                request_->context()->network_delegate(),
+                GURL("http://blah/redirect"))));
     EXPECT_FALSE(fallback_job);
-    fallback_job.reset(handler_->MaybeLoadFallbackForResponse(
-        request_->context()->network_delegate()));
+    fallback_job.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForResponse(
+            request_->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_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
-    job_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_TRUE(job_.get());
-    EXPECT_TRUE(job_->is_waiting());
+    EXPECT_TRUE(job_->IsWaiting());
 
     host_->FinishCacheSelection(cache.get(), NULL);
-    EXPECT_FALSE(job_->is_waiting());
-    EXPECT_TRUE(job_->is_delivering_error_response());
+    EXPECT_FALSE(job_->IsWaiting());
+    EXPECT_TRUE(job_->IsDeliveringErrorResponse());
 
     std::unique_ptr<AppCacheURLRequestJob> fallback_job(
-        handler_->MaybeLoadFallbackForRedirect(
-            request_->context()->network_delegate(),
-            GURL("http://blah/redirect")));
+        static_cast<AppCacheURLRequestJob*>(
+            handler_->MaybeLoadFallbackForRedirect(
+                request_->context()->network_delegate(),
+                GURL("http://blah/redirect"))));
     EXPECT_FALSE(fallback_job);
-    fallback_job.reset(handler_->MaybeLoadFallbackForResponse(
-        request_->context()->network_delegate()));
+    fallback_job.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForResponse(
+            request_->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_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
-    job_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_TRUE(job_.get());
-    EXPECT_TRUE(job_->is_delivering_appcache_response());
+    EXPECT_TRUE(job_->IsDeliveringAppCacheResponse());
 
     std::unique_ptr<AppCacheURLRequestJob> fallback_job(
-        handler_->MaybeLoadFallbackForRedirect(
-            request_->context()->network_delegate(),
-            GURL("http://blah/redirect")));
+        static_cast<AppCacheURLRequestJob*>(
+            handler_->MaybeLoadFallbackForRedirect(
+                request_->context()->network_delegate(),
+                GURL("http://blah/redirect"))));
     EXPECT_FALSE(fallback_job);
-    fallback_job.reset(handler_->MaybeLoadFallbackForResponse(
-        request_->context()->network_delegate()));
+    fallback_job.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForResponse(
+            request_->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_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
-    job_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_FALSE(job_.get());
 
-    job_.reset(handler_->MaybeLoadFallbackForRedirect(
-        request_->context()->network_delegate(),
-        GURL("http://not_blah/redirect")));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForRedirect(
+            request_->context()->network_delegate(),
+            GURL("http://not_blah/redirect"))));
     EXPECT_TRUE(job_.get());
-    EXPECT_TRUE(job_->is_delivering_appcache_response());
+    EXPECT_TRUE(job_->IsDeliveringAppCacheResponse());
 
     std::unique_ptr<AppCacheURLRequestJob> fallback_job(
-        handler_->MaybeLoadFallbackForResponse(
-            request_->context()->network_delegate()));
+        static_cast<AppCacheURLRequestJob*>(
+            handler_->MaybeLoadFallbackForResponse(
+                request_->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_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
-    job_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_FALSE(job_.get());
 
     std::unique_ptr<AppCacheURLRequestJob> fallback_job(
-        handler_->MaybeLoadFallbackForRedirect(
-            request_->context()->network_delegate(),
-            GURL("http://blah/redirect")));
+        static_cast<AppCacheURLRequestJob*>(
+            handler_->MaybeLoadFallbackForRedirect(
+                request_->context()->network_delegate(),
+                GURL("http://blah/redirect"))));
     EXPECT_FALSE(fallback_job);
 
     SimulateResponseCode(200);
-    fallback_job.reset(handler_->MaybeLoadFallbackForResponse(
-        request_->context()->network_delegate()));
+    fallback_job.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForResponse(
+            request_->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_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
-    job_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_FALSE(job_.get());
 
     std::unique_ptr<AppCacheURLRequestJob> fallback_job(
-        handler_->MaybeLoadFallbackForRedirect(
-            request_->context()->network_delegate(),
-            GURL("http://blah/redirect")));
+        static_cast<AppCacheURLRequestJob*>(
+            handler_->MaybeLoadFallbackForRedirect(
+                request_->context()->network_delegate(),
+                GURL("http://blah/redirect"))));
     EXPECT_FALSE(fallback_job);
-    fallback_job.reset(handler_->MaybeLoadFallbackForResponse(
-        request_->context()->network_delegate()));
+    fallback_job.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForResponse(
+            request_->context()->network_delegate())));
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // DestroyedHost -----------------------------
 
   void DestroyedHost() {
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1), AppCacheEntry(), false);
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
 
     backend_impl_->UnregisterHost(1);
     host_ = NULL;
 
-    EXPECT_FALSE(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect(
-        request_->context()->network_delegate(),
-        GURL("http://blah/redirect")));
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(
-        request_->context()->network_delegate()));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForRedirect(
+            request_->context()->network_delegate(),
+            GURL("http://blah/redirect"))));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForResponse(
+            request_->context()->network_delegate())));
 
     TestFinished();
   }
 
   // DestroyedHostWithWaitingJob -----------------------------
 
   void DestroyedHostWithWaitingJob() {
     // Precondition, the host is waiting on cache selection.
     host_->pending_selected_cache_id_ = 1;
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
 
-    job_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_TRUE(job_.get());
-    EXPECT_TRUE(job_->is_waiting());
+    EXPECT_TRUE(job_->IsWaiting());
 
     backend_impl_->UnregisterHost(1);
     host_ = NULL;
     EXPECT_TRUE(job_->has_been_killed());
 
-    EXPECT_FALSE(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect(
-        request_->context()->network_delegate(),
-        GURL("http://blah/redirect")));
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(
-        request_->context()->network_delegate()));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForRedirect(
+            request_->context()->network_delegate(),
+            GURL("http://blah/redirect"))));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForResponse(
+            request_->context()->network_delegate())));
 
     TestFinished();
   }
 
   // DestroyedService -----------------------------
 
   void DestroyedService() {
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1), AppCacheEntry(), false);
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
-    job_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_TRUE(job_.get());
 
     backend_impl_.reset();
     mock_frontend_.reset();
     mock_service_.reset();
     mock_policy_.reset();
     host_ = NULL;
 
     EXPECT_TRUE(job_->has_been_killed());
-    EXPECT_FALSE(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect(
-        request_->context()->network_delegate(),
-        GURL("http://blah/redirect")));
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(
-        request_->context()->network_delegate()));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForRedirect(
+            request_->context()->network_delegate(),
+            GURL("http://blah/redirect"))));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForResponse(
+            request_->context()->network_delegate())));
 
     TestFinished();
   }
 
   void DestroyedServiceWithCrossSiteNav() {
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_MAIN_FRAME, false);
     EXPECT_TRUE(handler_.get());
     handler_->PrepareForCrossSiteTransfer(backend_impl_->process_id());
     EXPECT_TRUE(handler_->host_for_cross_site_transfer_.get());
 
     backend_impl_.reset();
     mock_frontend_.reset();
     mock_service_.reset();
     mock_policy_.reset();
     host_ = NULL;
 
     EXPECT_FALSE(handler_->host_for_cross_site_transfer_.get());
-    EXPECT_FALSE(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect(
-        request_->context()->network_delegate(),
-        GURL("http://blah/redirect")));
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(
-        request_->context()->network_delegate()));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForRedirect(
+            request_->context()->network_delegate(),
+            GURL("http://blah/redirect"))));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForResponse(
+            request_->context()->network_delegate())));
 
     TestFinished();
   }
 
   // UnsupportedScheme -----------------------------
 
   void UnsupportedScheme() {
     // Precondition, the host is waiting on cache selection.
     host_->pending_selected_cache_id_ = 1;
 
     request_ = empty_context_->CreateRequest(GURL("ftp://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());  // we could redirect to http (conceivably)
 
-    EXPECT_FALSE(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect(
-        request_->context()->network_delegate(),
-        GURL("ftp://blah/redirect")));
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(
-        request_->context()->network_delegate()));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForRedirect(
+            request_->context()->network_delegate(),
+            GURL("ftp://blah/redirect"))));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForResponse(
+            request_->context()->network_delegate())));
 
     TestFinished();
   }
 
   // CanceledRequest -----------------------------
 
   void CanceledRequest() {
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
     handler_ =
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_MAIN_FRAME, false);
     EXPECT_TRUE(handler_.get());
 
-    job_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_TRUE(job_.get());
-    EXPECT_TRUE(job_->is_waiting());
-    EXPECT_FALSE(job_->has_been_started());
+    EXPECT_TRUE(job_->IsWaiting());
+    EXPECT_FALSE(job_->IsStarted());
 
-    base::WeakPtr<AppCacheURLRequestJob> weak_job = job_->GetWeakPtr();
+    base::WeakPtr<AppCacheJob> weak_job = job_->GetWeakPtr();
 
     job_factory_->SetJob(std::move(job_));
     request_->Start();
     ASSERT_TRUE(weak_job);
-    EXPECT_TRUE(weak_job->has_been_started());
+    EXPECT_TRUE(weak_job->IsStarted());
 
     request_->Cancel();
     ASSERT_FALSE(weak_job);
 
-    EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(
-        request_->context()->network_delegate()));
+    EXPECT_FALSE(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadFallbackForResponse(
+            request_->context()->network_delegate())));
 
     TestFinished();
   }
 
   // WorkerRequest -----------------------------
 
   void WorkerRequest() {
     EXPECT_TRUE(AppCacheRequestHandler::IsMainResourceType(
         RESOURCE_TYPE_MAIN_FRAME));
     EXPECT_TRUE(AppCacheRequestHandler::IsMainResourceType(
@@ skipping 49 matching lines @@
         host_->CreateRequestHandler(AppCacheURLRequest::Create(request_.get()),
                                     RESOURCE_TYPE_MAIN_FRAME, false);
     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_.reset(
-        handler_->MaybeLoadResource(request_->context()->network_delegate()));
+    job_.reset(static_cast<AppCacheURLRequestJob*>(
+        handler_->MaybeLoadResource(request_->context()->network_delegate())));
     EXPECT_TRUE(job_.get());
-    EXPECT_TRUE(job_->is_waiting());
+    EXPECT_TRUE(job_->IsWaiting());
 
     // 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());
+    EXPECT_FALSE(job_->IsWaiting());
+    EXPECT_FALSE(job_->IsDeliveringAppCacheResponse());
 
     EXPECT_EQ(0, handler_->found_cache_id_);
     EXPECT_EQ(0, handler_->found_group_id_);
     EXPECT_TRUE(handler_->found_manifest_url_.is_empty());
     EXPECT_TRUE(host_->preferred_manifest_url().is_empty());
     EXPECT_TRUE(host_->main_resource_blocked_);
     EXPECT_EQ(host_->blocked_manifest_url_, "http://blah/manifest/");
 
     TestFinished();
   }
@@ skipping 114 matching lines @@
 
 TEST_F(AppCacheRequestHandlerTest, WorkerRequest) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::WorkerRequest);
 }
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Blocked) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Blocked);
 }
 
 }  // namespace content