Remove AreCrossProcessFramesPossible from NavigatorImpl::DidNavigate

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 <utility>
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 520 matching lines @@
   }
 
   return NavigateToEntry(render_frame_host->frame_tree_node(), *frame_entry,
                          *entry, ReloadType::NONE, false, true, false, nullptr);
 }
 
 void NavigatorImpl::DidNavigate(
     RenderFrameHostImpl* render_frame_host,
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params,
     std::unique_ptr<NavigationHandleImpl> navigation_handle) {
-  FrameTree* frame_tree = render_frame_host->frame_tree_node()->frame_tree();
-  bool oopifs_possible = SiteIsolationPolicy::AreCrossProcessFramesPossible();
+  FrameTreeNode* ftn = render_frame_host->frame_tree_node();

[Charlie Reis, 2017/05/22 23:29:02]

nit: frame_tree_node (to be consistent with naming here, where we tend to spell
out the name)

[alexmos, 2017/05/22 23:43:02]

Done.

+  FrameTree* frame_tree = ftn->frame_tree();
 
   bool is_navigation_within_page = controller_->IsURLInPageNavigation(
       params.url, params.origin, params.was_within_same_document,
       render_frame_host);
 
   // If a frame claims it navigated within page, it must be the current frame,
   // not a pending one.
   if (is_navigation_within_page &&
-      render_frame_host !=
-          render_frame_host->frame_tree_node()
-              ->render_manager()
-              ->current_frame_host()) {
+      render_frame_host != ftn->render_manager()->current_frame_host()) {
     bad_message::ReceivedBadMessage(render_frame_host->GetProcess(),
                                     bad_message::NI_IN_PAGE_NAVIGATION);
     is_navigation_within_page = false;
   }
 
   if (ui::PageTransitionIsMainFrame(params.transition)) {
     if (delegate_) {
       // When overscroll navigation gesture is enabled, a screenshot of the page
       // in its current state is taken so that it can be used during the
       // nav-gesture. It is necessary to take the screenshot here, before
       // calling RenderFrameHostManager::DidNavigateMainFrame, because that can
       // change WebContents::GetRenderViewHost to return the new host, instead
       // of the one that may have just been swapped out.
       if (delegate_->CanOverscrollContent()) {
         // Don't take screenshots if we are staying on the same document. We
         // want same-document navigations to be super fast, and taking a
         // screenshot currently blocks GPU for a longer time than we are willing
         // to tolerate in this use case.
         if (!params.was_within_same_document)
           controller_->TakeScreenshot();
       }
 
       // Run tasks that must execute just before the commit.
       delegate_->DidNavigateMainFramePreCommit(is_navigation_within_page);
     }
-
-    if (!oopifs_possible)
-      frame_tree->root()->render_manager()->DidNavigateFrame(
-          render_frame_host, params.gesture == NavigationGestureUser);
   }
 
   // Save the origin of the new page.  Do this before calling
   // DidNavigateFrame(), because the origin needs to be included in the SwapOut
   // message, which is sent inside DidNavigateFrame().  SwapOut needs the
   // origin because it creates a RenderFrameProxy that needs this to initialize
   // its security context. This origin will also be sent to RenderFrameProxies
   // created via mojom::Renderer::CreateView and
   // mojom::Renderer::CreateFrameProxy.
-  render_frame_host->frame_tree_node()->SetCurrentOrigin(
-      params.origin, params.has_potentially_trustworthy_unique_origin);
+  ftn->SetCurrentOrigin(params.origin,
+                        params.has_potentially_trustworthy_unique_origin);
 
-  render_frame_host->frame_tree_node()->SetInsecureRequestPolicy(
-      params.insecure_request_policy);
+  ftn->SetInsecureRequestPolicy(params.insecure_request_policy);
 
   // Navigating to a new location means a new, fresh set of http headers and/or
   // <meta> elements - we need to reset CSP and Feature Policy.
   if (!is_navigation_within_page) {
     render_frame_host->ResetContentSecurityPolicies();
-    render_frame_host->frame_tree_node()->ResetCspHeaders();
-    render_frame_host->frame_tree_node()->ResetFeaturePolicyHeader();
+    ftn->ResetCspHeaders();
+    ftn->ResetFeaturePolicyHeader();
   }
 
-  // When using --site-per-process, we notify the RFHM for all navigations,
-  // not just main frame navigations.
-  if (oopifs_possible) {
-    FrameTreeNode* frame = render_frame_host->frame_tree_node();
-    frame->render_manager()->DidNavigateFrame(
-        render_frame_host, params.gesture == NavigationGestureUser);
-  }
+  ftn->render_manager()->DidNavigateFrame(
+      render_frame_host, params.gesture == NavigationGestureUser);
 
   // Update the site of the SiteInstance if it doesn't have one yet, unless
   // assigning a site is not necessary for this URL or the commit was for an
   // error page.  In that case, the SiteInstance can still be considered unused
   // until a navigation to a real page.
   SiteInstanceImpl* site_instance = render_frame_host->GetSiteInstance();
   if (!site_instance->HasSite() && ShouldAssignSiteForURL(params.url) &&
       !params.url_is_unreachable) {
     site_instance->SetSite(params.url);
   }
@@ skipping 27 matching lines @@
         new PageMsg_SetHistoryOffsetAndLength(
             MSG_ROUTING_NONE, controller_->GetLastCommittedEntryIndex(),
             controller_->GetEntryCount()),
         site_instance);
   }
 
   // Keep track of the last committed URL and origin in the RenderFrameHost
   // itself.  These allow GetLastCommittedURL and GetLastCommittedOrigin to
   // stay correct even if the render_frame_host later becomes pending deletion.
   // The URL is set regardless of whether it's for a net error or not.
-  render_frame_host->frame_tree_node()->SetCurrentURL(params.url);
+  ftn->SetCurrentURL(params.url);
   render_frame_host->SetLastCommittedOrigin(params.origin);
 
   // Separately, update the frame's last successful URL except for net error
   // pages, since those do not end up in the correct process after transfers
   // (see https://crbug.com/560511).  Instead, the next cross-process navigation
   // or transfer should decide whether to swap as if the net error had not
   // occurred.
   // TODO(creis): Remove this block and always set the URL once transfers handle
   // network errors or PlzNavigate is enabled.  See https://crbug.com/588314.
   if (!params.url_is_unreachable)
@@ skipping 624 matching lines @@
     if (navigation_handle)
       navigation_handle->update_entry_id_for_transfer(entry->GetUniqueID());
 
     controller_->SetPendingEntry(std::move(entry));
     if (delegate_)
       delegate_->NotifyChangedNavigationState(content::INVALIDATE_TYPE_URL);
   }
 }
 
 }  // namespace content