render_view_test.cc revision f2477e01787aa58f445919b809d89e252beef54f 
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/public/test/render_view_test.h"
6
7#include "base/run_loop.h"
8#include "content/common/dom_storage/dom_storage_types.h"
9#include "content/common/input_messages.h"
10#include "content/common/view_messages.h"
11#include "content/public/browser/native_web_keyboard_event.h"
12#include "content/public/common/renderer_preferences.h"
13#include "content/public/renderer/history_item_serialization.h"
14#include "content/renderer/render_thread_impl.h"
15#include "content/renderer/render_view_impl.h"
16#include "content/renderer/renderer_main_platform_delegate.h"
17#include "content/renderer/renderer_webkitplatformsupport_impl.h"
18#include "content/test/mock_render_process.h"
19#include "third_party/WebKit/public/platform/WebScreenInfo.h"
20#include "third_party/WebKit/public/platform/WebURLRequest.h"
21#include "third_party/WebKit/public/web/WebFrame.h"
22#include "third_party/WebKit/public/web/WebHistoryItem.h"
23#include "third_party/WebKit/public/web/WebInputEvent.h"
24#include "third_party/WebKit/public/web/WebKit.h"
25#include "third_party/WebKit/public/web/WebScriptController.h"
26#include "third_party/WebKit/public/web/WebScriptSource.h"
27#include "third_party/WebKit/public/web/WebView.h"
28#include "ui/base/resource/resource_bundle.h"
29#include "webkit/glue/webkit_glue.h"
30
31using blink::WebFrame;
32using blink::WebInputEvent;
33using blink::WebMouseEvent;
34using blink::WebScriptController;
35using blink::WebScriptSource;
36using blink::WebString;
37using blink::WebURLRequest;
38
39namespace {
40const int32 kOpenerId = -2;
41const int32 kRouteId = 5;
42const int32 kMainFrameRouteId = 6;
43const int32 kNewWindowRouteId = 7;
44const int32 kSurfaceId = 42;
45
46}  // namespace
47
48namespace content {
49
50class RendererWebKitPlatformSupportImplNoSandboxImpl
51    : public RendererWebKitPlatformSupportImpl {
52 public:
53  virtual blink::WebSandboxSupport* sandboxSupport() {
54    return NULL;
55  }
56};
57
58RenderViewTest::RendererWebKitPlatformSupportImplNoSandbox::
59    RendererWebKitPlatformSupportImplNoSandbox() {
60  webkit_platform_support_.reset(
61      new RendererWebKitPlatformSupportImplNoSandboxImpl());
62}
63
64RenderViewTest::RendererWebKitPlatformSupportImplNoSandbox::
65    ~RendererWebKitPlatformSupportImplNoSandbox() {
66}
67
68blink::Platform*
69    RenderViewTest::RendererWebKitPlatformSupportImplNoSandbox::Get() {
70  return webkit_platform_support_.get();
71}
72
73RenderViewTest::RenderViewTest()
74    : view_(NULL) {
75}
76
77RenderViewTest::~RenderViewTest() {
78}
79
80void RenderViewTest::ProcessPendingMessages() {
81  msg_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
82  msg_loop_.Run();
83}
84
85WebFrame* RenderViewTest::GetMainFrame() {
86  return view_->GetWebView()->mainFrame();
87}
88
89void RenderViewTest::ExecuteJavaScript(const char* js) {
90  GetMainFrame()->executeScript(WebScriptSource(WebString::fromUTF8(js)));
91}
92
93bool RenderViewTest::ExecuteJavaScriptAndReturnIntValue(
94    const string16& script,
95    int* int_result) {
96  v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
97  v8::Handle<v8::Value> result =
98      GetMainFrame()->executeScriptAndReturnValue(WebScriptSource(script));
99  if (result.IsEmpty() || !result->IsInt32())
100    return false;
101
102  if (int_result)
103    *int_result = result->Int32Value();
104
105  return true;
106}
107
108void RenderViewTest::LoadHTML(const char* html) {
109  std::string url_str = "data:text/html;charset=utf-8,";
110  url_str.append(html);
111  GURL url(url_str);
112
113  GetMainFrame()->loadRequest(WebURLRequest(url));
114
115  // The load actually happens asynchronously, so we pump messages to process
116  // the pending continuation.
117  ProcessPendingMessages();
118}
119
120void RenderViewTest::GoBack(const blink::WebHistoryItem& item) {
121  GoToOffset(-1, item);
122}
123
124void RenderViewTest::GoForward(const blink::WebHistoryItem& item) {
125  GoToOffset(1, item);
126}
127
128void RenderViewTest::SetUp() {
129  // Subclasses can set the ContentClient's renderer before calling
130  // RenderViewTest::SetUp().
131  ContentRendererClient* old_client =
132      SetRendererClientForTesting(&content_renderer_client_);
133  if (old_client)
134    SetRendererClientForTesting(old_client);
135
136  // Subclasses can set render_thread_ with their own implementation before
137  // calling RenderViewTest::SetUp().
138  if (!render_thread_)
139    render_thread_.reset(new MockRenderThread());
140  render_thread_->set_routing_id(kRouteId);
141  render_thread_->set_surface_id(kSurfaceId);
142  render_thread_->set_new_window_routing_id(kNewWindowRouteId);
143
144  command_line_.reset(new CommandLine(CommandLine::NO_PROGRAM));
145  params_.reset(new MainFunctionParams(*command_line_));
146  platform_.reset(new RendererMainPlatformDelegate(*params_));
147  platform_->PlatformInitialize();
148
149  // Setting flags and really doing anything with WebKit is fairly fragile and
150  // hacky, but this is the world we live in...
151  webkit_glue::SetJavaScriptFlags(" --expose-gc");
152  blink::initialize(webkit_platform_support_.Get());
153
154  // Ensure that we register any necessary schemes when initializing WebKit,
155  // since we are using a MockRenderThread.
156  RenderThreadImpl::RegisterSchemes();
157
158  // This check is needed because when run under content_browsertests,
159  // ResourceBundle isn't initialized (since we have to use a diferent test
160  // suite implementation than for content_unittests). For browser_tests, this
161  // is already initialized.
162  if (!ResourceBundle::HasSharedInstance())
163    ResourceBundle::InitSharedInstanceWithLocale("en-US", NULL);
164
165  mock_process_.reset(new MockRenderProcess);
166
167  // This needs to pass the mock render thread to the view.
168  RenderViewImpl* view = RenderViewImpl::Create(
169      kOpenerId,
170      RendererPreferences(),
171      WebPreferences(),
172      kRouteId,
173      kMainFrameRouteId,
174      kSurfaceId,
175      kInvalidSessionStorageNamespaceId,
176      string16(),
177      false, // is_renderer_created
178      false, // swapped_out
179      false, // hidden
180      1, // next_page_id
181      blink::WebScreenInfo(),
182      AccessibilityModeOff,
183      true);
184  view->AddRef();
185  view_ = view;
186}
187
188void RenderViewTest::TearDown() {
189  // Try very hard to collect garbage before shutting down.
190  // "5" was chosen following http://crbug.com/46571#c9
191  const int kGCIterations = 5;
192  for (int i = 0; i < kGCIterations; i++)
193    GetMainFrame()->collectGarbage();
194
195  // Run the loop so the release task from the renderwidget executes.
196  ProcessPendingMessages();
197
198  for (int i = 0; i < kGCIterations; i++)
199    GetMainFrame()->collectGarbage();
200
201  render_thread_->SendCloseMessage();
202  view_ = NULL;
203  mock_process_.reset();
204
205  // After telling the view to close and resetting mock_process_ we may get
206  // some new tasks which need to be processed before shutting down WebKit
207  // (http://crbug.com/21508).
208  base::RunLoop().RunUntilIdle();
209
210  blink::shutdown();
211
212  platform_->PlatformUninitialize();
213  platform_.reset();
214  params_.reset();
215  command_line_.reset();
216}
217
218void RenderViewTest::SendNativeKeyEvent(
219    const NativeWebKeyboardEvent& key_event) {
220  SendWebKeyboardEvent(key_event);
221}
222
223void RenderViewTest::SendWebKeyboardEvent(
224    const blink::WebKeyboardEvent& key_event) {
225  RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
226  impl->OnMessageReceived(
227      InputMsg_HandleInputEvent(0, &key_event, ui::LatencyInfo(), false));
228}
229
230void RenderViewTest::SendWebMouseEvent(
231    const blink::WebMouseEvent& mouse_event) {
232  RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
233  impl->OnMessageReceived(
234      InputMsg_HandleInputEvent(0, &mouse_event, ui::LatencyInfo(), false));
235}
236
237const char* const kGetCoordinatesScript =
238    "(function() {"
239    "  function GetCoordinates(elem) {"
240    "    if (!elem)"
241    "      return [ 0, 0];"
242    "    var coordinates = [ elem.offsetLeft, elem.offsetTop];"
243    "    var parent_coordinates = GetCoordinates(elem.offsetParent);"
244    "    coordinates[0] += parent_coordinates[0];"
245    "    coordinates[1] += parent_coordinates[1];"
246    "    return coordinates;"
247    "  };"
248    "  var elem = document.getElementById('$1');"
249    "  if (!elem)"
250    "    return null;"
251    "  var bounds = GetCoordinates(elem);"
252    "  bounds[2] = elem.offsetWidth;"
253    "  bounds[3] = elem.offsetHeight;"
254    "  return bounds;"
255    "})();";
256gfx::Rect RenderViewTest::GetElementBounds(const std::string& element_id) {
257  std::vector<std::string> params;
258  params.push_back(element_id);
259  std::string script =
260      ReplaceStringPlaceholders(kGetCoordinatesScript, params, NULL);
261
262  v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
263  v8::Handle<v8::Value>  value = GetMainFrame()->executeScriptAndReturnValue(
264      WebScriptSource(WebString::fromUTF8(script)));
265  if (value.IsEmpty() || !value->IsArray())
266    return gfx::Rect();
267
268  v8::Handle<v8::Array> array = value.As<v8::Array>();
269  if (array->Length() != 4)
270    return gfx::Rect();
271  std::vector<int> coords;
272  for (int i = 0; i < 4; ++i) {
273    v8::Handle<v8::Number> index = v8::Number::New(i);
274    v8::Local<v8::Value> value = array->Get(index);
275    if (value.IsEmpty() || !value->IsInt32())
276      return gfx::Rect();
277    coords.push_back(value->Int32Value());
278  }
279  return gfx::Rect(coords[0], coords[1], coords[2], coords[3]);
280}
281
282bool RenderViewTest::SimulateElementClick(const std::string& element_id) {
283  gfx::Rect bounds = GetElementBounds(element_id);
284  if (bounds.IsEmpty())
285    return false;
286  WebMouseEvent mouse_event;
287  mouse_event.type = WebInputEvent::MouseDown;
288  mouse_event.button = WebMouseEvent::ButtonLeft;
289  mouse_event.x = bounds.CenterPoint().x();
290  mouse_event.y = bounds.CenterPoint().y();
291  mouse_event.clickCount = 1;
292  scoped_ptr<IPC::Message> input_message(
293      new InputMsg_HandleInputEvent(0, &mouse_event, ui::LatencyInfo(), false));
294  RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
295  impl->OnMessageReceived(*input_message);
296  return true;
297}
298
299void RenderViewTest::SetFocused(const blink::WebNode& node) {
300  RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
301  impl->focusedNodeChanged(node);
302}
303
304void RenderViewTest::ClearHistory() {
305  RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
306  impl->page_id_ = -1;
307  impl->history_list_offset_ = -1;
308  impl->history_list_length_ = 0;
309  impl->history_page_ids_.clear();
310}
311
312void RenderViewTest::Reload(const GURL& url) {
313  ViewMsg_Navigate_Params params;
314  params.url = url;
315  params.navigation_type = ViewMsg_Navigate_Type::RELOAD;
316  RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
317  impl->OnNavigate(params);
318}
319
320uint32 RenderViewTest::GetNavigationIPCType() {
321  return ViewHostMsg_FrameNavigate::ID;
322}
323
324void RenderViewTest::Resize(gfx::Size new_size,
325                            gfx::Rect resizer_rect,
326                            bool is_fullscreen) {
327  ViewMsg_Resize_Params params;
328  params.screen_info = blink::WebScreenInfo();
329  params.new_size = new_size;
330  params.physical_backing_size = new_size;
331  params.overdraw_bottom_height = 0.f;
332  params.resizer_rect = resizer_rect;
333  params.is_fullscreen = is_fullscreen;
334  scoped_ptr<IPC::Message> resize_message(new ViewMsg_Resize(0, params));
335  OnMessageReceived(*resize_message);
336}
337
338bool RenderViewTest::OnMessageReceived(const IPC::Message& msg) {
339  RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
340  return impl->OnMessageReceived(msg);
341}
342
343void RenderViewTest::DidNavigateWithinPage(blink::WebFrame* frame,
344                                           bool is_new_navigation) {
345  RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
346  impl->didNavigateWithinPage(frame, is_new_navigation);
347}
348
349void RenderViewTest::SendContentStateImmediately() {
350  RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
351  impl->set_send_content_state_immediately(true);
352}
353
354blink::WebWidget* RenderViewTest::GetWebWidget() {
355  RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
356  return impl->webwidget();
357}
358
359void RenderViewTest::GoToOffset(int offset,
360                                const blink::WebHistoryItem& history_item) {
361  RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
362
363  int history_list_length = impl->historyBackListCount() +
364                            impl->historyForwardListCount() + 1;
365  int pending_offset = offset + impl->history_list_offset();
366
367  ViewMsg_Navigate_Params navigate_params;
368  navigate_params.navigation_type = ViewMsg_Navigate_Type::NORMAL;
369  navigate_params.transition = PAGE_TRANSITION_FORWARD_BACK;
370  navigate_params.current_history_list_length = history_list_length;
371  navigate_params.current_history_list_offset = impl->history_list_offset();
372  navigate_params.pending_history_list_offset = pending_offset;
373  navigate_params.page_id = impl->GetPageId() + offset;
374  navigate_params.page_state = HistoryItemToPageState(history_item);
375  navigate_params.request_time = base::Time::Now();
376
377  ViewMsg_Navigate navigate_message(impl->GetRoutingID(), navigate_params);
378  OnMessageReceived(navigate_message);
379
380  // The load actually happens asynchronously, so we pump messages to process
381  // the pending continuation.
382  ProcessPendingMessages();
383}
384
385}  // namespace content
386