PlzNavigate: add support in several navigation controller unit tests

content/test/test_render_frame_host.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/test/test_render_frame_host.h"
 
+#include "base/command_line.h"
 #include "content/browser/frame_host/frame_tree.h"
+#include "content/browser/frame_host/navigation_request.h"
+#include "content/browser/frame_host/navigator.h"
+#include "content/browser/frame_host/navigator_impl.h"
 #include "content/browser/frame_host/render_frame_host_delegate.h"
-#include "content/common/frame_messages.h"
+#include "content/public/browser/stream_handle.h"
+#include "content/public/common/content_switches.h"
+#include "content/test/browser_side_navigation_test_utils.h"
+#include "content/test/test_navigation_url_loader.h"
 #include "content/test/test_render_view_host.h"
 #include "net/base/load_flags.h"
 #include "third_party/WebKit/public/web/WebPageVisibilityState.h"
 #include "ui/base/page_transition_types.h"
 
 namespace content {
 
 TestRenderFrameHostCreationObserver::TestRenderFrameHostCreationObserver(
     WebContents* web_contents)
     : WebContentsObserver(web_contents), last_created_frame_(NULL) {
@@ skipping 91 matching lines @@
 void TestRenderFrameHost::SendNavigateWithFile(
     int page_id,
     const GURL& url,
     const base::FilePath& file_path) {
   SendNavigateWithParameters(page_id, url, ui::PAGE_TRANSITION_LINK, url, 200,
       &file_path, std::vector<GURL>());
 }
 
 void TestRenderFrameHost::SendNavigateWithParams(
     FrameHostMsg_DidCommitProvisionalLoad_Params* params) {
+  // PlzNavigate
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableBrowserSideNavigation)) {
+    SimulateIOThread(params->url);
+  }
+
   FrameHostMsg_DidCommitProvisionalLoad msg(GetRoutingID(), *params);
   OnDidCommitProvisionalLoad(msg);
 }
 
 void TestRenderFrameHost::SendNavigateWithRedirects(
     int page_id,
     const GURL& url,
     const std::vector<GURL>& redirects) {
   SendNavigateWithParameters(
       page_id, url, ui::PAGE_TRANSITION_LINK, url, 200, 0, redirects);
 }
 
 void TestRenderFrameHost::SendNavigateWithParameters(
     int page_id,
     const GURL& url,
     ui::PageTransition transition,
     const GURL& original_request_url,
     int response_code,
     const base::FilePath* file_path_for_history_item,
     const std::vector<GURL>& redirects) {
+  // PlzNavigate
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableBrowserSideNavigation)) {
+    SimulateIOThread(url);
+  }
+
   FrameHostMsg_DidCommitProvisionalLoad_Params params;
   params.page_id = page_id;
   params.url = url;
   params.referrer = Referrer();
   params.transition = transition;
   params.redirects = redirects;
   params.should_update_history = true;
   params.searchable_form_url = GURL();
   params.searchable_form_encoding = std::string();
   params.security_info = std::string();
@@ skipping 32 matching lines @@
   common_params.url = url;
   common_params.referrer = Referrer(GURL(), blink::WebReferrerPolicyDefault);
   common_params.transition = ui::PAGE_TRANSITION_LINK;
   OnBeginNavigation(begin_params, common_params);
 }
 
 void TestRenderFrameHost::DidDisownOpener() {
   OnDidDisownOpener();
 }
 
+void TestRenderFrameHost::SendRendererResponseToNavigation(bool proceed,
+                                                           const GURL& url) {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableBrowserSideNavigation)) {
+    // PlzNavigate: if there is a live renderer, send its response to the

[nasko, 2014/12/16 01:40:26]

Is the condition "live renderer"? The check below is about state of the request.

[clamy, 2014/12/17 15:47:57]

Done.

+    // navigation request.
+    NavigationRequest* request =
+        static_cast<NavigatorImpl*>(frame_tree_node_->navigator())
+            ->GetNavigationRequestForNodeForTesting(frame_tree_node_);
+    ASSERT_TRUE(request);
+    if (request->state() == NavigationRequest::WAITING_FOR_RENDERER_RESPONSE)
+      SendBeginNavigationWithURL(url);
+  } else {
+    SendBeforeUnloadACK(proceed);
+  }
+}
+
+void TestRenderFrameHost::SimulateIOThread(const GURL& url) {
+  // Simulate the network stack commit without any redirects.
+  NavigationRequest* request =
+      static_cast<NavigatorImpl*>(frame_tree_node_->navigator())
+          ->GetNavigationRequestForNodeForTesting(frame_tree_node_);
+
+  // We are simulating a renderer-initiated navigation.
+  if (!request) {
+    SendBeginNavigationWithURL(url);
+    request = static_cast<NavigatorImpl*>(frame_tree_node_->navigator())
+        ->GetNavigationRequestForNodeForTesting(frame_tree_node_);
+  }
+  ASSERT_TRUE(request);
+
+  // We may not have simulated the renderer response to the navigation request.
+  // Do that now.
+  if (request->state() == NavigationRequest::WAITING_FOR_RENDERER_RESPONSE)
+    SendBeginNavigationWithURL(url);
+
+  // We have already simulated the IO thread commit. Only the
+  // DidCommitProvisionalLoad from the renderer is missing.
+  if (request->state() == NavigationRequest::RESPONSE_STARTED)
+    return;
+
+  ASSERT_TRUE(request->state() == NavigationRequest::STARTED);
+  TestNavigationURLLoader* url_loader =
+      static_cast<TestNavigationURLLoader*>(request->loader_for_testing());
+  ASSERT_TRUE(url_loader);
+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  url_loader->CallOnResponseStarted(response, MakeEmptyStream());
+}
+
 }  // namespace content