PlzNavigate: implement CommitNavigation on the browser side

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/time/time.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/navigation_before_commit_info.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
+#include "content/browser/frame_host/navigation_parameters.h"
 #include "content/browser/frame_host/navigator_delegate.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/webui/web_ui_controller_factory_registry.h"
 #include "content/browser/webui/web_ui_impl.h"
 #include "content/common/frame_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.h"
@@ skipping 40 matching lines @@
 }
 
 RenderFrameHostManager* GetRenderManager(RenderFrameHostImpl* rfh) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSitePerProcess))
     return rfh->frame_tree_node()->render_manager();
 
   return rfh->frame_tree_node()->frame_tree()->root()->render_manager();
 }
 
-}  // namespace
-
-
-NavigatorImpl::NavigatorImpl(
-    NavigationControllerImpl* navigation_controller,
-    NavigatorDelegate* delegate)
-    : controller_(navigation_controller),
-      delegate_(delegate) {
-}
-
-// static.
-void NavigatorImpl::MakeNavigateParams(
+void MakeNavigateParams(
     const NavigationEntryImpl& entry,
-    const NavigationControllerImpl& controller,
+    NavigationControllerImpl* controller,
     NavigationController::ReloadType reload_type,
     base::TimeTicks navigation_start,
     FrameMsg_Navigate_Params* params) {
   params->page_id = entry.GetPageID();
   params->should_clear_history_list = entry.should_clear_history_list();
   params->should_replace_current_entry = entry.should_replace_entry();
-  if (entry.should_clear_history_list()) {
-    // Set the history list related parameters to the same values a
-    // NavigationController would return before its first navigation. This will
-    // fully clear the RenderView's view of the session history.
-    params->pending_history_list_offset = -1;
-    params->current_history_list_offset = -1;
-    params->current_history_list_length = 0;
-  } else {
-    params->pending_history_list_offset = controller.GetIndexOfEntry(&entry);
-    params->current_history_list_offset =
-        controller.GetLastCommittedEntryIndex();
-    params->current_history_list_length = controller.GetEntryCount();
-  }
   params->url = entry.GetURL();
+  controller->FillHistoryParametersForNavigationEntry(
+      entry,
+      &params->pending_history_list_offset,
+      &params->current_history_list_offset,
+      &params->current_history_list_length);
   if (!entry.GetBaseURLForDataURL().is_empty()) {
     params->base_url_for_data_url = entry.GetBaseURLForDataURL();
     params->history_url_for_data_url = entry.GetVirtualURL();
   }
   params->referrer = entry.GetReferrer();
   params->transition = entry.GetTransitionType();
   params->page_state = entry.GetPageState();
-  params->navigation_type =
-      GetNavigationType(controller.GetBrowserContext(), entry, reload_type);
+  params->navigation_type = GetNavigationType(
+      controller->GetBrowserContext(), entry, reload_type);
   // This is used by the old performance infrastructure to set up DocumentState
   // associated with the RenderView.
   // TODO(ppi): make it go away.
   params->request_time = base::Time::Now();
   params->extra_headers = entry.extra_headers();
   params->transferred_request_child_id =
       entry.transferred_global_request_id().child_id;
   params->transferred_request_request_id =
       entry.transferred_global_request_id().request_id;
   params->is_overriding_user_agent = entry.GetIsOverridingUserAgent();
@@ skipping 13 matching lines @@
     params->redirects = entry.GetRedirectChain();
   } else {
     params->redirects.clear();
   }
 
   params->can_load_local_resources = entry.GetCanLoadLocalResources();
   params->frame_to_navigate = entry.GetFrameToNavigate();
   params->browser_navigation_start = navigation_start;
 }
 
