OOPIF: Support session restore by combining/splitting frame states.

content/renderer/render_frame_impl.cc

 // Copyright 2013 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_frame_impl.h"
 
 #include <map>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 339 matching lines @@
 }
 
 bool IsBrowserInitiated(NavigationParams* pending) {
   // 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.
   return pending &&
          !pending->common_params.url.SchemeIs(url::kJavaScriptScheme);
 }
 
+bool IsHistoryNavigation(const PageState& page_state,
+                         const ExplodedFrameState& frame_state) {
+  if (SiteIsolationPolicy::UseSubframeNavigationEntries())
+    return frame_state.item_sequence_number != 0;
+
+  return page_state.IsValid();
+}
+
 NOINLINE void CrashIntentionally() {
   // NOTE(shess): Crash directly rather than using NOTREACHED() so
   // that the signature is easier to triage in crash reports.
   //
   // Linker's ICF feature may merge this function with other functions with the
   // same definition and it may confuse the crash report processing system.
   static int static_variable_to_make_this_function_unique = 0;
   base::debug::Alias(&static_variable_to_make_this_function_unique);
 
   volatile int* zero = nullptr;
@@ skipping 3870 matching lines @@
     if (entry) {
       params.page_state = HistoryEntryToPageState(entry);
       post_id = ExtractPostId(entry->root());
     } else {
       params.page_state = PageState::CreateFromURL(request.url());
     }
   } else {
     // In --site-per-process, just send a single HistoryItem for this frame,
     // rather than the whole tree.  It will be stored in the corresponding
     // FrameNavigationEntry.
-    params.page_state = SingleHistoryItemToPageState(item);
+    params.frame_state = HistoryItemToFrameState(item);
     post_id = ExtractPostId(item);
   }
   params.frame_unique_name = item.target().utf8();
   params.item_sequence_number = item.itemSequenceNumber();
   params.document_sequence_number = item.documentSequenceNumber();
 
   if (!frame->parent()) {
     // Top-level navigation.
 
     // Reset the zoom limits in case a plugin had changed them previously. This
@@ skipping 158 matching lines @@
   NavigateInternal(common_params, StartNavigationParams(), request_params,
                    stream_override.Pass());
 }
 
 void RenderFrameImpl::OnFailedNavigation(
     const CommonNavigationParams& common_params,
     const RequestNavigationParams& request_params,
     bool has_stale_copy_in_cache,
     int error_code) {
   bool is_reload = IsReload(common_params.navigation_type);
-  bool is_history_navigation = request_params.page_state.IsValid();
+  bool is_history_navigation = IsHistoryNavigation(request_params.page_state,
+                                                   request_params.frame_state);
   WebURLRequest::CachePolicy cache_policy =
       WebURLRequest::UseProtocolCachePolicy;
   RenderFrameImpl::PrepareRenderViewForNavigation(
       common_params.url, request_params, &is_reload, &cache_policy);
 
   GetContentClient()->SetActiveURL(common_params.url);
 
   pending_navigation_params_.reset(new NavigationParams(
       common_params, StartNavigationParams(), request_params));
 
@@ skipping 309 matching lines @@
     const StartNavigationParams& start_params,
     const RequestNavigationParams& request_params,
     scoped_ptr<StreamOverrideParameters> stream_params) {
   bool browser_side_navigation =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableBrowserSideNavigation);
 
   // Lower bound for browser initiated navigation start time.
   base::TimeTicks renderer_navigation_start = base::TimeTicks::Now();
   bool is_reload = IsReload(common_params.navigation_type);
-  bool is_history_navigation = request_params.page_state.IsValid();
+  bool is_history_navigation = IsHistoryNavigation(request_params.page_state,
+                                                   request_params.frame_state);
   WebURLRequest::CachePolicy cache_policy =
       WebURLRequest::UseProtocolCachePolicy;
   RenderFrameImpl::PrepareRenderViewForNavigation(
       common_params.url, request_params, &is_reload, &cache_policy);
 
   GetContentClient()->SetActiveURL(common_params.url);
 
   // If this frame isn't in the same process as the main frame, it may naively
   // assume that this is the first navigation in the iframe, but this may not
   // actually be the case. Inform the frame's state machine if this frame has
