Http cache: Avoid resuming (and keeping) truncated entries...

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/format_macros.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
@@ skipping 112 matching lines @@
                                           disk_cache::Entry* entry,
                                           bool truncated) {
   resource_size_ = 0;
   if (truncated) {
     DCHECK_EQ(headers->response_code(), 200);
     // We don't have the real length and the user may be trying to create a
     // sparse entry so let's not write to this entry.
     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;
     sparse_entry_ = false;
     byte_range_.set_first_byte_position(entry->GetDataSize(kDataStream));
+    resource_size_ = total_length;
     current_range_start_ = 0;
     return true;
   }
 
   if (headers->response_code() == 200) {
     DCHECK(byte_range_.IsValid());
     sparse_entry_ = false;
     resource_size_ = entry->GetDataSize(kDataStream);
     return true;
   }
 
-  std::string length_value;
-  if (!headers->GetNormalizedHeader(kLengthHeader, &length_value))
+  int64 length_value = headers->GetContentLength();
+  if (length_value <= 0)
     return false;  // We must have stored the resource length.
 
-  if (!StringToInt64(length_value, &resource_size_) || !resource_size_)
-    return false;
+  resource_size_ = length_value;
 
   // Make sure that this is really a sparse entry.
   int64 n;
   if (ERR_CACHE_OPERATION_NOT_SUPPORTED == entry->GetAvailableRange(0, 5, &n))
     return false;
 
   return true;
 }
 
 bool PartialData::IsRequestedRangeOK() {
@@ skipping 44 matching lines @@
     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 (truncated_) {
+    if (!byte_range_.HasLastBytePosition())
+      byte_range_.set_last_byte_position(end);
+  }
+
   if (start != current_range_start_)
     return false;
 
   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.
@@ skipping 91 matching lines @@
   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