OOPIF: History navigations for new child frames.

content/browser/frame_host/navigator_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/browser/frame_host/navigator_impl.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/time/time.h"
 #include "content/browser/frame_host/frame_tree.h"
@@ skipping 237 matching lines @@
         render_frame_host, url, error_code,
         error_description, was_ignored_by_handler);
   }
 }
 
 bool NavigatorImpl::NavigateToEntry(
     FrameTreeNode* frame_tree_node,
     const FrameNavigationEntry& frame_entry,
     const NavigationEntryImpl& entry,
     NavigationController::ReloadType reload_type,
-    bool is_same_document_history_load) {
+    bool is_same_document_history_load,
+    bool is_pending_entry) {
   TRACE_EVENT0("browser,navigation", "NavigatorImpl::NavigateToEntry");
 
   GURL dest_url = frame_entry.url();
   Referrer dest_referrer = frame_entry.referrer();
   if (reload_type ==
           NavigationController::ReloadType::RELOAD_ORIGINAL_REQUEST_URL &&
       entry.GetOriginalRequestURL().is_valid() && !entry.GetHasPostData()) {
     // We may have been redirected when navigating to the current URL.
     // Use the URL the user originally intended to visit, if it's valid and if a
     // POST wasn't involved; the latter case avoids issues with sending data to
@@ skipping 27 matching lines @@
 
   // PlzNavigate: the RenderFrameHosts are no longer asked to navigate.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableBrowserSideNavigation)) {
     navigation_data_.reset(new NavigationMetricsData(navigation_start, dest_url,
                                                      entry.restore_type()));
     RequestNavigation(frame_tree_node, dest_url, dest_referrer, frame_entry,
                       entry, reload_type, is_same_document_history_load,
                       navigation_start);
 
-    // Notify observers about navigation.
-    if (delegate_)
+    // Notify observers about navigation if this is for the pending entry.
+    if (delegate_ && is_pending_entry)
       delegate_->DidStartNavigationToPendingEntry(dest_url, reload_type);
 
     return true;
   }
 
   RenderFrameHostImpl* dest_render_frame_host =
       manager->Navigate(dest_url, frame_entry, entry);
   if (!dest_render_frame_host)
     return false;  // Unable to create the desired RenderFrameHost.
 
   // Make sure no code called via RFHM::Navigate clears the pending entry.
-  CHECK_EQ(controller_->GetPendingEntry(), &entry);
+  if (is_pending_entry)
+    CHECK_EQ(controller_->GetPendingEntry(), &entry);
 
   // For security, we should never send non-Web-UI URLs to a Web UI renderer.
   // Double check that here.
   CheckWebUIRendererDoesNotDisplayNormalURL(dest_render_frame_host, dest_url);
 
   // Navigate in the desired RenderFrameHost.
   // We can skip this step in the rare case that this is a transfer navigation
   // which began in the chosen RenderFrameHost, since the request has already
   // been issued.  In that case, simply resume the response.
   bool is_transfer_to_same =
@@ skipping 23 matching lines @@
             controller_->GetIndexOfEntry(&entry),
             controller_->GetLastCommittedEntryIndex(),
             controller_->GetEntryCount()));
   } else {
     // No need to navigate again.  Just resume the deferred request.
     dest_render_frame_host->GetProcess()->ResumeDeferredNavigation(
         entry.transferred_global_request_id());
   }
 
   // Make sure no code called via RFH::Navigate clears the pending entry.
-  CHECK_EQ(controller_->GetPendingEntry(), &entry);
+  if (is_pending_entry)
+    CHECK_EQ(controller_->GetPendingEntry(), &entry);
 
   if (controller_->GetPendingEntryIndex() == -1 &&
       dest_url.SchemeIs(url::kJavaScriptScheme)) {
     // If the pending entry index is -1 (which means a new navigation rather
     // than a history one), and the user typed in a javascript: URL, don't add
     // it to the session history.
     //
     // This is a hack. What we really want is to avoid adding to the history any
     // URL that doesn't generate content, and what would be great would be if we
     // had a message from the renderer telling us that a new page was not
     // created. The same message could be used for mailto: URLs and the like.
     return false;
   }
 
   // Notify observers about navigation.
