Add an abstraction for a job in the AppCacheRequestHandler class.

content/browser/appcache/appcache_url_request_job_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_url_request_job.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <memory>
@@ skipping 448 matching lines @@
   void Basic() {
     AppCacheStorage* storage = service_->storage();
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, nullptr);
 
     // Create an instance and see that it looks as expected.
 
     std::unique_ptr<AppCacheURLRequestJob> job(
         new AppCacheURLRequestJob(request_.get(), nullptr, storage, nullptr,
                                   false, base::Bind(&ExpectNotRestarted)));
-    EXPECT_TRUE(job->is_waiting());
-    EXPECT_FALSE(job->is_delivering_appcache_response());
-    EXPECT_FALSE(job->is_delivering_network_response());
-    EXPECT_FALSE(job->is_delivering_error_response());
-    EXPECT_FALSE(job->has_been_started());
+    EXPECT_TRUE(job->IsWaiting());
+    EXPECT_FALSE(job->IsDeliveringAppCacheResponse());
+    EXPECT_FALSE(job->IsDeliveringNetworkResponse());
+    EXPECT_FALSE(job->IsDeliveringErrorResponse());
+    EXPECT_FALSE(job->IsStarted());
     EXPECT_FALSE(job->has_been_killed());
     EXPECT_EQ(GURL(), job->manifest_url());
     EXPECT_EQ(kAppCacheNoCacheId, job->cache_id());
     EXPECT_FALSE(job->entry().has_response_id());
 
     TestFinished();
   }
 
   // DeliveryOrders -----------------------------------------------------
   void DeliveryOrders() {
     AppCacheStorage* storage = service_->storage();
     std::unique_ptr<net::URLRequest> request(empty_context_->CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, nullptr));
 
     // Create an instance, give it a delivery order and see that
     // it looks as expected.
 
     std::unique_ptr<AppCacheURLRequestJob> job(
         new AppCacheURLRequestJob(request.get(), nullptr, storage, nullptr,
                                   false, base::Bind(&ExpectNotRestarted)));
     job->DeliverErrorResponse();
-    EXPECT_TRUE(job->is_delivering_error_response());
-    EXPECT_FALSE(job->has_been_started());
+    EXPECT_TRUE(job->IsDeliveringErrorResponse());
+    EXPECT_FALSE(job->IsStarted());
 
     job.reset(new AppCacheURLRequestJob(request.get(), nullptr, storage,
                                         nullptr, false,
                                         base::Bind(&ExpectNotRestarted)));
     job->DeliverNetworkResponse();
-    EXPECT_TRUE(job->is_delivering_network_response());
-    EXPECT_FALSE(job->has_been_started());
+    EXPECT_TRUE(job->IsDeliveringNetworkResponse());
+    EXPECT_FALSE(job->IsStarted());
 
     job.reset(new AppCacheURLRequestJob(request.get(), nullptr, storage,
                                         nullptr, false,
                                         base::Bind(&ExpectNotRestarted)));
     const GURL kManifestUrl("http://blah/");
     const int64_t kCacheId(1);
     const AppCacheEntry kEntry(AppCacheEntry::EXPLICIT, 1);
     job->DeliverAppCachedResponse(kManifestUrl, kCacheId, kEntry, false);
-    EXPECT_FALSE(job->is_waiting());
-    EXPECT_TRUE(job->is_delivering_appcache_response());
-    EXPECT_FALSE(job->has_been_started());
+    EXPECT_FALSE(job->IsWaiting());
+    EXPECT_TRUE(job->IsDeliveringAppCacheResponse());
+    EXPECT_FALSE(job->IsStarted());
     EXPECT_EQ(kManifestUrl, job->manifest_url());
     EXPECT_EQ(kCacheId, job->cache_id());
     EXPECT_EQ(kEntry.types(), job->entry().types());
     EXPECT_EQ(kEntry.response_id(), job->entry().response_id());
 
     TestFinished();
   }
 
   // DeliverNetworkResponse --------------------------------------------------
 
   void DeliverNetworkResponse() {
     // This test has async steps.
     PushNextTask(
         base::Bind(&AppCacheURLRequestJobTest::VerifyDeliverNetworkResponse,
                    base::Unretained(this)));
 
     AppCacheStorage* storage = service_->storage();
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY,
                                              url_request_delegate_.get());
 
     // Set up to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     std::unique_ptr<AppCacheURLRequestJob> mock_job(new AppCacheURLRequestJob(
         request_.get(), nullptr, storage, nullptr, false,
         base::Bind(&SetIfCalled, &restart_callback_invoked_)));
     mock_job->DeliverNetworkResponse();
