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