Http Cache: Add support for resuming downloading a...

net/http/http_cache.cc

 // Copyright (c) 2006-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/http_cache.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/compiler_specific.h"
@@ skipping 46 matching lines @@
   // This bit is set if the response info has a security-bits field (security
   // strength, in bits, of the SSL connection) at the end.
   RESPONSE_INFO_HAS_SECURITY_BITS = 1 << 9,
 
   // This bit is set if the response info has a cert status at the end.
   RESPONSE_INFO_HAS_CERT_STATUS = 1 << 10,
 
   // This bit is set if the response info has vary header data.
   RESPONSE_INFO_HAS_VARY_DATA = 1 << 11,
 
-  // TODO(darin): Add other bits to indicate alternate request methods and
-  // whether or not we are storing a partial document.  For now, we don't
-  // support storing those.
+  // This bit is set if the request was cancelled before completion.
+  RESPONSE_INFO_TRUNCATED = 1 << 12,
+
+  // TODO(darin): Add other bits to indicate alternate request methods.
+  // For now, we don't support storing those.
 };
 
 //-----------------------------------------------------------------------------
 
 struct HeaderNameAndValue {
   const char* name;
   const char* value;
 };
 
 // If the request includes one of these request headers, then avoid caching
@@ skipping 92 matching lines @@
       : RevocableStore::Revocable(&cache->transactions_),
         request_(NULL),
         cache_(cache),
         entry_(NULL),
         network_trans_(NULL),
         callback_(NULL),
         mode_(NONE),
         reading_(false),
         invalid_range_(false),
         enable_range_support_(enable_range_support),
+        truncated_(false),
         read_offset_(0),
         effective_load_flags_(0),
         final_upload_progress_(0),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             network_info_callback_(this, &Transaction::OnNetworkInfoAvailable)),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             network_read_callback_(this, &Transaction::OnNetworkReadCompleted)),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             cache_read_callback_(new CancelableCompletionCallback<Transaction>(
                 this, &Transaction::OnCacheReadCompleted))) {
@@ skipping 49 matching lines @@
 
   const std::string& key() const { return cache_key_; }
 
   // Associates this transaction with a cache entry.
   int AddToEntry();
 
   // Called by the HttpCache when the given disk cache entry becomes accessible
   // to the transaction.  Returns network error code.
   int EntryAvailable(ActiveEntry* entry);
 
+  // This transaction is being deleted and we are not done writing to the cache.
+  // We need to indicate that the response data was truncated.
+  void AddTruncatedFlag();
+
  private:
   // This is a helper function used to trigger a completion callback.  It may
   // only be called if callback_ is non-null.
   void DoCallback(int rv);
 
   // This will trigger the completion callback if appropriate.
   int HandleResult(int rv);
 
   // Sets request_ and fields derived from it.
   void SetRequest(LoadLog* load_log, const HttpRequestInfo* request);
@@ skipping 59 matching lines @@
   int ReadFromEntry(IOBuffer* data, int data_len);
 
   // Called to populate response_ from the cache entry.
   int ReadResponseInfoFromEntry();
 
   // Called to write data to the cache entry.  If the write fails, then the
   // cache entry is destroyed.  Future calls to this function will just do
   // nothing without side-effect.
   void WriteToEntry(int index, int offset, IOBuffer* data, int data_len);
 
-  // Called to write response_ to the cache entry.
-  void WriteResponseInfoToEntry();
+  // Called to write response_ to the cache entry. |truncated| indicates if the
+  // entry should be marked as incomplete.
+  void WriteResponseInfoToEntry(bool truncated);
 
   // Called to append response data to the cache entry.
   void AppendResponseDataToEntry(IOBuffer* data, int data_len);
 
   // Called to truncate response content in the entry.
   void TruncateResponseData();
 
   // Called when we are done writing to the cache entry.
   void DoneWritingToEntry(bool success);
 
@@ skipping 34 matching lines @@
   HttpCache::ActiveEntry* entry_;
   scoped_ptr<HttpTransaction> network_trans_;
   CompletionCallback* callback_;  // Consumer's callback.
   HttpResponseInfo response_;
   HttpResponseInfo auth_response_;
   std::string cache_key_;
   Mode mode_;
   bool reading_;  // We are already reading.
   bool invalid_range_;  // We may bypass the cache for this request.
   bool enable_range_support_;
+  bool truncated_;  // We don't have all the response data.
   scoped_refptr<IOBuffer> read_buf_;
   int read_buf_len_;
   int read_offset_;
   int effective_load_flags_;
   scoped_ptr<PartialData> partial_;  // We are dealing with range requests.
   uint64 final_upload_progress_;
   CompletionCallbackImpl<Transaction> network_info_callback_;
   CompletionCallbackImpl<Transaction> network_read_callback_;
   scoped_refptr<CancelableCompletionCallback<Transaction> >
       cache_read_callback_;
 };
 
 HttpCache::Transaction::~Transaction() {
   if (!revoked()) {
     if (entry_) {
-      cache_->DoneWithEntry(entry_, this);
+      bool cancel_request = reading_ && !partial_.get() &&
+                            enable_range_support_ &&
+                            response_.headers->response_code() == 200;
+
+      cache_->DoneWithEntry(entry_, this, cancel_request);
     } else {
       cache_->RemovePendingTransaction(this);
     }
   }
 
   // If there is an outstanding callback, mark it as cancelled so running it
   // does nothing.
   cache_read_callback_->Cancel();
 
   // We could still have a cache read in progress, so we just null the cache_
@@ skipping 139 matching lines @@
 
   // If we have an intermediate auth response at this point, then it means the
   // user wishes to read the network response (the error page).  If there is a
   // previous response in the cache then we should leave it intact.
   if (auth_response_.headers && mode_ != NONE) {
     DCHECK(mode_ & WRITE);
     DoneWritingToEntry(mode_ == READ_WRITE);
     mode_ = NONE;
   }
 
+  reading_ = true;
   int rv;
 
   switch (mode_) {
     case READ_WRITE:
       DCHECK(partial_.get());
-      reading_ = true;
       if (!network_trans_.get()) {
         // We are just reading from the cache, but we may be writing later.
         rv = ReadFromEntry(buf, buf_len);
         break;
       }
     case NONE:
     case WRITE:
       DCHECK(network_trans_.get());
       rv = ReadFromNetwork(buf, buf_len);
       break;
@@ skipping 113 matching lines @@
     case UPDATE:
       rv = BeginExternallyConditionalizedRequest();
       break;
     default:
       NOTREACHED();
       rv = ERR_FAILED;
   }
   return rv;
 }
 
