Changes session restore to use a normal load rather than preferring...

chrome/renderer/render_view.cc

 // Copyright (c) 2009 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 "chrome/renderer/render_view.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 702 matching lines @@
   if (!webview())
     return;
 
   if (devtools_agent_.get())
     devtools_agent_->OnNavigate();
 
   child_process_logging::SetActiveURL(params.url);
 
   AboutHandler::MaybeHandle(params.url);
 
-  bool is_reload = params.reload;
+  bool is_reload = (params.navigation_type == ViewMsg_Navigate_Params::RELOAD);
 
   WebFrame* main_frame = webview()->mainFrame();
   if (is_reload && main_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.
     is_reload = false;
   }
 
   // A navigation resulting from loading a javascript URL should not be treated
   // as a browser initiated event.  Instead, we want it to look as if the page
   // initiated any load resulting from JS execution.
   if (!params.url.SchemeIs(chrome::kJavaScriptScheme)) {
-    pending_navigation_state_.reset(NavigationState::CreateBrowserInitiated(
-        params.page_id, params.transition, params.request_time));
+    NavigationState* state = NavigationState::CreateBrowserInitiated(
+        params.page_id, params.transition, params.request_time);
+    if (params.navigation_type == ViewMsg_Navigate_Params::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.
+      state->set_cache_policy_override(WebURLRequest::UseProtocolCachePolicy);
+    }
+    pending_navigation_state_.reset(state);
   }
 
   // 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) {
     main_frame->reload();
   } else if (!params.state.empty()) {
     // We must know the page ID of the page we are navigating back to.
@@ skipping 1570 matching lines @@
 }
 
 void RenderView::assignIdentifierToRequest(
     WebFrame* frame, unsigned identifier, const WebURLRequest& request) {
   // Ignore
 }
 
 void RenderView::willSendRequest(
     WebFrame* frame, unsigned identifier, WebURLRequest& request,
     const WebURLResponse& redirect_response) {
+  WebFrame* top_frame = frame->top();
+  if (!top_frame)
+    top_frame = frame;
+  WebDataSource* data_source = top_frame->provisionalDataSource();
+  if (!data_source)
+    data_source = top_frame->dataSource();
+  if (data_source) {
+    NavigationState* state = NavigationState::FromDataSource(data_source);
+    if (state && state->is_cache_policy_override_set())
+      request.setCachePolicy(state->cache_policy_override());
+  }
   request.setRequestorID(routing_id_);
 }
 
 void RenderView::didReceiveResponse(
     WebFrame* frame, unsigned identifier, const WebURLResponse& response) {
   // Consider loading an alternate error page for 404 responses.
   if (response.httpStatusCode() != 404)
     return;
 
   // Only do this for responses that correspond to a provisional data source
@@ skipping 1363 matching lines @@
       new PluginMsg_SignalModalDialogEvent(host_window_));
 
   message->EnableMessagePumping();  // Runs a nested message loop.
   bool rv = Send(message);
 
   PluginChannelHost::Broadcast(
       new PluginMsg_ResetModalDialogEvent(host_window_));
 
   return rv;
 }