Add an abstraction for a job in the AppCacheRequestHandler class.

content/browser/appcache/appcache_url_request_job.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 "content/browser/appcache/appcache_url_request_job.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 14 matching lines @@
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_with_source.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_status.h"
 
 namespace content {
 
-AppCacheURLRequestJob::AppCacheURLRequestJob(
-    net::URLRequest* request,
-    net::NetworkDelegate* network_delegate,
-    AppCacheStorage* storage,
-    AppCacheHost* host,
-    bool is_main_resource,
-    const OnPrepareToRestartCallback& restart_callback)
-    : net::URLRequestJob(request, network_delegate),
-      host_(host),
-      storage_(storage),
-      has_been_started_(false),
-      has_been_killed_(false),
-      delivery_type_(AWAITING_DELIVERY_ORDERS),
-      cache_id_(kAppCacheNoCacheId),
-      is_fallback_(false),
-      is_main_resource_(is_main_resource),
-      cache_entry_not_found_(false),
-      on_prepare_to_restart_callback_(restart_callback),
-      weak_factory_(this) {
-  DCHECK(storage_);
-}
-
 AppCacheURLRequestJob::~AppCacheURLRequestJob() {
   if (storage_)
     storage_->CancelDelegateCallbacks(this);
 }
 
+void AppCacheURLRequestJob::Kill() {
+  if (!has_been_killed_) {
+    has_been_killed_ = true;
+    reader_.reset();
+    handler_source_reader_.reset();
+    if (storage_) {
+      storage_->CancelDelegateCallbacks(this);
+      storage_ = NULL;
+    }
+    host_ = NULL;
+    info_ = NULL;
+    cache_ = NULL;
+    group_ = NULL;
+    range_response_info_.reset();
+    net::URLRequestJob::Kill();
+    AppCacheJob::weak_factory_.InvalidateWeakPtrs();
+  }
+}
+
+bool AppCacheURLRequestJob::IsStarted() const {
+  return has_been_started_;
+}
+
+bool AppCacheURLRequestJob::IsWaiting() const {
+  return delivery_type_ == AWAITING_DELIVERY_ORDERS;
+}
+
+bool AppCacheURLRequestJob::IsDeliveringAppCacheResponse() const {
+  return delivery_type_ == APPCACHED_DELIVERY;
+}
+
+bool AppCacheURLRequestJob::IsDeliveringNetworkResponse() const {
+  return delivery_type_ == NETWORK_DELIVERY;
+}
+
+bool AppCacheURLRequestJob::IsDeliveringErrorResponse() const {
+  return delivery_type_ == ERROR_DELIVERY;
+}
+
+bool AppCacheURLRequestJob::IsCacheEntryNotFound() const {
+  return cache_entry_not_found_;
+}
+
 void AppCacheURLRequestJob::DeliverAppCachedResponse(const GURL& manifest_url,
                                                      int64_t cache_id,
                                                      const AppCacheEntry& entry,
                                                      bool is_fallback) {
   DCHECK(!has_delivery_orders());
   DCHECK(entry.has_response_id());
   delivery_type_ = APPCACHED_DELIVERY;
   manifest_url_ = manifest_url;
   cache_id_ = cache_id;
   entry_ = entry;
   is_fallback_ = is_fallback;
   MaybeBeginDelivery();
 }
 
 void AppCacheURLRequestJob::DeliverNetworkResponse() {
   DCHECK(!has_delivery_orders());
   delivery_type_ = NETWORK_DELIVERY;
   storage_ = NULL;  // not needed
   MaybeBeginDelivery();
 }
 
 void AppCacheURLRequestJob::DeliverErrorResponse() {
   DCHECK(!has_delivery_orders());
   delivery_type_ = ERROR_DELIVERY;
   storage_ = NULL;  // not needed
   MaybeBeginDelivery();
 }
 
-base::WeakPtr<AppCacheURLRequestJob> AppCacheURLRequestJob::GetWeakPtr() {
-  return weak_factory_.GetWeakPtr();
+const GURL& AppCacheURLRequestJob::GetURL() const {
+  return request()->url();
+}
+
+net::URLRequestJob* AppCacheURLRequestJob::AsURLRequestJob() {
+  return this;
+}
+
+AppCacheURLRequestJob::AppCacheURLRequestJob(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate,
+    AppCacheStorage* storage,
+    AppCacheHost* host,
+    bool is_main_resource,
+    const OnPrepareToRestartCallback& restart_callback)
+    : net::URLRequestJob(request, network_delegate),
+      host_(host),
+      storage_(storage),
+      has_been_started_(false),
+      has_been_killed_(false),
+      delivery_type_(AWAITING_DELIVERY_ORDERS),
+      cache_id_(kAppCacheNoCacheId),
+      is_fallback_(false),
+      is_main_resource_(is_main_resource),
+      cache_entry_not_found_(false),
+      on_prepare_to_restart_callback_(restart_callback) {
+  DCHECK(storage_);
 }
 
 void AppCacheURLRequestJob::MaybeBeginDelivery() {
-  if (has_been_started() && has_delivery_orders()) {
+  if (IsStarted() && has_delivery_orders()) {
     // Start asynchronously so that all error reporting and data
     // callbacks happen as they would for network requests.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&AppCacheURLRequestJob::BeginDelivery,
-                              weak_factory_.GetWeakPtr()));
+                              StaticAsWeakPtr(this)));
   }
 }
 
 void AppCacheURLRequestJob::BeginDelivery() {
-  DCHECK(has_delivery_orders() && has_been_started());
+  DCHECK(has_delivery_orders() && IsStarted());
 
   if (has_been_killed())
     return;
 
   switch (delivery_type_) {
     case NETWORK_DELIVERY:
       AppCacheHistograms::AddNetworkJobStartDelaySample(
           base::TimeTicks::Now() - start_time_tick_);
       // To fallthru to the network, we restart the request which will
       // cause a new job to be created to retrieve the resource from the
@@ skipping 113 matching lines @@
   }
 
   BeginErrorDelivery("factory failed to produce a handler");
 }
 
 void AppCacheURLRequestJob::InvokeExecutableHandler(
     AppCacheExecutableHandler* handler) {
   handler->HandleRequest(
       request(),
       base::Bind(&AppCacheURLRequestJob::OnExecutableResponseCallback,
-                 weak_factory_.GetWeakPtr()));
+                 StaticAsWeakPtr(this)));
 }
 
 void AppCacheURLRequestJob::OnExecutableResponseCallback(
     const AppCacheExecutableHandler::Response& response) {
   DCHECK(!has_been_killed());
   if (response.use_network) {
     delivery_type_ = NETWORK_DELIVERY;
     storage_ = NULL;
     BeginDelivery();
     return;
@@ skipping 23 matching lines @@
     host_->frontend()->OnLogMessage(host_->host_id(), APPCACHE_LOG_ERROR,
                                     message);
   delivery_type_ = ERROR_DELIVERY;
   storage_ = NULL;
   BeginDelivery();
 }
 
 void AppCacheURLRequestJob::OnResponseInfoLoaded(
     AppCacheResponseInfo* response_info,
     int64_t response_id) {
-  DCHECK(is_delivering_appcache_response());
+  DCHECK(IsDeliveringAppCacheResponse());
   if (response_info) {
     info_ = response_info;
     reader_.reset(
         storage_->CreateResponseReader(manifest_url_, entry_.response_id()));
 
     if (is_range_request())
       SetupRangeResponse();
 
     NotifyHeadersComplete();
   } else {
@@ skipping 16 matching lines @@
 const net::HttpResponseInfo* AppCacheURLRequestJob::http_info() const {
   if (!info_.get())
     return NULL;
   if (range_response_info_)
     return range_response_info_.get();
   return info_->http_response_info();
 }
 
 void AppCacheURLRequestJob::SetupRangeResponse() {
   DCHECK(is_range_request() && info_.get() && reader_.get() &&
-         is_delivering_appcache_response());
+         IsDeliveringAppCacheResponse());
   int resource_size = static_cast<int>(info_->response_data_size());
   if (resource_size < 0 || !range_requested_.ComputeBounds(resource_size)) {
     range_requested_ = net::HttpByteRange();
     return;
   }
 
   DCHECK(range_requested_.IsValid());
   int offset = static_cast<int>(range_requested_.first_byte_position());
   int length = static_cast<int>(range_requested_.last_byte_position() -
                                 range_requested_.first_byte_position() + 1);
 
   // Tell the reader about the range to read.
   reader_->SetReadRange(offset, length);
 
   // Make a copy of the full response headers and fix them up
   // for the range we'll be returning.
   range_response_info_.reset(
       new net::HttpResponseInfo(*info_->http_response_info()));
   net::HttpResponseHeaders* headers = range_response_info_->headers.get();
   headers->UpdateWithNewRange(
       range_requested_, resource_size, true /* replace status line */);
 }
 
 void AppCacheURLRequestJob::OnReadComplete(int result) {
-  DCHECK(is_delivering_appcache_response());
+  DCHECK(IsDeliveringAppCacheResponse());
   if (result == 0) {
     AppCacheHistograms::CountResponseRetrieval(
         true, is_main_resource_, manifest_url_.GetOrigin());
   } else if (result < 0) {
     if (storage_->service()->storage() == storage_) {
       storage_->service()->CheckAppCacheResponse(manifest_url_, cache_id_,
                                                  entry_.response_id());
     }
     AppCacheHistograms::CountResponseRetrieval(
         false, is_main_resource_, manifest_url_.GetOrigin());
   }
   ReadRawDataComplete(result);
 }
 
 // net::URLRequestJob overrides ------------------------------------------------
 
 void AppCacheURLRequestJob::Start() {
-  DCHECK(!has_been_started());
+  DCHECK(!IsStarted());
   has_been_started_ = true;
   start_time_tick_ = base::TimeTicks::Now();
   MaybeBeginDelivery();
 }
 
-void AppCacheURLRequestJob::Kill() {
-  if (!has_been_killed_) {
-    has_been_killed_ = true;
-    reader_.reset();
-    handler_source_reader_.reset();
-    if (storage_) {
-      storage_->CancelDelegateCallbacks(this);
-      storage_ = NULL;
-    }
-    host_ = NULL;
-    info_ = NULL;
-    cache_ = NULL;
-    group_ = NULL;
-    range_response_info_.reset();
-    net::URLRequestJob::Kill();
-    weak_factory_.InvalidateWeakPtrs();
-  }
-}
-
 net::LoadState AppCacheURLRequestJob::GetLoadState() const {
-  if (!has_been_started())
+  if (!IsStarted())
     return net::LOAD_STATE_IDLE;
   if (!has_delivery_orders())
     return net::LOAD_STATE_WAITING_FOR_APPCACHE;
   if (delivery_type_ != APPCACHED_DELIVERY)
     return net::LOAD_STATE_IDLE;
   if (!info_.get())
     return net::LOAD_STATE_WAITING_FOR_APPCACHE;
   if (reader_.get() && reader_->IsReadPending())
     return net::LOAD_STATE_READING_RESPONSE;
   return net::LOAD_STATE_IDLE;
@@ skipping 11 matching lines @@
   return http_info()->headers->GetCharset(charset);
 }
 
 void AppCacheURLRequestJob::GetResponseInfo(net::HttpResponseInfo* info) {
   if (!http_info())
     return;
   *info = *http_info();
 }
 
 int AppCacheURLRequestJob::ReadRawData(net::IOBuffer* buf, int buf_size) {
-  DCHECK(is_delivering_appcache_response());
+  DCHECK(IsDeliveringAppCacheResponse());
   DCHECK_NE(buf_size, 0);
   DCHECK(!reader_->IsReadPending());
   reader_->ReadData(buf, buf_size,
                     base::Bind(&AppCacheURLRequestJob::OnReadComplete,
                                base::Unretained(this)));
   return net::ERR_IO_PENDING;
 }
 
 net::HostPortPair AppCacheURLRequestJob::GetSocketAddress() const {
   if (!http_info())
@@ skipping 15 matching lines @@
   if (ranges.size() == 1U)
     range_requested_ = ranges[0];
 }
 
 void AppCacheURLRequestJob::NotifyRestartRequired() {
   on_prepare_to_restart_callback_.Run();
   URLRequestJob::NotifyRestartRequired();
 }
 
 }  // namespace content