Allow automatic use of stale cache entries if site is unreachable.

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 128 matching lines @@
       target_state_(STATE_NONE),
       reading_(false),
       invalid_range_(false),
       truncated_(false),
       is_sparse_(false),
       range_requested_(false),
       handling_206_(false),
       cache_pending_(false),
       done_reading_(false),
       vary_mismatch_(false),
+      couldnt_conditionalize_request_(false),
       io_buf_len_(0),
       read_offset_(0),
       effective_load_flags_(0),
       write_len_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(
           base::Bind(&Transaction::OnIOComplete,
                      weak_factory_.GetWeakPtr()))),
       transaction_pattern_(PATTERN_UNDEFINED),
       bytes_read_from_cache_(0),
@@ skipping 34 matching lines @@
     }
   }
 
   // Cancel any outstanding callbacks before we drop our reference to the
   // HttpCache.  This probably isn't strictly necessary, but might as well.
   weak_factory_.InvalidateWeakPtrs();
 
   // We could still have a cache read or write in progress, so we just null the
   // cache_ pointer to signal that we are dead.  See DoCacheReadCompleted.
   cache_.reset();
+
+#if !defined(NDEBUG)
+  // Dump the state transitions.
+  DumpStatePath();
+#endif
 }
 
 int HttpCache::Transaction::WriteMetadata(IOBuffer* buf, int buf_len,
                                           const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
   DCHECK(!callback.is_null());
   if (!cache_ || !entry_)
     return ERR_UNEXPECTED;
 
@@ skipping 343 matching lines @@
 //
 //   Read() 3:
 //   CacheReadData* -> StartPartialCacheValidation ->
 //   CompletePartialCacheValidation -> BeginCacheValidation() -> SendRequest* ->
 //   SuccessfulSendRequest -> UpdateCachedResponse* -> OverwriteCachedResponse
 //   -> PartialHeadersReceived -> NetworkRead* -> CacheWriteData*
 //
 int HttpCache::Transaction::DoLoop(int result) {
   DCHECK(next_state_ != STATE_NONE);
 
+
   int rv = result;
   do {
+    state_path_.push_back(next_state_);
+
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
       case STATE_GET_BACKEND:
         DCHECK_EQ(OK, rv);
         rv = DoGetBackend();
         break;
       case STATE_GET_BACKEND_COMPLETE:
         rv = DoGetBackendComplete(rv);
         break;
@@ skipping 226 matching lines @@
   rv = network_trans_->Start(request_, io_callback_, net_log_);
   return rv;
 }
 
 int HttpCache::Transaction::DoSendRequestComplete(int result) {
   ReportNetworkActionFinish();
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
+  // If requested, and we have a readable cache entry, and we have
+  // an error indicating that we're offline as opposed to in contact
+  // with a bad server, read from cache anyway.
+  if (effective_load_flags_  & LOAD_CACHE_RETURN_IF_OFFLINE &&
+      mode_ == READ_WRITE && entry_ && !partial_ && result != OK) {
+    switch (result) {
+      // Errors that mean we didn't have a connection to the host.
+      // Go ahead and read from the cache anyway.
+      case ERR_NAME_NOT_RESOLVED:
+      case ERR_INTERNET_DISCONNECTED:
+      case ERR_ADDRESS_UNREACHABLE:
+      case ERR_CONNECTION_TIMED_OUT:
+        network_trans_.reset();
+        cache_->ConvertWriterToReader(entry_);
+        mode_ = READ;
+
+        // If there is metadata, read it.  Otherwise, we're done.
+        if (entry_->disk_entry->GetDataSize(kMetadataIndex))
+          next_state_ = STATE_CACHE_READ_METADATA;
+        return OK;
+      default:
+        break;
+    }
+  }
+
+  // If we tried to conditionalize the request and failed, we know
+  // we won't be reading from the cache after this point.
+  if (couldnt_conditionalize_request_)
+    mode_ = WRITE;
+
   if (result == OK) {
     next_state_ = STATE_SUCCESSFUL_SEND_REQUEST;
     return OK;
   }
 
   // Do not record requests that have network errors or restarts.
   UpdateTransactionPattern(PATTERN_NOT_COVERED);
   if (IsCertificateError(result)) {
     const HttpResponseInfo* response = network_trans_->GetResponseInfo();
     // If we get a certificate error, then there is a certificate in ssl_info,
@@ skipping 66 matching lines @@
 
   if (mode_ != NONE && request_->method == "POST" &&
       NonErrorResponse(new_response->headers->response_code())) {
     cache_->DoomMainEntryForUrl(request_->url);
   }
 
   // Are we expecting a response to a conditional query?
   if (mode_ == READ_WRITE || mode_ == UPDATE) {
     if (new_response->headers->response_code() == 304 || handling_206_) {
       UpdateTransactionPattern(PATTERN_ENTRY_VALIDATED);
+      // TODO(rdsmith): we just 304ed, so we have good data, but now we
+      // are falling into this update state cos we want the new headers
+      // and the freshness they can give us.
       next_state_ = STATE_UPDATE_CACHED_RESPONSE;
       return OK;
     }
     UpdateTransactionPattern(PATTERN_ENTRY_UPDATED);
     mode_ = WRITE;
   }
 
   next_state_ = STATE_OVERWRITE_CACHED_RESPONSE;
   return OK;
 }
@@ skipping 874 matching lines @@
     mode_ = READ;
 
     if (entry_->disk_entry->GetDataSize(kMetadataIndex))
       next_state_ = STATE_CACHE_READ_METADATA;
   } else {
     // Make the network request conditional, to see if we may reuse our cached
     // response.  If we cannot do so, then we just resort to a normal fetch.
     // Our mode remains READ_WRITE for a conditional request.  We'll switch to
     // either READ or WRITE mode once we hear back from the server.
     if (!ConditionalizeRequest()) {
+      couldnt_conditionalize_request_ = true;
       UpdateTransactionPattern(PATTERN_ENTRY_CANT_CONDITIONALIZE);
       if (partial_.get())
         return DoRestartPartialRequest();
 
       DCHECK_NE(206, response_.headers->response_code());
-      mode_ = WRITE;
+      // We don't want to switch mode to WRITE here as in offline
+      // mode we may still need to read from the cache.  Instead
+      // we record and test on whether we could conditionalize the
+      // request.
     }
     next_state_ = STATE_SEND_REQUEST;
   }
   return OK;
 }
 
 int HttpCache::Transaction::BeginPartialCacheValidation() {
   DCHECK(mode_ == READ_WRITE);
 
   if (response_.headers->response_code() != 206 && !partial_.get() &&
@@ skipping 746 matching lines @@
   }
 }
 
 int HttpCache::Transaction::ResetCacheIOStart(int return_value) {
   DCHECK(cache_io_start_.is_null());
   if (return_value == ERR_IO_PENDING)
     cache_io_start_ = base::TimeTicks::Now();
   return return_value;
 }
 
+#if !defined(NDEBUG)
+
+// This list must be kept in sync with the HttpCache::Transaction::State enum.
+
+static const char *state_names[] = {
+  "NONE",
+  "GET_BACKEND",
+  "GET_BACKEND_COMPLETE",
+  "SEND_REQUEST",
+  "SEND_REQUEST_COMPLETE",
+  "SUCCESSFUL_SEND_REQUEST",
+  "NETWORK_READ",
+  "NETWORK_READ_COMPLETE",
+  "INIT_ENTRY",
+  "OPEN_ENTRY",
+  "OPEN_ENTRY_COMPLETE",
+  "CREATE_ENTRY",
+  "CREATE_ENTRY_COMPLETE",
+  "DOOM_ENTRY",
+  "DOOM_ENTRY_COMPLETE",
+  "ADD_TO_ENTRY",
+  "ADD_TO_ENTRY_COMPLETE",
+  "ADD_TO_ENTRY_COMPLETE_AFTER_DELAY",
+  "START_PARTIAL_CACHE_VALIDATION",
+  "COMPLETE_PARTIAL_CACHE_VALIDATION",
+  "UPDATE_CACHED_RESPONSE",
+  "UPDATE_CACHED_RESPONSE_COMPLETE",
+  "OVERWRITE_CACHED_RESPONSE",
+  "TRUNCATE_CACHED_DATA",
+  "TRUNCATE_CACHED_DATA_COMPLETE",
+  "TRUNCATE_CACHED_METADATA",
+  "TRUNCATE_CACHED_METADATA_COMPLETE",
+  "PARTIAL_HEADERS_RECEIVED",
+  "CACHE_READ_RESPONSE",
+  "CACHE_READ_RESPONSE_COMPLETE",
+  "CACHE_WRITE_RESPONSE",
+  "CACHE_WRITE_TRUNCATED_RESPONSE",
+  "CACHE_WRITE_RESPONSE_COMPLETE",
+  "CACHE_READ_METADATA",
+  "CACHE_READ_METADATA_COMPLETE",
+  "CACHE_QUERY_DATA",
+  "CACHE_QUERY_DATA_COMPLETE",
+  "CACHE_READ_DATA",
+  "CACHE_READ_DATA_COMPLETE",
+  "CACHE_WRITE_DATA",
+  "CACHE_WRITE_DATA_COMPLETE",
+};
+
+
+void HttpCache::Transaction::DumpStatePath() {
+  std::string entry_path;
+  for (std::vector<int>::const_iterator it = state_path_.begin();
+       it != state_path_.end(); ++it) {
+    if (it != state_path_.begin())
+      entry_path += " -> ";
+    entry_path += state_names[*it];
+  }
+  LOG(WARNING) << "Path state transitions for " << cache_key_
+               << ": " << entry_path;
+}
+
+#endif
+
 }  // namespace net