+void HttpCache::Transaction::AddTruncatedFlag() {
+  DCHECK(mode_ & WRITE);
+  truncated_ = true;
+  WriteResponseInfoToEntry(true);
+}
+
 void HttpCache::Transaction::DoCallback(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
   DCHECK(callback_);
 
   // since Run may result in Read being called, clear callback_ up front.
   CompletionCallback* c = callback_;
   callback_ = NULL;
   c->Run(rv);
 }
 
@@ skipping 160 matching lines @@
   int rv = ReadResponseInfoFromEntry();
   if (rv != OK)
     return HandleResult(rv);
 
   // We don't support any combination of LOAD_ONLY_FROM_CACHE and byte ranges.
   if (response_.headers->response_code() == 206 || partial_.get()) {
     NOTREACHED();
     return HandleResult(ERR_CACHE_MISS);
   }
 
+  // We don't have the whole resource.
+  if (truncated_)
+    return HandleResult(ERR_CACHE_MISS);
+
   return HandleResult(rv);
 }
 
 int HttpCache::Transaction::BeginCacheValidation() {
   DCHECK(mode_ == READ_WRITE);
 
   if ((effective_load_flags_ & LOAD_PREFERRING_CACHE ||
        !RequiresValidation()) && !partial_.get()) {
     cache_->ConvertWriterToReader(entry_);
     mode_ = READ;
@@ skipping 11 matching lines @@
 
 int HttpCache::Transaction::BeginPartialCacheValidation() {
   DCHECK(mode_ == READ_WRITE);
 
   int rv = ReadResponseInfoFromEntry();
   if (rv != OK) {
     DCHECK(rv != ERR_IO_PENDING);
     return HandleResult(rv);
   }
 
-  if (response_.headers->response_code() != 206 && !partial_.get())
+  if (response_.headers->response_code() != 206 && !partial_.get() &&
+      !truncated_)
     return BeginCacheValidation();
 
   if (!enable_range_support_)
     return BeginCacheValidation();
 
   bool byte_range_requested = partial_.get() != NULL;
   if (!byte_range_requested) {
     // The request is not for a range, but we have stored just ranges.
     partial_.reset(new PartialData());
     if (!custom_request_.get()) {
       custom_request_.reset(new HttpRequestInfo(*request_));
       request_ = custom_request_.get();
       DCHECK(custom_request_->extra_headers.empty());
     }
   }
 
-  if (!partial_->UpdateFromStoredHeaders(response_.headers,
-                                         entry_->disk_entry)) {
+  if (!partial_->UpdateFromStoredHeaders(response_.headers, entry_->disk_entry,
+                                         truncated_)) {
     // The stored data cannot be used. Get rid of it and restart this request.
     DoomPartialEntry(!byte_range_requested);
     mode_ = WRITE;
     return AddToEntry();
   }
 
   if (!partial_->IsRequestedRangeOK()) {
     // The stored data is fine, but the request may be invalid.
     invalid_range_ = true;
   }
@@ skipping 40 matching lines @@
   }
 
   // Retrieve either the cached response's "etag" or "last-modified" header,
   // depending on which is applicable for the caller's request header.
   std::string validator;
   response_.headers->EnumerateHeader(
       NULL,
       external_validation_.type_info().related_response_header_name,
       &validator);
 
-  if (response_.headers->response_code() != 200 ||
-      validator.empty() ||
-      validator != external_validation_.value) {
+  if (response_.headers->response_code() != 200 || truncated_ ||
+      validator.empty() || validator != external_validation_.value) {
     // The externally conditionalized request is not a validation request
     // for our existing cache entry. Proceed with caching disabled.
     DoneWritingToEntry(true);
   }
 
   return BeginNetworkRequest();
 }
 
 int HttpCache::Transaction::BeginNetworkRequest() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
@@ skipping 241 matching lines @@
     rv = DoCacheReadCompleted(rv);
   } else if (rv != ERR_IO_PENDING) {
     cache_read_callback_->Release();
   }
   return rv;
 }
 
 int HttpCache::Transaction::ReadResponseInfoFromEntry() {
   DCHECK(entry_);
 
-  if (!HttpCache::ReadResponseInfo(entry_->disk_entry, &response_))
+  if (!HttpCache::ReadResponseInfo(entry_->disk_entry, &response_, &truncated_))
     return ERR_CACHE_READ_FAILURE;
   return OK;
 }
 
 void HttpCache::Transaction::WriteToEntry(int index, int offset,
                                           IOBuffer* data, int data_len) {
   if (!entry_)
     return;
 
   int rv = 0;
   if (!partial_.get() || !data_len) {
     rv = entry_->disk_entry->WriteData(index, offset, data, data_len, NULL,
                                        true);
   } else {
     rv = partial_->CacheWrite(entry_->disk_entry, data, data_len, NULL);
   }
   if (rv != data_len) {
     DLOG(ERROR) << "failed to write response data to cache";
     DoneWritingToEntry(false);
   }
 }
 
-void HttpCache::Transaction::WriteResponseInfoToEntry() {
+void HttpCache::Transaction::WriteResponseInfoToEntry(bool truncated) {
   if (!entry_)
     return;
 
   // Do not cache no-store content (unless we are record mode).  Do not cache
   // content with cert errors either.  This is to prevent not reporting net
   // errors when loading a resource from the cache.  When we load a page over
   // HTTPS with a cert error we show an SSL blocking page.  If the user clicks
   // proceed we reload the resource ignoring the errors.  The loaded resource
   // is then cached.  If that resource is subsequently loaded from the cache,
   // no net error is reported (even though the cert status contains the actual
   // errors) and no SSL blocking page is shown.  An alternative would be to
   // reverse-map the cert status to a net error and replay the net error.
   if ((cache_->mode() != RECORD &&
       response_.headers->HasHeaderValue("cache-control", "no-store")) ||
       net::IsCertStatusError(response_.ssl_info.cert_status)) {
     DoneWritingToEntry(false);
     return;
   }
 
   // When writing headers, we normally only write the non-transient
   // headers; when in record mode, record everything.
   bool skip_transient_headers = (cache_->mode() != RECORD);
 
+  if (truncated) {
+    DCHECK_EQ(200, response_.headers->response_code());
+  }
+
   if (!HttpCache::WriteResponseInfo(entry_->disk_entry, &response_,
-                                    skip_transient_headers)) {
+                                    skip_transient_headers, truncated)) {
     DLOG(ERROR) << "failed to write response info to cache";
     DoneWritingToEntry(false);
   }
 }
 
 void HttpCache::Transaction::AppendResponseDataToEntry(IOBuffer* data,
                                                        int data_len) {
   if (!entry_ || !data_len)
     return;
 
@@ skipping 16 matching lines @@
   if (cache_->mode() == RECORD)
     DLOG(INFO) << "Recorded: " << request_->method << request_->url
                << " status: " << response_.headers->response_code();
 
   cache_->DoneWritingToEntry(entry_, success);
   entry_ = NULL;
   mode_ = NONE;  // switch to 'pass through' mode
 }
 
 void HttpCache::Transaction::DoomPartialEntry(bool delete_object) {
-  cache_->DoneWithEntry(entry_, this);
+  cache_->DoneWithEntry(entry_, this, false);
   cache_->DoomEntry(cache_key_);
   entry_ = NULL;
   if (delete_object)
     partial_.reset(NULL);
 }
 
 int HttpCache::Transaction::DoNetworkReadCompleted(int result) {
   DCHECK(mode_ & WRITE || mode_ == NONE);
 
   if (revoked())
@@ skipping 72 matching lines @@
     return;
   }
 
   if (result == OK) {
     const HttpResponseInfo* new_response = network_trans_->GetResponseInfo();
     if (new_response->headers->response_code() == 401 ||
         new_response->headers->response_code() == 407) {
       auth_response_ = *new_response;
     } else {
       bool partial_content = ValidatePartialResponse(new_response->headers);
-      if (partial_content && mode_ == READ_WRITE &&
+      if (partial_content && mode_ == READ_WRITE && !truncated_ &&
           response_.headers->response_code() == 200) {
         // We have stored the full entry, but it changed and the server is
         // sending a range. We have to delete the old entry.
         DoneWritingToEntry(false);
       }
 
       // Are we expecting a response to a conditional query?
       if (mode_ == READ_WRITE || mode_ == UPDATE) {
         if (new_response->headers->response_code() == 304 || partial_content) {
           // Update cached response based on headers in new_response.
           // TODO(wtc): should we update cached certificate
           // (response_.ssl_info), too?
           response_.headers->Update(*new_response->headers);
           response_.response_time = new_response->response_time;
           response_.request_time = new_response->request_time;
 
           if (response_.headers->HasHeaderValue("cache-control", "no-store")) {
             cache_->DoomEntry(cache_key_);
           } else {
             // If we are already reading, we already updated the headers for
             // this request; doing it again will change Content-Length.
             if (!reading_)
-              WriteResponseInfoToEntry();
+              WriteResponseInfoToEntry(false);
           }
 
           if (mode_ == UPDATE) {
             DCHECK(!partial_content);
             // We got a "not modified" response and already updated the
             // corresponding cache entry above.
             //
             // By closing the cached entry now, we make sure that the
             // 304 rather than the cached 200 response, is what will be
             // returned to the user.
@@ skipping 12 matching lines @@
           mode_ = WRITE;
         }
       }
 
       if (!(mode_ & READ)) {
         // We change the value of Content-Length for partial content.
         if (partial_content && partial_.get())
           partial_->FixContentLength(new_response->headers);
 
         response_ = *new_response;
-        WriteResponseInfoToEntry();
+        WriteResponseInfoToEntry(truncated_);
 
         // Truncate response data.
         TruncateResponseData();
 
         // If this response is a redirect, then we can stop writing now.  (We
         // don't need to cache the response body of a redirect.)
         if (response_.headers->IsRedirect(NULL))
           DoneWritingToEntry(true);
       }
-      if (reading_) {
-        DCHECK(partial_.get());
+      if (reading_ && partial_.get()) {
         if (network_trans_.get()) {
           result = ReadFromNetwork(read_buf_, read_buf_len_);
         } else {
           result = ReadFromEntry(read_buf_, read_buf_len_);
         }
         if (result >= 0 || result == net::ERR_IO_PENDING)
           return;
       } else if (partial_.get()) {
         // We are about to return the headers for a byte-range request to the
         // user, so let's fix them.
@@ skipping 119 matching lines @@
 HttpCache* HttpCache::GetCache() {
   return this;
 }
 
 void HttpCache::Suspend(bool suspend) {
   network_layer_->Suspend(suspend);
 }
 
 // static
 bool HttpCache::ParseResponseInfo(const char* data, int len,
-                                  HttpResponseInfo* response_info) {
+                                  HttpResponseInfo* response_info,
+                                  bool* response_truncated) {
   Pickle pickle(data, len);
   void* iter = NULL;
 
   // read flags and verify version
   int flags;
   if (!pickle.ReadInt(&iter, &flags))
     return false;
   int version = flags & RESPONSE_INFO_VERSION_MASK;
   if (version != RESPONSE_INFO_VERSION) {
     DLOG(ERROR) << "unexpected response info version: " << version;
@@ skipping 33 matching lines @@
       return false;
     response_info->ssl_info.security_bits = security_bits;
   }
 
   // read vary-data
   if (flags & RESPONSE_INFO_HAS_VARY_DATA) {
     if (!response_info->vary_data.InitFromPickle(pickle, &iter))
       return false;
   }
 
+  *response_truncated = (flags & RESPONSE_INFO_TRUNCATED) ? true : false;
+
   return true;
 }
 
 // static
 bool HttpCache::ReadResponseInfo(disk_cache::Entry* disk_entry,
-                                 HttpResponseInfo* response_info) {
+                                 HttpResponseInfo* response_info,
+                                 bool* response_truncated) {
   int size = disk_entry->GetDataSize(kResponseInfoIndex);
 
   scoped_refptr<IOBuffer> buffer = new IOBuffer(size);
   int rv = disk_entry->ReadData(kResponseInfoIndex, 0, buffer, size, NULL);
   if (rv != size) {
     DLOG(ERROR) << "ReadData failed: " << rv;
     return false;
   }
 
-  return ParseResponseInfo(buffer->data(), size, response_info);
+  return ParseResponseInfo(buffer->data(), size, response_info,
+                           response_truncated);
 }
 
 // static
 bool HttpCache::WriteResponseInfo(disk_cache::Entry* disk_entry,
                                   const HttpResponseInfo* response_info,
-                                  bool skip_transient_headers) {
+                                  bool skip_transient_headers,
+                                  bool response_truncated) {
   int flags = RESPONSE_INFO_VERSION;
   if (response_info->ssl_info.cert) {
     flags |= RESPONSE_INFO_HAS_CERT;
     flags |= RESPONSE_INFO_HAS_CERT_STATUS;
   }
   if (response_info->ssl_info.security_bits != -1)
     flags |= RESPONSE_INFO_HAS_SECURITY_BITS;
   if (response_info->vary_data.is_valid())
     flags |= RESPONSE_INFO_HAS_VARY_DATA;
+  if (response_truncated)
+    flags |= RESPONSE_INFO_TRUNCATED;
 
   Pickle pickle;
   pickle.WriteInt(flags);
   pickle.WriteInt64(response_info->request_time.ToInternalValue());
   pickle.WriteInt64(response_info->response_time.ToInternalValue());
 
   net::HttpResponseHeaders::PersistOptions persist_options =
       net::HttpResponseHeaders::PERSIST_RAW;
 
   if (skip_transient_headers) {
@@ skipping 201 matching lines @@
 
   // We do this before calling EntryAvailable to force any further calls to
   // AddTransactionToEntry to add their transaction to the pending queue, which
   // ensures FIFO ordering.
   if (!entry->writer && !entry->pending_queue.empty())
     ProcessPendingQueue(entry);
 
   return trans->EntryAvailable(entry);
 }
 
-void HttpCache::DoneWithEntry(ActiveEntry* entry, Transaction* trans) {
+void HttpCache::DoneWithEntry(ActiveEntry* entry, Transaction* trans,
+                              bool cancel) {
   // If we already posted a task to move on to the next transaction and this was
   // the writer, there is nothing to cancel.
   if (entry->will_process_pending_queue && entry->readers.empty())
     return;
 
   if (entry->writer) {
     DCHECK(trans == entry->writer);
 
-    // Assume that this is not a successful write.
-    DoneWritingToEntry(entry, false);
+    // Assume there was a failure.
+    bool success = false;
+    if (cancel) {
+      DCHECK(entry->disk_entry);
+      // This is a successful operation in the sense that we want to keep the
+      // entry.
+      success = true;
+      // Double check that there is something worth keeping.
+      if (!entry->disk_entry->GetDataSize(kResponseContentIndex))
+        success = false;
+      trans->AddTruncatedFlag();
+    }
+    DoneWritingToEntry(entry, success);
   } else {
     DoneReadingFromEntry(entry, trans);
   }
 }
 
 void HttpCache::DoneWritingToEntry(ActiveEntry* entry, bool success) {
   DCHECK(entry->readers.empty());
 
   entry->writer = NULL;
 
@@ skipping 97 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->tcp_socket_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net