PlzNavigate: implement CommitNavigation on the browser side

content/browser/frame_host/render_frame_host_manager.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/render_frame_host_manager.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 30 matching lines @@
 #include "content/public/common/content_switches.h"
 #include "content/public/common/referrer.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/load_flags.h"
 
 namespace content {
 
 namespace {
 
 // PlzNavigate
+// Returns the net load flags to use based on the navigation type.
+int LoadFlagFromNavigationType(FrameMsg_Navigate_Type::Value navigation_type) {
+  int load_flags = net::LOAD_NORMAL;
+  switch (navigation_type) {
+    case FrameMsg_Navigate_Type::RELOAD:
+    case FrameMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL:
+      load_flags |= net::LOAD_VALIDATE_CACHE;
+      break;
+    case FrameMsg_Navigate_Type::RELOAD_IGNORING_CACHE:
+      load_flags |= net::LOAD_BYPASS_CACHE;
+      break;
+    case FrameMsg_Navigate_Type::RESTORE:
+      load_flags |= net::LOAD_PREFERRING_CACHE;
+      break;
+    case FrameMsg_Navigate_Type::RESTORE_WITH_POST:
+      load_flags |= net::LOAD_ONLY_FROM_CACHE;
+      break;
+    case FrameMsg_Navigate_Type::NORMAL:
+    default :
+      break;
+  }
+  return load_flags;
+}
+
+// PlzNavigate
 // Simulates a renderer response to a navigation request when there is no live
 // renderer.
 FrameHostMsg_BeginNavigation_Params BeginNavigationFromNavigate(
-    const FrameMsg_Navigate_Params& navigate_params) {
+    const FrameMsg_Navigate_Params& navigate_params,
+    FrameMsg_Navigate_Type::Value navigation_type) {
   FrameHostMsg_BeginNavigation_Params begin_navigation_params;
   begin_navigation_params.method = navigate_params.is_post ? "POST" : "GET";
   begin_navigation_params.url = navigate_params.url;
   begin_navigation_params.referrer =
       Referrer(navigate_params.referrer.url, navigate_params.referrer.policy);
-
-  // TODO(clamy): This should be modified to take into account caching policy
-  // requirements (eg for POST reloads).
-  begin_navigation_params.load_flags = net::LOAD_NORMAL;
+  begin_navigation_params.load_flags =
+      LoadFlagFromNavigationType(navigation_type);
 
   // TODO(clamy): Post data from the browser should be put in the request body.
 
   begin_navigation_params.has_user_gesture = false;
   begin_navigation_params.transition_type = navigate_params.transition;
   begin_navigation_params.should_replace_current_entry =
       navigate_params.should_replace_current_entry;
   begin_navigation_params.allow_download =
       navigate_params.allow_download;
   return begin_navigation_params;
 }
 
+void UpdateCommitNavParamsFromBeginNavParams(
+    const FrameHostMsg_BeginNavigation_Params& begin_navigation_params,
+    FrameMsg_CommitNavigation_Params* commit_navigation_params) {
+  commit_navigation_params->referrer = begin_navigation_params.referrer;
+  commit_navigation_params->transition =
+      begin_navigation_params.transition_type;
+}
+
+void UpdateCommitNavParamsFromCommitInfo(
+    const NavigationBeforeCommitInfo& commit_info,
+    FrameMsg_CommitNavigation_Params* commit_navigation_params) {
+  commit_navigation_params->url = commit_info.navigation_url;
+  commit_navigation_params->stream_url = commit_info.stream_url;
+  commit_navigation_params->browser_navigation_start =
+      commit_info.browser_navigation_start;
+}
+
 }  // namespace
 
 bool RenderFrameHostManager::ClearRFHsPendingShutdown(FrameTreeNode* node) {
   node->render_manager()->pending_delete_hosts_.clear();
   return true;
 }
 
 RenderFrameHostManager::RenderFrameHostManager(
     FrameTreeNode* frame_tree_node,
     RenderFrameHostDelegate* render_frame_delegate,
@@ skipping 455 matching lines @@
   if (iter != pending_delete_hosts_.end() && iter->second.get() == rfh)
     pending_delete_hosts_.erase(site_instance_id);
 }
 
 void RenderFrameHostManager::ResetProxyHosts() {
   STLDeleteValues(&proxy_hosts_);
 }
 
 // PlzNavigate
 bool RenderFrameHostManager::RequestNavigation(
-    const NavigationEntryImpl& entry,
+    scoped_ptr<FrameMsg_CommitNavigation_Params> commit_navigation_params,
     const FrameMsg_Navigate_Params& navigate_params) {
   CHECK(CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation));
+  commit_navigation_params_ = commit_navigation_params.Pass();
   // TODO(clamy): replace RenderViewHost::IsRenderViewLive by
   // RenderFrameHost::IsLive.
   if (render_frame_host_->render_view_host()->IsRenderViewLive())
     // TODO(clamy): send a RequestNavigation IPC.
     return true;
 
   // The navigation request is sent directly to the IO thread.
-  OnBeginNavigation(BeginNavigationFromNavigate(navigate_params));
+  OnBeginNavigation(BeginNavigationFromNavigate(
+      navigate_params, commit_navigation_params_->navigation_type));
   return true;
 }
 
 // PlzNavigate
 void RenderFrameHostManager::OnBeginNavigation(
     const FrameHostMsg_BeginNavigation_Params& params) {
   CHECK(CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation));
   // TODO(clamy): Check if navigations are blocked and if so, return
   // immediately.
   NavigationRequestInfo info(params);
 
   info.first_party_for_cookies = frame_tree_node_->IsMainFrame() ?
       params.url : frame_tree_node_->frame_tree()->root()->current_url();
   info.is_main_frame = frame_tree_node_->IsMainFrame();
   info.parent_is_main_frame = !frame_tree_node_->parent() ?
       false : frame_tree_node_->parent()->IsMainFrame();
   info.is_showing = GetRenderWidgetHostView()->IsShowing();
 
   // TODO(clamy): Check if the current RFH should be initialized (in case it has
   // crashed) not to display a sad tab while navigating.
   // TODO(clamy): Spawn a speculative renderer process if we do not have one to
   // use for the navigation.
   navigation_request_.reset(new NavigationRequest(
       info, frame_tree_node_->frame_tree_node_id()));
   navigation_request_->BeginNavigation(params.request_body);
