| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "content/test/test_web_contents.h" |
| |
| #include <utility> |
| |
| #include "content/browser/browser_url_handler_impl.h" |
| #include "content/browser/frame_host/cross_process_frame_connector.h" |
| #include "content/browser/frame_host/navigation_entry_impl.h" |
| #include "content/browser/frame_host/navigator.h" |
| #include "content/browser/renderer_host/render_view_host_impl.h" |
| #include "content/browser/site_instance_impl.h" |
| #include "content/common/frame_messages.h" |
| #include "content/common/view_messages.h" |
| #include "content/public/browser/notification_registrar.h" |
| #include "content/public/browser/notification_source.h" |
| #include "content/public/browser/notification_types.h" |
| #include "content/public/common/page_state.h" |
| #include "content/public/test/mock_render_process_host.h" |
| #include "content/test/test_render_view_host.h" |
| #include "ui/base/page_transition_types.h" |
| |
| namespace content { |
| |
| TestWebContents::TestWebContents(BrowserContext* browser_context) |
| : WebContentsImpl(browser_context, NULL), |
| delegate_view_override_(NULL), |
| expect_set_history_length_and_prune_(false), |
| expect_set_history_length_and_prune_site_instance_(NULL), |
| expect_set_history_length_and_prune_history_length_(0), |
| expect_set_history_length_and_prune_min_page_id_(-1) { |
| } |
| |
| TestWebContents* TestWebContents::Create(BrowserContext* browser_context, |
| SiteInstance* instance) { |
| TestWebContents* test_web_contents = new TestWebContents(browser_context); |
| test_web_contents->Init(WebContents::CreateParams(browser_context, instance)); |
| return test_web_contents; |
| } |
| |
| TestWebContents::~TestWebContents() { |
| EXPECT_FALSE(expect_set_history_length_and_prune_); |
| } |
| |
| TestRenderFrameHost* TestWebContents::GetMainFrame() { |
| return static_cast<TestRenderFrameHost*>(WebContentsImpl::GetMainFrame()); |
| } |
| |
| TestRenderViewHost* TestWebContents::GetRenderViewHost() const { |
| return static_cast<TestRenderViewHost*>( |
| WebContentsImpl::GetRenderViewHost()); |
| } |
| |
| TestRenderFrameHost* TestWebContents::GetPendingMainFrame() const { |
| return static_cast<TestRenderFrameHost*>( |
| GetRenderManager()->pending_frame_host()); |
| } |
| |
| void TestWebContents::TestDidNavigate(RenderFrameHost* render_frame_host, |
| int page_id, |
| const GURL& url, |
| ui::PageTransition transition) { |
| TestDidNavigateWithReferrer(render_frame_host, |
| page_id, |
| url, |
| Referrer(), |
| transition); |
| } |
| |
| void TestWebContents::TestDidNavigateWithReferrer( |
| RenderFrameHost* render_frame_host, |
| int page_id, |
| const GURL& url, |
| const Referrer& referrer, |
| ui::PageTransition transition) { |
| FrameHostMsg_DidCommitProvisionalLoad_Params params; |
| |
| params.page_id = page_id; |
| params.url = url; |
| params.referrer = referrer; |
| params.transition = transition; |
| params.redirects = std::vector<GURL>(); |
| params.should_update_history = false; |
| params.searchable_form_url = GURL(); |
| params.searchable_form_encoding = std::string(); |
| params.security_info = std::string(); |
| params.gesture = NavigationGestureUser; |
| params.was_within_same_page = false; |
| params.is_post = false; |
| params.page_state = PageState::CreateFromURL(url); |
| |
| RenderFrameHostImpl* rfhi = |
| static_cast<RenderFrameHostImpl*>(render_frame_host); |
| rfhi->frame_tree_node()->navigator()->DidNavigate(rfhi, params); |
| } |
| |
| WebPreferences TestWebContents::TestComputeWebkitPrefs() { |
| return ComputeWebkitPrefs(); |
| } |
| |
| bool TestWebContents::CreateRenderViewForRenderManager( |
| RenderViewHost* render_view_host, |
| int opener_route_id, |
| int proxy_routing_id, |
| bool for_main_frame) { |
| UpdateMaxPageIDIfNecessary(render_view_host); |
| // This will go to a TestRenderViewHost. |
| static_cast<RenderViewHostImpl*>( |
| render_view_host)->CreateRenderView(base::string16(), |
| opener_route_id, |
| proxy_routing_id, |
| -1, false); |
| return true; |
| } |
| |
| WebContents* TestWebContents::Clone() { |
| WebContentsImpl* contents = |
| Create(GetBrowserContext(), SiteInstance::Create(GetBrowserContext())); |
| contents->GetController().CopyStateFrom(controller_); |
| return contents; |
| } |
| |
| void TestWebContents::NavigateAndCommit(const GURL& url) { |
| GetController().LoadURL( |
| url, Referrer(), ui::PAGE_TRANSITION_LINK, std::string()); |
| GURL loaded_url(url); |
| bool reverse_on_redirect = false; |
| BrowserURLHandlerImpl::GetInstance()->RewriteURLIfNecessary( |
| &loaded_url, GetBrowserContext(), &reverse_on_redirect); |
| |
| // LoadURL created a navigation entry, now simulate the RenderView sending |
| // a notification that it actually navigated. |
| CommitPendingNavigation(); |
| } |
| |
| void TestWebContents::TestSetIsLoading(bool value) { |
| SetIsLoading(GetRenderViewHost(), value, true, NULL); |
| } |
| |
| void TestWebContents::CommitPendingNavigation() { |
| // If we are doing a cross-site navigation, this simulates the current RVH |
| // notifying that it has unloaded so the pending RVH is resumed and can |
| // navigate. |
| ProceedWithCrossSiteNavigation(); |
| TestRenderFrameHost* old_rfh = GetMainFrame(); |
| TestRenderFrameHost* rfh = GetPendingMainFrame(); |
| if (!rfh) |
| rfh = old_rfh; |
| |
| const NavigationEntry* entry = GetController().GetPendingEntry(); |
| DCHECK(entry); |
| int page_id = entry->GetPageID(); |
| if (page_id == -1) { |
| // It's a new navigation, assign a never-seen page id to it. |
| page_id = GetMaxPageIDForSiteInstance(rfh->GetSiteInstance()) + 1; |
| } |
| |
| rfh->SendNavigate(page_id, entry->GetURL()); |
| // Simulate the SwapOut_ACK. This is needed when cross-site navigation happens |
| // (old_rfh != rfh). |
| if (old_rfh != rfh) |
| old_rfh->OnSwappedOut(false); |
| } |
| |
| void TestWebContents::ProceedWithCrossSiteNavigation() { |
| if (!GetPendingMainFrame()) |
| return; |
| GetMainFrame()->GetRenderViewHost()->SendBeforeUnloadACK(true); |
| } |
| |
| RenderViewHostDelegateView* TestWebContents::GetDelegateView() { |
| if (delegate_view_override_) |
| return delegate_view_override_; |
| return WebContentsImpl::GetDelegateView(); |
| } |
| |
| void TestWebContents::SetOpener(TestWebContents* opener) { |
| // This is normally only set in the WebContents constructor, which also |
| // registers an observer for when the opener gets closed. |
| opener_ = opener; |
| AddDestructionObserver(opener_); |
| } |
| |
| void TestWebContents::AddPendingContents(TestWebContents* contents) { |
| // This is normally only done in WebContentsImpl::CreateNewWindow. |
| pending_contents_[contents->GetRenderViewHost()->GetRoutingID()] = contents; |
| AddDestructionObserver(contents); |
| } |
| |
| void TestWebContents::ExpectSetHistoryLengthAndPrune( |
| const SiteInstance* site_instance, |
| int history_length, |
| int32 min_page_id) { |
| expect_set_history_length_and_prune_ = true; |
| expect_set_history_length_and_prune_site_instance_ = |
| static_cast<const SiteInstanceImpl*>(site_instance); |
| expect_set_history_length_and_prune_history_length_ = history_length; |
| expect_set_history_length_and_prune_min_page_id_ = min_page_id; |
| } |
| |
| void TestWebContents::SetHistoryLengthAndPrune( |
| const SiteInstance* site_instance, int history_length, |
| int32 min_page_id) { |
| EXPECT_TRUE(expect_set_history_length_and_prune_); |
| expect_set_history_length_and_prune_ = false; |
| EXPECT_EQ(expect_set_history_length_and_prune_site_instance_.get(), |
| site_instance); |
| EXPECT_EQ(expect_set_history_length_and_prune_history_length_, |
| history_length); |
| EXPECT_EQ(expect_set_history_length_and_prune_min_page_id_, min_page_id); |
| } |
| |
| void TestWebContents::TestDidFinishLoad(const GURL& url) { |
| FrameHostMsg_DidFinishLoad msg(0, url); |
| frame_tree_.root()->current_frame_host()->OnMessageReceived(msg); |
| } |
| |
| void TestWebContents::TestDidFailLoadWithError( |
| const GURL& url, |
| int error_code, |
| const base::string16& error_description) { |
| FrameHostMsg_DidFailLoadWithError msg( |
| 0, url, error_code, error_description); |
| frame_tree_.root()->current_frame_host()->OnMessageReceived(msg); |
| } |
| |
| void TestWebContents::CreateNewWindow( |
| int render_process_id, |
| int route_id, |
| int main_frame_route_id, |
| const ViewHostMsg_CreateWindow_Params& params, |
| SessionStorageNamespace* session_storage_namespace) { |
| } |
| |
| void TestWebContents::CreateNewWidget(int render_process_id, |
| int route_id, |
| blink::WebPopupType popup_type) { |
| } |
| |
| void TestWebContents::CreateNewFullscreenWidget(int render_process_id, |
| int route_id) { |
| } |
| |
| void TestWebContents::ShowCreatedWindow(int route_id, |
| WindowOpenDisposition disposition, |
| const gfx::Rect& initial_pos, |
| bool user_gesture) { |
| } |
| |
| void TestWebContents::ShowCreatedWidget(int route_id, |
| const gfx::Rect& initial_pos) { |
| } |
| |
| void TestWebContents::ShowCreatedFullscreenWidget(int route_id) { |
| } |
| |
| } // namespace content |