-    EXPECT_TRUE(mock_job->is_delivering_network_response());
-    EXPECT_FALSE(mock_job->has_been_started());
+    EXPECT_TRUE(mock_job->IsDeliveringNetworkResponse());
+    EXPECT_FALSE(mock_job->IsStarted());
     job_factory_->SetJob(std::move(mock_job));
 
     // Start the request.
     request_->Start();
 
     // The job should have been picked up.
     EXPECT_FALSE(job_factory_->has_job());
     // Completion is async.
   }
 
@@ skipping 16 matching lines @@
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY,
                                              url_request_delegate_.get());
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     std::unique_ptr<AppCacheURLRequestJob> mock_job(
         new AppCacheURLRequestJob(request_.get(), nullptr, storage, nullptr,
                                   false, base::Bind(&ExpectNotRestarted)));
     mock_job->DeliverErrorResponse();
-    EXPECT_TRUE(mock_job->is_delivering_error_response());
-    EXPECT_FALSE(mock_job->has_been_started());
+    EXPECT_TRUE(mock_job->IsDeliveringErrorResponse());
+    EXPECT_FALSE(mock_job->IsStarted());
     job_factory_->SetJob(std::move(mock_job));
 
     // Start the request.
     request_->Start();
 
     // The job should have been picked up.
     EXPECT_FALSE(job_factory_->has_job());
     // Completion is async.
   }
 
@@ skipping 34 matching lines @@
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     std::unique_ptr<AppCacheURLRequestJob> job(
         new AppCacheURLRequestJob(request_.get(), NULL, storage, NULL, false,
                                   base::Bind(&ExpectNotRestarted)));
 
     if (start_after_delivery_orders) {
       job->DeliverAppCachedResponse(
           GURL(), 111,
           AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_), false);
-      EXPECT_TRUE(job->is_delivering_appcache_response());
+      EXPECT_TRUE(job->IsDeliveringAppCacheResponse());
     }
 
     // Start the request.
-    EXPECT_FALSE(job->has_been_started());
-    base::WeakPtr<AppCacheURLRequestJob> weak_job = job->GetWeakPtr();
+    EXPECT_FALSE(job->IsStarted());
+    base::WeakPtr<AppCacheJob> weak_job = job->GetWeakPtr();
     job_factory_->SetJob(std::move(job));
     request_->Start();
     EXPECT_FALSE(job_factory_->has_job());
     ASSERT_TRUE(weak_job);
-    EXPECT_TRUE(weak_job->has_been_started());
+    EXPECT_TRUE(weak_job->IsStarted());
 
     if (!start_after_delivery_orders) {
       weak_job->DeliverAppCachedResponse(
           GURL(), 111,
           AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_), false);
       ASSERT_TRUE(weak_job);
-      EXPECT_TRUE(weak_job->is_delivering_appcache_response());
+      EXPECT_TRUE(weak_job->IsDeliveringAppCacheResponse());
     }
 
     // Completion is async.
   }
 
   void VerifyDeliverSmallAppCachedResponse() {
     EXPECT_EQ(net::OK, url_request_delegate_->request_status());
     EXPECT_TRUE(CompareHttpResponseInfos(
         write_info_buffer_->http_info.get(),
         &url_request_delegate_->received_info_));
@@ skipping 80 matching lines @@
     extra_headers.SetHeader("Range", "bytes= 1-3");
     request_->SetExtraRequestHeaders(extra_headers);
 
     // Create job with orders to deliver an appcached entry.
     std::unique_ptr<AppCacheURLRequestJob> job(
         new AppCacheURLRequestJob(request_.get(), NULL, storage, NULL, false,
                                   base::Bind(&ExpectNotRestarted)));
     job->DeliverAppCachedResponse(
         GURL(), 111,
         AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_), false);
-    EXPECT_TRUE(job->is_delivering_appcache_response());
+    EXPECT_TRUE(job->IsDeliveringAppCacheResponse());
 
     // Start the request.
-    EXPECT_FALSE(job->has_been_started());
+    EXPECT_FALSE(job->IsStarted());
     job_factory_->SetJob(std::move(job));
     request_->Start();
     EXPECT_FALSE(job_factory_->has_job());
     // Completion is async.
   }
 
   void VerifyDeliverPartialResponse() {
     EXPECT_EQ(net::OK, url_request_delegate_->request_status());
     EXPECT_EQ(3, url_request_delegate_->amount_received_);
     EXPECT_EQ(0, memcmp(kHttpBasicBody + 1,
@@ skipping 127 matching lines @@
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequest) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequest);
 }
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequestWithIOPending) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequestWithIOPending);
 }
 
 }  // namespace content