Http Cache: Add code for simulating an infinite HTTP cache.

net/http/http_cache_transaction.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/http_cache_transaction.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 96 matching lines @@
         return true;
     }
   }
   return false;
 }
 
 //-----------------------------------------------------------------------------
 
 HttpCache::Transaction::Transaction(
     HttpCache* cache,
-    HttpTransactionDelegate* transaction_delegate)
+    HttpTransactionDelegate* transaction_delegate,
+    InfiniteCacheTransaction* infinite_cache_transaction)
     : next_state_(STATE_NONE),
       request_(NULL),
       cache_(cache->AsWeakPtr()),
       entry_(NULL),
       new_entry_(NULL),
       network_trans_(NULL),
+      infinite_cache_transaction_(infinite_cache_transaction),
       new_response_(NULL),
       mode_(NONE),
       target_state_(STATE_NONE),
       reading_(false),
       invalid_range_(false),
       truncated_(false),
       is_sparse_(false),
       range_requested_(false),
       handling_206_(false),
       cache_pending_(false),
@@ skipping 70 matching lines @@
   if (partial_.get() && !truncated_)
     return true;
 
   if (!CanResume(true))
     return false;
 
   // We may have received the whole resource already.
   if (done_reading_)
     return true;
 
+  if (infinite_cache_transaction_.get())
+    infinite_cache_transaction_->OnTruncatedResponse();
+
   truncated_ = true;
   target_state_ = STATE_NONE;
   next_state_ = STATE_CACHE_WRITE_TRUNCATED_RESPONSE;
   DoLoop(OK);
   return true;
 }
 
 LoadState HttpCache::Transaction::GetWriterLoadState() const {
   if (network_trans_.get())
     return network_trans_->GetLoadState();
@@ skipping 15 matching lines @@
   // Ensure that we only have one asynchronous call at a time.
   DCHECK(callback_.is_null());
   DCHECK(!reading_);
   DCHECK(!network_trans_.get());
   DCHECK(!entry_);
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
   SetRequest(net_log, request);
+  if (infinite_cache_transaction_.get()) {
+    if ((effective_load_flags_ & LOAD_BYPASS_CACHE) ||
+        (effective_load_flags_ & LOAD_ONLY_FROM_CACHE) ||
+        (effective_load_flags_ & LOAD_DISABLE_CACHE) ||
+        (effective_load_flags_ & LOAD_VALIDATE_CACHE) ||
+        (effective_load_flags_ & LOAD_PREFERRING_CACHE) ||
+        partial_.get()) {
+      infinite_cache_transaction_.reset();
+    } else {
+      infinite_cache_transaction_->OnRequestStart(request);
+    }
+  }
 
   // We have to wait until the backend is initialized so we start the SM.
   next_state_ = STATE_GET_BACKEND;
   int rv = DoLoop(OK);
 
   // Setting this here allows us to check for the existence of a callback_ to
   // determine if we are still inside Start.
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
@@ skipping 518 matching lines @@
     DCHECK(response);
     response_.cert_request_info = response->cert_request_info;
   }
   return result;
 }
 
 // We received the response headers and there is no error.
 int HttpCache::Transaction::DoSuccessfulSendRequest() {
   DCHECK(!new_response_);
   const HttpResponseInfo* new_response = network_trans_->GetResponseInfo();
+  if (infinite_cache_transaction_.get())
+    infinite_cache_transaction_->OnResponseReceived(new_response);
+
   if (new_response->headers->response_code() == 401 ||
       new_response->headers->response_code() == 407) {
     auth_response_ = *new_response;
     return OK;
   }
 
   new_response_ = new_response;
   if (!ValidatePartialResponse() && !auth_response_.headers) {
     // Something went wrong with this request and we have to restart it.
     // If we have an authentication response, we are exposed to weird things
@@ skipping 56 matching lines @@
   DCHECK(mode_ & WRITE || mode_ == NONE);
 
   ReportNetworkActionFinish();
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
   if (result > 0)
     bytes_read_from_network_ += result;
 
+  if (infinite_cache_transaction_.get())
+    infinite_cache_transaction_->OnDataRead(read_buf_->data(), result);
+
   // If there is an error or we aren't saving the data, we are done; just wait
   // until the destructor runs to see if we can keep the data.
   if (mode_ == NONE || result < 0)
     return result;
 
   next_state_ = STATE_CACHE_WRITE_DATA;
   return result;
 }
 
 int HttpCache::Transaction::DoInitEntry() {
@@ skipping 515 matching lines @@
   if (!cache_)
     return ERR_UNEXPECTED;
 
   return ValidateEntryHeadersAndContinue();
 }
 
 int HttpCache::Transaction::DoCacheReadData() {
   DCHECK(entry_);
   next_state_ = STATE_CACHE_READ_DATA_COMPLETE;
 
+  if (infinite_cache_transaction_.get())
+    infinite_cache_transaction_->OnServedFromCache();
+
   if (net_log_.IsLoggingAllEvents())
     net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_DATA);
   ReportCacheActionStart();
   if (partial_.get()) {
     return partial_->CacheRead(entry_->disk_entry, read_buf_, io_buf_len_,
                                io_callback_);
   }
 
   return entry_->disk_entry->ReadData(kResponseContentIndex, read_offset_,
                                       read_buf_, io_buf_len_, io_callback_);
@@ skipping 970 matching lines @@
             before_send_percent);
       }
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 }  // namespace net