Http cache: Fix handling of truncated entries....

net/http/partial_data.cc

 // Copyright (c) 2010 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/format_macros.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 93 matching lines @@
   delete this;
 }
 
 // -----------------------------------------------------------------------------
 
 PartialData::PartialData()
     : range_present_(false),
       final_range_(false),
       sparse_entry_(true),
       truncated_(false),
+      initial_validation_(false),
       core_(NULL),
       callback_(NULL) {
 }
 
 PartialData::~PartialData() {
   if (core_)
     core_->Cancel();
 }
 
 bool PartialData::Init(const HttpRequestHeaders& headers) {
@@ skipping 22 matching lines @@
   DCHECK(extra_headers_.IsEmpty());
   extra_headers_.CopyFrom(headers);
 }
 
 void PartialData::RestoreHeaders(HttpRequestHeaders* headers) const {
   DCHECK(current_range_start_ >= 0 || byte_range_.IsSuffixByteRange());
   int64 end = byte_range_.IsSuffixByteRange() ?
               byte_range_.suffix_length() : byte_range_.last_byte_position();
 
   headers->CopyFrom(extra_headers_);
-  if (byte_range_.IsValid())
+  if (!truncated_ && byte_range_.IsValid())
     AddRangeHeader(current_range_start_, end, headers);
 }
 
 int PartialData::ShouldValidateCache(disk_cache::Entry* entry,
                                      CompletionCallback* callback) {
   DCHECK_GE(current_range_start_, 0);
 
   // Scan the disk cache for the first cached portion within this range.
   int len = GetNextRangeLen();
   if (!len)
     return 0;
 
   DVLOG(3) << "ShouldValidateCache len: " << len;
 
   if (sparse_entry_) {
     DCHECK(!callback_);
     Core* core = Core::CreateCore(this);
     cached_min_len_ = core->GetAvailableRange(entry, current_range_start_, len,
                                               &cached_start_);
 
     if (cached_min_len_ == ERR_IO_PENDING) {
       callback_ = callback;
       return ERR_IO_PENDING;
     }
-  } else if (truncated_) {
-    if (!current_range_start_) {
-      // Update the cached range only the first time.
-      cached_min_len_ = static_cast<int32>(byte_range_.first_byte_position());
-      cached_start_ = 0;
-    }
-  } else {
+  } else if (!truncated_) {
     if (byte_range_.HasFirstBytePosition() &&
         byte_range_.first_byte_position() >= resource_size_) {
       // The caller should take care of this condition because we should have
       // failed IsRequestedRangeOK(), but it's better to be consistent here.
       len = 0;
     }
     cached_min_len_ = len;
     cached_start_ = current_range_start_;
   }
 
@@ skipping 54 matching lines @@
     if (byte_range_.IsValid())
       return false;
 
     // Now we avoid resume if there is no content length, but that was not
     // always the case so double check here.
     int64 total_length = headers->GetContentLength();
     if (total_length <= 0 || !headers->HasStrongValidators())
       return false;
 
     truncated_ = true;
+    initial_validation_ = true;
     sparse_entry_ = false;
-    byte_range_.set_first_byte_position(entry->GetDataSize(kDataStream));
+    int current_len = entry->GetDataSize(kDataStream);
+    byte_range_.set_first_byte_position(current_len);
     resource_size_ = total_length;
-    current_range_start_ = 0;
+    current_range_start_ = current_len;
+    cached_min_len_ = current_len;
+    cached_start_ = current_len + 1;
     return true;
   }
 
   if (headers->response_code() == 200) {
     DCHECK(byte_range_.IsValid());
     sparse_entry_ = false;
     resource_size_ = entry->GetDataSize(kDataStream);
     DVLOG(2) << "UpdateFromStoredHeaders size: " << resource_size_;
     return true;
   }
 
   int64 length_value = headers->GetContentLength();
   if (length_value <= 0)
     return false;  // We must have stored the resource length.
 
   resource_size_ = length_value;
 
   // Make sure that this is really a sparse entry.
   return entry->CouldBeSparse();
 }
 
+void PartialData::SetRangeToStartDownload() {
+  DCHECK(truncated_);
+  DCHECK(!sparse_entry_);
+  current_range_start_ = 0;
+  cached_start_ = 0;
+  initial_validation_ = false;
+}
+
 bool PartialData::IsRequestedRangeOK() {
   if (byte_range_.IsValid()) {
+    if (!byte_range_.ComputeBounds(resource_size_))
+      return false;
     if (truncated_)
       return true;
-    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);
   }
 
   bool rv = current_range_start_ >= 0;
@@ skipping 167 matching lines @@
   cached_min_len_ = result;
   if (result >= 0)
     result = 1;  // Return success, go ahead and validate the entry.
 
   CompletionCallback* cb = callback_;
   callback_ = NULL;
   cb->Run(result);
 }
 
 }  // namespace net