+}  // namespace
+
+
+NavigatorImpl::NavigatorImpl(
+    NavigationControllerImpl* navigation_controller,
+    NavigatorDelegate* delegate)
+    : controller_(navigation_controller),
+      delegate_(delegate) {
+}
+
 NavigationController* NavigatorImpl::GetController() {
   return controller_;
 }
 
 void NavigatorImpl::DidStartProvisionalLoad(
     RenderFrameHostImpl* render_frame_host,
     const GURL& url,
     bool is_transition_navigation) {
   bool is_error_page = (url.spec() == kUnreachableWebDataURL);
   bool is_iframe_srcdoc = (url.spec() == kAboutSrcDocURL);
@@ skipping 181 matching lines @@
   // "Open link in new tab"). We need to keep it above RFHM::Navigate() call to
   // capture the time needed for the RenderFrameHost initialization.
   base::TimeTicks navigation_start = base::TimeTicks::Now();
 
   // WebContents uses this to fill LoadNotificationDetails when the load
   // completes, so that PerformanceMonitor that listens to the notification can
   // record the load time. PerformanceMonitor is no longer maintained.
   // TODO(ppi): make this go away.
   current_load_start_ = base::TimeTicks::Now();
 
-  // Create the navigation parameters.
-  FrameMsg_Navigate_Params navigate_params;
-  MakeNavigateParams(
-      entry, *controller_, reload_type, navigation_start, &navigate_params);
-
   RenderFrameHostManager* manager =
       render_frame_host->frame_tree_node()->render_manager();
 
   // PlzNavigate: the RenderFrameHosts are no longer asked to navigate. Instead
   // the RenderFrameHostManager handles the navigation requests for that frame
   // node.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation)) {
-    return manager->RequestNavigation(entry, navigate_params);
+    scoped_ptr<NavigationParameters> navigation_parameters(
+        new NavigationParameters(
+            entry,
+            controller_,
+            current_load_start_,
+            GetNavigationType(
+                controller_->GetBrowserContext(), entry, reload_type)));
+    return manager->RequestNavigation(navigation_parameters.Pass());
   }
 
   RenderFrameHostImpl* dest_render_frame_host = manager->Navigate(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);
 
   // For security, we should never send non-Web-UI URLs to a Web UI renderer.
   // Double check that here.
   CheckWebUIRendererDoesNotDisplayNormalURL(
       dest_render_frame_host, entry.GetURL());
 
   // Notify observers that we will navigate in this RenderFrame.
   if (delegate_)
     delegate_->AboutToNavigateRenderFrame(dest_render_frame_host);
 
+  // Create the navigation parameters.
+  FrameMsg_Navigate_Params navigate_params;
+  MakeNavigateParams(
+      entry, controller_, reload_type, navigation_start, &navigate_params);
+
   // 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 =
       navigate_params.transferred_request_child_id != -1 &&
       navigate_params.transferred_request_child_id ==
           dest_render_frame_host->GetProcess()->GetID();
   if (!is_transfer_to_same) {
     dest_render_frame_host->Navigate(navigate_params);
@@ skipping 264 matching lines @@
     // Navigations in Web UI pages count as browser-initiated navigations.
     params.is_renderer_initiated = false;
   }
 
   if (delegate_)
     delegate_->RequestOpenURL(render_frame_host, params);
 }
 
 void NavigatorImpl::CommitNavigation(
     RenderFrameHostImpl* render_frame_host,
-    const NavigationBeforeCommitInfo& info) {
+    const FrameMsg_CommitNavigation_Params& commit_navigation_params) {
   CheckWebUIRendererDoesNotDisplayNormalURL(
-      render_frame_host, info.navigation_url);
-  // TODO(clamy): the render_frame_host should now send a commit IPC to the
-  // renderer.
+      render_frame_host, commit_navigation_params.url);
+  render_frame_host->CommitNavigation(commit_navigation_params);
+}
+
+NavigationParameters* NavigatorImpl::MakeNavigationParametersForTest(

[(Do not use) nasko, 2014/09/05 17:04:48]

I know this is for testing, but it seems that it will be good for this to return
a scoped_ptr, so the test doesn't have to explicitly delete it. We shouldn't be
leaking memory even in tests, otherwise leak detection can only be done in real
Chrome instance, which is not ideal.

[clamy, 2014/09/08 18:37:12]

Done.

+    const NavigationEntryImpl& entry,
+    NavigationController::ReloadType reload_type) {
+  FrameMsg_Navigate_Type::Value navigation_type = GetNavigationType(
+      controller_->GetBrowserContext(),
+      entry,
+      reload_type);
+  return new NavigationParameters(
+      entry, controller_, base::TimeTicks::Now(), navigation_type);
 }
 
 void NavigatorImpl::CheckWebUIRendererDoesNotDisplayNormalURL(
     RenderFrameHostImpl* render_frame_host,
     const GURL& url) {
   int enabled_bindings =
       render_frame_host->render_view_host()->GetEnabledBindings();
   bool is_allowed_in_web_ui_renderer =
       WebUIControllerFactoryRegistry::GetInstance()->IsURLAcceptableForWebUI(
           controller_->GetBrowserContext(), url);
   if ((enabled_bindings & BINDINGS_POLICY_WEB_UI) &&
       !is_allowed_in_web_ui_renderer) {
     // Log the URL to help us diagnose any future failures of this CHECK.
     GetContentClient()->SetActiveURL(url);
     CHECK(0);
   }
 }
 
 }  // namespace content