-  if (delegate_) {
+  if (delegate_ && is_pending_entry)
     delegate_->DidStartNavigationToPendingEntry(dest_url, reload_type);
-  }
 
   return true;
 }
 
 bool NavigatorImpl::NavigateToPendingEntry(
     FrameTreeNode* frame_tree_node,
     const FrameNavigationEntry& frame_entry,
     NavigationController::ReloadType reload_type,
     bool is_same_document_history_load) {
   return NavigateToEntry(frame_tree_node, frame_entry,
                          *controller_->GetPendingEntry(), reload_type,
-                         is_same_document_history_load);
+                         is_same_document_history_load, true);
+}
+
+void NavigatorImpl::NavigateNewChildFrame(
+    RenderFrameHostImpl* render_frame_host,
+    const std::string& unique_name) {
+  // TODO(creis): Handle the fallback case where frame_entry isn't found, or
+  // where NavigateToEntry returns false.
+  NavigationEntryImpl* entry =
+      controller_->GetEntryWithUniqueID(render_frame_host->nav_entry_id());

[Avi (use Gerrit), 2015/11/24 22:09:47]

Boy, this "last commit" nav entry id is coming in handy...

So the way I'm understanding it, we get a request to navigate a new child frame,
so we're assuming that we need to work on the last commit. Can that id ever be
stale?

[Charlie Reis, 2015/11/24 23:05:54]

Right.  The renderer sends this IPC when it knows a back/forward is in progress
(i.e., we haven't gotten to DidStopLoading yet during a history navigation in
its parent).  That means we should use the NavigationEntry that the newly
created RenderFrame thinks it's on.  (And that nav_entry_id is inherited from
its parent, as of https://codereview.chromium.org/1437643004.)
Good question.  I think maybe yes, if the RenderFrame is about to be destroyed. 
In that case, we'll hit the early return below and it should be fine.  For
example:
1) Visit page A, then page B (with iframe B1), then C, each in a different
process.
2) Go back from C to B.
3) Quickly go back from B to A, then commit a new page D (pruning B and C from
history).
4) In the meantime, B creates its child frame and we get NavigateNewChildFrame
after D has committed and the NavEntry is gone.

Then again, that might not be possible in practice-- I think we'll delete the
FTN and RFH for B's iframe when going back to A in step 3, so the
NavigateNewChildFrame IPC won't be handled anywhere.

+  if (!entry)
+    return;
+
+  FrameNavigationEntry* frame_entry =
+      entry->GetFrameEntryByUniqueName(unique_name);
+  if (!frame_entry)
+    return;
+
+  // Update the FNE's FTN ID, since the frame will have a new one.

[Avi (use Gerrit), 2015/11/24 22:09:47]

I didn't understand this comment the first time I read it. Perhaps:

// Update the FNE's FTN ID (which is currently the ID of the old FTN that no
longer exists) to be the ID of the newly-created frame.

... or something like that.

[Charlie Reis, 2015/11/24 23:05:54]

Done.

+  frame_entry->set_frame_tree_node_id(
+      render_frame_host->frame_tree_node()->frame_tree_node_id());
+
+  NavigateToEntry(render_frame_host->frame_tree_node(), *frame_entry, *entry,
+                  NavigationControllerImpl::NO_RELOAD, false, false);
 }
 
 void NavigatorImpl::DidNavigate(
     RenderFrameHostImpl* render_frame_host,
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
   FrameTree* frame_tree = render_frame_host->frame_tree_node()->frame_tree();
   bool oopifs_possible = SiteIsolationPolicy::AreCrossProcessFramesPossible();
 
   bool is_navigation_within_page = controller_->IsURLInPageNavigation(
       params.url, params.was_within_same_page, render_frame_host);
@@ skipping 550 matching lines @@
       entry->set_should_replace_entry(pending_entry->should_replace_entry());
       entry->SetRedirectChain(pending_entry->GetRedirectChain());
     }
     controller_->SetPendingEntry(entry.Pass());
     if (delegate_)
       delegate_->NotifyChangedNavigationState(content::INVALIDATE_TYPE_URL);
   }
 }
 
 }  // namespace content