DRAFT CL: Add FrameNavigationEntry and track subframe session histories.

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 1110 matching lines @@
       frame->reload(ignore_cache);
   } else if (is_history_navigation) {
     // We must know the page ID of the page we are navigating back to.
     DCHECK_NE(history_params.page_id, -1);
     scoped_ptr<HistoryEntry> entry =
         PageStateToHistoryEntry(history_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));
-      render_view_->history_controller()->GoToEntry(entry.Pass(), cache_policy);
+
+      // TODO(creis): Remove this HistoryEntry hack.  We need it to find the
+      // frame sequence number when swapping a remote frame back to local.
+      RenderFrameProxy* proxy =
+          RenderFrameProxy::FromRoutingID(proxy_routing_id_);
+      if (proxy)
+        HistoryEntry::UpdateFrameMap(proxy_routing_id_, routing_id_);
+
+      // TODO(creis): Same vs different document load.
+      // TODO(creis): Change PageState to FrameState.  In the meantime, we store
+      // the relevant frame's HistoryItem in the root of the PageState.
+      blink::WebHistoryItem history_item = entry->root();
+      frame->loadHistoryItem(history_item,
+                             blink::WebHistoryDifferentDocumentLoad,
+                             cache_policy);
     }
   } else if (!common_params.base_url_for_data_url.is_empty()) {
     LoadDataURL(common_params, frame);
   } else {
     // Navigate to the given URL.
     WebURLRequest request = CreateURLRequestForNavigation(
         common_params, scoped_ptr<StreamOverrideParameters>(),
         frame->isViewSourceModeEnabled());
 
     if (!start_params.extra_headers.empty()) {
@@ skipping 150 matching lines @@
   if (is_main_frame)
     render_view_->suppress_dialogs_until_swap_out_ = false;
 
   Send(new FrameHostMsg_SwapOut_ACK(routing_id_));
 
   // Now that all of the cleanup is complete and the browser side is notified,
   // start using the RenderFrameProxy, if one is created.
   if (proxy) {
     if (!is_main_frame) {
       frame_->swap(proxy->web_frame());
+      // TODO(creis): Remove this HistoryEntry hack.
+      HistoryEntry::UpdateFrameMap(routing_id_, proxy_routing_id);
 
       if (is_loading)
         proxy->OnDidStartLoading();
 
       if (is_site_per_process) {
         // TODO(nasko): delete the frame here, since we've replaced it with a
         // proxy.
       }
     } else {
       set_render_frame_proxy(proxy);
@@ skipping 1216 matching lines @@
 
   if (internal_data->must_reset_scroll_and_scale_state()) {
     render_view_->webview()->resetScrollAndScaleState();
     internal_data->set_must_reset_scroll_and_scale_state(false);
   }
   internal_data->set_use_error_page(false);
 
   bool is_new_navigation = commit_type == blink::WebStandardCommit;
   if (is_new_navigation) {
     // We bump our Page ID to correspond with the new session history entry.
-    render_view_->page_id_ = render_view_->next_page_id_++;
+    // TODO(creis): Update this.
+    //render_view_->page_id_ = render_view_->next_page_id_++;
+    render_view_->page_id_ = -1;
 
     // Don't update history list values for kSwappedOutURL, since
     // we don't want to forget the entry that was there, and since we will
     // never come back to kSwappedOutURL.  Note that we have to call
     // UpdateSessionHistory and update page_id_ even in this case, so that
     // the current entry gets a state update and so that we don't send a
     // state update to the wrong entry when we swap back in.
     DCHECK_IMPLIES(
         navigation_state->start_params().should_replace_current_entry,
         render_view_->history_list_length_ > 0);
@@ skipping 49 matching lines @@
     }
   }
 
   // Remember that we've already processed this request, so we don't update
   // the session history again.  We do this regardless of whether this is
   // a session history navigation, because if we attempted a session history
   // navigation without valid HistoryItem state, WebCore will think it is a
   // new navigation.
   navigation_state->set_request_committed(true);
 
-  SendDidCommitProvisionalLoad(frame, commit_type);
+  SendDidCommitProvisionalLoad(frame, commit_type, item);
 
   // Check whether we have new encoding name.
   UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
 }
 
 void RenderFrameImpl::didCreateNewDocument(blink::WebLocalFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
 
   FOR_EACH_OBSERVER(RenderViewObserver, render_view_->observers(),
                     DidCreateNewDocument(frame));
@@ skipping 1098 matching lines @@
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, WasShown());
 }
 
 bool RenderFrameImpl::IsHidden() {
   return GetRenderWidget()->is_hidden();
 }
 
 // Tell the embedding application that the URL of the active page has changed.
 void RenderFrameImpl::SendDidCommitProvisionalLoad(
       blink::WebFrame* frame,
-      blink::WebHistoryCommitType commit_type) {
+      blink::WebHistoryCommitType commit_type,
+      const blink::WebHistoryItem& item) {
   DCHECK(!frame_ || frame_ == frame);
   WebDataSource* ds = frame->dataSource();
   DCHECK(ds);
 
   const WebURLRequest& request = ds->request();
   const WebURLResponse& response = ds->response();
 
   DocumentState* document_state = DocumentState::FromDataSource(ds);
   NavigationStateImpl* navigation_state =
       static_cast<NavigationStateImpl*>(document_state->navigation_state());
@@ skipping 45 matching lines @@
 
   params.searchable_form_url = internal_data->searchable_form_url();
   params.searchable_form_encoding = internal_data->searchable_form_encoding();
 
   params.gesture = render_view_->navigation_gesture_;
   render_view_->navigation_gesture_ = NavigationGestureUnknown;
 
   // Make navigation state a part of the DidCommitProvisionalLoad message so
   // that committed entry has it at all times.
   HistoryEntry* entry = render_view_->history_controller()->GetCurrentEntry();
-  if (entry)
-    params.page_state = HistoryEntryToPageState(entry);
-  else
-    params.page_state = PageState::CreateFromURL(request.url());
+  // TODO(creis): Change PageState to FrameState.
+  params.page_state = SingleHistoryItemToPageState(item);
+  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
     // will also call us back which will cause us to send a message to
     // update WebContentsImpl.
     render_view_->webview()->zoomLimitsChanged(
         ZoomFactorToZoomLevel(kMinimumZoomFactor),
         ZoomFactorToZoomLevel(kMaximumZoomFactor));
@@ skipping 594 matching lines @@
   MaybeHandleDebugURL(url);
   if (!render_view_->webview())
     return false;
 
   FOR_EACH_OBSERVER(
       RenderViewObserver, render_view_->observers_, Navigate(url));
 
   // If this is a stale back/forward (due to a recent navigation the browser
   // didn't know about), ignore it. Only check if swapped in because if the
   // frame is swapped out, it won't commit before asking the browser.
+  // TODO(creis): Make this check work for OOPIF.
   if (!render_view_->is_swapped_out() && is_history_navigation &&
       render_view_->history_list_offset_ !=
           history_params.current_history_list_offset) {
     return false;
   }
 
   render_view_->history_list_offset_ =
       history_params.current_history_list_offset;
   render_view_->history_list_length_ =
       history_params.current_history_list_length;
@@ skipping 143 matching lines @@
 
 #if defined(ENABLE_BROWSER_CDMS)
 RendererCdmManager* RenderFrameImpl::GetCdmManager() {
   if (!cdm_manager_)
     cdm_manager_ = new RendererCdmManager(this);
   return cdm_manager_;
 }
 #endif  // defined(ENABLE_BROWSER_CDMS)
 
 }  // namespace content