• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
31 using blink::WebFrame;
32 using blink::WebInputEvent;
33 using blink::WebMouseEvent;
34 using blink::WebScriptController;
35 using blink::WebScriptSource;
36 using blink::WebString;
37 using blink::WebURLRequest;
38 
39 namespace {
40 const int32 kOpenerId = -2;
41 const int32 kRouteId = 5;
42 const int32 kMainFrameRouteId = 6;
43 const int32 kNewWindowRouteId = 7;
44 const int32 kSurfaceId = 42;
45 
46 }  // namespace
47 
48 namespace content {
49 
50 class RendererWebKitPlatformSupportImplNoSandboxImpl
51     : public RendererWebKitPlatformSupportImpl {
52  public:
sandboxSupport()53   virtual blink::WebSandboxSupport* sandboxSupport() {
54     return NULL;
55   }
56 };
57 
58 RenderViewTest::RendererWebKitPlatformSupportImplNoSandbox::
RendererWebKitPlatformSupportImplNoSandbox()59     RendererWebKitPlatformSupportImplNoSandbox() {
60   webkit_platform_support_.reset(
61       new RendererWebKitPlatformSupportImplNoSandboxImpl());
62 }
63 
64 RenderViewTest::RendererWebKitPlatformSupportImplNoSandbox::
~RendererWebKitPlatformSupportImplNoSandbox()65     ~RendererWebKitPlatformSupportImplNoSandbox() {
66 }
67 
68 blink::Platform*
Get()69     RenderViewTest::RendererWebKitPlatformSupportImplNoSandbox::Get() {
70   return webkit_platform_support_.get();
71 }
72 
RenderViewTest()73 RenderViewTest::RenderViewTest()
74     : view_(NULL) {
75 }
76 
~RenderViewTest()77 RenderViewTest::~RenderViewTest() {
78 }
79 
ProcessPendingMessages()80 void RenderViewTest::ProcessPendingMessages() {
81   msg_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
82   msg_loop_.Run();
83 }
84 
GetMainFrame()85 WebFrame* RenderViewTest::GetMainFrame() {
86   return view_->GetWebView()->mainFrame();
87 }
88 
ExecuteJavaScript(const char * js)89 void RenderViewTest::ExecuteJavaScript(const char* js) {
90   GetMainFrame()->executeScript(WebScriptSource(WebString::fromUTF8(js)));
91 }
92 
ExecuteJavaScriptAndReturnIntValue(const base::string16 & script,int * int_result)93 bool RenderViewTest::ExecuteJavaScriptAndReturnIntValue(
94     const base::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 
LoadHTML(const char * html)108 void 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 
GoBack(const blink::WebHistoryItem & item)120 void RenderViewTest::GoBack(const blink::WebHistoryItem& item) {
121   GoToOffset(-1, item);
122 }
123 
GoForward(const blink::WebHistoryItem & item)124 void RenderViewTest::GoForward(const blink::WebHistoryItem& item) {
125   GoToOffset(1, item);
126 }
127 
SetUp()128 void 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       base::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 
TearDown()188 void 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 
SendNativeKeyEvent(const NativeWebKeyboardEvent & key_event)218 void RenderViewTest::SendNativeKeyEvent(
219     const NativeWebKeyboardEvent& key_event) {
220   SendWebKeyboardEvent(key_event);
221 }
222 
SendWebKeyboardEvent(const blink::WebKeyboardEvent & key_event)223 void 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 
SendWebMouseEvent(const blink::WebMouseEvent & mouse_event)230 void 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 
237 const 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     "})();";
GetElementBounds(const std::string & element_id)256 gfx::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 
SimulateElementClick(const std::string & element_id)282 bool 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 
SetFocused(const blink::WebNode & node)299 void RenderViewTest::SetFocused(const blink::WebNode& node) {
300   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
301   impl->focusedNodeChanged(node);
302 }
303 
ClearHistory()304 void 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 
Reload(const GURL & url)312 void 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 
GetNavigationIPCType()320 uint32 RenderViewTest::GetNavigationIPCType() {
321   return ViewHostMsg_FrameNavigate::ID;
322 }
323 
Resize(gfx::Size new_size,gfx::Rect resizer_rect,bool is_fullscreen)324 void 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 
OnMessageReceived(const IPC::Message & msg)338 bool RenderViewTest::OnMessageReceived(const IPC::Message& msg) {
339   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
340   return impl->OnMessageReceived(msg);
341 }
342 
DidNavigateWithinPage(blink::WebFrame * frame,bool is_new_navigation)343 void 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 
SendContentStateImmediately()349 void RenderViewTest::SendContentStateImmediately() {
350   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
351   impl->set_send_content_state_immediately(true);
352 }
353 
GetWebWidget()354 blink::WebWidget* RenderViewTest::GetWebWidget() {
355   RenderViewImpl* impl = static_cast<RenderViewImpl*>(view_);
356   return impl->webwidget();
357 }
358 
GoToOffset(int offset,const blink::WebHistoryItem & history_item)359 void 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