#include "base/run_loop.h"
#include "content/common/dom_storage/dom_storage_types.h"
+#include "content/common/frame_messages.h"
#include "content/common/input_messages.h"
#include "content/common/view_messages.h"
+#include "content/public/browser/content_browser_client.h"
#include "content/public/browser/native_web_keyboard_event.h"
+#include "content/public/common/content_client.h"
#include "content/public/common/renderer_preferences.h"
-#include "content/public/renderer/history_item_serialization.h"
+#include "content/public/renderer/content_renderer_client.h"
+#include "content/renderer/history_controller.h"
+#include "content/renderer/history_serialization.h"
#include "content/renderer/render_thread_impl.h"
#include "content/renderer/render_view_impl.h"
#include "content/renderer/renderer_main_platform_delegate.h"
#include "content/renderer/renderer_webkitplatformsupport_impl.h"
+#include "content/test/frame_load_waiter.h"
#include "content/test/mock_render_process.h"
#include "third_party/WebKit/public/platform/WebScreenInfo.h"
#include "third_party/WebKit/public/platform/WebURLRequest.h"
-#include "third_party/WebKit/public/web/WebFrame.h"
#include "third_party/WebKit/public/web/WebHistoryItem.h"
#include "third_party/WebKit/public/web/WebInputEvent.h"
#include "third_party/WebKit/public/web/WebKit.h"
-#include "third_party/WebKit/public/web/WebScriptController.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
#include "third_party/WebKit/public/web/WebScriptSource.h"
#include "third_party/WebKit/public/web/WebView.h"
#include "ui/base/resource/resource_bundle.h"
-#include "webkit/glue/webkit_glue.h"
+#include "v8/include/v8.h"
+
+#if defined(OS_MACOSX)
+#include "base/mac/scoped_nsautorelease_pool.h"
+#endif
-using blink::WebFrame;
using blink::WebInputEvent;
+using blink::WebLocalFrame;
using blink::WebMouseEvent;
-using blink::WebScriptController;
using blink::WebScriptSource;
using blink::WebString;
using blink::WebURLRequest;
msg_loop_.Run();
}
-WebFrame* RenderViewTest::GetMainFrame() {
- return view_->GetWebView()->mainFrame();
+WebLocalFrame* RenderViewTest::GetMainFrame() {
+ return view_->GetWebView()->mainFrame()->toWebLocalFrame();
}
void RenderViewTest::ExecuteJavaScript(const char* js) {
std::string url_str = "data:text/html;charset=utf-8,";
url_str.append(html);
GURL url(url_str);
-
GetMainFrame()->loadRequest(WebURLRequest(url));
-
// The load actually happens asynchronously, so we pump messages to process
// the pending continuation.
- ProcessPendingMessages();
+ FrameLoadWaiter(view_->GetMainRenderFrame()).Wait();
}
-void RenderViewTest::GoBack(const blink::WebHistoryItem& item) {
- GoToOffset(-1, item);
+PageState RenderViewTest::GetCurrentPageState() {
+ RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
+ return HistoryEntryToPageState(impl->history_controller()->GetCurrentEntry());
+}
+
+void RenderViewTest::GoBack(const PageState& state) {
+ GoToOffset(-1, state);
}
-void RenderViewTest::GoForward(const blink::WebHistoryItem& item) {
- GoToOffset(1, item);
+void RenderViewTest::GoForward(const PageState& state) {
+ GoToOffset(1, state);
}
void RenderViewTest::SetUp() {
- // Subclasses can set the ContentClient's renderer before calling
- // RenderViewTest::SetUp().
- ContentRendererClient* old_client =
- SetRendererClientForTesting(&content_renderer_client_);
- if (old_client)
- SetRendererClientForTesting(old_client);
+ content_client_.reset(CreateContentClient());
+ content_browser_client_.reset(CreateContentBrowserClient());
+ content_renderer_client_.reset(CreateContentRendererClient());
+ SetContentClient(content_client_.get());
+ SetBrowserClientForTesting(content_browser_client_.get());
+ SetRendererClientForTesting(content_renderer_client_.get());
// Subclasses can set render_thread_ with their own implementation before
// calling RenderViewTest::SetUp().
render_thread_->set_new_window_routing_id(kNewWindowRouteId);
render_thread_->set_new_frame_routing_id(kNewFrameRouteId);
+#if defined(OS_MACOSX)
+ autorelease_pool_.reset(new base::mac::ScopedNSAutoreleasePool());
+#endif
command_line_.reset(new CommandLine(CommandLine::NO_PROGRAM));
params_.reset(new MainFunctionParams(*command_line_));
platform_.reset(new RendererMainPlatformDelegate(*params_));
// Setting flags and really doing anything with WebKit is fairly fragile and
// hacky, but this is the world we live in...
- webkit_glue::SetJavaScriptFlags(" --expose-gc");
+ std::string flags("--expose-gc");
+ v8::V8::SetFlagsFromString(flags.c_str(), static_cast<int>(flags.size()));
blink::initialize(webkit_platform_support_.Get());
// Ensure that we register any necessary schemes when initializing WebKit,
// ResourceBundle isn't initialized (since we have to use a diferent test
// suite implementation than for content_unittests). For browser_tests, this
// is already initialized.
- if (!ResourceBundle::HasSharedInstance())
- ResourceBundle::InitSharedInstanceWithLocale("en-US", NULL);
+ if (!ui::ResourceBundle::HasSharedInstance())
+ ui::ResourceBundle::InitSharedInstanceWithLocale(
+ "en-US", NULL, ui::ResourceBundle::LOAD_COMMON_RESOURCES);
mock_process_.reset(new MockRenderProcess);
// This needs to pass the mock render thread to the view.
- RenderViewImpl* view = RenderViewImpl::Create(
- kOpenerId,
- RendererPreferences(),
- WebPreferences(),
- kRouteId,
- kMainFrameRouteId,
- kSurfaceId,
- kInvalidSessionStorageNamespaceId,
- base::string16(),
- false, // is_renderer_created
- false, // swapped_out
- false, // hidden
- 1, // next_page_id
- blink::WebScreenInfo(),
- AccessibilityModeOff,
- true);
+ RenderViewImpl* view =
+ RenderViewImpl::Create(kOpenerId,
+ false, // window_was_created_with_opener
+ RendererPreferences(),
+ WebPreferences(),
+ kRouteId,
+ kMainFrameRouteId,
+ kSurfaceId,
+ kInvalidSessionStorageNamespaceId,
+ base::string16(),
+ false, // is_renderer_created
+ false, // swapped_out
+ MSG_ROUTING_NONE, // proxy_routing_id
+ false, // hidden
+ false, // never_visible
+ 1, // next_page_id
+ blink::WebScreenInfo());
view->AddRef();
view_ = view;
}
// (http://crbug.com/21508).
base::RunLoop().RunUntilIdle();
+#if defined(OS_MACOSX)
+ // Needs to run before blink::shutdown().
+ autorelease_pool_.reset(NULL);
+#endif
+
blink::shutdown();
platform_->PlatformUninitialize();
" var parent_coordinates = GetCoordinates(elem.offsetParent);"
" coordinates[0] += parent_coordinates[0];"
" coordinates[1] += parent_coordinates[1];"
- " return coordinates;"
+ " return [ Math.round(coordinates[0]),"
+ " Math.round(coordinates[1])];"
" };"
" var elem = document.getElementById('$1');"
" if (!elem)"
" return null;"
" var bounds = GetCoordinates(elem);"
- " bounds[2] = elem.offsetWidth;"
- " bounds[3] = elem.offsetHeight;"
+ " bounds[2] = Math.round(elem.offsetWidth);"
+ " bounds[3] = Math.round(elem.offsetHeight);"
" return bounds;"
"})();";
gfx::Rect RenderViewTest::GetElementBounds(const std::string& element_id) {
}
void RenderViewTest::Reload(const GURL& url) {
- ViewMsg_Navigate_Params params;
+ FrameMsg_Navigate_Params params;
params.url = url;
- params.navigation_type = ViewMsg_Navigate_Type::RELOAD;
+ params.navigation_type = FrameMsg_Navigate_Type::RELOAD;
RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
- impl->OnNavigate(params);
+ impl->main_render_frame()->OnNavigate(params);
+ FrameLoadWaiter(impl->main_render_frame()).Wait();
}
uint32 RenderViewTest::GetNavigationIPCType() {
- return ViewHostMsg_FrameNavigate::ID;
+ return FrameHostMsg_DidCommitProvisionalLoad::ID;
}
void RenderViewTest::Resize(gfx::Size new_size,
return impl->OnMessageReceived(msg);
}
-void RenderViewTest::DidNavigateWithinPage(blink::WebFrame* frame,
+void RenderViewTest::DidNavigateWithinPage(blink::WebLocalFrame* frame,
bool is_new_navigation) {
RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
- impl->didNavigateWithinPage(frame, is_new_navigation);
+ blink::WebHistoryItem item;
+ item.initialize();
+ impl->main_render_frame()->didNavigateWithinPage(
+ frame,
+ item,
+ is_new_navigation ? blink::WebStandardCommit
+ : blink::WebHistoryInertCommit);
}
void RenderViewTest::SendContentStateImmediately() {
return impl->webwidget();
}
-void RenderViewTest::GoToOffset(int offset,
- const blink::WebHistoryItem& history_item) {
+
+ContentClient* RenderViewTest::CreateContentClient() {
+ return new ContentClient;
+}
+
+ContentBrowserClient* RenderViewTest::CreateContentBrowserClient() {
+ return new ContentBrowserClient;
+}
+
+ContentRendererClient* RenderViewTest::CreateContentRendererClient() {
+ return new ContentRendererClient;
+}
+
+void RenderViewTest::GoToOffset(int offset, const PageState& state) {
RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
int history_list_length = impl->historyBackListCount() +
impl->historyForwardListCount() + 1;
int pending_offset = offset + impl->history_list_offset();
- ViewMsg_Navigate_Params navigate_params;
- navigate_params.navigation_type = ViewMsg_Navigate_Type::NORMAL;
+ FrameMsg_Navigate_Params navigate_params;
+ navigate_params.navigation_type = FrameMsg_Navigate_Type::NORMAL;
navigate_params.transition = PAGE_TRANSITION_FORWARD_BACK;
navigate_params.current_history_list_length = history_list_length;
navigate_params.current_history_list_offset = impl->history_list_offset();
navigate_params.pending_history_list_offset = pending_offset;
- navigate_params.page_id = impl->GetPageId() + offset;
- navigate_params.page_state = HistoryItemToPageState(history_item);
+ navigate_params.page_id = impl->page_id_ + offset;
+ navigate_params.page_state = state;
navigate_params.request_time = base::Time::Now();
- ViewMsg_Navigate navigate_message(impl->GetRoutingID(), navigate_params);
- OnMessageReceived(navigate_message);
+ FrameMsg_Navigate navigate_message(impl->main_render_frame()->GetRoutingID(),
+ navigate_params);
+ impl->main_render_frame()->OnMessageReceived(navigate_message);
// The load actually happens asynchronously, so we pump messages to process
// the pending continuation.
- ProcessPendingMessages();
+ FrameLoadWaiter(view_->GetMainRenderFrame()).Wait();
}
} // namespace content