[net] Better StopCaching() handling for HttpCache::Transaction.

net/http/partial_data.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 "net/http/partial_data.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 
 namespace net {
 
 namespace {
 
 // The headers that we have to process.
 const char kLengthHeader[] = "Content-Length";
 const char kRangeHeader[] = "Content-Range";
 const int kDataStream = 1;
+const int64 kUnbounded = kint64max;
 
 }  // namespace
 
 PartialData::PartialData()
     : current_range_start_(0),
       current_range_end_(0),
       cached_start_(0),
       resource_size_(0),
       cached_min_len_(0),
       range_present_(false),
@@ skipping 16 matching lines @@
   if (!HttpUtil::ParseRangeHeader(range_header, &ranges) || ranges.size() != 1)
     return false;
 
   // We can handle this range request.
   byte_range_ = ranges[0];
   if (!byte_range_.IsValid())
     return false;
 
   current_range_start_ = byte_range_.first_byte_position();
 
-  DVLOG(1) << "Range start: " << current_range_start_ << " end: " <<
-               byte_range_.last_byte_position();
+  DVLOG(1) << "Range start: " << current_range_start_
+           << " end: " << byte_range_.last_byte_position();
   return true;
 }
 
 void PartialData::SetHeaders(const HttpRequestHeaders& headers) {
   DCHECK(extra_headers_.IsEmpty());
   extra_headers_.CopyFrom(headers);
 }
 
 void PartialData::RestoreHeaders(HttpRequestHeaders* headers) const {
   DCHECK(current_range_start_ >= 0 || byte_range_.IsSuffixByteRange());
@@ skipping 12 matching lines @@
                        HttpByteRange::Bounded(
                            current_range_start_, end).GetHeaderValue());
   }
 }
 
 int PartialData::ShouldValidateCache(disk_cache::Entry* entry,
                                      const 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)
+  int64 current_range_len =
+      byte_range_.HasLastBytePosition()
+          ? byte_range_.last_byte_position() - current_range_start_ + 1
+          : kUnbounded;
+  if (!current_range_len)
     return 0;
 
-  DVLOG(3) << "ShouldValidateCache len: " << len;
+  DVLOG(3) << "ShouldValidateCache current_range_len: " << current_range_len;
 
   if (sparse_entry_) {
     DCHECK(callback_.is_null());
     int64* start = new int64;
+    // TODO(asanka): Use the full |current_range_len| when int64_t is plumbed
+    // all the way through.
+    int cached_len = std::min<int64>(kint32max, current_range_len);
+
     // This callback now owns "start". We make sure to keep it
     // in a local variable since we want to use it later.
     CompletionCallback cb =
         base::Bind(&PartialData::GetAvailableRangeCompleted,
                    weak_factory_.GetWeakPtr(), base::Owned(start));
     cached_min_len_ =
-        entry->GetAvailableRange(current_range_start_, len, start, cb);
+        entry->GetAvailableRange(current_range_start_, cached_len, start, cb);
 
     if (cached_min_len_ == ERR_IO_PENDING) {
       callback_ = callback;
       return ERR_IO_PENDING;
     } else {
       cached_start_ = *start;
     }
   } 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;
+      current_range_len = 0;
     }