@@ skipping 65 matching lines @@
       request = frame_->requestForReload(load_type, override_url);
     }
     should_load_request = true;
   } else if (is_history_navigation) {
     // We must know the page ID of the page we are navigating back to.
     DCHECK_NE(request_params.page_id, -1);
     // We must know the nav entry ID of the page we are navigating back to,
     // which should be the case because history navigations are routed via the
     // browser.
     DCHECK_NE(0, request_params.nav_entry_id);
-    scoped_ptr<HistoryEntry> entry =
-        PageStateToHistoryEntry(request_params.page_state);
-    if (entry) {
-      // Ensure we didn't save the swapped out URL in UpdateState, since the
-      // browser should never be telling us to navigate to swappedout://.
-      CHECK(entry->root().urlString() != WebString::fromUTF8(kSwappedOutURL));
 
-      if (!browser_side_navigation) {
-        scoped_ptr<NavigationParams> navigation_params(
-            new NavigationParams(*pending_navigation_params_.get()));
-        if (!SiteIsolationPolicy::UseSubframeNavigationEntries()) {
+    scoped_ptr<NavigationParams> navigation_params(
+        new NavigationParams(*pending_navigation_params_.get()));
+
+    if (SiteIsolationPolicy::UseSubframeNavigationEntries() &&
+        !browser_side_navigation) {
+      // In --site-per-process, the browser process sends a WebHistoryItem
+      // destined for this frame.
+      SetPendingNavigationParams(navigation_params.Pass());
+      blink::WebHistoryItem history_item =
+          FrameStateToHistoryItem(request_params.frame_state);
+      blink::WebHistoryLoadType load_type =
+          request_params.is_same_document_history_load
+              ? blink::WebHistorySameDocumentLoad
+              : blink::WebHistoryDifferentDocumentLoad;
+
+      // Navigate the frame directly.
+      // TODO(creis): Use InitialHistoryLoad rather than BackForward for a
+      // history navigation in a newly created subframe.
+      WebURLRequest request =
+          frame_->requestFromHistoryItem(history_item, cache_policy);
+      frame_->load(request, blink::WebFrameLoadType::BackForward, history_item,
+                   load_type);
+    } else {
+      scoped_ptr<HistoryEntry> entry =
+          PageStateToHistoryEntry(request_params.page_state);
+      if (entry) {
+        // Ensure we didn't save the swapped out URL in UpdateState, since the
+        // browser should never be telling us to navigate to swappedout://.
+        CHECK(entry->root().urlString() != WebString::fromUTF8(kSwappedOutURL));
+
+        if (!browser_side_navigation) {
           // By default, tell the HistoryController to go the deserialized
           // HistoryEntry.  This only works if all frames are in the same
           // process.
           DCHECK(!frame_->parent());
           render_view_->history_controller()->GoToEntry(
               frame_, entry.Pass(), navigation_params.Pass(), cache_policy);
         } else {
-          // In --site-per-process, the browser process sends a single
-          // WebHistoryItem destined for this frame.
-          // TODO(creis): Change PageState to FrameState.  In the meantime, we
-          // store the relevant frame's WebHistoryItem in the root of the
-          // PageState.
-          SetPendingNavigationParams(navigation_params.Pass());
-          blink::WebHistoryItem history_item = entry->root();
-          blink::WebHistoryLoadType load_type =
-              request_params.is_same_document_history_load
-                  ? blink::WebHistorySameDocumentLoad
-                  : blink::WebHistoryDifferentDocumentLoad;
-
-          // Navigate the frame directly.
-          // TODO(creis): Use InitialHistoryLoad rather than BackForward for a
-          // history navigation in a newly created subframe.
-          WebURLRequest request =
-              frame_->requestFromHistoryItem(history_item, cache_policy);
-          frame_->load(request, blink::WebFrameLoadType::BackForward,
-                       history_item, load_type);
+          // TODO(clamy): this should be set to the HistoryItem sent by the
+          // browser once the HistoryController has moved to the browser.
+          // TODO(clamy): distinguish between different document and same
+          // document
+          // loads.
+          // TODO(clamy): update this for subframes history loads.
+          item_for_history_navigation =
+              entry->GetHistoryNodeForFrame(this)->item();
+          load_type = blink::WebFrameLoadType::BackForward;
+          should_load_request = true;
         }
-      } else {
-        // TODO(clamy): this should be set to the HistoryItem sent by the
-        // browser once the HistoryController has moved to the browser.
-        // TODO(clamy): distinguish between different document and same document
-        // loads.
-        // TODO(clamy): update this for subframes history loads.
-        item_for_history_navigation =
-            entry->GetHistoryNodeForFrame(this)->item();
-        load_type = blink::WebFrameLoadType::BackForward;
-        should_load_request = true;
       }
     }
   } else {
     // Navigate to the given URL.
     if (!start_params.extra_headers.empty() && !browser_side_navigation) {
       for (net::HttpUtil::HeadersIterator i(start_params.extra_headers.begin(),
                                             start_params.extra_headers.end(),
                                             "\n");
            i.GetNext();) {
         request.addHTTPHeaderField(WebString::fromUTF8(i.name()),
@@ skipping 294 matching lines @@
                  << params.url.possibly_invalid_spec();
   }
 }
 
 void RenderFrameImpl::SendUpdateState() {
   DCHECK(SiteIsolationPolicy::UseSubframeNavigationEntries());
   if (current_history_item_.isNull())
     return;
 
   Send(new FrameHostMsg_UpdateState(
-      routing_id_, SingleHistoryItemToPageState(current_history_item_)));
+      routing_id_, HistoryItemToFrameState(current_history_item_)));
 }
 
 void RenderFrameImpl::SendFailedProvisionalLoad(
     const blink::WebURLRequest& request,
     const blink::WebURLError& error,
     blink::WebLocalFrame* frame) {
   bool show_repost_interstitial =
       (error.reason == net::ERR_CACHE_MISS &&
        base::EqualsASCII(base::StringPiece16(request.httpMethod()), "POST"));
 
@@ skipping 65 matching lines @@
     // 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(pending_navigation_params_->common_params.navigation_type))
+  if (IsReload(pending_navigation_params_->common_params.navigation_type)) {
     document_state->set_load_type(DocumentState::RELOAD);
-  else if (pending_navigation_params_->request_params.page_state.IsValid())
+  } else if (IsHistoryNavigation(
+               pending_navigation_params_->request_params.page_state,
+               pending_navigation_params_->request_params.frame_state)) {
     document_state->set_load_type(DocumentState::HISTORY_LOAD);
-  else
+  } else {
     document_state->set_load_type(DocumentState::NORMAL_LOAD);
+  }
 
   internal_data->set_is_overriding_user_agent(
       pending_navigation_params_->request_params.is_overriding_user_agent);
   internal_data->set_must_reset_scroll_and_scale_state(
       pending_navigation_params_->common_params.navigation_type ==
       FrameMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL);
   document_state->set_can_load_local_resources(
       pending_navigation_params_->request_params.can_load_local_resources);
 }
 
@@ skipping 183 matching lines @@
       media::ConvertToSwitchOutputDeviceCB(web_callbacks);
   scoped_refptr<media::AudioOutputDevice> device =
       AudioDeviceFactory::NewOutputDevice(routing_id_, 0, sink_id.utf8(),
                                           security_origin);
   media::OutputDeviceStatus status = device->GetDeviceStatus();
   device->Stop();
   callback.Run(status);
 }
 
 }  // namespace content