Add support for HTTP range requests in the AppCacheURLLoaderImpl 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"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_group.h"
 #include "content/browser/appcache/appcache_histograms.h"
 #include "content/browser/appcache/appcache_host.h"
 #include "content/browser/appcache/appcache_service_impl.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #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() {
   if (storage_)
     storage_->CancelDelegateCallbacks(this);
@@ skipping 266 matching lines @@
 void AppCacheURLRequestJob::OnResponseInfoLoaded(
     AppCacheResponseInfo* response_info,
     int64_t response_id) {
   DCHECK(IsDeliveringAppCacheResponse());
   if (response_info) {
     info_ = response_info;
     reader_.reset(
         storage_->CreateResponseReader(manifest_url_, entry_.response_id()));
 
     if (is_range_request())
-      SetupRangeResponse();
+      SetupRangeResponse(reader_.get());
 
     NotifyHeadersComplete();
   } else {
     if (storage_->service()->storage() == storage_) {
       // A resource that is expected to be in the appcache is missing.
       // See http://code.google.com/p/chromium/issues/detail?id=50657
       // Instead of failing the request, we restart the request. The retry
       // attempt will fallthru to the network instead of trying to load
       // from the appcache.
       storage_->service()->CheckAppCacheResponse(manifest_url_, cache_id_,
                                                  entry_.response_id());
       AppCacheHistograms::CountResponseRetrieval(
           false, is_main_resource_, manifest_url_.GetOrigin());
     }
     cache_entry_not_found_ = true;
     NotifyRestartRequired();
   }
 }
 
 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() &&
-         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(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());
     }
@@ skipping 55 matching lines @@
 }
 
 net::HostPortPair AppCacheURLRequestJob::GetSocketAddress() const {
   if (!http_info())
     return net::HostPortPair();
   return http_info()->socket_address;
 }
 
 void AppCacheURLRequestJob::SetExtraRequestHeaders(
     const net::HttpRequestHeaders& headers) {
-  std::string value;
-  std::vector<net::HttpByteRange> ranges;
-  if (!headers.GetHeader(net::HttpRequestHeaders::kRange, &value) ||
-      !net::HttpUtil::ParseRangeHeader(value, &ranges)) {
-    return;
-  }
-
-  // If multiple ranges are requested, we play dumb and
-  // return the entire response with 200 OK.
-  if (ranges.size() == 1U)
-    range_requested_ = ranges[0];
+  InitializeRangeRequestInfo(headers);
 }
 
 void AppCacheURLRequestJob::NotifyRestartRequired() {
   on_prepare_to_restart_callback_.Run();
   URLRequestJob::NotifyRestartRequired();
 }
 
 }  // namespace content