content/test/test_render_frame_host.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/test/test_render_frame_host.h"
   6
   7 #include "base/command_line.h"
   8 #include "content/browser/frame_host/frame_tree.h"
   9 #include "content/browser/frame_host/navigation_request.h"
  10 #include "content/browser/frame_host/navigator.h"
  11 #include "content/browser/frame_host/navigator_impl.h"
  12 #include "content/browser/frame_host/render_frame_host_delegate.h"
  13 #include "content/public/browser/stream_handle.h"
  14 #include "content/public/common/content_switches.h"
  15 #include "content/test/browser_side_navigation_test_utils.h"
  16 #include "content/test/test_navigation_url_loader.h"
  17 #include "content/test/test_render_view_host.h"
  18 #include "net/base/load_flags.h"
  19 #include "third_party/WebKit/public/web/WebPageVisibilityState.h"
  20 #include "ui/base/page_transition_types.h"
  21
  22 namespace content {
  23
  24 TestRenderFrameHostCreationObserver::TestRenderFrameHostCreationObserver(
  25     WebContents* web_contents)
  26     : WebContentsObserver(web_contents), last_created_frame_(NULL) {
  27 }
  28
  29 TestRenderFrameHostCreationObserver::~TestRenderFrameHostCreationObserver() {
  30 }
  31
  32 void TestRenderFrameHostCreationObserver::RenderFrameCreated(
  33     RenderFrameHost* render_frame_host) {
  34   last_created_frame_ = render_frame_host;
  35 }
  36
  37 TestRenderFrameHost::TestRenderFrameHost(RenderViewHostImpl* render_view_host,
  38                                          RenderFrameHostDelegate* delegate,
  39                                          FrameTree* frame_tree,
  40                                          FrameTreeNode* frame_tree_node,
  41                                          int routing_id,
  42                                          int flags)
  43     : RenderFrameHostImpl(render_view_host,
  44                           delegate,
  45                           frame_tree,
  46                           frame_tree_node,
  47                           routing_id,
  48                           flags),
  49       child_creation_observer_(delegate ? delegate->GetAsWebContents() : NULL),
  50       contents_mime_type_("text/html"),
  51       simulate_history_list_was_cleared_(false) {
  52 }
  53
  54 TestRenderFrameHost::~TestRenderFrameHost() {}
  55
  56 TestRenderViewHost* TestRenderFrameHost::GetRenderViewHost() {
  57   return static_cast<TestRenderViewHost*>(
  58       RenderFrameHostImpl::GetRenderViewHost());
  59 }
  60
  61 TestRenderFrameHost* TestRenderFrameHost::AppendChild(
  62     const std::string& frame_name) {
  63   OnCreateChildFrame(GetProcess()->GetNextRoutingID(), frame_name);
  64   return static_cast<TestRenderFrameHost*>(
  65       child_creation_observer_.last_created_frame());
  66 }
  67
  68 void TestRenderFrameHost::SendNavigateWithTransition(
  69     int page_id,
  70     const GURL& url,
  71     ui::PageTransition transition) {
  72   SendNavigateWithTransitionAndResponseCode(page_id, url, transition, 200);
  73 }
  74
  75 void TestRenderFrameHost::SetContentsMimeType(const std::string& mime_type) {
  76   contents_mime_type_ = mime_type;
  77 }
  78
  79 void TestRenderFrameHost::SendBeforeUnloadACK(bool proceed) {
  80   base::TimeTicks now = base::TimeTicks::Now();
  81   OnBeforeUnloadACK(proceed, now, now);
  82 }
  83
  84 void TestRenderFrameHost::SimulateSwapOutACK() {
  85   OnSwappedOut();
  86 }
  87
  88 void TestRenderFrameHost::SendNavigate(int page_id, const GURL& url) {
  89   SendNavigateWithTransition(page_id, url, ui::PAGE_TRANSITION_LINK);
  90 }
  91
  92 void TestRenderFrameHost::SendFailedNavigate(int page_id, const GURL& url) {
  93   SendNavigateWithTransitionAndResponseCode(
  94       page_id, url, ui::PAGE_TRANSITION_RELOAD, 500);
  95 }
  96
  97 void TestRenderFrameHost::SendNavigateWithTransitionAndResponseCode(
  98     int page_id,
  99     const GURL& url, ui::PageTransition transition,
 100     int response_code) {
 101   // DidStartProvisionalLoad may delete the pending entry that holds |url|,
 102   // so we keep a copy of it to use in SendNavigateWithParameters.
 103   GURL url_copy(url);
 104   OnDidStartProvisionalLoadForFrame(url_copy, false);
 105   SendNavigateWithParameters(page_id, url_copy, transition, url_copy,
 106       response_code, 0, std::vector<GURL>());
 107 }
 108
 109 void TestRenderFrameHost::SendNavigateWithOriginalRequestURL(
 110     int page_id,
 111     const GURL& url,
 112     const GURL& original_request_url) {
 113   OnDidStartProvisionalLoadForFrame(url, false);
 114   SendNavigateWithParameters(page_id, url, ui::PAGE_TRANSITION_LINK,
 115       original_request_url, 200, 0, std::vector<GURL>());
 116 }
 117
 118 void TestRenderFrameHost::SendNavigateWithFile(
 119     int page_id,
 120     const GURL& url,
 121     const base::FilePath& file_path) {
 122   SendNavigateWithParameters(page_id, url, ui::PAGE_TRANSITION_LINK, url, 200,
 123       &file_path, std::vector<GURL>());
 124 }
 125
 126 void TestRenderFrameHost::SendNavigateWithParams(
 127     FrameHostMsg_DidCommitProvisionalLoad_Params* params) {
 128   FrameHostMsg_DidCommitProvisionalLoad msg(GetRoutingID(), *params);
 129   OnDidCommitProvisionalLoad(msg);
 130 }
 131
 132 void TestRenderFrameHost::SendNavigateWithRedirects(
 133     int page_id,
 134     const GURL& url,
 135     const std::vector<GURL>& redirects) {
 136   SendNavigateWithParameters(
 137       page_id, url, ui::PAGE_TRANSITION_LINK, url, 200, 0, redirects);
 138 }
 139
 140 void TestRenderFrameHost::SendNavigateWithParameters(
 141     int page_id,
 142     const GURL& url,
 143     ui::PageTransition transition,
 144     const GURL& original_request_url,
 145     int response_code,
 146     const base::FilePath* file_path_for_history_item,
 147     const std::vector<GURL>& redirects) {
 148   FrameHostMsg_DidCommitProvisionalLoad_Params params;
 149   params.page_id = page_id;
 150   params.url = url;
 151   params.referrer = Referrer();
 152   params.transition = transition;
 153   params.redirects = redirects;
 154   params.should_update_history = true;
 155   params.searchable_form_url = GURL();
 156   params.searchable_form_encoding = std::string();
 157   params.security_info = std::string();
 158   params.gesture = NavigationGestureUser;
 159   params.contents_mime_type = contents_mime_type_;
 160   params.is_post = false;
 161   params.http_status_code = response_code;
 162   params.socket_address.set_host("2001:db8::1");
 163   params.socket_address.set_port(80);
 164   params.history_list_was_cleared = simulate_history_list_was_cleared_;
 165   params.original_request_url = original_request_url;
 166
 167   url::Replacements<char> replacements;
 168   replacements.ClearRef();
 169   params.was_within_same_page = transition != ui::PAGE_TRANSITION_RELOAD &&
 170       transition != ui::PAGE_TRANSITION_TYPED &&
 171       url.ReplaceComponents(replacements) ==
 172           GetLastCommittedURL().ReplaceComponents(replacements);
 173
 174   params.page_state = PageState::CreateForTesting(
 175       url,
 176       false,
 177       file_path_for_history_item ? "data" : NULL,
 178       file_path_for_history_item);
 179
 180   FrameHostMsg_DidCommitProvisionalLoad msg(GetRoutingID(), params);
 181   OnDidCommitProvisionalLoad(msg);
 182 }
 183
 184 void TestRenderFrameHost::SendBeginNavigationWithURL(const GURL& url) {
 185   FrameHostMsg_BeginNavigation_Params begin_params;
 186   CommonNavigationParams common_params;
 187   begin_params.method = "GET";
 188   begin_params.load_flags = net::LOAD_NORMAL;
 189   begin_params.has_user_gesture = false;
 190   common_params.url = url;
 191   common_params.referrer = Referrer(GURL(), blink::WebReferrerPolicyDefault);
 192   common_params.transition = ui::PAGE_TRANSITION_LINK;
 193   OnBeginNavigation(begin_params, common_params);
 194 }
 195
 196 void TestRenderFrameHost::DidDisownOpener() {
 197   OnDidDisownOpener();
 198 }
 199
 200 void TestRenderFrameHost::PrepareForCommit(const GURL& url) {
 201   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
 202           switches::kEnableBrowserSideNavigation)) {
 203     SendBeforeUnloadACK(true);
 204     return;
 205   }
 206
 207   // PlzNavigate
 208   // Simulate the network stack commit without any redirects.
 209   NavigationRequest* request =
 210       static_cast<NavigatorImpl*>(frame_tree_node_->navigator())
 211           ->GetNavigationRequestForNodeForTesting(frame_tree_node_);
 212
 213   // We are simulating a renderer-initiated navigation.
 214   if (!request) {
 215     SendBeginNavigationWithURL(url);
 216     request = static_cast<NavigatorImpl*>(frame_tree_node_->navigator())
 217         ->GetNavigationRequestForNodeForTesting(frame_tree_node_);
 218   }
 219   ASSERT_TRUE(request);
 220
 221   // We may not have simulated the renderer response to the navigation request.
 222   // Do that now.
 223   if (request->state() == NavigationRequest::WAITING_FOR_RENDERER_RESPONSE)
 224     SendBeginNavigationWithURL(url);
 225
 226   // We have already simulated the IO thread commit. Only the
 227   // DidCommitProvisionalLoad from the renderer is missing.
 228   if (request->state() == NavigationRequest::RESPONSE_STARTED)
 229     return;
 230
 231   ASSERT_TRUE(request->state() == NavigationRequest::STARTED);
 232   TestNavigationURLLoader* url_loader =
 233       static_cast<TestNavigationURLLoader*>(request->loader_for_testing());
 234   ASSERT_TRUE(url_loader);
 235   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 236   url_loader->CallOnResponseStarted(response, MakeEmptyStream());
 237 }
 238
 239 }  // namespace content