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/common/frame_messages.h"
  14 #include "content/public/browser/stream_handle.h"
  15 #include "content/public/common/content_switches.h"
  16 #include "content/test/browser_side_navigation_test_utils.h"
  17 #include "content/test/test_navigation_url_loader.h"
  18 #include "content/test/test_render_view_host.h"
  19 #include "net/base/load_flags.h"
  20 #include "third_party/WebKit/public/platform/WebPageVisibilityState.h"
  21 #include "ui/base/page_transition_types.h"
  22
  23 namespace content {
  24
  25 TestRenderFrameHostCreationObserver::TestRenderFrameHostCreationObserver(
  26     WebContents* web_contents)
  27     : WebContentsObserver(web_contents), last_created_frame_(NULL) {
  28 }
  29
  30 TestRenderFrameHostCreationObserver::~TestRenderFrameHostCreationObserver() {
  31 }
  32
  33 void TestRenderFrameHostCreationObserver::RenderFrameCreated(
  34     RenderFrameHost* render_frame_host) {
  35   last_created_frame_ = render_frame_host;
  36 }
  37
  38 TestRenderFrameHost::TestRenderFrameHost(SiteInstance* site_instance,
  39                                          RenderViewHostImpl* render_view_host,
  40                                          RenderFrameHostDelegate* delegate,
  41                                          RenderWidgetHostDelegate* rwh_delegate,
  42                                          FrameTree* frame_tree,
  43                                          FrameTreeNode* frame_tree_node,
  44                                          int routing_id,
  45                                          int flags)
  46     : RenderFrameHostImpl(site_instance,
  47                           render_view_host,
  48                           delegate,
  49                           rwh_delegate,
  50                           frame_tree,
  51                           frame_tree_node,
  52                           routing_id,
  53                           flags),
  54       child_creation_observer_(delegate ? delegate->GetAsWebContents() : NULL),
  55       contents_mime_type_("text/html"),
  56       simulate_history_list_was_cleared_(false) {
  57   if (frame_tree_node_->IsMainFrame())
  58     SetRenderFrameCreated(true);
  59 }
  60
  61 TestRenderFrameHost::~TestRenderFrameHost() {
  62   SetRenderFrameCreated(false);
  63 }
  64
  65 TestRenderViewHost* TestRenderFrameHost::GetRenderViewHost() {
  66   return static_cast<TestRenderViewHost*>(
  67       RenderFrameHostImpl::GetRenderViewHost());
  68 }
  69
  70 MockRenderProcessHost* TestRenderFrameHost::GetProcess() {
  71   return static_cast<MockRenderProcessHost*>(RenderFrameHostImpl::GetProcess());
  72 }
  73
  74 TestRenderFrameHost* TestRenderFrameHost::AppendChild(
  75     const std::string& frame_name) {
  76   OnCreateChildFrame(GetProcess()->GetNextRoutingID(), frame_name,
  77                      SandboxFlags::NONE);
  78   return static_cast<TestRenderFrameHost*>(
  79       child_creation_observer_.last_created_frame());
  80 }
  81
  82 void TestRenderFrameHost::SetContentsMimeType(const std::string& mime_type) {
  83   contents_mime_type_ = mime_type;
  84 }
  85
  86 void TestRenderFrameHost::SendBeforeUnloadACK(bool proceed) {
  87   base::TimeTicks now = base::TimeTicks::Now();
  88   OnBeforeUnloadACK(proceed, now, now);
  89 }
  90
  91 void TestRenderFrameHost::SimulateSwapOutACK() {
  92   OnSwappedOut();
  93 }
  94
  95 void TestRenderFrameHost::SendNavigate(int page_id,
  96                                        int nav_entry_id,
  97                                        bool did_create_new_entry,
  98                                        const GURL& url) {
  99   SendNavigateWithTransition(page_id, nav_entry_id, did_create_new_entry, url,
 100                              ui::PAGE_TRANSITION_LINK);
 101 }
 102
 103 void TestRenderFrameHost::SendFailedNavigate(int page_id,
 104                                              int nav_entry_id,
 105                                              bool did_create_new_entry,
 106                                              const GURL& url) {
 107   SendNavigateWithTransitionAndResponseCode(page_id, nav_entry_id,
 108                                             did_create_new_entry, url,
 109                                             ui::PAGE_TRANSITION_RELOAD, 500);
 110 }
 111
 112 void TestRenderFrameHost::SendNavigateWithTransition(
 113     int page_id,
 114     int nav_entry_id,
 115     bool did_create_new_entry,
 116     const GURL& url,
 117     ui::PageTransition transition) {
 118   SendNavigateWithTransitionAndResponseCode(
 119       page_id, nav_entry_id, did_create_new_entry, url, transition, 200);
 120 }
 121
 122 void TestRenderFrameHost::SendNavigateWithTransitionAndResponseCode(
 123     int page_id,
 124     int nav_entry_id,
 125     bool did_create_new_entry,
 126     const GURL& url,
 127     ui::PageTransition transition,
 128     int response_code) {
 129   // DidStartProvisionalLoad may delete the pending entry that holds |url|,
 130   // so we keep a copy of it to use in SendNavigateWithParameters.
 131   GURL url_copy(url);
 132
 133   // Ensure that the RenderFrameCreated notification has been sent to observers
 134   // before navigating the frame.
 135   SetRenderFrameCreated(true);
 136
 137   OnDidStartProvisionalLoadForFrame(url_copy, false);
 138   SendNavigateWithParameters(page_id, nav_entry_id, did_create_new_entry,
 139                              url_copy, transition, url_copy, response_code, 0,
 140                              std::vector<GURL>());
 141 }
 142
 143 void TestRenderFrameHost::SendNavigateWithOriginalRequestURL(
 144     int page_id,
 145     int nav_entry_id,
 146     bool did_create_new_entry,
 147     const GURL& url,
 148     const GURL& original_request_url) {
 149   // Ensure that the RenderFrameCreated notification has been sent to observers
 150   // before navigating the frame.
 151   SetRenderFrameCreated(true);
 152
 153   OnDidStartProvisionalLoadForFrame(url, false);
 154   SendNavigateWithParameters(page_id, nav_entry_id, did_create_new_entry, url,
 155                              ui::PAGE_TRANSITION_LINK, original_request_url,
 156                              200, 0, std::vector<GURL>());
 157 }
 158
 159 void TestRenderFrameHost::SendNavigateWithFile(
 160     int page_id,
 161     int nav_entry_id,
 162     bool did_create_new_entry,
 163     const GURL& url,
 164     const base::FilePath& file_path) {
 165   SendNavigateWithParameters(page_id, nav_entry_id, did_create_new_entry, url,
 166                              ui::PAGE_TRANSITION_LINK, url, 200, &file_path,
 167                              std::vector<GURL>());
 168 }
 169
 170 void TestRenderFrameHost::SendNavigateWithParams(
 171     FrameHostMsg_DidCommitProvisionalLoad_Params* params) {
 172   FrameHostMsg_DidCommitProvisionalLoad msg(GetRoutingID(), *params);
 173   OnDidCommitProvisionalLoad(msg);
 174 }
 175
 176 void TestRenderFrameHost::SendNavigateWithRedirects(
 177     int page_id,
 178     int nav_entry_id,
 179     bool did_create_new_entry,
 180     const GURL& url,
 181     const std::vector<GURL>& redirects) {
 182   SendNavigateWithParameters(page_id, nav_entry_id, did_create_new_entry, url,
 183                              ui::PAGE_TRANSITION_LINK, url, 200, 0, redirects);
 184 }
 185
 186 void TestRenderFrameHost::SendNavigateWithParameters(
 187     int page_id,
 188     int nav_entry_id,
 189     bool did_create_new_entry,
 190     const GURL& url,
 191     ui::PageTransition transition,
 192     const GURL& original_request_url,
 193     int response_code,
 194     const base::FilePath* file_path_for_history_item,
 195     const std::vector<GURL>& redirects) {
 196   FrameHostMsg_DidCommitProvisionalLoad_Params params;
 197   params.page_id = page_id;
 198   params.nav_entry_id = nav_entry_id;
 199   params.url = url;
 200   params.referrer = Referrer();
 201   params.transition = transition;
 202   params.redirects = redirects;
 203   params.should_update_history = true;
 204   params.searchable_form_url = GURL();
 205   params.searchable_form_encoding = std::string();
 206   params.did_create_new_entry = did_create_new_entry;
 207   params.security_info = std::string();
 208   params.gesture = NavigationGestureUser;
 209   params.contents_mime_type = contents_mime_type_;
 210   params.is_post = false;
 211   params.http_status_code = response_code;
 212   params.socket_address.set_host("2001:db8::1");
 213   params.socket_address.set_port(80);
 214   params.history_list_was_cleared = simulate_history_list_was_cleared_;
 215   params.original_request_url = original_request_url;
 216
 217   url::Replacements<char> replacements;
 218   replacements.ClearRef();
 219   params.was_within_same_page = transition != ui::PAGE_TRANSITION_RELOAD &&
 220       transition != ui::PAGE_TRANSITION_TYPED &&
 221       url.ReplaceComponents(replacements) ==
 222           GetLastCommittedURL().ReplaceComponents(replacements);
 223
 224   params.page_state = PageState::CreateForTesting(
 225       url,
 226       false,
 227       file_path_for_history_item ? "data" : NULL,
 228       file_path_for_history_item);
 229
 230   FrameHostMsg_DidCommitProvisionalLoad msg(GetRoutingID(), params);
 231   OnDidCommitProvisionalLoad(msg);
 232 }
 233
 234 void TestRenderFrameHost::NavigateAndCommitRendererInitiated(
 235     int page_id,
 236     bool did_create_new_entry,
 237     const GURL& url) {
 238   SendRendererInitiatedNavigationRequest(url, false);
 239   PrepareForCommit();
 240   SendNavigate(page_id, 0, did_create_new_entry, url);
 241 }
 242
 243 void TestRenderFrameHost::SendRendererInitiatedNavigationRequest(
 244     const GURL& url,
 245     bool has_user_gesture) {
 246   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
 247           switches::kEnableBrowserSideNavigation)) {
 248     BeginNavigationParams begin_params("GET", std::string(), net::LOAD_NORMAL,
 249                                        has_user_gesture);
 250     CommonNavigationParams common_params;
 251     common_params.url = url;
 252     common_params.referrer = Referrer(GURL(), blink::WebReferrerPolicyDefault);
 253     common_params.transition = ui::PAGE_TRANSITION_LINK;
 254     OnBeginNavigation(common_params, begin_params,
 255                       scoped_refptr<ResourceRequestBody>());
 256   }
 257 }
 258
 259 void TestRenderFrameHost::DidDisownOpener() {
 260   OnDidDisownOpener();
 261 }
 262
 263 void TestRenderFrameHost::PrepareForCommit() {
 264   PrepareForCommitWithServerRedirect(GURL());
 265 }
 266
 267 void TestRenderFrameHost::PrepareForCommitWithServerRedirect(
 268     const GURL& redirect_url) {
 269   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
 270           switches::kEnableBrowserSideNavigation)) {
 271     // Non PlzNavigate
 272     if (IsWaitingForBeforeUnloadACK())
 273       SendBeforeUnloadACK(true);
 274     return;
 275   }
 276
 277   // PlzNavigate
 278   NavigationRequest* request = frame_tree_node_->navigation_request();
 279   CHECK(request);
 280
 281   // Simulate a beforeUnload ACK from the renderer if the browser is waiting for
 282   // it. If it runs it will update the request state.
 283   if (request->state() == NavigationRequest::WAITING_FOR_RENDERER_RESPONSE)
 284     SendBeforeUnloadACK(true);
 285
 286   // If a network request is not needed for this URL, just check the request is
 287   // in the correct state and return.
 288   if (!request->ShouldMakeNetworkRequest(request->common_params().url)) {
 289     CHECK(request->state() == NavigationRequest::RESPONSE_STARTED);
 290     return;
 291   }
 292
 293   CHECK(request->state() == NavigationRequest::STARTED);
 294
 295   TestNavigationURLLoader* url_loader =
 296       static_cast<TestNavigationURLLoader*>(request->loader_for_testing());
 297   CHECK(url_loader);
 298
 299   // If a non-empty |redirect_url| was provided, simulate a server redirect.
 300   if (!redirect_url.is_empty())
 301     url_loader->SimulateServerRedirect(redirect_url);
 302
 303   // Simulate the network stack commit.
 304   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 305   // TODO(carlosk): ideally with PlzNavigate it should be possible someday to
 306   // fully commit the navigation at this call to CallOnResponseStarted.
 307   url_loader->CallOnResponseStarted(response, MakeEmptyStream());
 308 }
 309
 310 }  // namespace content