+
+  DCHECK(commit_navigation_params_.get());
+  UpdateCommitNavParamsFromBeginNavParams(
+      params, commit_navigation_params_.get());
 }
 
 // PlzNavigate
 void RenderFrameHostManager::CommitNavigation(
     const NavigationBeforeCommitInfo& info) {
   CHECK(CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation));
   // Pick the right RenderFrameHost to commit the navigation.
   SiteInstance* current_instance = render_frame_host_->GetSiteInstance();
   // TODO(clamy): Replace the default values by the right ones. This may require
@@ skipping 12 matching lines @@
         current_instance, new_instance, frame_tree_node_->IsMainFrame());
     DCHECK(pending_render_frame_host_.get());
     // TODO(clamy): Wait until the navigation has committed before swapping
     // renderers.
     scoped_ptr<RenderFrameHostImpl> old_render_frame_host =
         SetRenderFrameHost(pending_render_frame_host_.Pass());
     if (frame_tree_node_->IsMainFrame())
       render_frame_host_->render_view_host()->AttachToFrameTree();
   }
 
+  DCHECK(commit_navigation_params_.get());
+  UpdateCommitNavParamsFromCommitInfo(info, commit_navigation_params_.get());
   frame_tree_node_->navigator()->CommitNavigation(
-      render_frame_host_.get(), info);
+      render_frame_host_.get(), commit_navigation_params_.Pass());
 }
 
 void RenderFrameHostManager::Observe(
     int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   switch (type) {
     case NOTIFICATION_RENDERER_PROCESS_CLOSED:
     case NOTIFICATION_RENDERER_PROCESS_CLOSING:
       RendererProcessClosing(
@@ skipping 1040 matching lines @@
 void RenderFrameHostManager::DeleteRenderFrameProxyHost(
     SiteInstance* instance) {
   RenderFrameProxyHostMap::iterator iter = proxy_hosts_.find(instance->GetId());
   if (iter != proxy_hosts_.end()) {
     delete iter->second;
     proxy_hosts_.erase(iter);
   }
 }
 
 }  // namespace content