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 }
  58
  59 TestRenderFrameHost::~TestRenderFrameHost() {}
  60
  61 TestRenderViewHost* TestRenderFrameHost::GetRenderViewHost() {
  62   return static_cast<TestRenderViewHost*>(
  63       RenderFrameHostImpl::GetRenderViewHost());
  64 }
  65
  66 TestRenderFrameHost* TestRenderFrameHost::AppendChild(
  67     const std::string& frame_name) {
  68   OnCreateChildFrame(GetProcess()->GetNextRoutingID(), frame_name,
  69                      SandboxFlags::NONE);
  70   return static_cast<TestRenderFrameHost*>(
  71       child_creation_observer_.last_created_frame());
  72 }
  73
  74 void TestRenderFrameHost::SendNavigateWithTransition(
  75     int page_id,
  76     const GURL& url,
  77     ui::PageTransition transition) {
  78   SendNavigateWithTransitionAndResponseCode(page_id, url, transition, 200);
  79 }
  80
  81 void TestRenderFrameHost::SetContentsMimeType(const std::string& mime_type) {
  82   contents_mime_type_ = mime_type;
  83 }
  84
  85 void TestRenderFrameHost::SendBeforeUnloadACK(bool proceed) {
  86   base::TimeTicks now = base::TimeTicks::Now();
  87   OnBeforeUnloadACK(proceed, now, now);
  88 }
  89
  90 void TestRenderFrameHost::SimulateSwapOutACK() {
  91   OnSwappedOut();
  92 }
  93
  94 void TestRenderFrameHost::SendNavigate(int page_id, const GURL& url) {
  95   SendNavigateWithTransition(page_id, url, ui::PAGE_TRANSITION_LINK);
  96 }
  97
  98 void TestRenderFrameHost::SendFailedNavigate(int page_id, const GURL& url) {
  99   SendNavigateWithTransitionAndResponseCode(
 100       page_id, url, ui::PAGE_TRANSITION_RELOAD, 500);
 101 }
 102
 103 void TestRenderFrameHost::SendNavigateWithTransitionAndResponseCode(
 104     int page_id,
 105     const GURL& url, ui::PageTransition transition,
 106     int response_code) {
 107   // DidStartProvisionalLoad may delete the pending entry that holds |url|,
 108   // so we keep a copy of it to use in SendNavigateWithParameters.
 109   GURL url_copy(url);
 110   OnDidStartProvisionalLoadForFrame(url_copy, false);
 111   SendNavigateWithParameters(page_id, url_copy, transition, url_copy,
 112       response_code, 0, std::vector<GURL>());
 113 }
 114
 115 void TestRenderFrameHost::SendNavigateWithOriginalRequestURL(
 116     int page_id,
 117     const GURL& url,
 118     const GURL& original_request_url) {
 119   OnDidStartProvisionalLoadForFrame(url, false);
 120   SendNavigateWithParameters(page_id, url, ui::PAGE_TRANSITION_LINK,
 121       original_request_url, 200, 0, std::vector<GURL>());
 122 }
 123
 124 void TestRenderFrameHost::SendNavigateWithFile(
 125     int page_id,
 126     const GURL& url,
 127     const base::FilePath& file_path) {
 128   SendNavigateWithParameters(page_id, url, ui::PAGE_TRANSITION_LINK, url, 200,
 129       &file_path, std::vector<GURL>());
 130 }
 131
 132 void TestRenderFrameHost::SendNavigateWithParams(
 133     FrameHostMsg_DidCommitProvisionalLoad_Params* params) {
 134   FrameHostMsg_DidCommitProvisionalLoad msg(GetRoutingID(), *params);
 135   OnDidCommitProvisionalLoad(msg);
 136 }
 137
 138 void TestRenderFrameHost::SendNavigateWithRedirects(
 139     int page_id,
 140     const GURL& url,
 141     const std::vector<GURL>& redirects) {
 142   SendNavigateWithParameters(
 143       page_id, url, ui::PAGE_TRANSITION_LINK, url, 200, 0, redirects);
 144 }
 145
 146 void TestRenderFrameHost::SendNavigateWithParameters(
 147     int page_id,
 148     const GURL& url,
 149     ui::PageTransition transition,
 150     const GURL& original_request_url,
 151     int response_code,
 152     const base::FilePath* file_path_for_history_item,
 153     const std::vector<GURL>& redirects) {
 154   FrameHostMsg_DidCommitProvisionalLoad_Params params;
 155   params.page_id = page_id;
 156   params.url = url;
 157   params.referrer = Referrer();
 158   params.transition = transition;
 159   params.redirects = redirects;
 160   params.should_update_history = true;
 161   params.searchable_form_url = GURL();
 162   params.searchable_form_encoding = std::string();
 163   params.security_info = std::string();
 164   params.gesture = NavigationGestureUser;
 165   params.contents_mime_type = contents_mime_type_;
 166   params.is_post = false;
 167   params.http_status_code = response_code;
 168   params.socket_address.set_host("2001:db8::1");
 169   params.socket_address.set_port(80);
 170   params.history_list_was_cleared = simulate_history_list_was_cleared_;
 171   params.original_request_url = original_request_url;
 172
 173   url::Replacements<char> replacements;
 174   replacements.ClearRef();
 175   params.was_within_same_page = transition != ui::PAGE_TRANSITION_RELOAD &&
 176       transition != ui::PAGE_TRANSITION_TYPED &&
 177       url.ReplaceComponents(replacements) ==
 178           GetLastCommittedURL().ReplaceComponents(replacements);
 179
 180   params.page_state = PageState::CreateForTesting(
 181       url,
 182       false,
 183       file_path_for_history_item ? "data" : NULL,
 184       file_path_for_history_item);
 185
 186   FrameHostMsg_DidCommitProvisionalLoad msg(GetRoutingID(), params);
 187   OnDidCommitProvisionalLoad(msg);
 188 }
 189
 190 void TestRenderFrameHost::SendBeginNavigationWithURL(const GURL& url) {
 191   BeginNavigationParams begin_params(
 192       "GET", std::string(), net::LOAD_NORMAL, false);
 193   CommonNavigationParams common_params;
 194   common_params.url = url;
 195   common_params.referrer = Referrer(GURL(), blink::WebReferrerPolicyDefault);
 196   common_params.transition = ui::PAGE_TRANSITION_LINK;
 197   OnBeginNavigation(common_params, begin_params,
 198                     scoped_refptr<ResourceRequestBody>());
 199 }
 200
 201 void TestRenderFrameHost::DidDisownOpener() {
 202   OnDidDisownOpener();
 203 }
 204
 205 void TestRenderFrameHost::PrepareForCommit(const GURL& url) {
 206   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
 207           switches::kEnableBrowserSideNavigation)) {
 208     SendBeforeUnloadACK(true);
 209     return;
 210   }
 211
 212   // PlzNavigate
 213   // Simulate the network stack commit without any redirects.
 214   NavigationRequest* request =
 215       static_cast<NavigatorImpl*>(frame_tree_node_->navigator())
 216           ->GetNavigationRequestForNodeForTesting(frame_tree_node_);
 217
 218   // We are simulating a renderer-initiated navigation.
 219   if (!request) {
 220     SendBeginNavigationWithURL(url);
 221     request = static_cast<NavigatorImpl*>(frame_tree_node_->navigator())
 222         ->GetNavigationRequestForNodeForTesting(frame_tree_node_);
 223   }
 224   ASSERT_TRUE(request);
 225
 226   // We may not have simulated the renderer response to the navigation request.
 227   // Do that now.
 228   if (request->state() == NavigationRequest::WAITING_FOR_RENDERER_RESPONSE)
 229     SendBeforeUnloadACK(true);
 230
 231   // We have already simulated the IO thread commit. Only the
 232   // DidCommitProvisionalLoad from the renderer is missing.
 233   if (request->state() == NavigationRequest::RESPONSE_STARTED)
 234     return;
 235
 236   ASSERT_TRUE(request->state() == NavigationRequest::STARTED);
 237   TestNavigationURLLoader* url_loader =
 238       static_cast<TestNavigationURLLoader*>(request->loader_for_testing());
 239   ASSERT_TRUE(url_loader);
 240   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 241   url_loader->CallOnResponseStarted(response, MakeEmptyStream());
 242 }
 243
 244 void TestRenderFrameHost::SendBeforeUnloadHandlersPresent(bool present) {
 245   OnBeforeUnloadHandlersPresent(present);
 246 }
 247
 248 void TestRenderFrameHost::SendUnloadHandlersPresent(bool present) {
 249   OnUnloadHandlersPresent(present);
 250 }
 251
 252 }  // namespace content