Cache failover to LOAD_PREFERRING_CACHE if network response suggests offline.

net/http/http_response_info.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_response_info.h"
 
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/time.h"
 #include "net/base/auth.h"
@@ skipping 63 matching lines @@
   RESPONSE_INFO_WAS_PROXY = 1 << 15,
 
   // This bit is set if the response info has an SSL connection status field.
   // This contains the ciphersuite used to fetch the resource as well as the
   // protocol version, compression method and whether SSLv3 fallback was used.
   RESPONSE_INFO_HAS_SSL_CONNECTION_STATUS = 1 << 16,
 
   // This bit is set if the response info has protocol version.
   RESPONSE_INFO_HAS_NPN_NEGOTIATED_PROTOCOL = 1 << 17,
 
+  // This bit is set if the request was overriden from cache due to
+  // various load flags being set.
+  RESPONSE_INFO_WAS_CACHE_OVERRIDE = 1 << 18,

[rvargas (doing something else), 2013/03/05 02:58:19]

This enum is for storing info about this response on the storage, i.e. for stuff
that tells us something about what we have stored in the cache (as opposed to a
property of how we are fulfilling a request).

[Randy Smith (Not in Mondays), 2013/03/05 23:16:14]

The enum was used for pickling and unpickling.  If you're sure we'll never need
to get this info from an HttpResponseInfo that's been persisted, I'll yank out
references to the enum; it just seems weird to me for a bit not to survive
persisting.

[rvargas (doing something else), 2013/03/06 03:11:48]

But we don't really want to persist this flag. That would mean that after
returning content from from the cache (offline), the entry would change on disk
saying that the flag was set... and we would be reading that flag again later.

[Randy Smith (Not in Mondays), 2013/03/06 22:55:55]

Done.

+
   // TODO(darin): Add other bits to indicate alternate request methods.
   // For now, we don't support storing those.
 };
 
 HttpResponseInfo::HttpResponseInfo()
     : was_cached(false),
       was_fetched_via_spdy(false),
       was_npn_negotiated(false),
-      was_fetched_via_proxy(false) {
+      was_fetched_via_proxy(false),
+      was_cache_override(false) {
 }
 
 HttpResponseInfo::HttpResponseInfo(const HttpResponseInfo& rhs)
     : was_cached(rhs.was_cached),
       was_fetched_via_spdy(rhs.was_fetched_via_spdy),
       was_npn_negotiated(rhs.was_npn_negotiated),
       was_fetched_via_proxy(rhs.was_fetched_via_proxy),
+      was_cache_override(rhs.was_cache_override),
       socket_address(rhs.socket_address),
       npn_negotiated_protocol(rhs.npn_negotiated_protocol),
       request_time(rhs.request_time),
       response_time(rhs.response_time),
       auth_challenge(rhs.auth_challenge),
       cert_request_info(rhs.cert_request_info),
       ssl_info(rhs.ssl_info),
       headers(rhs.headers),
       vary_data(rhs.vary_data),
       metadata(rhs.metadata) {
 }
 
 HttpResponseInfo::~HttpResponseInfo() {
 }
 
 HttpResponseInfo& HttpResponseInfo::operator=(const HttpResponseInfo& rhs) {
   was_cached = rhs.was_cached;
   was_fetched_via_spdy = rhs.was_fetched_via_spdy;
   was_npn_negotiated = rhs.was_npn_negotiated;
   was_fetched_via_proxy = rhs.was_fetched_via_proxy;
+  was_cache_override = rhs.was_cache_override;
   socket_address = rhs.socket_address;
   npn_negotiated_protocol = rhs.npn_negotiated_protocol;
   request_time = rhs.request_time;
   response_time = rhs.response_time;
   auth_challenge = rhs.auth_challenge;
   cert_request_info = rhs.cert_request_info;
   ssl_info = rhs.ssl_info;
   headers = rhs.headers;
   vary_data = rhs.vary_data;
   metadata = rhs.metadata;
@@ skipping 84 matching lines @@
     if (!pickle.ReadString(&iter, &npn_negotiated_protocol))
       return false;
   }
 
   was_fetched_via_spdy = (flags & RESPONSE_INFO_WAS_SPDY) != 0;
 
   was_npn_negotiated = (flags & RESPONSE_INFO_WAS_NPN) != 0;
 
   was_fetched_via_proxy = (flags & RESPONSE_INFO_WAS_PROXY) != 0;
 
+  was_cache_override = (flags & RESPONSE_INFO_WAS_CACHE_OVERRIDE) != 0;
+
   *response_truncated = (flags & RESPONSE_INFO_TRUNCATED) != 0;
 
   return true;
 }
 
 void HttpResponseInfo::Persist(Pickle* pickle,
                                bool skip_transient_headers,
                                bool response_truncated) const {
   int flags = RESPONSE_INFO_VERSION;
   if (ssl_info.is_valid()) {
     flags |= RESPONSE_INFO_HAS_CERT;
     flags |= RESPONSE_INFO_HAS_CERT_STATUS;
     if (ssl_info.security_bits != -1)
       flags |= RESPONSE_INFO_HAS_SECURITY_BITS;
     if (ssl_info.connection_status != 0)
       flags |= RESPONSE_INFO_HAS_SSL_CONNECTION_STATUS;
   }
   if (vary_data.is_valid())
     flags |= RESPONSE_INFO_HAS_VARY_DATA;
   if (response_truncated)
     flags |= RESPONSE_INFO_TRUNCATED;
   if (was_fetched_via_spdy)
     flags |= RESPONSE_INFO_WAS_SPDY;
   if (was_npn_negotiated) {
     flags |= RESPONSE_INFO_WAS_NPN;
     flags |= RESPONSE_INFO_HAS_NPN_NEGOTIATED_PROTOCOL;
   }
   if (was_fetched_via_proxy)
     flags |= RESPONSE_INFO_WAS_PROXY;
+  if (was_cache_override)
+    flags |= RESPONSE_INFO_WAS_CACHE_OVERRIDE;
 
   pickle->WriteInt(flags);
   pickle->WriteInt64(request_time.ToInternalValue());
   pickle->WriteInt64(response_time.ToInternalValue());
 
   net::HttpResponseHeaders::PersistOptions persist_options =
       net::HttpResponseHeaders::PERSIST_RAW;
 
   if (skip_transient_headers) {
     persist_options =
@@ skipping 20 matching lines @@
     vary_data.Persist(pickle);
 
   pickle->WriteString(socket_address.host());
   pickle->WriteUInt16(socket_address.port());
 
   if (was_npn_negotiated)
     pickle->WriteString(npn_negotiated_protocol);
 }
 
 }  // namespace net