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