Override cache policy when changing a reload to a back/forward navigation.

content/renderer/render_view_impl.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 "content/renderer/render_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/auto_reset.h"
@@ skipping 1342 matching lines @@
 }
 
 void RenderViewImpl::OnNavigate(const ViewMsg_Navigate_Params& params) {
   MaybeHandleDebugURL(params.url);
   if (!webview())
     return;
 
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, Navigate(params.url));
 
   bool is_reload = IsReload(params);
+  WebURLRequest::CachePolicy cache_policy =
+      WebURLRequest::UseProtocolCachePolicy;
 
   // If this is a stale back/forward (due to a recent navigation the browser
   // didn't know about), ignore it.
   if (IsBackForwardToStaleEntry(params, is_reload))
     return;
 
   // Swap this renderer back in if necessary.
   if (is_swapped_out_) {
     // We marked the view as hidden when swapping the view out, so be sure to
     // reset the visibility state before navigating to the new URL.
     webview()->setVisibilityState(visibilityState(), false);
 
     // If this is an attempt to reload while we are swapped out, we should not
     // reload swappedout://, but the previous page, which is stored in
     // params.state.  Setting is_reload to false will treat this like a back
     // navigation to accomplish that.
     is_reload = false;
+    cache_policy = WebURLRequest::ReloadIgnoringCacheData;
 
     // We refresh timezone when a view is swapped in since timezone
     // can get out of sync when the system timezone is updated while
     // the view is swapped out.
     NotifyTimezoneChange(webview()->mainFrame());
 
     SetSwappedOut(false);
   }
 
   if (params.should_clear_history_list) {
@@ skipping 13 matching lines @@
 
   WebFrame* frame = webview()->mainFrame();
   if (!params.frame_to_navigate.empty()) {
     frame = webview()->findFrameByName(
         WebString::fromUTF8(params.frame_to_navigate));
     CHECK(frame) << "Invalid frame name passed: " << params.frame_to_navigate;
   }
 
   if (is_reload && frame->currentHistoryItem().isNull()) {
     // We cannot reload if we do not have any history state.  This happens, for
-    // example, when recovering from a crash.  Our workaround here is a bit of
-    // a hack since it means that reload after a crashed tab does not cause an
-    // end-to-end cache validation.
+    // example, when recovering from a crash.
     is_reload = false;
+    cache_policy = WebURLRequest::ReloadIgnoringCacheData;

[darin (slow to review), 2014/01/07 07:39:59]

good fix for that old bug.

   }
 
   pending_navigation_params_.reset(new ViewMsg_Navigate_Params(params));
 
   // If we are reloading, then WebKit will use the history state of the current
   // page, so we should just ignore any given history state.  Otherwise, if we
   // have history state, then we need to navigate to it, which corresponds to a
   // back/forward navigation event.
   if (is_reload) {
     bool reload_original_url =
         (params.navigation_type ==
             ViewMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL);
     bool ignore_cache = (params.navigation_type ==
                              ViewMsg_Navigate_Type::RELOAD_IGNORING_CACHE);
 
     if (reload_original_url)
       frame->reloadWithOverrideURL(params.url, true);
     else
       frame->reload(ignore_cache);
   } else if (params.page_state.IsValid()) {
     // We must know the page ID of the page we are navigating back to.
     DCHECK_NE(params.page_id, -1);
     WebHistoryItem item = PageStateToHistoryItem(params.page_state);
     if (!item.isNull()) {
       // Ensure we didn't save the swapped out URL in UpdateState, since the
       // browser should never be telling us to navigate to swappedout://.
       CHECK(item.urlString() != WebString::fromUTF8(kSwappedOutURL));
-      frame->loadHistoryItem(item);
+      frame->loadHistoryItem(item, cache_policy);
     }
   } else if (!params.base_url_for_data_url.is_empty()) {
     // A loadData request with a specified base URL.
     std::string mime_type, charset, data;
     if (net::DataURL::Parse(params.url, &mime_type, &charset, &data)) {
       frame->loadData(
           WebData(data.c_str(), data.length()),
           WebString::fromUTF8(mime_type),
           WebString::fromUTF8(charset),
           params.base_url_for_data_url,
@@ skipping 1990 matching lines @@
   InternalDocumentStateData* internal_data =
       InternalDocumentStateData::FromDocumentState(document_state);
 
   if (!params.url.SchemeIs(kJavaScriptScheme) &&
       params.navigation_type == ViewMsg_Navigate_Type::RESTORE) {
     // We're doing a load of a page that was restored from the last session. By
     // default this prefers the cache over loading (LOAD_PREFERRING_CACHE) which
     // can result in stale data for pages that are set to expire. We explicitly
     // override that by setting the policy here so that as necessary we load
     // from the network.
+    //
+    // TODO(davidben): Remove this in favor of passing a cache policy to the
+    // loadHistoryItem call in OnNavigate. That requires not overloading
+    // UseProtocolCachePolicy to mean both "normal load" and "determine cache
+    // policy based on load type, etc".
     internal_data->set_cache_policy_override(
         WebURLRequest::UseProtocolCachePolicy);
   }
 
   if (IsReload(params))
     document_state->set_load_type(DocumentState::RELOAD);
   else if (params.page_state.IsValid())
     document_state->set_load_type(DocumentState::HISTORY_LOAD);
   else
     document_state->set_load_type(DocumentState::NORMAL_LOAD);
@@ skipping 2983 matching lines @@
   for (size_t i = 0; i < icon_urls.size(); i++) {
     WebURL url = icon_urls[i].iconURL();
     if (!url.isEmpty())
       urls.push_back(FaviconURL(url,
                                 ToFaviconType(icon_urls[i].iconType())));
   }
   SendUpdateFaviconURL(urls);
 }
 
 }  // namespace content