Disk cache: Add a method to cancel pending sparse operations....

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 172 matching lines @@
         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))) {
+                this, &Transaction::OnCacheReadCompleted))),
+        ALLOW_THIS_IN_INITIALIZER_LIST(
+            entry_ready_callback_(new CancelableCompletionCallback<Transaction>(
+                this, &Transaction::OnCacheEntryReady))) {
   }
 
   // Clean up the transaction.
   virtual ~Transaction();
 
   // HttpTransaction methods:
   virtual int Start(const HttpRequestInfo*, CompletionCallback*, LoadLog*);
   virtual int RestartIgnoringLastError(CompletionCallback*);
   virtual int RestartWithCertificate(X509Certificate* client_cert,
                                      CompletionCallback* callback);
@@ skipping 69 matching lines @@
   // Called to begin reading from the cache.  Returns network error code.
   int BeginCacheRead();
 
   // Called to begin validating the cache entry.  Returns network error code.
   int BeginCacheValidation();
 
   // Called to begin validating an entry that stores partial content.  Returns
   // a network error code.
   int BeginPartialCacheValidation();
 
+  // Validates the entry headers against the requested range and continues with
+  // the validation of the rest of the entry.  Returns a network error code.
+  int ValidateEntryHeadersAndContinue(bool byte_range_requested);
+
   // Performs the cache validation for the next chunk of data stored by the
   // cache.  If this chunk is not currently stored, starts the network request
   // to fetch it.  Returns a network error code.
   int ContinuePartialCacheValidation();
 
   // Called to start requests which were given an "if-modified-since" or
   // "if-none-match" validation header by the caller (NOT when the request was
   // conditionalized internally in response to LOAD_VALIDATE_CACHE).
   // Returns a network error code.
   int BeginExternallyConditionalizedRequest();
@@ skipping 74 matching lines @@
 
   // Called to signal completion of the network transaction's Start method:
   void OnNetworkInfoAvailable(int result);
 
   // Called to signal completion of the network transaction's Read method:
   void OnNetworkReadCompleted(int result);
 
   // Called to signal completion of the cache's ReadData method:
   void OnCacheReadCompleted(int result);
 
+  // Called to signal completion of the cache entry's ReadyForSparseIO method:
+  void OnCacheEntryReady(int result);
+
   scoped_refptr<LoadLog> load_log_;
   const HttpRequestInfo* request_;
   scoped_ptr<HttpRequestInfo> custom_request_;
   // If extra_headers specified a "if-modified-since" or "if-none-match",
   // |external_validation_| contains the value of that header.
   ValidationHeader external_validation_;
   base::WeakPtr<HttpCache> cache_;
   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_;
+  scoped_refptr<CancelableCompletionCallback<Transaction> >
+      entry_ready_callback_;
 };
 
 HttpCache::Transaction::~Transaction() {
   if (cache_) {
     if (entry_) {
       bool cancel_request = reading_ && enable_range_support_;
-      if (cancel_request && !partial_.get())
-        cancel_request &= (response_.headers->response_code() == 200);
+      if (cancel_request) {
+        if (partial_.get()) {
+          entry_->disk_entry->CancelSparseIO();
+        } else {
+          cancel_request &= (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();
@@ skipping 527 matching lines @@
   }
 
   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) {
+  if (byte_range_requested) {
+    if (OK != entry_->disk_entry->ReadyForSparseIO(entry_ready_callback_))
+      return ERR_IO_PENDING;
+  } else {
     // 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();
     }
   }
 
+  return ValidateEntryHeadersAndContinue(byte_range_requested);
+}
+
+int HttpCache::Transaction::ValidateEntryHeadersAndContinue(
+    bool byte_range_requested) {
+  DCHECK(mode_ == READ_WRITE);
+
   if (!partial_->UpdateFromStoredHeaders(response_.headers, entry_->disk_entry,
                                          truncated_)) {
     // The stored data cannot be used. Get rid of it and restart this request.
     // We need to also reset the |truncated_| flag as a new entry is created.
     DoomPartialEntry(!byte_range_requested);
     mode_ = WRITE;
     truncated_ = false;
     return AddToEntry();
   }
 
@@ skipping 595 matching lines @@
 }
 
 void HttpCache::Transaction::OnNetworkReadCompleted(int result) {
   DoNetworkReadCompleted(result);
 }
 
 void HttpCache::Transaction::OnCacheReadCompleted(int result) {
   DoCacheReadCompleted(result);
 }
 
+void HttpCache::Transaction::OnCacheEntryReady(int result) {
+  DCHECK_EQ(OK, result);
+  ValidateEntryHeadersAndContinue(true);
+}
+
 //-----------------------------------------------------------------------------
 
 HttpCache::HttpCache(HostResolver* host_resolver,
                      ProxyService* proxy_service,
                      SSLConfigService* ssl_config_service,
                      const std::wstring& cache_dir,
                      int cache_size)
     : disk_cache_dir_(cache_dir),
       mode_(NORMAL),
       type_(DISK_CACHE),
@@ skipping 535 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->tcp_socket_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net