test_web_contents.cc revision a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7 
1// Copyright (c) 2012 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_web_contents.h"
6
7#include <utility>
8
9#include "content/browser/browser_url_handler_impl.h"
10#include "content/browser/frame_host/navigation_entry_impl.h"
11#include "content/browser/renderer_host/render_view_host_impl.h"
12#include "content/browser/site_instance_impl.h"
13#include "content/common/view_messages.h"
14#include "content/public/browser/notification_registrar.h"
15#include "content/public/browser/notification_source.h"
16#include "content/public/browser/notification_types.h"
17#include "content/public/common/page_state.h"
18#include "content/public/common/page_transition_types.h"
19#include "content/public/test/mock_render_process_host.h"
20#include "content/test/test_render_view_host.h"
21
22namespace content {
23
24TestWebContents::TestWebContents(BrowserContext* browser_context)
25    : WebContentsImpl(browser_context, NULL),
26      transition_cross_site(false),
27      delegate_view_override_(NULL),
28      expect_set_history_length_and_prune_(false),
29      expect_set_history_length_and_prune_site_instance_(NULL),
30      expect_set_history_length_and_prune_history_length_(0),
31      expect_set_history_length_and_prune_min_page_id_(-1) {
32}
33
34TestWebContents* TestWebContents::Create(BrowserContext* browser_context,
35                                         SiteInstance* instance) {
36  TestWebContents* test_web_contents = new TestWebContents(browser_context);
37  test_web_contents->Init(WebContents::CreateParams(browser_context, instance));
38  return test_web_contents;
39}
40
41TestWebContents::~TestWebContents() {
42  EXPECT_FALSE(expect_set_history_length_and_prune_);
43}
44
45RenderViewHost* TestWebContents::GetPendingRenderViewHost() const {
46  return GetRenderManager()->pending_render_view_host_;
47}
48
49TestRenderViewHost* TestWebContents::pending_test_rvh() const {
50  return static_cast<TestRenderViewHost*>(GetPendingRenderViewHost());
51}
52
53void TestWebContents::TestDidNavigate(RenderViewHost* render_view_host,
54                                      int page_id,
55                                      const GURL& url,
56                                      PageTransition transition) {
57  TestDidNavigateWithReferrer(render_view_host,
58                              page_id,
59                              url,
60                              Referrer(),
61                              transition);
62}
63
64void TestWebContents::TestDidNavigateWithReferrer(
65    RenderViewHost* render_view_host,
66    int page_id,
67    const GURL& url,
68    const Referrer& referrer,
69    PageTransition transition) {
70  ViewHostMsg_FrameNavigate_Params params;
71
72  params.page_id = page_id;
73  params.url = url;
74  params.referrer = referrer;
75  params.transition = transition;
76  params.redirects = std::vector<GURL>();
77  params.should_update_history = false;
78  params.searchable_form_url = GURL();
79  params.searchable_form_encoding = std::string();
80  params.security_info = std::string();
81  params.gesture = NavigationGestureUser;
82  params.was_within_same_page = false;
83  params.is_post = false;
84  params.page_state = PageState::CreateFromURL(url);
85
86  DidNavigate(render_view_host, params);
87}
88
89WebPreferences TestWebContents::TestGetWebkitPrefs() {
90  return GetWebkitPrefs();
91}
92
93bool TestWebContents::CreateRenderViewForRenderManager(
94    RenderViewHost* render_view_host, int opener_route_id) {
95  // This will go to a TestRenderViewHost.
96  static_cast<RenderViewHostImpl*>(
97      render_view_host)->CreateRenderView(base::string16(),
98                                          opener_route_id,
99                                          -1);
100  return true;
101}
102
103WebContents* TestWebContents::Clone() {
104  WebContentsImpl* contents =
105      Create(GetBrowserContext(), SiteInstance::Create(GetBrowserContext()));
106  contents->GetController().CopyStateFrom(controller_);
107  return contents;
108}
109
110void TestWebContents::NavigateAndCommit(const GURL& url) {
111  GetController().LoadURL(
112      url, Referrer(), PAGE_TRANSITION_LINK, std::string());
113  GURL loaded_url(url);
114  bool reverse_on_redirect = false;
115  BrowserURLHandlerImpl::GetInstance()->RewriteURLIfNecessary(
116      &loaded_url, GetBrowserContext(), &reverse_on_redirect);
117
118  // LoadURL created a navigation entry, now simulate the RenderView sending
119  // a notification that it actually navigated.
120  CommitPendingNavigation();
121}
122
123void TestWebContents::TestSetIsLoading(bool value) {
124  SetIsLoading(GetRenderViewHost(), value, NULL);
125}
126
127void TestWebContents::CommitPendingNavigation() {
128  // If we are doing a cross-site navigation, this simulates the current RVH
129  // notifying that it has unloaded so the pending RVH is resumed and can
130  // navigate.
131  ProceedWithCrossSiteNavigation();
132  RenderViewHost* old_rvh = GetRenderViewHost();
133  TestRenderViewHost* rvh =
134      static_cast<TestRenderViewHost*>(GetPendingRenderViewHost());
135  if (!rvh)
136    rvh = static_cast<TestRenderViewHost*>(old_rvh);
137
138  const NavigationEntry* entry = GetController().GetPendingEntry();
139  DCHECK(entry);
140  int page_id = entry->GetPageID();
141  if (page_id == -1) {
142    // It's a new navigation, assign a never-seen page id to it.
143    page_id = GetMaxPageIDForSiteInstance(rvh->GetSiteInstance()) + 1;
144  }
145
146  // Simulate the SwapOut_ACK that happens when we swap out the old
147  // RVH, before the navigation commits. This is needed when
148  // cross-site navigation happens (old_rvh != rvh).
149  if (old_rvh != rvh)
150    static_cast<RenderViewHostImpl*>(old_rvh)->OnSwappedOut(false);
151  rvh->SendNavigate(page_id, entry->GetURL());
152}
153
154void TestWebContents::ProceedWithCrossSiteNavigation() {
155  if (!GetPendingRenderViewHost())
156    return;
157  TestRenderViewHost* rvh = static_cast<TestRenderViewHost*>(
158      GetRenderViewHost());
159  rvh->SendShouldCloseACK(true);
160}
161
162RenderViewHostDelegateView* TestWebContents::GetDelegateView() {
163  if (delegate_view_override_)
164    return delegate_view_override_;
165  return WebContentsImpl::GetDelegateView();
166}
167
168void TestWebContents::SetOpener(TestWebContents* opener) {
169  // This is normally only set in the WebContents constructor, which also
170  // registers an observer for when the opener gets closed.
171  opener_ = opener;
172  AddDestructionObserver(opener_);
173}
174
175void TestWebContents::AddPendingContents(TestWebContents* contents) {
176  // This is normally only done in WebContentsImpl::CreateNewWindow.
177  pending_contents_[contents->GetRenderViewHost()->GetRoutingID()] = contents;
178  AddDestructionObserver(contents);
179}
180
181void TestWebContents::ExpectSetHistoryLengthAndPrune(
182    const SiteInstance* site_instance,
183    int history_length,
184    int32 min_page_id) {
185  expect_set_history_length_and_prune_ = true;
186  expect_set_history_length_and_prune_site_instance_ =
187      static_cast<const SiteInstanceImpl*>(site_instance);
188  expect_set_history_length_and_prune_history_length_ = history_length;
189  expect_set_history_length_and_prune_min_page_id_ = min_page_id;
190}
191
192void TestWebContents::SetHistoryLengthAndPrune(
193    const SiteInstance* site_instance, int history_length,
194    int32 min_page_id) {
195  EXPECT_TRUE(expect_set_history_length_and_prune_);
196  expect_set_history_length_and_prune_ = false;
197  EXPECT_EQ(expect_set_history_length_and_prune_site_instance_, site_instance);
198  EXPECT_EQ(expect_set_history_length_and_prune_history_length_,
199            history_length);
200  EXPECT_EQ(expect_set_history_length_and_prune_min_page_id_, min_page_id);
201}
202
203void TestWebContents::TestDidFinishLoad(int64 frame_id,
204                                        const GURL& url,
205                                        bool is_main_frame) {
206  ViewHostMsg_DidFinishLoad msg(0, frame_id, url, is_main_frame);
207  OnMessageReceived(GetRenderViewHost(), msg);
208}
209
210void TestWebContents::TestDidFailLoadWithError(
211    int64 frame_id,
212    const GURL& url,
213    bool is_main_frame,
214    int error_code,
215    const base::string16& error_description) {
216  ViewHostMsg_DidFailLoadWithError msg(
217      0, frame_id, url, is_main_frame, error_code, error_description);
218  OnMessageReceived(GetRenderViewHost(), msg);
219}
220
221void TestWebContents::CreateNewWindow(
222    int render_process_id,
223    int route_id,
224    int main_frame_route_id,
225    const ViewHostMsg_CreateWindow_Params& params,
226    SessionStorageNamespace* session_storage_namespace) {
227}
228
229void TestWebContents::CreateNewWidget(int render_process_id,
230                                      int route_id,
231                                      blink::WebPopupType popup_type) {
232}
233
234void TestWebContents::CreateNewFullscreenWidget(int render_process_id,
235                                                int route_id) {
236}
237
238void TestWebContents::ShowCreatedWindow(int route_id,
239                                        WindowOpenDisposition disposition,
240                                        const gfx::Rect& initial_pos,
241                                        bool user_gesture) {
242}
243
244void TestWebContents::ShowCreatedWidget(int route_id,
245                                        const gfx::Rect& initial_pos) {
246}
247
248void TestWebContents::ShowCreatedFullscreenWidget(int route_id) {
249}
250
251}  // namespace content
252