-    cached_min_len_ = len;
+    cached_min_len_ = current_range_len;
     cached_start_ = current_range_start_;
   }
 
   if (cached_min_len_ < 0)
     return cached_min_len_;
 
   // Return a positive number to indicate success (versus error or finished).
   return 1;
 }
 
 void PartialData::PrepareCacheValidation(disk_cache::Entry* entry,
                                          HttpRequestHeaders* headers) {
   DCHECK_GE(current_range_start_, 0);
   DCHECK_GE(cached_min_len_, 0);
 
-  int len = GetNextRangeLen();
-  DCHECK_NE(0, len);
+  int64 current_range_len =
+      byte_range_.HasLastBytePosition()
+          ? byte_range_.last_byte_position() - current_range_start_ + 1
+          : kUnbounded;
+  // PrepareCacheValidation shouldn't have been called if ShouldValidateCache()
+  // returned 0.
+  DCHECK_NE(0, current_range_len);
   range_present_ = false;
 
   headers->CopyFrom(extra_headers_);
 
   if (!cached_min_len_) {
     // We don't have anything else stored.
     final_range_ = true;
-    cached_start_ =
-        byte_range_.HasLastBytePosition() ? current_range_start_  + len : 0;
+    cached_start_ = byte_range_.HasLastBytePosition()
+                        ? current_range_start_ + current_range_len
+                        : 0;
   }
 
-  if (current_range_start_ == cached_start_) {
+  if (current_range_start_ == cached_start_ && cached_min_len_) {
     // The data lives in the cache.
     range_present_ = true;
     current_range_end_ = cached_start_ + cached_min_len_ - 1;
-    if (len == cached_min_len_)
+    if (current_range_len == cached_min_len_)
       final_range_ = true;
   } else {
     // This range is not in the cache.
     current_range_end_ = cached_start_ - 1;
   }
+
   headers->SetHeader(
       HttpRequestHeaders::kRange,
       HttpByteRange::Bounded(current_range_start_, current_range_end_)
           .GetHeaderValue());
 }
 
 bool PartialData::IsCurrentRangeCached() const {
   return range_present_;
 }
 
 bool PartialData::IsLastRange() const {
   return final_range_;
 }
 
 bool PartialData::UpdateFromStoredHeaders(const HttpResponseHeaders* headers,
                                           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.
+    std::string header_string;
+    headers->GetNormalizedHeaders(&header_string);
     if (byte_range_.IsValid())
       return false;
 
     if (!headers->HasStrongValidators())
       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)
@@ skipping 33 matching lines @@
 }
 
 void PartialData::SetRangeToStartDownload() {
   DCHECK(truncated_);
   DCHECK(!sparse_entry_);
   current_range_start_ = 0;
   cached_start_ = 0;
   initial_validation_ = false;
 }
 
+bool PartialData::SkipCacheForRemainder() {
+  if (byte_range_.HasLastBytePosition() &&
+      current_range_start_ > byte_range_.last_byte_position()) {
+    return false;
+  }
+
+  // Don't look for any more cached sparse ranges.
+  sparse_entry_ = false;
+
+  // Ignoring the remainder of the cached entry is equivalent to the cache entry
+  // having been truncated.
+  truncated_ = true;
+
+  // Current range is not cached.
+  cached_start_ = 0;
+  cached_min_len_ = 0;
+  return true;
+}
+
 bool PartialData::IsRequestedRangeOK() {
   if (byte_range_.IsValid()) {
     if (!byte_range_.ComputeBounds(resource_size_))
       return false;
     if (truncated_)
       return true;
 
     if (current_range_start_ < 0)
       current_range_start_ = byte_range_.first_byte_position();
   } else {
@@ skipping 107 matching lines @@
 void PartialData::FixContentLength(HttpResponseHeaders* headers) {
   headers->RemoveHeader(kLengthHeader);
   headers->AddHeader(base::StringPrintf("%s: %" PRId64, kLengthHeader,
                                         resource_size_));
 }
 
 int PartialData::CacheRead(disk_cache::Entry* entry,
                            IOBuffer* data,
                            int data_len,
                            const CompletionCallback& callback) {
-  int read_len = std::min(data_len, cached_min_len_);
+  int read_len = std::min<int64>(data_len, cached_min_len_);
   if (!read_len)
     return 0;
 
   int rv = 0;
   if (sparse_entry_) {
     rv = entry->ReadSparseData(current_range_start_, data, read_len,
                                callback);
   } else {
     if (current_range_start_ > kint32max)
       return ERR_INVALID_ARGUMENT;
@@ skipping 28 matching lines @@
     cached_min_len_ -= result;
     DCHECK_GE(cached_min_len_, 0);
   }
 }
 
 void PartialData::OnNetworkReadCompleted(int result) {
   if (result > 0)
     current_range_start_ += result;
 }
 
-int PartialData::GetNextRangeLen() {
-  int64 range_len =
-      byte_range_.HasLastBytePosition() ?
-      byte_range_.last_byte_position() - current_range_start_ + 1 :
-      kint32max;
-  if (range_len > kint32max)
-    range_len = kint32max;
-  return static_cast<int32>(range_len);
-}
-
 void PartialData::GetAvailableRangeCompleted(int64* start, int result) {
   DCHECK(!callback_.is_null());
   DCHECK_NE(ERR_IO_PENDING, result);
 
   cached_start_ = *start;
   cached_min_len_ = result;
   if (result >= 0)
     result = 1;  // Return success, go ahead and validate the entry.
 
   CompletionCallback cb = callback_;
   callback_.Reset();
   cb.Run(result);
 }
 
 }  // namespace net