Bypass the cache for the second or later HttpCache::Transaction...

net/http/http_cache.cc

 // Copyright (c) 2006-2008 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 "base/compiler_specific.h"
 
@@ skipping 49 matching lines @@
   // 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.
 };
 
 //-----------------------------------------------------------------------------
 
+static int kTransactionTimeoutInMillisecond = 5000;
+
 struct HeaderNameAndValue {
   const char* name;
   const char* value;
 };
 
 // If the request includes one of these request headers, then avoid caching
 // to avoid getting confused.
 static const HeaderNameAndValue kPassThroughHeaders[] = {
   { "range", NULL },                // causes unexpected 206s
   { "if-modified-since", NULL },    // causes unexpected 304s
@@ skipping 67 matching lines @@
         mode_(NONE),
         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(task_factory_(this)),
+        is_waiting_for_entry_(false) {
   }
 
   // Clean up the transaction.
   virtual ~Transaction();
 
   // HttpTransaction methods:
   virtual int Start(const HttpRequestInfo*, CompletionCallback*);
   virtual int RestartIgnoringLastError(CompletionCallback*);
   virtual int RestartWithAuth(const std::wstring& username,
                               const std::wstring& password,
@@ skipping 31 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);
 
+  // Called by the HttpCache when the given disk cache entry is busy. Sets up
+  // a timeout alarm to MessageLoop.
+  void PendOnEntry(ActiveEntry* entry);
+
  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);
 
   // Set request_ and fields derived from it.
   void SetRequest(const HttpRequestInfo* request);
@@ skipping 52 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 bypass cache when it took too much time to get access to cache.
+  void OnAddToEntryTimeout(ActiveEntry* entry);
+
   const HttpRequestInfo* request_;
   scoped_ptr<HttpRequestInfo> custom_request_;
   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_;
   scoped_refptr<IOBuffer> read_buf_;
   int read_offset_;
   int effective_load_flags_;
   uint64 final_upload_progress_;
   CompletionCallbackImpl<Transaction> network_info_callback_;
   CompletionCallbackImpl<Transaction> network_read_callback_;
   scoped_refptr<CancelableCompletionCallback<Transaction> >
       cache_read_callback_;
+
+  ScopedRunnableMethodFactory<Transaction> task_factory_;
+  bool is_waiting_for_entry_;
 };
 
 HttpCache::Transaction::~Transaction() {
   if (!revoked()) {
     if (entry_) {
       cache_->DoneWithEntry(entry_, this);
     } else {
       cache_->RemovePendingTransaction(this);
     }
   }
@@ skipping 222 matching lines @@
   //
   //  o if we are a reader for the transaction, then we can start reading the
   //    cache entry.
   //
   //  o if we can read or write, then we should check if the cache entry needs
   //    to be validated and then issue a network request if needed or just read
   //    from the cache if the cache entry is already valid.
   //
   int rv;
   entry_ = entry;
+  is_waiting_for_entry_ = false;
   switch (mode_) {
     case READ:
       rv = BeginCacheRead();
       break;
     case WRITE:
       rv = BeginNetworkRequest();
       break;
     case READ_WRITE:
       rv = BeginCacheValidation();
       break;
@@ skipping 392 matching lines @@
 
   if (result > 0) {
     read_offset_ += result;
   } else if (result == 0) {  // end of file
     cache_->DoneReadingFromEntry(entry_, this);
     entry_ = NULL;
   }
   HandleResult(result);
 }
 
+void HttpCache::Transaction::PendOnEntry(ActiveEntry* entry) {
+  if (is_waiting_for_entry_) {
+    // Don't add timeout alarm more than once.
+    return;
+  }
+
+  is_waiting_for_entry_ = true;
+
+  MessageLoop::current()->PostDelayedTask(
+    FROM_HERE,
+    task_factory_.NewRunnableMethod(&Transaction::OnAddToEntryTimeout, entry),
+    kTransactionTimeoutInMillisecond);
+}
+
+void HttpCache::Transaction::OnAddToEntryTimeout(ActiveEntry* entry) {
+  if (!is_waiting_for_entry_) {
+    // Already added to entry.
+    return;
+  }
+
+  if (mode_ == READ) {
+    // We cannot bypass the cache.
+    return;
+  }
+
+  // Check that the writer is still busy, and then give up accessing cache.
+  if (entry->writer &&
+      entry->writer->GetLoadState() == LOAD_STATE_WAITING_FOR_USER_ACTION) {
+    // There is a writer transaction suspended due to some error. Bypass
+    // cache if we can.
+    entry->pending_queue.remove(this);
+    mode_ = NONE;
+    is_waiting_for_entry_ = false;
+    BeginNetworkRequest();
+  }
+}
+
 //-----------------------------------------------------------------------------
 
 HttpCache::HttpCache(ProxyService* proxy_service,
                      const std::wstring& cache_dir,
                      int cache_size)
     : disk_cache_dir_(cache_dir),
       mode_(NORMAL),
       type_(DISK_CACHE),
       network_layer_(HttpNetworkLayer::CreateFactory(proxy_service)),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
@@ skipping 347 matching lines @@
   // We implement a basic reader/writer lock for the disk cache entry.  If
   // there is already a writer, then everyone has to wait for the writer to
   // finish before they can access the cache entry.  There can be multiple
   // readers.
   //
   // NOTE: If the transaction can only write, then the entry should not be in
   // use (since any existing entry should have already been doomed).
 
   if (entry->writer || entry->will_process_pending_queue) {
     entry->pending_queue.push_back(trans);
+    trans->PendOnEntry(entry);
+
     return ERR_IO_PENDING;
   }
 
   if (trans->mode() & Transaction::WRITE) {
     // transaction needs exclusive access to the entry
     if (entry->readers.empty()) {
       entry->writer = trans;
     } else {
       entry->pending_queue.push_back(trans);
       return ERR_IO_PENDING;
@@ skipping 127 matching lines @@
     return;  // have to wait
 
   entry->pending_queue.erase(entry->pending_queue.begin());
 
   AddTransactionToEntry(entry, next);
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net