[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 <limits>
+
 #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;
 
 }  // namespace
 
+// static
+const int64 PartialData::kUnbounded = std::numeric_limits<int64>::max();
+
 PartialData::PartialData()
     : current_range_start_(0),
       current_range_end_(0),
       cached_start_(0),
       resource_size_(0),
       cached_min_len_(0),
       range_present_(false),
       final_range_(false),
       sparse_entry_(true),
       truncated_(false),
@@ skipping 47 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();
+  int64 len = GetNextRangeLen();
   if (!len)
     return 0;
 
   DVLOG(3) << "ShouldValidateCache len: " << len;
 
   if (sparse_entry_) {
     DCHECK(callback_.is_null());
     int64* start = new int64;
+    // TODO(asanka): Use the full len when int64s are plumbed all the way
+    // through.
+    int cached_len = std::min<int64>(std::numeric_limits<int32>::max(), 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_) {
@@ skipping 10 matching lines @@
 
   // 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();
+  int64 len = GetNextRangeLen();
+  // PrepareCacheValidation shouldn't have been called if ShouldValidateCache()
+  // returned 0.
   DCHECK_NE(0, len);
   range_present_ = false;
 
   headers->CopyFrom(extra_headers_);
 
+  // Do we need to request the remainder from the network? If so just issue an
+  // open ended range request.
+  if (len == kUnbounded) {
+    DCHECK_EQ(0, cached_min_len_);  // Nothing else should be stored. All cached
+                                    // ranges are finite, so we don't expect len
+                                    // to be kUnbounded.
+    cached_start_ = 0;
+    current_range_end_ = -1;
+    final_range_ = true;
+    headers->SetHeader(
+        HttpRequestHeaders::kRange,
+        HttpByteRange::RightUnbounded(current_range_start_).GetHeaderValue());
+    return;
+  }
+
   if (!cached_min_len_) {
     // We don't have anything else stored.
     final_range_ = true;
     cached_start_ =
-        byte_range_.HasLastBytePosition() ? current_range_start_  + len : 0;
+        byte_range_.HasLastBytePosition() ? current_range_start_ + len : 0;
   }
 
   if (current_range_start_ == cached_start_) {
     // The data lives in the cache.
     range_present_ = true;
     current_range_end_ = cached_start_ + cached_min_len_ - 1;
     if (len == cached_min_len_)
       final_range_ = true;
   } else {
     // This range is not in the cache.
@@ skipping 194 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);
+int64 PartialData::GetNextRangeLen() {
+  return byte_range_.HasLastBytePosition()

[rvargas (doing something else), 2015/07/27 22:25:12]

It seems like we should eliminate this method.

[asanka, 2015/08/18 22:46:59]

New patchset adds another call site. Let me know if you still this we should get
rid of it.

[rvargas (doing something else), 2015/08/19 23:46:37]

The reason was that the code at the call sites would be clearer if this is
inlined+simplified.

That may not be true for the new call site, but at the same time, what does it
mean to call SkipCacheForRemainder if !byte_range_.HasLastBytePos()?

I think I still lean to get rid of this method even if we add a little code
duplication.

[asanka, 2015/09/04 19:09:03]

SG. Removed. I think it also makes the handling of the kUnbounded case much more
explicit.

+             ? byte_range_.last_byte_position() - current_range_start_ + 1
+             : kUnbounded;
 }
 
 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