Http cache: Extend support for byte range requests....

net/http/partial_data.cc

 // Copyright (c) 2009 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 "net/http/partial_data.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
@@ skipping 35 matching lines @@
 
   AddRangeHeader(current_range_start_, end, headers);
 }
 
 int PartialData::PrepareCacheValidation(disk_cache::Entry* entry,
                                         std::string* headers) {
   DCHECK(current_range_start_ >= 0);
 
   // Scan the disk cache for the first cached portion within this range.
   int64 range_len = byte_range_.HasLastBytePosition() ?
-      byte_range_.last_byte_position() - current_range_start_ + 1: kint32max;
+      byte_range_.last_byte_position() - current_range_start_ + 1 : kint32max;
   if (range_len > kint32max)
     range_len = kint32max;
   int len = static_cast<int32>(range_len);
   if (!len)
     return 0;
   range_present_ = false;
 
   cached_min_len_ = entry->GetAvailableRange(current_range_start_, len,
                                              &cached_start_);
   if (cached_min_len_ < 0) {
@@ skipping 26 matching lines @@
 }
 
 bool PartialData::IsCurrentRangeCached() const {
   return range_present_;
 }
 
 bool PartialData::IsLastRange() const {
   return final_range_;
 }
 
-bool PartialData::UpdateFromStoredHeaders(const HttpResponseHeaders* headers) {
+bool PartialData::UpdateFromStoredHeaders(const HttpResponseHeaders* headers,
+                                          disk_cache::Entry* entry) {
   std::string length_value;
   resource_size_ = 0;
   if (!headers->GetNormalizedHeader(kLengthHeader, &length_value))
     return false;  // We must have stored the resource length.
 
-  if (!StringToInt64(length_value, &resource_size_))
+  if (!StringToInt64(length_value, &resource_size_) || !resource_size_)
     return false;
 
-  if (resource_size_ && !byte_range_.ComputeBounds(resource_size_))
+  if (byte_range_.IsValid()) {
+    if (!byte_range_.ComputeBounds(resource_size_))
+      return false;
+
+    if (current_range_start_ < 0)
+      current_range_start_ = byte_range_.first_byte_position();
+  } else {
+    // This is not a range request but we have partial data stored.
+    current_range_start_ = 0;
+    byte_range_.set_last_byte_position(resource_size_ - 1);
+  }
+
+  // Make sure that this is really a sparse entry.
+  int64 n;
+  if (ERR_CACHE_OPERATION_NOT_SUPPORTED == entry->GetAvailableRange(0, 5, &n))
     return false;
 
-  if (current_range_start_ < 0)
-    current_range_start_ = byte_range_.first_byte_position();
-
   return current_range_start_ >= 0;
 }
 
 bool PartialData::ResponseHeadersOK(const HttpResponseHeaders* headers) {
   int64 start, end, total_length;
   if (!headers->GetContentRange(&start, &end, &total_length))
     return false;
   if (total_length <= 0)
     return false;
 
   if (!resource_size_) {
     // First response. Update our values with the ones provided by the server.
     resource_size_ = total_length;
     if (!byte_range_.HasFirstBytePosition()) {
       byte_range_.set_first_byte_position(start);
       current_range_start_ = start;
     }
     if (!byte_range_.HasLastBytePosition())
       byte_range_.set_last_byte_position(end);
   } else if (resource_size_ != total_length) {
     return false;
   }
 
   if (start != current_range_start_)
     return false;
 
-  if (end > byte_range_.last_byte_position())
+  if (byte_range_.IsValid() && end > byte_range_.last_byte_position())
     return false;
 
   return true;
 }
 
 // We are making multiple requests to complete the range requested by the user.
 // Just assume that everything is fine and say that we are returning what was
 // requested.
 void PartialData::FixResponseHeaders(HttpResponseHeaders* headers) {
   headers->RemoveHeader(kLengthHeader);
   headers->RemoveHeader(kRangeHeader);
 
-  DCHECK(byte_range_.HasFirstBytePosition());
-  DCHECK(byte_range_.HasLastBytePosition());
-  headers->AddHeader(StringPrintf("%s: bytes %lld-%lld/%lld", kRangeHeader,
-                                  byte_range_.first_byte_position(),
-                                  byte_range_.last_byte_position(),
-                                  resource_size_));
+  int64 range_len;
+  if (byte_range_.IsValid()) {
+    DCHECK(byte_range_.HasFirstBytePosition());
+    DCHECK(byte_range_.HasLastBytePosition());
+    headers->AddHeader(StringPrintf("%s: bytes %lld-%lld/%lld", kRangeHeader,
+                                    byte_range_.first_byte_position(),
+                                    byte_range_.last_byte_position(),
+                                    resource_size_));
+    range_len = byte_range_.last_byte_position() -
+                byte_range_.first_byte_position() + 1;
+  } else {
+    // TODO(rvargas): Is it safe to change the protocol version?
+    headers->ReplaceStatusLine("HTTP/1.1 200 OK");
+    DCHECK_NE(resource_size_, 0);
+    range_len = resource_size_;
+  }
 
-  int64 range_len = byte_range_.last_byte_position() -
-                    byte_range_.first_byte_position() + 1;
   headers->AddHeader(StringPrintf("%s: %lld", kLengthHeader, range_len));
 }
 
 void PartialData::FixContentLength(HttpResponseHeaders* headers) {
   headers->RemoveHeader(kLengthHeader);
   headers->AddHeader(StringPrintf("%s: %lld", kLengthHeader, resource_size_));
 }
 
 int PartialData::CacheRead(disk_cache::Entry* entry, IOBuffer* data,
                            int data_len, CompletionCallback* callback) {
@@ skipping 31 matching lines @@
   std::string my_start, my_end;
   if (start >= 0)
     my_start = Int64ToString(start);
   if (end >= 0)
     my_end = Int64ToString(end);
 
   headers->append(StringPrintf("Range: bytes=%s-%s\r\n", my_start.c_str(),
                                my_end.c_str()));
 }
 
-
 }  // namespace net