Roll Chrome into Mojo.

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"
@@ skipping 85 matching lines @@
           "422516 PartialData::Core::OnIOComplete"));
 
   if (owner_)
     owner_->GetAvailableRangeCompleted(result, start_);
   delete this;
 }
 
 // -----------------------------------------------------------------------------
 
 PartialData::PartialData()
-    : range_present_(false),
+    : 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),
       initial_validation_(false),
       core_(NULL) {
 }
 
 PartialData::~PartialData() {
   if (core_)
     core_->Cancel();
 }
 
 bool PartialData::Init(const HttpRequestHeaders& headers) {
   std::string range_header;
   if (!headers.GetHeader(HttpRequestHeaders::kRange, &range_header))
     return false;
 
   std::vector<HttpByteRange> ranges;
   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;
 
-  resource_size_ = 0;
   current_range_start_ = byte_range_.first_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);
@@ skipping 71 matching lines @@
   if (!cached_min_len_) {
     // We don't have anything else stored.
     final_range_ = true;
     cached_start_ =
         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;
     headers->SetHeader(
         HttpRequestHeaders::kRange,
-        net::HttpByteRange::Bounded(
-            current_range_start_,
-            cached_start_ + cached_min_len_ - 1).GetHeaderValue());
+        HttpByteRange::Bounded(current_range_start_, current_range_end_)
+            .GetHeaderValue());
   } else {
     // This range is not in the cache.
+    current_range_end_ = cached_start_ - 1;
     headers->SetHeader(
         HttpRequestHeaders::kRange,
-        net::HttpByteRange::Bounded(
-            current_range_start_, cached_start_ - 1).GetHeaderValue());
+        HttpByteRange::Bounded(current_range_start_, current_range_end_)
+            .GetHeaderValue());
   }
 }
 
 bool PartialData::IsCurrentRangeCached() const {
   return range_present_;
 }
 
 bool PartialData::IsLastRange() const {
   return final_range_;
 }
@@ skipping 31 matching lines @@
   }
 
   if (headers->response_code() != 206) {
     DCHECK(byte_range_.IsValid());
     sparse_entry_ = false;
     resource_size_ = entry->GetDataSize(kDataStream);
     DVLOG(2) << "UpdateFromStoredHeaders size: " << resource_size_;
     return true;
   }
 
+  if (!headers->HasStrongValidators())
+    return false;
+
   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();
 }
 
@@ skipping 65 matching lines @@
   }
 
   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())
+  if (!current_range_end_) {
+    // There is nothing in the cache.
+    DCHECK(byte_range_.HasLastBytePosition());
+    current_range_end_ = byte_range_.last_byte_position();
+    if (current_range_end_ >= resource_size_) {
+      // We didn't know the real file size, and the server is saying that the
+      // requested range goes beyond the size. Fix it.
+      current_range_end_ = end;
+      byte_range_.set_last_byte_position(end);
+    }
+  }
+
+  // If we received a range, but it's not exactly the range we asked for, avoid
+  // trouble and signal an error.
+  if (end != current_range_end_)
     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,
                                      bool success) {
@@ skipping 97 matching lines @@
   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