1 /*
2 * Copyright (C) 2010 Google Inc. All rights reserved.
3 * Copyright (C) 2010 Pawel Hajdan (phajdan.jr@chromium.org)
4 * Copyright (C) 2012 Apple Inc. All Rights Reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are
8 * met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * * Redistributions in binary form must reproduce the above
13 * copyright notice, this list of conditions and the following disclaimer
14 * in the documentation and/or other materials provided with the
15 * distribution.
16 * * Neither the name of Google Inc. nor the names of its
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #include "TestRunner.h"
34
35 #include "MockWebSpeechInputController.h"
36 #include "MockWebSpeechRecognizer.h"
37 #include "NotificationPresenter.h"
38 #include "TestInterfaces.h"
39 #include "WebPermissions.h"
40 #include "public/platform/WebData.h"
41 #include "public/platform/WebDeviceMotionData.h"
42 #include "public/platform/WebDeviceOrientationData.h"
43 #include "public/platform/WebPoint.h"
44 #include "public/platform/WebURLResponse.h"
45 #include "public/testing/WebPreferences.h"
46 #include "public/testing/WebTestDelegate.h"
47 #include "public/testing/WebTestProxy.h"
48 #include "public/web/WebBindings.h"
49 #include "public/web/WebDataSource.h"
50 #include "public/web/WebDocument.h"
51 #include "public/web/WebElement.h"
52 #include "public/web/WebFindOptions.h"
53 #include "public/web/WebFrame.h"
54 #include "public/web/WebGeolocationClientMock.h"
55 #include "public/web/WebInputElement.h"
56 #include "public/web/WebMIDIClientMock.h"
57 #include "public/web/WebScriptSource.h"
58 #include "public/web/WebSecurityPolicy.h"
59 #include "public/web/WebSerializedScriptValue.h"
60 #include "public/web/WebSettings.h"
61 #include "public/web/WebSurroundingText.h"
62 #include "public/web/WebView.h"
63 #include "v8/include/v8.h"
64 #include <limits>
65
66 #if defined(__linux__) || defined(ANDROID)
67 #include "public/web/linux/WebFontRendering.h"
68 #endif
69
70 using namespace blink;
71 using namespace std;
72
73 namespace WebTestRunner {
74
75 namespace {
76
77 class InvokeCallbackTask : public WebMethodTask<TestRunner> {
78 public:
InvokeCallbackTask(TestRunner * object,WebScopedPtr<CppVariant> callbackArguments)79 InvokeCallbackTask(TestRunner* object, WebScopedPtr<CppVariant> callbackArguments)
80 : WebMethodTask<TestRunner>(object)
81 , m_callbackArguments(callbackArguments)
82 {
83 }
84
runIfValid()85 virtual void runIfValid()
86 {
87 CppVariant invokeResult;
88 m_callbackArguments->invokeDefault(m_callbackArguments.get(), 1, invokeResult);
89 }
90
91 private:
92 WebScopedPtr<CppVariant> m_callbackArguments;
93 };
94
95 }
96
~WorkQueue()97 TestRunner::WorkQueue::~WorkQueue()
98 {
99 reset();
100 }
101
processWorkSoon()102 void TestRunner::WorkQueue::processWorkSoon()
103 {
104 if (m_controller->topLoadingFrame())
105 return;
106
107 if (!m_queue.empty()) {
108 // We delay processing queued work to avoid recursion problems.
109 m_controller->m_delegate->postTask(new WorkQueueTask(this));
110 } else if (!m_controller->m_waitUntilDone)
111 m_controller->m_delegate->testFinished();
112 }
113
processWork()114 void TestRunner::WorkQueue::processWork()
115 {
116 // Quit doing work once a load is in progress.
117 while (!m_queue.empty()) {
118 bool startedLoad = m_queue.front()->run(m_controller->m_delegate, m_controller->m_webView);
119 delete m_queue.front();
120 m_queue.pop_front();
121 if (startedLoad)
122 return;
123 }
124
125 if (!m_controller->m_waitUntilDone && !m_controller->topLoadingFrame())
126 m_controller->m_delegate->testFinished();
127 }
128
reset()129 void TestRunner::WorkQueue::reset()
130 {
131 m_frozen = false;
132 while (!m_queue.empty()) {
133 delete m_queue.front();
134 m_queue.pop_front();
135 }
136 }
137
addWork(WorkItem * work)138 void TestRunner::WorkQueue::addWork(WorkItem* work)
139 {
140 if (m_frozen) {
141 delete work;
142 return;
143 }
144 m_queue.push_back(work);
145 }
146
147
TestRunner(TestInterfaces * interfaces)148 TestRunner::TestRunner(TestInterfaces* interfaces)
149 : m_testIsRunning(false)
150 , m_closeRemainingWindows(false)
151 , m_workQueue(this)
152 , m_testInterfaces(interfaces)
153 , m_delegate(0)
154 , m_webView(0)
155 , m_pageOverlay(0)
156 , m_webPermissions(new WebPermissions)
157 , m_notificationPresenter(new NotificationPresenter)
158 {
159 // Initialize the map that associates methods of this class with the names
160 // they will use when called by JavaScript. The actual binding of those
161 // names to their methods will be done by calling bindToJavaScript() (defined
162 // by CppBoundClass, the parent to TestRunner).
163
164 // Methods controlling test execution.
165 bindMethod("notifyDone", &TestRunner::notifyDone);
166 bindMethod("queueBackNavigation", &TestRunner::queueBackNavigation);
167 bindMethod("queueForwardNavigation", &TestRunner::queueForwardNavigation);
168 bindMethod("queueLoadingScript", &TestRunner::queueLoadingScript);
169 bindMethod("queueLoad", &TestRunner::queueLoad);
170 bindMethod("queueLoadHTMLString", &TestRunner::queueLoadHTMLString);
171 bindMethod("queueNonLoadingScript", &TestRunner::queueNonLoadingScript);
172 bindMethod("queueReload", &TestRunner::queueReload);
173 bindMethod("setCloseRemainingWindowsWhenComplete", &TestRunner::setCloseRemainingWindowsWhenComplete);
174 bindMethod("resetTestHelperControllers", &TestRunner::resetTestHelperControllers);
175 bindMethod("setCustomPolicyDelegate", &TestRunner::setCustomPolicyDelegate);
176 bindMethod("waitForPolicyDelegate", &TestRunner::waitForPolicyDelegate);
177 bindMethod("waitUntilDone", &TestRunner::waitUntilDone);
178 bindMethod("windowCount", &TestRunner::windowCount);
179 // Methods implemented in terms of chromium's public WebKit API.
180 bindMethod("setTabKeyCyclesThroughElements", &TestRunner::setTabKeyCyclesThroughElements);
181 bindMethod("execCommand", &TestRunner::execCommand);
182 bindMethod("isCommandEnabled", &TestRunner::isCommandEnabled);
183 bindMethod("callShouldCloseOnWebView", &TestRunner::callShouldCloseOnWebView);
184 bindMethod("setDomainRelaxationForbiddenForURLScheme", &TestRunner::setDomainRelaxationForbiddenForURLScheme);
185 bindMethod("evaluateScriptInIsolatedWorldAndReturnValue", &TestRunner::evaluateScriptInIsolatedWorldAndReturnValue);
186 bindMethod("evaluateScriptInIsolatedWorld", &TestRunner::evaluateScriptInIsolatedWorld);
187 bindMethod("setIsolatedWorldSecurityOrigin", &TestRunner::setIsolatedWorldSecurityOrigin);
188 bindMethod("setIsolatedWorldContentSecurityPolicy", &TestRunner::setIsolatedWorldContentSecurityPolicy);
189 bindMethod("addOriginAccessWhitelistEntry", &TestRunner::addOriginAccessWhitelistEntry);
190 bindMethod("removeOriginAccessWhitelistEntry", &TestRunner::removeOriginAccessWhitelistEntry);
191 bindMethod("hasCustomPageSizeStyle", &TestRunner::hasCustomPageSizeStyle);
192 bindMethod("forceRedSelectionColors", &TestRunner::forceRedSelectionColors);
193 bindMethod("injectStyleSheet", &TestRunner::injectStyleSheet);
194 bindMethod("startSpeechInput", &TestRunner::startSpeechInput);
195 bindMethod("findString", &TestRunner::findString);
196 bindMethod("setValueForUser", &TestRunner::setValueForUser);
197 bindMethod("selectionAsMarkup", &TestRunner::selectionAsMarkup);
198 bindMethod("setTextSubpixelPositioning", &TestRunner::setTextSubpixelPositioning);
199 bindMethod("setPageVisibility", &TestRunner::setPageVisibility);
200 bindMethod("setTextDirection", &TestRunner::setTextDirection);
201 bindMethod("textSurroundingNode", &TestRunner::textSurroundingNode);
202 bindMethod("useUnfortunateSynchronousResizeMode", &TestRunner::useUnfortunateSynchronousResizeMode);
203 bindMethod("disableAutoResizeMode", &TestRunner::disableAutoResizeMode);
204 bindMethod("enableAutoResizeMode", &TestRunner::enableAutoResizeMode);
205 bindMethod("setMockDeviceMotion", &TestRunner::setMockDeviceMotion);
206 bindMethod("setMockDeviceOrientation", &TestRunner::setMockDeviceOrientation);
207 bindMethod("didAcquirePointerLock", &TestRunner::didAcquirePointerLock);
208 bindMethod("didLosePointerLock", &TestRunner::didLosePointerLock);
209 bindMethod("didNotAcquirePointerLock", &TestRunner::didNotAcquirePointerLock);
210 bindMethod("setPointerLockWillRespondAsynchronously", &TestRunner::setPointerLockWillRespondAsynchronously);
211 bindMethod("setPointerLockWillFailSynchronously", &TestRunner::setPointerLockWillFailSynchronously);
212
213 // The following modify WebPreferences.
214 bindMethod("setPopupBlockingEnabled", &TestRunner::setPopupBlockingEnabled);
215 bindMethod("setJavaScriptCanAccessClipboard", &TestRunner::setJavaScriptCanAccessClipboard);
216 bindMethod("setXSSAuditorEnabled", &TestRunner::setXSSAuditorEnabled);
217 bindMethod("setAllowUniversalAccessFromFileURLs", &TestRunner::setAllowUniversalAccessFromFileURLs);
218 bindMethod("setAllowFileAccessFromFileURLs", &TestRunner::setAllowFileAccessFromFileURLs);
219 bindMethod("overridePreference", &TestRunner::overridePreference);
220 bindMethod("setPluginsEnabled", &TestRunner::setPluginsEnabled);
221
222 // The following modify the state of the TestRunner.
223 bindMethod("dumpEditingCallbacks", &TestRunner::dumpEditingCallbacks);
224 bindMethod("dumpAsText", &TestRunner::dumpAsText);
225 bindMethod("dumpAsTextWithPixelResults", &TestRunner::dumpAsTextWithPixelResults);
226 bindMethod("dumpChildFramesAsText", &TestRunner::dumpChildFramesAsText);
227 bindMethod("dumpChildFrameScrollPositions", &TestRunner::dumpChildFrameScrollPositions);
228 bindMethod("dumpIconChanges", &TestRunner::dumpIconChanges);
229 bindMethod("setAudioData", &TestRunner::setAudioData);
230 bindMethod("dumpFrameLoadCallbacks", &TestRunner::dumpFrameLoadCallbacks);
231 bindMethod("dumpPingLoaderCallbacks", &TestRunner::dumpPingLoaderCallbacks);
232 bindMethod("dumpUserGestureInFrameLoadCallbacks", &TestRunner::dumpUserGestureInFrameLoadCallbacks);
233 bindMethod("dumpTitleChanges", &TestRunner::dumpTitleChanges);
234 bindMethod("dumpCreateView", &TestRunner::dumpCreateView);
235 bindMethod("setCanOpenWindows", &TestRunner::setCanOpenWindows);
236 bindMethod("dumpResourceLoadCallbacks", &TestRunner::dumpResourceLoadCallbacks);
237 bindMethod("dumpResourceRequestCallbacks", &TestRunner::dumpResourceRequestCallbacks);
238 bindMethod("dumpResourceResponseMIMETypes", &TestRunner::dumpResourceResponseMIMETypes);
239 bindMethod("dumpPermissionClientCallbacks", &TestRunner::dumpPermissionClientCallbacks);
240 bindMethod("setImagesAllowed", &TestRunner::setImagesAllowed);
241 bindMethod("setScriptsAllowed", &TestRunner::setScriptsAllowed);
242 bindMethod("setStorageAllowed", &TestRunner::setStorageAllowed);
243 bindMethod("setPluginsAllowed", &TestRunner::setPluginsAllowed);
244 bindMethod("setAllowDisplayOfInsecureContent", &TestRunner::setAllowDisplayOfInsecureContent);
245 bindMethod("setAllowRunningOfInsecureContent", &TestRunner::setAllowRunningOfInsecureContent);
246 bindMethod("dumpStatusCallbacks", &TestRunner::dumpWindowStatusChanges);
247 bindMethod("dumpProgressFinishedCallback", &TestRunner::dumpProgressFinishedCallback);
248 bindMethod("dumpSpellCheckCallbacks", &TestRunner::dumpSpellCheckCallbacks);
249 bindMethod("dumpBackForwardList", &TestRunner::dumpBackForwardList);
250 bindMethod("setDeferMainResourceDataLoad", &TestRunner::setDeferMainResourceDataLoad);
251 bindMethod("dumpSelectionRect", &TestRunner::dumpSelectionRect);
252 bindMethod("testRepaint", &TestRunner::testRepaint);
253 bindMethod("repaintSweepHorizontally", &TestRunner::repaintSweepHorizontally);
254 bindMethod("setPrinting", &TestRunner::setPrinting);
255 bindMethod("setShouldStayOnPageAfterHandlingBeforeUnload", &TestRunner::setShouldStayOnPageAfterHandlingBeforeUnload);
256 bindMethod("setWillSendRequestClearHeader", &TestRunner::setWillSendRequestClearHeader);
257 bindMethod("dumpResourceRequestPriorities", &TestRunner::dumpResourceRequestPriorities);
258
259 // The following methods interact with the WebTestProxy.
260 // The following methods interact with the WebTestDelegate.
261 bindMethod("showWebInspector", &TestRunner::showWebInspector);
262 bindMethod("closeWebInspector", &TestRunner::closeWebInspector);
263 bindMethod("evaluateInWebInspector", &TestRunner::evaluateInWebInspector);
264 bindMethod("clearAllDatabases", &TestRunner::clearAllDatabases);
265 bindMethod("setDatabaseQuota", &TestRunner::setDatabaseQuota);
266 bindMethod("setAlwaysAcceptCookies", &TestRunner::setAlwaysAcceptCookies);
267 bindMethod("setWindowIsKey", &TestRunner::setWindowIsKey);
268 bindMethod("pathToLocalResource", &TestRunner::pathToLocalResource);
269 bindMethod("setBackingScaleFactor", &TestRunner::setBackingScaleFactor);
270 bindMethod("setPOSIXLocale", &TestRunner::setPOSIXLocale);
271 bindMethod("numberOfPendingGeolocationPermissionRequests", &TestRunner:: numberOfPendingGeolocationPermissionRequests);
272 bindMethod("setGeolocationPermission", &TestRunner::setGeolocationPermission);
273 bindMethod("setMockGeolocationPositionUnavailableError", &TestRunner::setMockGeolocationPositionUnavailableError);
274 bindMethod("setMockGeolocationPosition", &TestRunner::setMockGeolocationPosition);
275 bindMethod("setMIDIAccessorResult", &TestRunner::setMIDIAccessorResult);
276 bindMethod("setMIDISysExPermission", &TestRunner::setMIDISysExPermission);
277 bindMethod("grantWebNotificationPermission", &TestRunner::grantWebNotificationPermission);
278 bindMethod("simulateLegacyWebNotificationClick", &TestRunner::simulateLegacyWebNotificationClick);
279 bindMethod("cancelAllActiveNotifications", &TestRunner::cancelAllActiveNotifications);
280 bindMethod("addMockSpeechInputResult", &TestRunner::addMockSpeechInputResult);
281 bindMethod("setMockSpeechInputDumpRect", &TestRunner::setMockSpeechInputDumpRect);
282 bindMethod("addMockSpeechRecognitionResult", &TestRunner::addMockSpeechRecognitionResult);
283 bindMethod("setMockSpeechRecognitionError", &TestRunner::setMockSpeechRecognitionError);
284 bindMethod("wasMockSpeechRecognitionAborted", &TestRunner::wasMockSpeechRecognitionAborted);
285 bindMethod("display", &TestRunner::display);
286 bindMethod("displayInvalidatedRegion", &TestRunner::displayInvalidatedRegion);
287 bindMethod("isChooserShown", &TestRunner::isChooserShown);
288
289 // The following modify WebPageOverlays.
290 bindMethod("addWebPageOverlay", &TestRunner::addWebPageOverlay);
291 bindMethod("removeWebPageOverlay", &TestRunner::removeWebPageOverlay);
292
293 // Properties.
294 bindProperty("globalFlag", &m_globalFlag);
295 bindProperty("platformName", &m_platformName);
296 bindProperty("tooltipText", &m_tooltipText);
297 bindProperty("disableNotifyDone", &m_disableNotifyDone);
298
299 // webHistoryItemCount is used by tests in LayoutTests\http\tests\history
300 bindProperty("webHistoryItemCount", &m_webHistoryItemCount);
301 bindProperty("interceptPostMessage", &m_interceptPostMessage);
302
303 // The following are stubs.
304 bindMethod("dumpDatabaseCallbacks", &TestRunner::notImplemented);
305 bindMethod("denyWebNotificationPermission", &TestRunner::notImplemented);
306 bindMethod("removeAllWebNotificationPermissions", &TestRunner::notImplemented);
307 bindMethod("simulateWebNotificationClick", &TestRunner::notImplemented);
308 bindMethod("setIconDatabaseEnabled", &TestRunner::notImplemented);
309 bindMethod("setScrollbarPolicy", &TestRunner::notImplemented);
310 bindMethod("clearAllApplicationCaches", &TestRunner::notImplemented);
311 bindMethod("clearApplicationCacheForOrigin", &TestRunner::notImplemented);
312 bindMethod("clearBackForwardList", &TestRunner::notImplemented);
313 bindMethod("keepWebHistory", &TestRunner::notImplemented);
314 bindMethod("setApplicationCacheOriginQuota", &TestRunner::notImplemented);
315 bindMethod("setCallCloseOnWebViews", &TestRunner::notImplemented);
316 bindMethod("setMainFrameIsFirstResponder", &TestRunner::notImplemented);
317 bindMethod("setUseDashboardCompatibilityMode", &TestRunner::notImplemented);
318 bindMethod("deleteAllLocalStorage", &TestRunner::notImplemented);
319 bindMethod("localStorageDiskUsageForOrigin", &TestRunner::notImplemented);
320 bindMethod("originsWithLocalStorage", &TestRunner::notImplemented);
321 bindMethod("deleteLocalStorageForOrigin", &TestRunner::notImplemented);
322 bindMethod("observeStorageTrackerNotifications", &TestRunner::notImplemented);
323 bindMethod("syncLocalStorage", &TestRunner::notImplemented);
324 bindMethod("addDisallowedURL", &TestRunner::notImplemented);
325 bindMethod("applicationCacheDiskUsageForOrigin", &TestRunner::notImplemented);
326 bindMethod("abortModal", &TestRunner::notImplemented);
327
328 // The fallback method is called when an unknown method is invoked.
329 bindFallbackMethod(&TestRunner::fallbackMethod);
330 }
331
~TestRunner()332 TestRunner::~TestRunner()
333 {
334 }
335
setDelegate(WebTestDelegate * delegate)336 void TestRunner::setDelegate(WebTestDelegate* delegate)
337 {
338 m_delegate = delegate;
339 m_webPermissions->setDelegate(delegate);
340 m_notificationPresenter->setDelegate(delegate);
341 }
342
setWebView(WebView * webView,WebTestProxyBase * proxy)343 void TestRunner::setWebView(WebView* webView, WebTestProxyBase* proxy)
344 {
345 m_webView = webView;
346 m_proxy = proxy;
347 }
348
reset()349 void TestRunner::reset()
350 {
351 if (m_webView) {
352 m_webView->setZoomLevel(0);
353 m_webView->setTextZoomFactor(1);
354 m_webView->setTabKeyCyclesThroughElements(true);
355 #if !defined(__APPLE__) && !defined(WIN32) // Actually, TOOLKIT_GTK
356 // (Constants copied because we can't depend on the header that defined
357 // them from this file.)
358 m_webView->setSelectionColors(0xff1e90ff, 0xff000000, 0xffc8c8c8, 0xff323232);
359 #endif
360 m_webView->removeInjectedStyleSheets();
361 m_webView->setVisibilityState(WebPageVisibilityStateVisible, true);
362 m_webView->mainFrame()->enableViewSourceMode(false);
363
364 if (m_pageOverlay) {
365 m_webView->removePageOverlay(m_pageOverlay);
366 delete m_pageOverlay;
367 m_pageOverlay = 0;
368 }
369 }
370
371 m_topLoadingFrame = 0;
372 m_waitUntilDone = false;
373 m_policyDelegateEnabled = false;
374 m_policyDelegateIsPermissive = false;
375 m_policyDelegateShouldNotifyDone = false;
376
377 WebSecurityPolicy::resetOriginAccessWhitelists();
378 #if defined(__linux__) || defined(ANDROID)
379 WebFontRendering::setSubpixelPositioning(false);
380 #endif
381
382 if (m_delegate) {
383 // Reset the default quota for each origin to 5MB
384 m_delegate->setDatabaseQuota(5 * 1024 * 1024);
385 m_delegate->setDeviceScaleFactor(1);
386 m_delegate->setAcceptAllCookies(false);
387 m_delegate->setLocale("");
388 m_delegate->useUnfortunateSynchronousResizeMode(false);
389 m_delegate->disableAutoResizeMode(WebSize());
390 m_delegate->deleteAllCookies();
391 }
392
393 m_dumpEditingCallbacks = false;
394 m_dumpAsText = false;
395 m_dumpAsMarkup = false;
396 m_generatePixelResults = true;
397 m_dumpChildFrameScrollPositions = false;
398 m_dumpChildFramesAsText = false;
399 m_dumpIconChanges = false;
400 m_dumpAsAudio = false;
401 m_dumpFrameLoadCallbacks = false;
402 m_dumpPingLoaderCallbacks = false;
403 m_dumpUserGestureInFrameLoadCallbacks = false;
404 m_dumpTitleChanges = false;
405 m_dumpCreateView = false;
406 m_canOpenWindows = false;
407 m_dumpResourceLoadCallbacks = false;
408 m_dumpResourceRequestCallbacks = false;
409 m_dumpResourceResponseMIMETypes = false;
410 m_dumpWindowStatusChanges = false;
411 m_dumpProgressFinishedCallback = false;
412 m_dumpSpellCheckCallbacks = false;
413 m_dumpBackForwardList = false;
414 m_deferMainResourceDataLoad = true;
415 m_dumpSelectionRect = false;
416 m_testRepaint = false;
417 m_sweepHorizontally = false;
418 m_isPrinting = false;
419 m_midiAccessorResult = true;
420 m_shouldStayOnPageAfterHandlingBeforeUnload = false;
421 m_shouldDumpResourcePriorities = false;
422
423 m_httpHeadersToClear.clear();
424
425 m_globalFlag.set(false);
426 m_webHistoryItemCount.set(0);
427 m_interceptPostMessage.set(false);
428 m_platformName.set("chromium");
429 m_tooltipText.set("");
430 m_disableNotifyDone.set(false);
431
432 m_webPermissions->reset();
433
434 m_notificationPresenter->reset();
435
436 m_pointerLocked = false;
437 m_pointerLockPlannedResult = PointerLockWillSucceed;
438
439 m_taskList.revokeAll();
440 m_workQueue.reset();
441
442 if (m_closeRemainingWindows && m_delegate)
443 m_delegate->closeRemainingWindows();
444 else
445 m_closeRemainingWindows = true;
446 }
447
448
setTestIsRunning(bool running)449 void TestRunner::setTestIsRunning(bool running)
450 {
451 m_testIsRunning = running;
452 }
453
shouldDumpEditingCallbacks() const454 bool TestRunner::shouldDumpEditingCallbacks() const
455 {
456 return m_dumpEditingCallbacks;
457 }
458
checkResponseMimeType()459 void TestRunner::checkResponseMimeType()
460 {
461 // Text output: the test page can request different types of output
462 // which we handle here.
463 if (!m_dumpAsText) {
464 string mimeType = m_webView->mainFrame()->dataSource()->response().mimeType().utf8();
465 if (mimeType == "text/plain") {
466 m_dumpAsText = true;
467 m_generatePixelResults = false;
468 }
469 }
470 }
471
shouldDumpAsText()472 bool TestRunner::shouldDumpAsText()
473 {
474 checkResponseMimeType();
475 return m_dumpAsText;
476 }
477
setShouldDumpAsText(bool value)478 void TestRunner::setShouldDumpAsText(bool value)
479 {
480 m_dumpAsText = value;
481 }
482
shouldDumpAsMarkup()483 bool TestRunner::shouldDumpAsMarkup()
484 {
485 return m_dumpAsMarkup;
486 }
487
setShouldDumpAsMarkup(bool value)488 void TestRunner::setShouldDumpAsMarkup(bool value)
489 {
490 m_dumpAsMarkup = value;
491 }
492
shouldGeneratePixelResults()493 bool TestRunner::shouldGeneratePixelResults()
494 {
495 checkResponseMimeType();
496 return m_generatePixelResults;
497 }
498
setShouldGeneratePixelResults(bool value)499 void TestRunner::setShouldGeneratePixelResults(bool value)
500 {
501 m_generatePixelResults = value;
502 }
503
shouldDumpChildFrameScrollPositions() const504 bool TestRunner::shouldDumpChildFrameScrollPositions() const
505 {
506 return m_dumpChildFrameScrollPositions;
507 }
508
shouldDumpChildFramesAsText() const509 bool TestRunner::shouldDumpChildFramesAsText() const
510 {
511 return m_dumpChildFramesAsText;
512 }
513
shouldDumpAsAudio() const514 bool TestRunner::shouldDumpAsAudio() const
515 {
516 return m_dumpAsAudio;
517 }
518
audioData() const519 const WebArrayBufferView* TestRunner::audioData() const
520 {
521 return &m_audioData;
522 }
523
shouldDumpFrameLoadCallbacks() const524 bool TestRunner::shouldDumpFrameLoadCallbacks() const
525 {
526 return m_testIsRunning && m_dumpFrameLoadCallbacks;
527 }
528
setShouldDumpFrameLoadCallbacks(bool value)529 void TestRunner::setShouldDumpFrameLoadCallbacks(bool value)
530 {
531 m_dumpFrameLoadCallbacks = value;
532 }
533
shouldDumpPingLoaderCallbacks() const534 bool TestRunner::shouldDumpPingLoaderCallbacks() const
535 {
536 return m_testIsRunning && m_dumpPingLoaderCallbacks;
537 }
538
setShouldDumpPingLoaderCallbacks(bool value)539 void TestRunner::setShouldDumpPingLoaderCallbacks(bool value)
540 {
541 m_dumpPingLoaderCallbacks = value;
542 }
543
setShouldEnableViewSource(bool value)544 void TestRunner::setShouldEnableViewSource(bool value)
545 {
546 m_webView->mainFrame()->enableViewSourceMode(value);
547 }
548
shouldDumpUserGestureInFrameLoadCallbacks() const549 bool TestRunner::shouldDumpUserGestureInFrameLoadCallbacks() const
550 {
551 return m_testIsRunning && m_dumpUserGestureInFrameLoadCallbacks;
552 }
553
shouldDumpTitleChanges() const554 bool TestRunner::shouldDumpTitleChanges() const
555 {
556 return m_dumpTitleChanges;
557 }
558
shouldDumpIconChanges() const559 bool TestRunner::shouldDumpIconChanges() const
560 {
561 return m_dumpIconChanges;
562 }
563
shouldDumpCreateView() const564 bool TestRunner::shouldDumpCreateView() const
565 {
566 return m_dumpCreateView;
567 }
568
canOpenWindows() const569 bool TestRunner::canOpenWindows() const
570 {
571 return m_canOpenWindows;
572 }
573
shouldDumpResourceLoadCallbacks() const574 bool TestRunner::shouldDumpResourceLoadCallbacks() const
575 {
576 return m_testIsRunning && m_dumpResourceLoadCallbacks;
577 }
578
shouldDumpResourceRequestCallbacks() const579 bool TestRunner::shouldDumpResourceRequestCallbacks() const
580 {
581 return m_testIsRunning && m_dumpResourceRequestCallbacks;
582 }
583
shouldDumpResourceResponseMIMETypes() const584 bool TestRunner::shouldDumpResourceResponseMIMETypes() const
585 {
586 return m_testIsRunning && m_dumpResourceResponseMIMETypes;
587 }
588
webPermissions() const589 WebPermissionClient* TestRunner::webPermissions() const
590 {
591 return m_webPermissions.get();
592 }
593
shouldDumpStatusCallbacks() const594 bool TestRunner::shouldDumpStatusCallbacks() const
595 {
596 return m_dumpWindowStatusChanges;
597 }
598
shouldDumpProgressFinishedCallback() const599 bool TestRunner::shouldDumpProgressFinishedCallback() const
600 {
601 return m_dumpProgressFinishedCallback;
602 }
603
shouldDumpSpellCheckCallbacks() const604 bool TestRunner::shouldDumpSpellCheckCallbacks() const
605 {
606 return m_dumpSpellCheckCallbacks;
607 }
608
shouldDumpBackForwardList() const609 bool TestRunner::shouldDumpBackForwardList() const
610 {
611 return m_dumpBackForwardList;
612 }
613
deferMainResourceDataLoad() const614 bool TestRunner::deferMainResourceDataLoad() const
615 {
616 return m_deferMainResourceDataLoad;
617 }
618
shouldDumpSelectionRect() const619 bool TestRunner::shouldDumpSelectionRect() const
620 {
621 return m_dumpSelectionRect;
622 }
623
testRepaint() const624 bool TestRunner::testRepaint() const
625 {
626 return m_testRepaint;
627 }
628
sweepHorizontally() const629 bool TestRunner::sweepHorizontally() const
630 {
631 return m_sweepHorizontally;
632 }
633
isPrinting() const634 bool TestRunner::isPrinting() const
635 {
636 return m_isPrinting;
637 }
638
shouldStayOnPageAfterHandlingBeforeUnload() const639 bool TestRunner::shouldStayOnPageAfterHandlingBeforeUnload() const
640 {
641 return m_shouldStayOnPageAfterHandlingBeforeUnload;
642 }
643
httpHeadersToClear() const644 const std::set<std::string>* TestRunner::httpHeadersToClear() const
645 {
646 return &m_httpHeadersToClear;
647 }
648
setTopLoadingFrame(WebFrame * frame,bool clear)649 void TestRunner::setTopLoadingFrame(WebFrame* frame, bool clear)
650 {
651 if (frame->top()->view() != m_webView)
652 return;
653 if (!m_testIsRunning)
654 return;
655 if (clear) {
656 m_topLoadingFrame = 0;
657 locationChangeDone();
658 } else if (!m_topLoadingFrame)
659 m_topLoadingFrame = frame;
660 }
661
topLoadingFrame() const662 WebFrame* TestRunner::topLoadingFrame() const
663 {
664 return m_topLoadingFrame;
665 }
666
policyDelegateDone()667 void TestRunner::policyDelegateDone()
668 {
669 BLINK_ASSERT(m_waitUntilDone);
670 m_delegate->testFinished();
671 m_waitUntilDone = false;
672 }
673
policyDelegateEnabled() const674 bool TestRunner::policyDelegateEnabled() const
675 {
676 return m_policyDelegateEnabled;
677 }
678
policyDelegateIsPermissive() const679 bool TestRunner::policyDelegateIsPermissive() const
680 {
681 return m_policyDelegateIsPermissive;
682 }
683
policyDelegateShouldNotifyDone() const684 bool TestRunner::policyDelegateShouldNotifyDone() const
685 {
686 return m_policyDelegateShouldNotifyDone;
687 }
688
shouldInterceptPostMessage() const689 bool TestRunner::shouldInterceptPostMessage() const
690 {
691 return m_interceptPostMessage.isBool() && m_interceptPostMessage.toBoolean();
692 }
693
shouldDumpResourcePriorities() const694 bool TestRunner::shouldDumpResourcePriorities() const
695 {
696 return m_shouldDumpResourcePriorities;
697 }
698
notificationPresenter() const699 WebNotificationPresenter* TestRunner::notificationPresenter() const
700 {
701 return m_notificationPresenter.get();
702 }
703
requestPointerLock()704 bool TestRunner::requestPointerLock()
705 {
706 switch (m_pointerLockPlannedResult) {
707 case PointerLockWillSucceed:
708 m_delegate->postDelayedTask(new HostMethodTask(this, &TestRunner::didAcquirePointerLockInternal), 0);
709 return true;
710 case PointerLockWillRespondAsync:
711 BLINK_ASSERT(!m_pointerLocked);
712 return true;
713 case PointerLockWillFailSync:
714 BLINK_ASSERT(!m_pointerLocked);
715 return false;
716 default:
717 BLINK_ASSERT_NOT_REACHED();
718 return false;
719 }
720 }
721
requestPointerUnlock()722 void TestRunner::requestPointerUnlock()
723 {
724 m_delegate->postDelayedTask(new HostMethodTask(this, &TestRunner::didLosePointerLockInternal), 0);
725 }
726
isPointerLocked()727 bool TestRunner::isPointerLocked()
728 {
729 return m_pointerLocked;
730 }
731
setToolTipText(const blink::WebString & text)732 void TestRunner::setToolTipText(const blink::WebString& text)
733 {
734 m_tooltipText.set(text.utf8());
735 }
736
midiAccessorResult()737 bool TestRunner::midiAccessorResult()
738 {
739 return m_midiAccessorResult;
740 }
741
TestPageOverlay(blink::WebView * webView)742 TestRunner::TestPageOverlay::TestPageOverlay(blink::WebView* webView) : m_webView(webView)
743 {
744 }
745
~TestPageOverlay()746 TestRunner::TestPageOverlay::~TestPageOverlay()
747 {
748 }
749
paintPageOverlay(blink::WebCanvas * canvas)750 void TestRunner::TestPageOverlay::paintPageOverlay(blink::WebCanvas* canvas)
751 {
752 SkRect rect = SkRect::MakeWH(m_webView->size().width, m_webView->size().height);
753 SkPaint paint;
754 paint.setColor(SK_ColorCYAN);
755 paint.setStyle(SkPaint::kFill_Style);
756 canvas->drawRect(rect, paint);
757 }
758
didAcquirePointerLockInternal()759 void TestRunner::didAcquirePointerLockInternal()
760 {
761 m_pointerLocked = true;
762 m_webView->didAcquirePointerLock();
763
764 // Reset planned result to default.
765 m_pointerLockPlannedResult = PointerLockWillSucceed;
766 }
767
didNotAcquirePointerLockInternal()768 void TestRunner::didNotAcquirePointerLockInternal()
769 {
770 BLINK_ASSERT(!m_pointerLocked);
771 m_pointerLocked = false;
772 m_webView->didNotAcquirePointerLock();
773
774 // Reset planned result to default.
775 m_pointerLockPlannedResult = PointerLockWillSucceed;
776 }
777
didLosePointerLockInternal()778 void TestRunner::didLosePointerLockInternal()
779 {
780 bool wasLocked = m_pointerLocked;
781 m_pointerLocked = false;
782 if (wasLocked)
783 m_webView->didLosePointerLock();
784 }
785
showDevTools()786 void TestRunner::showDevTools()
787 {
788 m_delegate->showDevTools();
789 }
790
waitUntilDone(const CppArgumentList &,CppVariant * result)791 void TestRunner::waitUntilDone(const CppArgumentList&, CppVariant* result)
792 {
793 m_waitUntilDone = true;
794 result->setNull();
795 }
796
notifyDone(const CppArgumentList &,CppVariant * result)797 void TestRunner::notifyDone(const CppArgumentList&, CppVariant* result)
798 {
799 if (m_disableNotifyDone.toBoolean())
800 return;
801
802 // Test didn't timeout. Kill the timeout timer.
803 taskList()->revokeAll();
804
805 completeNotifyDone();
806 result->setNull();
807 }
808
completeNotifyDone()809 void TestRunner::completeNotifyDone()
810 {
811 if (m_waitUntilDone && !topLoadingFrame() && m_workQueue.isEmpty())
812 m_delegate->testFinished();
813 m_waitUntilDone = false;
814 }
815
816 class WorkItemBackForward : public TestRunner::WorkItem {
817 public:
WorkItemBackForward(int distance)818 WorkItemBackForward(int distance) : m_distance(distance) { }
run(WebTestDelegate * delegate,WebView *)819 bool run(WebTestDelegate* delegate, WebView*)
820 {
821 delegate->goToOffset(m_distance);
822 return true; // FIXME: Did it really start a navigation?
823 }
824
825 private:
826 int m_distance;
827 };
828
queueBackNavigation(const CppArgumentList & arguments,CppVariant * result)829 void TestRunner::queueBackNavigation(const CppArgumentList& arguments, CppVariant* result)
830 {
831 if (arguments.size() > 0 && arguments[0].isNumber())
832 m_workQueue.addWork(new WorkItemBackForward(-arguments[0].toInt32()));
833 result->setNull();
834 }
835
queueForwardNavigation(const CppArgumentList & arguments,CppVariant * result)836 void TestRunner::queueForwardNavigation(const CppArgumentList& arguments, CppVariant* result)
837 {
838 if (arguments.size() > 0 && arguments[0].isNumber())
839 m_workQueue.addWork(new WorkItemBackForward(arguments[0].toInt32()));
840 result->setNull();
841 }
842
843 class WorkItemReload : public TestRunner::WorkItem {
844 public:
run(WebTestDelegate * delegate,WebView *)845 bool run(WebTestDelegate* delegate, WebView*)
846 {
847 delegate->reload();
848 return true;
849 }
850 };
851
queueReload(const CppArgumentList &,CppVariant * result)852 void TestRunner::queueReload(const CppArgumentList&, CppVariant* result)
853 {
854 m_workQueue.addWork(new WorkItemReload);
855 result->setNull();
856 }
857
858 class WorkItemLoadingScript : public TestRunner::WorkItem {
859 public:
WorkItemLoadingScript(const string & script)860 WorkItemLoadingScript(const string& script) : m_script(script) { }
run(WebTestDelegate *,WebView * webView)861 bool run(WebTestDelegate*, WebView* webView)
862 {
863 webView->mainFrame()->executeScript(WebScriptSource(WebString::fromUTF8(m_script)));
864 return true; // FIXME: Did it really start a navigation?
865 }
866
867 private:
868 string m_script;
869 };
870
871 class WorkItemNonLoadingScript : public TestRunner::WorkItem {
872 public:
WorkItemNonLoadingScript(const string & script)873 WorkItemNonLoadingScript(const string& script) : m_script(script) { }
run(WebTestDelegate *,WebView * webView)874 bool run(WebTestDelegate*, WebView* webView)
875 {
876 webView->mainFrame()->executeScript(WebScriptSource(WebString::fromUTF8(m_script)));
877 return false;
878 }
879
880 private:
881 string m_script;
882 };
883
queueLoadingScript(const CppArgumentList & arguments,CppVariant * result)884 void TestRunner::queueLoadingScript(const CppArgumentList& arguments, CppVariant* result)
885 {
886 if (arguments.size() > 0 && arguments[0].isString())
887 m_workQueue.addWork(new WorkItemLoadingScript(arguments[0].toString()));
888 result->setNull();
889 }
890
queueNonLoadingScript(const CppArgumentList & arguments,CppVariant * result)891 void TestRunner::queueNonLoadingScript(const CppArgumentList& arguments, CppVariant* result)
892 {
893 if (arguments.size() > 0 && arguments[0].isString())
894 m_workQueue.addWork(new WorkItemNonLoadingScript(arguments[0].toString()));
895 result->setNull();
896 }
897
898 class WorkItemLoad : public TestRunner::WorkItem {
899 public:
WorkItemLoad(const WebURL & url,const string & target)900 WorkItemLoad(const WebURL& url, const string& target)
901 : m_url(url)
902 , m_target(target) { }
run(WebTestDelegate * delegate,WebView *)903 bool run(WebTestDelegate* delegate, WebView*)
904 {
905 delegate->loadURLForFrame(m_url, m_target);
906 return true; // FIXME: Did it really start a navigation?
907 }
908
909 private:
910 WebURL m_url;
911 string m_target;
912 };
913
queueLoad(const CppArgumentList & arguments,CppVariant * result)914 void TestRunner::queueLoad(const CppArgumentList& arguments, CppVariant* result)
915 {
916 if (arguments.size() > 0 && arguments[0].isString()) {
917 // FIXME: Implement WebURL::resolve() and avoid GURL.
918 GURL currentURL = m_webView->mainFrame()->document().url();
919 GURL fullURL = currentURL.Resolve(arguments[0].toString());
920
921 string target = "";
922 if (arguments.size() > 1 && arguments[1].isString())
923 target = arguments[1].toString();
924
925 m_workQueue.addWork(new WorkItemLoad(fullURL, target));
926 }
927 result->setNull();
928 }
929
930 class WorkItemLoadHTMLString : public TestRunner::WorkItem {
931 public:
WorkItemLoadHTMLString(const std::string & html,const WebURL & baseURL)932 WorkItemLoadHTMLString(const std::string& html, const WebURL& baseURL)
933 : m_html(html)
934 , m_baseURL(baseURL) { }
WorkItemLoadHTMLString(const std::string & html,const WebURL & baseURL,const WebURL & unreachableURL)935 WorkItemLoadHTMLString(const std::string& html, const WebURL& baseURL, const WebURL& unreachableURL)
936 : m_html(html)
937 , m_baseURL(baseURL)
938 , m_unreachableURL(unreachableURL) { }
run(WebTestDelegate *,WebView * webView)939 bool run(WebTestDelegate*, WebView* webView)
940 {
941 webView->mainFrame()->loadHTMLString(
942 blink::WebData(m_html.data(), m_html.length()), m_baseURL, m_unreachableURL);
943 return true;
944 }
945
946 private:
947 std::string m_html;
948 WebURL m_baseURL;
949 WebURL m_unreachableURL;
950 };
951
queueLoadHTMLString(const CppArgumentList & arguments,CppVariant * result)952 void TestRunner::queueLoadHTMLString(const CppArgumentList& arguments, CppVariant* result)
953 {
954 if (arguments.size() > 0 && arguments[0].isString()) {
955 string html = arguments[0].toString();
956 WebURL baseURL(GURL(""));
957 if (arguments.size() > 1 && arguments[1].isString())
958 baseURL = WebURL(GURL(arguments[1].toString()));
959 if (arguments.size() > 2 && arguments[2].isString())
960 m_workQueue.addWork(new WorkItemLoadHTMLString(html, baseURL, WebURL(GURL(arguments[2].toString()))));
961 else
962 m_workQueue.addWork(new WorkItemLoadHTMLString(html, baseURL));
963 }
964 result->setNull();
965 }
966
locationChangeDone()967 void TestRunner::locationChangeDone()
968 {
969 m_webHistoryItemCount.set(m_delegate->navigationEntryCount());
970
971 // No more new work after the first complete load.
972 m_workQueue.setFrozen(true);
973
974 if (!m_waitUntilDone)
975 m_workQueue.processWorkSoon();
976 }
977
windowCount(const CppArgumentList &,CppVariant * result)978 void TestRunner::windowCount(const CppArgumentList&, CppVariant* result)
979 {
980 result->set(static_cast<int>(m_testInterfaces->windowList().size()));
981 }
982
setCloseRemainingWindowsWhenComplete(const CppArgumentList & arguments,CppVariant * result)983 void TestRunner::setCloseRemainingWindowsWhenComplete(const CppArgumentList& arguments, CppVariant* result)
984 {
985 if (arguments.size() > 0 && arguments[0].isBool())
986 m_closeRemainingWindows = arguments[0].value.boolValue;
987 result->setNull();
988 }
989
resetTestHelperControllers(const CppArgumentList & arguments,CppVariant * result)990 void TestRunner::resetTestHelperControllers(const CppArgumentList& arguments, CppVariant* result)
991 {
992 m_testInterfaces->resetTestHelperControllers();
993
994 result->setNull();
995 }
996
setCustomPolicyDelegate(const CppArgumentList & arguments,CppVariant * result)997 void TestRunner::setCustomPolicyDelegate(const CppArgumentList& arguments, CppVariant* result)
998 {
999 if (arguments.size() > 0 && arguments[0].isBool()) {
1000 m_policyDelegateEnabled = arguments[0].value.boolValue;
1001 m_policyDelegateIsPermissive = false;
1002 if (arguments.size() > 1 && arguments[1].isBool())
1003 m_policyDelegateIsPermissive = arguments[1].value.boolValue;
1004 }
1005 result->setNull();
1006 }
1007
waitForPolicyDelegate(const CppArgumentList &,CppVariant * result)1008 void TestRunner::waitForPolicyDelegate(const CppArgumentList&, CppVariant* result)
1009 {
1010 m_policyDelegateEnabled = true;
1011 m_policyDelegateShouldNotifyDone = true;
1012 m_waitUntilDone = true;
1013 result->setNull();
1014 }
1015
dumpPermissionClientCallbacks(const CppArgumentList &,CppVariant * result)1016 void TestRunner::dumpPermissionClientCallbacks(const CppArgumentList&, CppVariant* result)
1017 {
1018 m_webPermissions->setDumpCallbacks(true);
1019 result->setNull();
1020 }
1021
setImagesAllowed(const CppArgumentList & arguments,CppVariant * result)1022 void TestRunner::setImagesAllowed(const CppArgumentList& arguments, CppVariant* result)
1023 {
1024 if (arguments.size() > 0 && arguments[0].isBool())
1025 m_webPermissions->setImagesAllowed(arguments[0].toBoolean());
1026 result->setNull();
1027 }
1028
setScriptsAllowed(const CppArgumentList & arguments,CppVariant * result)1029 void TestRunner::setScriptsAllowed(const CppArgumentList& arguments, CppVariant* result)
1030 {
1031 if (arguments.size() > 0 && arguments[0].isBool())
1032 m_webPermissions->setScriptsAllowed(arguments[0].toBoolean());
1033 result->setNull();
1034 }
1035
setStorageAllowed(const CppArgumentList & arguments,CppVariant * result)1036 void TestRunner::setStorageAllowed(const CppArgumentList& arguments, CppVariant* result)
1037 {
1038 if (arguments.size() > 0 && arguments[0].isBool())
1039 m_webPermissions->setStorageAllowed(arguments[0].toBoolean());
1040 result->setNull();
1041 }
1042
setPluginsAllowed(const CppArgumentList & arguments,CppVariant * result)1043 void TestRunner::setPluginsAllowed(const CppArgumentList& arguments, CppVariant* result)
1044 {
1045 if (arguments.size() > 0 && arguments[0].isBool())
1046 m_webPermissions->setPluginsAllowed(arguments[0].toBoolean());
1047 result->setNull();
1048 }
1049
setAllowDisplayOfInsecureContent(const CppArgumentList & arguments,CppVariant * result)1050 void TestRunner::setAllowDisplayOfInsecureContent(const CppArgumentList& arguments, CppVariant* result)
1051 {
1052 if (arguments.size() > 0 && arguments[0].isBool())
1053 m_webPermissions->setDisplayingInsecureContentAllowed(arguments[0].toBoolean());
1054
1055 result->setNull();
1056 }
1057
setAllowRunningOfInsecureContent(const CppArgumentList & arguments,CppVariant * result)1058 void TestRunner::setAllowRunningOfInsecureContent(const CppArgumentList& arguments, CppVariant* result)
1059 {
1060 if (arguments.size() > 0 && arguments[0].isBool())
1061 m_webPermissions->setRunningInsecureContentAllowed(arguments[0].value.boolValue);
1062
1063 result->setNull();
1064 }
1065
dumpWindowStatusChanges(const CppArgumentList &,CppVariant * result)1066 void TestRunner::dumpWindowStatusChanges(const CppArgumentList&, CppVariant* result)
1067 {
1068 m_dumpWindowStatusChanges = true;
1069 result->setNull();
1070 }
1071
dumpProgressFinishedCallback(const CppArgumentList &,CppVariant * result)1072 void TestRunner::dumpProgressFinishedCallback(const CppArgumentList&, CppVariant* result)
1073 {
1074 m_dumpProgressFinishedCallback = true;
1075 result->setNull();
1076 }
1077
dumpSpellCheckCallbacks(const CppArgumentList &,CppVariant * result)1078 void TestRunner::dumpSpellCheckCallbacks(const CppArgumentList&, CppVariant* result)
1079 {
1080 m_dumpSpellCheckCallbacks = true;
1081 result->setNull();
1082 }
1083
dumpBackForwardList(const CppArgumentList &,CppVariant * result)1084 void TestRunner::dumpBackForwardList(const CppArgumentList&, CppVariant* result)
1085 {
1086 m_dumpBackForwardList = true;
1087 result->setNull();
1088 }
1089
setDeferMainResourceDataLoad(const CppArgumentList & arguments,CppVariant * result)1090 void TestRunner::setDeferMainResourceDataLoad(const CppArgumentList& arguments, CppVariant* result)
1091 {
1092 if (arguments.size() == 1)
1093 m_deferMainResourceDataLoad = cppVariantToBool(arguments[0]);
1094 }
1095
dumpSelectionRect(const CppArgumentList & arguments,CppVariant * result)1096 void TestRunner::dumpSelectionRect(const CppArgumentList& arguments, CppVariant* result)
1097 {
1098 m_dumpSelectionRect = true;
1099 result->setNull();
1100 }
1101
testRepaint(const CppArgumentList &,CppVariant * result)1102 void TestRunner::testRepaint(const CppArgumentList&, CppVariant* result)
1103 {
1104 m_testRepaint = true;
1105 result->setNull();
1106 }
1107
repaintSweepHorizontally(const CppArgumentList &,CppVariant * result)1108 void TestRunner::repaintSweepHorizontally(const CppArgumentList&, CppVariant* result)
1109 {
1110 m_sweepHorizontally = true;
1111 result->setNull();
1112 }
1113
setPrinting(const CppArgumentList & arguments,CppVariant * result)1114 void TestRunner::setPrinting(const CppArgumentList& arguments, CppVariant* result)
1115 {
1116 m_isPrinting = true;
1117 result->setNull();
1118 }
1119
setShouldStayOnPageAfterHandlingBeforeUnload(const CppArgumentList & arguments,CppVariant * result)1120 void TestRunner::setShouldStayOnPageAfterHandlingBeforeUnload(const CppArgumentList& arguments, CppVariant* result)
1121 {
1122 if (arguments.size() == 1 && arguments[0].isBool())
1123 m_shouldStayOnPageAfterHandlingBeforeUnload = arguments[0].toBoolean();
1124
1125 result->setNull();
1126 }
1127
setWillSendRequestClearHeader(const CppArgumentList & arguments,CppVariant * result)1128 void TestRunner::setWillSendRequestClearHeader(const CppArgumentList& arguments, CppVariant* result)
1129 {
1130 if (arguments.size() > 0 && arguments[0].isString()) {
1131 string header = arguments[0].toString();
1132 if (!header.empty())
1133 m_httpHeadersToClear.insert(header);
1134 }
1135 result->setNull();
1136 }
1137
setTabKeyCyclesThroughElements(const CppArgumentList & arguments,CppVariant * result)1138 void TestRunner::setTabKeyCyclesThroughElements(const CppArgumentList& arguments, CppVariant* result)
1139 {
1140 if (arguments.size() > 0 && arguments[0].isBool())
1141 m_webView->setTabKeyCyclesThroughElements(arguments[0].toBoolean());
1142 result->setNull();
1143 }
1144
execCommand(const CppArgumentList & arguments,CppVariant * result)1145 void TestRunner::execCommand(const CppArgumentList& arguments, CppVariant* result)
1146 {
1147 result->setNull();
1148 if (arguments.size() <= 0 || !arguments[0].isString())
1149 return;
1150
1151 std::string command = arguments[0].toString();
1152 std::string value("");
1153 // Ignore the second parameter (which is userInterface)
1154 // since this command emulates a manual action.
1155 if (arguments.size() >= 3 && arguments[2].isString())
1156 value = arguments[2].toString();
1157
1158 // Note: webkit's version does not return the boolean, so neither do we.
1159 m_webView->focusedFrame()->executeCommand(WebString::fromUTF8(command), WebString::fromUTF8(value));
1160 }
1161
isCommandEnabled(const CppArgumentList & arguments,CppVariant * result)1162 void TestRunner::isCommandEnabled(const CppArgumentList& arguments, CppVariant* result)
1163 {
1164 if (arguments.size() <= 0 || !arguments[0].isString()) {
1165 result->setNull();
1166 return;
1167 }
1168
1169 std::string command = arguments[0].toString();
1170 bool rv = m_webView->focusedFrame()->isCommandEnabled(WebString::fromUTF8(command));
1171 result->set(rv);
1172 }
1173
callShouldCloseOnWebView(const CppArgumentList &,CppVariant * result)1174 void TestRunner::callShouldCloseOnWebView(const CppArgumentList&, CppVariant* result)
1175 {
1176 result->set(m_webView->dispatchBeforeUnloadEvent());
1177 }
1178
setDomainRelaxationForbiddenForURLScheme(const CppArgumentList & arguments,CppVariant * result)1179 void TestRunner::setDomainRelaxationForbiddenForURLScheme(const CppArgumentList& arguments, CppVariant* result)
1180 {
1181 if (arguments.size() != 2 || !arguments[0].isBool() || !arguments[1].isString())
1182 return;
1183 m_webView->setDomainRelaxationForbidden(cppVariantToBool(arguments[0]), cppVariantToWebString(arguments[1]));
1184 }
1185
evaluateScriptInIsolatedWorldAndReturnValue(const CppArgumentList & arguments,CppVariant * result)1186 void TestRunner::evaluateScriptInIsolatedWorldAndReturnValue(const CppArgumentList& arguments, CppVariant* result)
1187 {
1188 v8::HandleScope scope(v8::Isolate::GetCurrent());
1189 WebVector<v8::Local<v8::Value> > values;
1190 if (arguments.size() >= 2 && arguments[0].isNumber() && arguments[1].isString()) {
1191 WebScriptSource source(cppVariantToWebString(arguments[1]));
1192 // This relies on the iframe focusing itself when it loads. This is a bit
1193 // sketchy, but it seems to be what other tests do.
1194 m_webView->focusedFrame()->executeScriptInIsolatedWorld(arguments[0].toInt32(), &source, 1, 1, &values);
1195 }
1196 result->setNull();
1197 // Since only one script was added, only one result is expected
1198 if (values.size() == 1 && !values[0].IsEmpty()) {
1199 v8::Local<v8::Value> scriptValue = values[0];
1200 // FIXME: There are many more types that can be handled.
1201 if (scriptValue->IsString()) {
1202 v8::String::Utf8Value utf8V8(scriptValue);
1203 result->set(std::string(*utf8V8));
1204 } else if (scriptValue->IsBoolean())
1205 result->set(scriptValue->ToBoolean()->Value());
1206 else if (scriptValue->IsNumber()) {
1207 if (scriptValue->IsInt32())
1208 result->set(scriptValue->ToInt32()->Value());
1209 else
1210 result->set(scriptValue->ToNumber()->Value());
1211 } else if (scriptValue->IsNull())
1212 result->setNull();
1213 }
1214 }
1215
evaluateScriptInIsolatedWorld(const CppArgumentList & arguments,CppVariant * result)1216 void TestRunner::evaluateScriptInIsolatedWorld(const CppArgumentList& arguments, CppVariant* result)
1217 {
1218 if (arguments.size() >= 2 && arguments[0].isNumber() && arguments[1].isString()) {
1219 WebScriptSource source(cppVariantToWebString(arguments[1]));
1220 // This relies on the iframe focusing itself when it loads. This is a bit
1221 // sketchy, but it seems to be what other tests do.
1222 m_webView->focusedFrame()->executeScriptInIsolatedWorld(arguments[0].toInt32(), &source, 1, 1);
1223 }
1224 result->setNull();
1225 }
1226
setIsolatedWorldSecurityOrigin(const CppArgumentList & arguments,CppVariant * result)1227 void TestRunner::setIsolatedWorldSecurityOrigin(const CppArgumentList& arguments, CppVariant* result)
1228 {
1229 result->setNull();
1230
1231 if (arguments.size() != 2 || !arguments[0].isNumber() || !(arguments[1].isString() || arguments[1].isNull()))
1232 return;
1233
1234 WebSecurityOrigin origin;
1235 if (arguments[1].isString())
1236 origin = WebSecurityOrigin::createFromString(cppVariantToWebString(arguments[1]));
1237 m_webView->focusedFrame()->setIsolatedWorldSecurityOrigin(arguments[0].toInt32(), origin);
1238 }
1239
setIsolatedWorldContentSecurityPolicy(const CppArgumentList & arguments,CppVariant * result)1240 void TestRunner::setIsolatedWorldContentSecurityPolicy(const CppArgumentList& arguments, CppVariant* result)
1241 {
1242 result->setNull();
1243
1244 if (arguments.size() != 2 || !arguments[0].isNumber() || !arguments[1].isString())
1245 return;
1246
1247 m_webView->focusedFrame()->setIsolatedWorldContentSecurityPolicy(arguments[0].toInt32(), cppVariantToWebString(arguments[1]));
1248 }
1249
addOriginAccessWhitelistEntry(const CppArgumentList & arguments,CppVariant * result)1250 void TestRunner::addOriginAccessWhitelistEntry(const CppArgumentList& arguments, CppVariant* result)
1251 {
1252 result->setNull();
1253
1254 if (arguments.size() != 4 || !arguments[0].isString() || !arguments[1].isString()
1255 || !arguments[2].isString() || !arguments[3].isBool())
1256 return;
1257
1258 blink::WebURL url(GURL(arguments[0].toString()));
1259 if (!url.isValid())
1260 return;
1261
1262 WebSecurityPolicy::addOriginAccessWhitelistEntry(
1263 url,
1264 cppVariantToWebString(arguments[1]),
1265 cppVariantToWebString(arguments[2]),
1266 arguments[3].toBoolean());
1267 }
1268
removeOriginAccessWhitelistEntry(const CppArgumentList & arguments,CppVariant * result)1269 void TestRunner::removeOriginAccessWhitelistEntry(const CppArgumentList& arguments, CppVariant* result)
1270 {
1271 result->setNull();
1272
1273 if (arguments.size() != 4 || !arguments[0].isString() || !arguments[1].isString()
1274 || !arguments[2].isString() || !arguments[3].isBool())
1275 return;
1276
1277 blink::WebURL url(GURL(arguments[0].toString()));
1278 if (!url.isValid())
1279 return;
1280
1281 WebSecurityPolicy::removeOriginAccessWhitelistEntry(
1282 url,
1283 cppVariantToWebString(arguments[1]),
1284 cppVariantToWebString(arguments[2]),
1285 arguments[3].toBoolean());
1286 }
1287
hasCustomPageSizeStyle(const CppArgumentList & arguments,CppVariant * result)1288 void TestRunner::hasCustomPageSizeStyle(const CppArgumentList& arguments, CppVariant* result)
1289 {
1290 result->set(false);
1291 int pageIndex = 0;
1292 if (arguments.size() > 1)
1293 return;
1294 if (arguments.size() == 1)
1295 pageIndex = cppVariantToInt32(arguments[0]);
1296 WebFrame* frame = m_webView->mainFrame();
1297 if (!frame)
1298 return;
1299 result->set(frame->hasCustomPageSizeStyle(pageIndex));
1300 }
1301
forceRedSelectionColors(const CppArgumentList & arguments,CppVariant * result)1302 void TestRunner::forceRedSelectionColors(const CppArgumentList& arguments, CppVariant* result)
1303 {
1304 result->setNull();
1305 m_webView->setSelectionColors(0xffee0000, 0xff00ee00, 0xff000000, 0xffc0c0c0);
1306 }
1307
injectStyleSheet(const CppArgumentList & arguments,CppVariant * result)1308 void TestRunner::injectStyleSheet(const CppArgumentList& arguments, CppVariant* result)
1309 {
1310 result->setNull();
1311 if (arguments.size() < 2 || !arguments[0].isString() || !arguments[1].isBool())
1312 return;
1313 WebView::injectStyleSheet(
1314 cppVariantToWebString(arguments[0]), WebVector<WebString>(),
1315 arguments[1].toBoolean() ? WebView::InjectStyleInAllFrames : WebView::InjectStyleInTopFrameOnly);
1316 }
1317
startSpeechInput(const CppArgumentList & arguments,CppVariant * result)1318 void TestRunner::startSpeechInput(const CppArgumentList& arguments, CppVariant* result)
1319 {
1320 result->setNull();
1321 if (arguments.size() != 1)
1322 return;
1323
1324 WebElement element;
1325 if (!WebBindings::getElement(arguments[0].value.objectValue, &element))
1326 return;
1327
1328 WebInputElement* input = toWebInputElement(&element);
1329 if (!input)
1330 return;
1331
1332 if (!input->isSpeechInputEnabled())
1333 return;
1334
1335 input->startSpeechInput();
1336 }
1337
findString(const CppArgumentList & arguments,CppVariant * result)1338 void TestRunner::findString(const CppArgumentList& arguments, CppVariant* result)
1339 {
1340 if (arguments.size() < 1 || !arguments[0].isString())
1341 return;
1342
1343 WebFindOptions findOptions;
1344 bool wrapAround = false;
1345 if (arguments.size() >= 2) {
1346 vector<string> optionsArray = arguments[1].toStringVector();
1347 findOptions.matchCase = true;
1348 findOptions.findNext = true;
1349
1350 for (size_t i = 0; i < optionsArray.size(); ++i) {
1351 const std::string& option = optionsArray[i];
1352 if (option == "CaseInsensitive")
1353 findOptions.matchCase = false;
1354 else if (option == "Backwards")
1355 findOptions.forward = false;
1356 else if (option == "StartInSelection")
1357 findOptions.findNext = false;
1358 else if (option == "AtWordStarts")
1359 findOptions.wordStart = true;
1360 else if (option == "TreatMedialCapitalAsWordStart")
1361 findOptions.medialCapitalAsWordStart = true;
1362 else if (option == "WrapAround")
1363 wrapAround = true;
1364 }
1365 }
1366
1367 WebFrame* frame = m_webView->mainFrame();
1368 const bool findResult = frame->find(0, cppVariantToWebString(arguments[0]), findOptions, wrapAround, 0);
1369 frame->stopFinding(false);
1370 result->set(findResult);
1371 }
1372
setValueForUser(const CppArgumentList & arguments,CppVariant * result)1373 void TestRunner::setValueForUser(const CppArgumentList& arguments, CppVariant* result)
1374 {
1375 result->setNull();
1376 if (arguments.size() != 2)
1377 return;
1378
1379 WebElement element;
1380 if (!WebBindings::getElement(arguments[0].value.objectValue, &element))
1381 return;
1382
1383 WebInputElement* input = toWebInputElement(&element);
1384 if (!input)
1385 return;
1386
1387 input->setValue(cppVariantToWebString(arguments[1]), true);
1388 }
1389
selectionAsMarkup(const CppArgumentList & arguments,CppVariant * result)1390 void TestRunner::selectionAsMarkup(const CppArgumentList& arguments, CppVariant* result)
1391 {
1392 result->set(m_webView->mainFrame()->selectionAsMarkup().utf8());
1393 }
1394
setTextSubpixelPositioning(const CppArgumentList & arguments,CppVariant * result)1395 void TestRunner::setTextSubpixelPositioning(const CppArgumentList& arguments, CppVariant* result)
1396 {
1397 #if defined(__linux__) || defined(ANDROID)
1398 // Since FontConfig doesn't provide a variable to control subpixel positioning, we'll fall back
1399 // to setting it globally for all fonts.
1400 if (arguments.size() > 0 && arguments[0].isBool())
1401 WebFontRendering::setSubpixelPositioning(arguments[0].value.boolValue);
1402 #endif
1403 result->setNull();
1404 }
1405
setPageVisibility(const CppArgumentList & arguments,CppVariant * result)1406 void TestRunner::setPageVisibility(const CppArgumentList& arguments, CppVariant* result)
1407 {
1408 if (arguments.size() > 0 && arguments[0].isString()) {
1409 string newVisibility = arguments[0].toString();
1410 if (newVisibility == "visible")
1411 m_webView->setVisibilityState(WebPageVisibilityStateVisible, false);
1412 else if (newVisibility == "hidden")
1413 m_webView->setVisibilityState(WebPageVisibilityStateHidden, false);
1414 else if (newVisibility == "prerender")
1415 m_webView->setVisibilityState(WebPageVisibilityStatePrerender, false);
1416 }
1417 }
1418
setTextDirection(const CppArgumentList & arguments,CppVariant * result)1419 void TestRunner::setTextDirection(const CppArgumentList& arguments, CppVariant* result)
1420 {
1421 result->setNull();
1422 if (arguments.size() != 1 || !arguments[0].isString())
1423 return;
1424
1425 // Map a direction name to a WebTextDirection value.
1426 std::string directionName = arguments[0].toString();
1427 blink::WebTextDirection direction;
1428 if (directionName == "auto")
1429 direction = blink::WebTextDirectionDefault;
1430 else if (directionName == "rtl")
1431 direction = blink::WebTextDirectionRightToLeft;
1432 else if (directionName == "ltr")
1433 direction = blink::WebTextDirectionLeftToRight;
1434 else
1435 return;
1436
1437 m_webView->setTextDirection(direction);
1438 }
1439
textSurroundingNode(const CppArgumentList & arguments,CppVariant * result)1440 void TestRunner::textSurroundingNode(const CppArgumentList& arguments, CppVariant* result)
1441 {
1442 result->setNull();
1443 if (arguments.size() < 4 || !arguments[0].isObject() || !arguments[1].isNumber() || !arguments[2].isNumber() || !arguments[3].isNumber())
1444 return;
1445
1446 WebNode node;
1447 if (!WebBindings::getNode(arguments[0].value.objectValue, &node))
1448 return;
1449
1450 if (node.isNull() || !node.isTextNode())
1451 return;
1452
1453 WebPoint point(arguments[1].toInt32(), arguments[2].toInt32());
1454 unsigned maxLength = arguments[3].toInt32();
1455
1456 WebSurroundingText surroundingText;
1457 surroundingText.initialize(node, point, maxLength);
1458 if (surroundingText.isNull())
1459 return;
1460
1461 result->set(surroundingText.textContent().utf8());
1462 }
1463
dumpResourceRequestPriorities(const CppArgumentList & arguments,CppVariant * result)1464 void TestRunner::dumpResourceRequestPriorities(const CppArgumentList& arguments, CppVariant* result)
1465 {
1466 m_shouldDumpResourcePriorities = true;
1467 result->setNull();
1468 }
1469
useUnfortunateSynchronousResizeMode(const CppArgumentList & arguments,CppVariant * result)1470 void TestRunner::useUnfortunateSynchronousResizeMode(const CppArgumentList& arguments, CppVariant* result)
1471 {
1472 result->setNull();
1473 m_delegate->useUnfortunateSynchronousResizeMode(true);
1474 }
1475
enableAutoResizeMode(const CppArgumentList & arguments,CppVariant * result)1476 void TestRunner::enableAutoResizeMode(const CppArgumentList& arguments, CppVariant* result)
1477 {
1478 if (arguments.size() != 4) {
1479 result->set(false);
1480 return;
1481 }
1482 int minWidth = cppVariantToInt32(arguments[0]);
1483 int minHeight = cppVariantToInt32(arguments[1]);
1484 blink::WebSize minSize(minWidth, minHeight);
1485
1486 int maxWidth = cppVariantToInt32(arguments[2]);
1487 int maxHeight = cppVariantToInt32(arguments[3]);
1488 blink::WebSize maxSize(maxWidth, maxHeight);
1489
1490 m_delegate->enableAutoResizeMode(minSize, maxSize);
1491 result->set(true);
1492 }
1493
disableAutoResizeMode(const CppArgumentList & arguments,CppVariant * result)1494 void TestRunner::disableAutoResizeMode(const CppArgumentList& arguments, CppVariant* result)
1495 {
1496 if (arguments.size() !=2) {
1497 result->set(false);
1498 return;
1499 }
1500 int newWidth = cppVariantToInt32(arguments[0]);
1501 int newHeight = cppVariantToInt32(arguments[1]);
1502 blink::WebSize newSize(newWidth, newHeight);
1503
1504 m_delegate->disableAutoResizeMode(newSize);
1505 result->set(true);
1506 }
1507
setMockDeviceMotion(const CppArgumentList & arguments,CppVariant * result)1508 void TestRunner::setMockDeviceMotion(const CppArgumentList& arguments, CppVariant* result)
1509 {
1510 result->setNull();
1511 if (arguments.size() < 19
1512 || !arguments[0].isBool() || !arguments[1].isNumber() // acceleration.x
1513 || !arguments[2].isBool() || !arguments[3].isNumber() // acceleration.y
1514 || !arguments[4].isBool() || !arguments[5].isNumber() // acceleration.z
1515 || !arguments[6].isBool() || !arguments[7].isNumber() // accelerationIncludingGravity.x
1516 || !arguments[8].isBool() || !arguments[9].isNumber() // accelerationIncludingGravity.y
1517 || !arguments[10].isBool() || !arguments[11].isNumber() // accelerationIncludingGravity.z
1518 || !arguments[12].isBool() || !arguments[13].isNumber() // rotationRate.alpha
1519 || !arguments[14].isBool() || !arguments[15].isNumber() // rotationRate.beta
1520 || !arguments[16].isBool() || !arguments[17].isNumber() // rotationRate.gamma
1521 || !arguments[18].isNumber()) // interval
1522 return;
1523
1524 WebDeviceMotionData motion;
1525
1526 // acceleration
1527 motion.hasAccelerationX = arguments[0].toBoolean();
1528 motion.accelerationX = arguments[1].toDouble();
1529 motion.hasAccelerationY = arguments[2].toBoolean();
1530 motion.accelerationY = arguments[3].toDouble();
1531 motion.hasAccelerationZ = arguments[4].toBoolean();
1532 motion.accelerationZ = arguments[5].toDouble();
1533
1534 // accelerationIncludingGravity
1535 motion.hasAccelerationIncludingGravityX = arguments[6].toBoolean();
1536 motion.accelerationIncludingGravityX = arguments[7].toDouble();
1537 motion.hasAccelerationIncludingGravityY = arguments[8].toBoolean();
1538 motion.accelerationIncludingGravityY = arguments[9].toDouble();
1539 motion.hasAccelerationIncludingGravityZ = arguments[10].toBoolean();
1540 motion.accelerationIncludingGravityZ = arguments[11].toDouble();
1541
1542 // rotationRate
1543 motion.hasRotationRateAlpha = arguments[12].toBoolean();
1544 motion.rotationRateAlpha = arguments[13].toDouble();
1545 motion.hasRotationRateBeta = arguments[14].toBoolean();
1546 motion.rotationRateBeta = arguments[15].toDouble();
1547 motion.hasRotationRateGamma = arguments[16].toBoolean();
1548 motion.rotationRateGamma = arguments[17].toDouble();
1549
1550 // interval
1551 motion.interval = arguments[18].toDouble();
1552
1553 m_delegate->setDeviceMotionData(motion);
1554 }
1555
setMockDeviceOrientation(const CppArgumentList & arguments,CppVariant * result)1556 void TestRunner::setMockDeviceOrientation(const CppArgumentList& arguments, CppVariant* result)
1557 {
1558 result->setNull();
1559 if (arguments.size() < 8
1560 || !arguments[0].isBool() || !arguments[1].isNumber() // alpha
1561 || !arguments[2].isBool() || !arguments[3].isNumber() // beta
1562 || !arguments[4].isBool() || !arguments[5].isNumber() // gamma
1563 || !arguments[6].isBool() || !arguments[7].isBool()) // absolute
1564 return;
1565
1566 WebDeviceOrientationData orientation;
1567
1568 // alpha
1569 orientation.hasAlpha = arguments[0].toBoolean();
1570 orientation.alpha = arguments[1].toDouble();
1571
1572 // beta
1573 orientation.hasBeta = arguments[2].toBoolean();
1574 orientation.beta = arguments[3].toDouble();
1575
1576 // gamma
1577 orientation.hasGamma = arguments[4].toBoolean();
1578 orientation.gamma = arguments[5].toDouble();
1579
1580 // absolute
1581 orientation.hasAbsolute = arguments[6].toBoolean();
1582 orientation.absolute = arguments[7].toBoolean();
1583
1584 m_delegate->setDeviceOrientationData(orientation);
1585 }
1586
setPopupBlockingEnabled(const CppArgumentList & arguments,CppVariant * result)1587 void TestRunner::setPopupBlockingEnabled(const CppArgumentList& arguments, CppVariant* result)
1588 {
1589 if (arguments.size() > 0 && arguments[0].isBool()) {
1590 bool blockPopups = arguments[0].toBoolean();
1591 m_delegate->preferences()->javaScriptCanOpenWindowsAutomatically = !blockPopups;
1592 m_delegate->applyPreferences();
1593 }
1594 result->setNull();
1595 }
1596
setJavaScriptCanAccessClipboard(const CppArgumentList & arguments,CppVariant * result)1597 void TestRunner::setJavaScriptCanAccessClipboard(const CppArgumentList& arguments, CppVariant* result)
1598 {
1599 if (arguments.size() > 0 && arguments[0].isBool()) {
1600 m_delegate->preferences()->javaScriptCanAccessClipboard = arguments[0].value.boolValue;
1601 m_delegate->applyPreferences();
1602 }
1603 result->setNull();
1604 }
1605
setXSSAuditorEnabled(const CppArgumentList & arguments,CppVariant * result)1606 void TestRunner::setXSSAuditorEnabled(const CppArgumentList& arguments, CppVariant* result)
1607 {
1608 if (arguments.size() > 0 && arguments[0].isBool()) {
1609 m_delegate->preferences()->XSSAuditorEnabled = arguments[0].value.boolValue;
1610 m_delegate->applyPreferences();
1611 }
1612 result->setNull();
1613 }
1614
setAllowUniversalAccessFromFileURLs(const CppArgumentList & arguments,CppVariant * result)1615 void TestRunner::setAllowUniversalAccessFromFileURLs(const CppArgumentList& arguments, CppVariant* result)
1616 {
1617 if (arguments.size() > 0 && arguments[0].isBool()) {
1618 m_delegate->preferences()->allowUniversalAccessFromFileURLs = arguments[0].value.boolValue;
1619 m_delegate->applyPreferences();
1620 }
1621 result->setNull();
1622 }
1623
setAllowFileAccessFromFileURLs(const CppArgumentList & arguments,CppVariant * result)1624 void TestRunner::setAllowFileAccessFromFileURLs(const CppArgumentList& arguments, CppVariant* result)
1625 {
1626 if (arguments.size() > 0 && arguments[0].isBool()) {
1627 m_delegate->preferences()->allowFileAccessFromFileURLs = arguments[0].value.boolValue;
1628 m_delegate->applyPreferences();
1629 }
1630 result->setNull();
1631 }
1632
overridePreference(const CppArgumentList & arguments,CppVariant * result)1633 void TestRunner::overridePreference(const CppArgumentList& arguments, CppVariant* result)
1634 {
1635 result->setNull();
1636 if (arguments.size() != 2 || !arguments[0].isString())
1637 return;
1638
1639 string key = arguments[0].toString();
1640 CppVariant value = arguments[1];
1641 WebPreferences* prefs = m_delegate->preferences();
1642 if (key == "WebKitDefaultFontSize")
1643 prefs->defaultFontSize = cppVariantToInt32(value);
1644 else if (key == "WebKitMinimumFontSize")
1645 prefs->minimumFontSize = cppVariantToInt32(value);
1646 else if (key == "WebKitDefaultTextEncodingName")
1647 prefs->defaultTextEncodingName = cppVariantToWebString(value);
1648 else if (key == "WebKitJavaScriptEnabled")
1649 prefs->javaScriptEnabled = cppVariantToBool(value);
1650 else if (key == "WebKitSupportsMultipleWindows")
1651 prefs->supportsMultipleWindows = cppVariantToBool(value);
1652 else if (key == "WebKitDisplayImagesKey")
1653 prefs->loadsImagesAutomatically = cppVariantToBool(value);
1654 else if (key == "WebKitPluginsEnabled")
1655 prefs->pluginsEnabled = cppVariantToBool(value);
1656 else if (key == "WebKitJavaEnabled")
1657 prefs->javaEnabled = cppVariantToBool(value);
1658 else if (key == "WebKitOfflineWebApplicationCacheEnabled")
1659 prefs->offlineWebApplicationCacheEnabled = cppVariantToBool(value);
1660 else if (key == "WebKitTabToLinksPreferenceKey")
1661 prefs->tabsToLinks = cppVariantToBool(value);
1662 else if (key == "WebKitWebGLEnabled")
1663 prefs->experimentalWebGLEnabled = cppVariantToBool(value);
1664 else if (key == "WebKitCSSRegionsEnabled")
1665 prefs->experimentalCSSRegionsEnabled = cppVariantToBool(value);
1666 else if (key == "WebKitCSSGridLayoutEnabled")
1667 prefs->experimentalCSSGridLayoutEnabled = cppVariantToBool(value);
1668 else if (key == "WebKitHyperlinkAuditingEnabled")
1669 prefs->hyperlinkAuditingEnabled = cppVariantToBool(value);
1670 else if (key == "WebKitEnableCaretBrowsing")
1671 prefs->caretBrowsingEnabled = cppVariantToBool(value);
1672 else if (key == "WebKitAllowDisplayingInsecureContent")
1673 prefs->allowDisplayOfInsecureContent = cppVariantToBool(value);
1674 else if (key == "WebKitAllowRunningInsecureContent")
1675 prefs->allowRunningOfInsecureContent = cppVariantToBool(value);
1676 else if (key == "WebKitCSSCustomFilterEnabled")
1677 prefs->cssCustomFilterEnabled = cppVariantToBool(value);
1678 else if (key == "WebKitShouldRespectImageOrientation")
1679 prefs->shouldRespectImageOrientation = cppVariantToBool(value);
1680 else if (key == "WebKitWebAudioEnabled")
1681 BLINK_ASSERT(cppVariantToBool(value));
1682 else {
1683 string message("Invalid name for preference: ");
1684 message.append(key);
1685 printErrorMessage(message);
1686 }
1687 m_delegate->applyPreferences();
1688 }
1689
setPluginsEnabled(const CppArgumentList & arguments,CppVariant * result)1690 void TestRunner::setPluginsEnabled(const CppArgumentList& arguments, CppVariant* result)
1691 {
1692 if (arguments.size() > 0 && arguments[0].isBool()) {
1693 m_delegate->preferences()->pluginsEnabled = arguments[0].toBoolean();
1694 m_delegate->applyPreferences();
1695 }
1696 result->setNull();
1697 }
1698
showWebInspector(const CppArgumentList &,CppVariant * result)1699 void TestRunner::showWebInspector(const CppArgumentList&, CppVariant* result)
1700 {
1701 showDevTools();
1702 result->setNull();
1703 }
1704
closeWebInspector(const CppArgumentList & args,CppVariant * result)1705 void TestRunner::closeWebInspector(const CppArgumentList& args, CppVariant* result)
1706 {
1707 m_delegate->closeDevTools();
1708 result->setNull();
1709 }
1710
isChooserShown(const CppArgumentList &,CppVariant * result)1711 void TestRunner::isChooserShown(const CppArgumentList&, CppVariant* result)
1712 {
1713 result->set(m_proxy->isChooserShown());
1714 }
1715
evaluateInWebInspector(const CppArgumentList & arguments,CppVariant * result)1716 void TestRunner::evaluateInWebInspector(const CppArgumentList& arguments, CppVariant* result)
1717 {
1718 result->setNull();
1719 if (arguments.size() < 2 || !arguments[0].isNumber() || !arguments[1].isString())
1720 return;
1721 m_delegate->evaluateInWebInspector(arguments[0].toInt32(), arguments[1].toString());
1722 }
1723
clearAllDatabases(const CppArgumentList & arguments,CppVariant * result)1724 void TestRunner::clearAllDatabases(const CppArgumentList& arguments, CppVariant* result)
1725 {
1726 result->setNull();
1727 m_delegate->clearAllDatabases();
1728 }
1729
setDatabaseQuota(const CppArgumentList & arguments,CppVariant * result)1730 void TestRunner::setDatabaseQuota(const CppArgumentList& arguments, CppVariant* result)
1731 {
1732 result->setNull();
1733 if ((arguments.size() >= 1) && arguments[0].isNumber())
1734 m_delegate->setDatabaseQuota(arguments[0].toInt32());
1735 }
1736
setAlwaysAcceptCookies(const CppArgumentList & arguments,CppVariant * result)1737 void TestRunner::setAlwaysAcceptCookies(const CppArgumentList& arguments, CppVariant* result)
1738 {
1739 if (arguments.size() > 0)
1740 m_delegate->setAcceptAllCookies(cppVariantToBool(arguments[0]));
1741 result->setNull();
1742 }
1743
setWindowIsKey(const CppArgumentList & arguments,CppVariant * result)1744 void TestRunner::setWindowIsKey(const CppArgumentList& arguments, CppVariant* result)
1745 {
1746 if (arguments.size() > 0 && arguments[0].isBool())
1747 m_delegate->setFocus(m_proxy, arguments[0].value.boolValue);
1748 result->setNull();
1749 }
1750
pathToLocalResource(const CppArgumentList & arguments,CppVariant * result)1751 void TestRunner::pathToLocalResource(const CppArgumentList& arguments, CppVariant* result)
1752 {
1753 result->setNull();
1754 if (arguments.size() <= 0 || !arguments[0].isString())
1755 return;
1756
1757 result->set(m_delegate->pathToLocalResource(arguments[0].toString()));
1758 }
1759
setBackingScaleFactor(const CppArgumentList & arguments,CppVariant * result)1760 void TestRunner::setBackingScaleFactor(const CppArgumentList& arguments, CppVariant* result)
1761 {
1762 if (arguments.size() < 2 || !arguments[0].isNumber() || !arguments[1].isObject())
1763 return;
1764
1765 float value = arguments[0].value.doubleValue;
1766 m_delegate->setDeviceScaleFactor(value);
1767 m_proxy->discardBackingStore();
1768
1769 WebScopedPtr<CppVariant> callbackArguments(new CppVariant());
1770 callbackArguments->set(arguments[1]);
1771 result->setNull();
1772 m_delegate->postTask(new InvokeCallbackTask(this, callbackArguments));
1773 }
1774
setPOSIXLocale(const CppArgumentList & arguments,CppVariant * result)1775 void TestRunner::setPOSIXLocale(const CppArgumentList& arguments, CppVariant* result)
1776 {
1777 result->setNull();
1778 if (arguments.size() == 1 && arguments[0].isString())
1779 m_delegate->setLocale(arguments[0].toString());
1780 }
1781
numberOfPendingGeolocationPermissionRequests(const CppArgumentList & arguments,CppVariant * result)1782 void TestRunner::numberOfPendingGeolocationPermissionRequests(const CppArgumentList& arguments, CppVariant* result)
1783 {
1784 result->set(m_proxy->geolocationClientMock()->numberOfPendingPermissionRequests());
1785 }
1786
1787 // FIXME: For greater test flexibility, we should be able to set each page's geolocation mock individually.
1788 // https://bugs.webkit.org/show_bug.cgi?id=52368
setGeolocationPermission(const CppArgumentList & arguments,CppVariant * result)1789 void TestRunner::setGeolocationPermission(const CppArgumentList& arguments, CppVariant* result)
1790 {
1791 result->setNull();
1792 if (arguments.size() < 1 || !arguments[0].isBool())
1793 return;
1794 const vector<WebTestProxyBase*>& windowList = m_testInterfaces->windowList();
1795 for (unsigned i = 0; i < windowList.size(); ++i)
1796 windowList.at(i)->geolocationClientMock()->setPermission(arguments[0].toBoolean());
1797 }
1798
setMockGeolocationPosition(const CppArgumentList & arguments,CppVariant * result)1799 void TestRunner::setMockGeolocationPosition(const CppArgumentList& arguments, CppVariant* result)
1800 {
1801 result->setNull();
1802 if (arguments.size() < 3 || !arguments[0].isNumber() || !arguments[1].isNumber() || !arguments[2].isNumber())
1803 return;
1804 const vector<WebTestProxyBase*>& windowList = m_testInterfaces->windowList();
1805 for (unsigned i = 0; i < windowList.size(); ++i)
1806 windowList.at(i)->geolocationClientMock()->setPosition(arguments[0].toDouble(), arguments[1].toDouble(), arguments[2].toDouble());
1807 }
1808
setMockGeolocationPositionUnavailableError(const CppArgumentList & arguments,CppVariant * result)1809 void TestRunner::setMockGeolocationPositionUnavailableError(const CppArgumentList& arguments, CppVariant* result)
1810 {
1811 result->setNull();
1812 if (arguments.size() != 1 || !arguments[0].isString())
1813 return;
1814 const vector<WebTestProxyBase*>& windowList = m_testInterfaces->windowList();
1815 for (unsigned i = 0; i < windowList.size(); ++i)
1816 windowList.at(i)->geolocationClientMock()->setPositionUnavailableError(WebString::fromUTF8(arguments[0].toString()));
1817 }
1818
setMIDIAccessorResult(const CppArgumentList & arguments,CppVariant * result)1819 void TestRunner::setMIDIAccessorResult(const CppArgumentList& arguments, CppVariant* result)
1820 {
1821 result->setNull();
1822 if (arguments.size() < 1 || !arguments[0].isBool())
1823 return;
1824 m_midiAccessorResult = arguments[0].toBoolean();
1825 }
1826
setMIDISysExPermission(const CppArgumentList & arguments,CppVariant * result)1827 void TestRunner::setMIDISysExPermission(const CppArgumentList& arguments, CppVariant* result)
1828 {
1829 result->setNull();
1830 if (arguments.size() < 1 || !arguments[0].isBool())
1831 return;
1832 const vector<WebTestProxyBase*>& windowList = m_testInterfaces->windowList();
1833 for (unsigned i = 0; i < windowList.size(); ++i)
1834 windowList.at(i)->midiClientMock()->setSysExPermission(arguments[0].toBoolean());
1835 }
1836
grantWebNotificationPermission(const CppArgumentList & arguments,CppVariant * result)1837 void TestRunner::grantWebNotificationPermission(const CppArgumentList& arguments, CppVariant* result)
1838 {
1839 if (arguments.size() != 1 || !arguments[0].isString()) {
1840 result->set(false);
1841 return;
1842 }
1843 m_notificationPresenter->grantPermission(WebString::fromUTF8(arguments[0].toString()));
1844 result->set(true);
1845 }
1846
simulateLegacyWebNotificationClick(const CppArgumentList & arguments,CppVariant * result)1847 void TestRunner::simulateLegacyWebNotificationClick(const CppArgumentList& arguments, CppVariant* result)
1848 {
1849 if (arguments.size() != 1 || !arguments[0].isString()) {
1850 result->set(false);
1851 return;
1852 }
1853 result->set(m_notificationPresenter->simulateClick(WebString::fromUTF8(arguments[0].toString())));
1854 }
1855
cancelAllActiveNotifications(const CppArgumentList & arguments,CppVariant * result)1856 void TestRunner::cancelAllActiveNotifications(const CppArgumentList& arguments, CppVariant* result)
1857 {
1858 m_notificationPresenter->cancelAllActiveNotifications();
1859 result->set(true);
1860 }
1861
addMockSpeechInputResult(const CppArgumentList & arguments,CppVariant * result)1862 void TestRunner::addMockSpeechInputResult(const CppArgumentList& arguments, CppVariant* result)
1863 {
1864 result->setNull();
1865 if (arguments.size() < 3 || !arguments[0].isString() || !arguments[1].isNumber() || !arguments[2].isString())
1866 return;
1867
1868 #if ENABLE_INPUT_SPEECH
1869 m_proxy->speechInputControllerMock()->addMockRecognitionResult(WebString::fromUTF8(arguments[0].toString()), arguments[1].toDouble(), WebString::fromUTF8(arguments[2].toString()));
1870 #endif
1871 }
1872
setMockSpeechInputDumpRect(const CppArgumentList & arguments,CppVariant * result)1873 void TestRunner::setMockSpeechInputDumpRect(const CppArgumentList& arguments, CppVariant* result)
1874 {
1875 result->setNull();
1876 if (arguments.size() < 1 || !arguments[0].isBool())
1877 return;
1878
1879 #if ENABLE_INPUT_SPEECH
1880 m_proxy->speechInputControllerMock()->setDumpRect(arguments[0].toBoolean());
1881 #endif
1882 }
1883
addMockSpeechRecognitionResult(const CppArgumentList & arguments,CppVariant * result)1884 void TestRunner::addMockSpeechRecognitionResult(const CppArgumentList& arguments, CppVariant* result)
1885 {
1886 result->setNull();
1887 if (arguments.size() < 2 || !arguments[0].isString() || !arguments[1].isNumber())
1888 return;
1889
1890 m_proxy->speechRecognizerMock()->addMockResult(WebString::fromUTF8(arguments[0].toString()), arguments[1].toDouble());
1891 }
1892
setMockSpeechRecognitionError(const CppArgumentList & arguments,CppVariant * result)1893 void TestRunner::setMockSpeechRecognitionError(const CppArgumentList& arguments, CppVariant* result)
1894 {
1895 result->setNull();
1896 if (arguments.size() != 2 || !arguments[0].isString() || !arguments[1].isString())
1897 return;
1898
1899 m_proxy->speechRecognizerMock()->setError(WebString::fromUTF8(arguments[0].toString()), WebString::fromUTF8(arguments[1].toString()));
1900 }
1901
wasMockSpeechRecognitionAborted(const CppArgumentList &,CppVariant * result)1902 void TestRunner::wasMockSpeechRecognitionAborted(const CppArgumentList&, CppVariant* result)
1903 {
1904 result->set(m_proxy->speechRecognizerMock()->wasAborted());
1905 }
1906
addWebPageOverlay(const CppArgumentList &,CppVariant * result)1907 void TestRunner::addWebPageOverlay(const CppArgumentList&, CppVariant* result)
1908 {
1909 if (m_webView && !m_pageOverlay) {
1910 m_pageOverlay = new TestPageOverlay(m_webView);
1911 m_webView->addPageOverlay(m_pageOverlay, 0);
1912 }
1913 result->setNull();
1914 }
1915
removeWebPageOverlay(const CppArgumentList &,CppVariant * result)1916 void TestRunner::removeWebPageOverlay(const CppArgumentList&, CppVariant* result)
1917 {
1918 if (m_webView && m_pageOverlay) {
1919 m_webView->removePageOverlay(m_pageOverlay);
1920 delete m_pageOverlay;
1921 m_pageOverlay = 0;
1922 }
1923
1924 result->setNull();
1925 }
1926
display(const CppArgumentList & arguments,CppVariant * result)1927 void TestRunner::display(const CppArgumentList& arguments, CppVariant* result)
1928 {
1929 m_proxy->display();
1930 result->setNull();
1931 }
1932
displayInvalidatedRegion(const CppArgumentList & arguments,CppVariant * result)1933 void TestRunner::displayInvalidatedRegion(const CppArgumentList& arguments, CppVariant* result)
1934 {
1935 m_proxy->displayInvalidatedRegion();
1936 result->setNull();
1937 }
1938
dumpEditingCallbacks(const CppArgumentList &,CppVariant * result)1939 void TestRunner::dumpEditingCallbacks(const CppArgumentList&, CppVariant* result)
1940 {
1941 m_dumpEditingCallbacks = true;
1942 result->setNull();
1943 }
1944
dumpAsText(const CppArgumentList &,CppVariant * result)1945 void TestRunner::dumpAsText(const CppArgumentList&, CppVariant* result)
1946 {
1947 m_dumpAsText = true;
1948 m_generatePixelResults = false;
1949
1950 result->setNull();
1951 }
1952
dumpAsTextWithPixelResults(const CppArgumentList &,CppVariant * result)1953 void TestRunner::dumpAsTextWithPixelResults(const CppArgumentList&, CppVariant* result)
1954 {
1955 m_dumpAsText = true;
1956 m_generatePixelResults = true;
1957
1958 result->setNull();
1959 }
1960
dumpChildFrameScrollPositions(const CppArgumentList &,CppVariant * result)1961 void TestRunner::dumpChildFrameScrollPositions(const CppArgumentList&, CppVariant* result)
1962 {
1963 m_dumpChildFrameScrollPositions = true;
1964 result->setNull();
1965 }
1966
dumpChildFramesAsText(const CppArgumentList &,CppVariant * result)1967 void TestRunner::dumpChildFramesAsText(const CppArgumentList&, CppVariant* result)
1968 {
1969 m_dumpChildFramesAsText = true;
1970 result->setNull();
1971 }
1972
dumpIconChanges(const CppArgumentList &,CppVariant * result)1973 void TestRunner::dumpIconChanges(const CppArgumentList&, CppVariant* result)
1974 {
1975 m_dumpIconChanges = true;
1976 result->setNull();
1977 }
1978
setAudioData(const CppArgumentList & arguments,CppVariant * result)1979 void TestRunner::setAudioData(const CppArgumentList& arguments, CppVariant* result)
1980 {
1981 result->setNull();
1982
1983 if (arguments.size() < 1 || !arguments[0].isObject())
1984 return;
1985
1986 // Check that passed-in object is, in fact, an ArrayBufferView.
1987 NPObject* npobject = NPVARIANT_TO_OBJECT(arguments[0]);
1988 if (!npobject)
1989 return;
1990 if (!WebBindings::getArrayBufferView(npobject, &m_audioData))
1991 return;
1992
1993 m_dumpAsAudio = true;
1994 }
1995
dumpFrameLoadCallbacks(const CppArgumentList &,CppVariant * result)1996 void TestRunner::dumpFrameLoadCallbacks(const CppArgumentList&, CppVariant* result)
1997 {
1998 m_dumpFrameLoadCallbacks = true;
1999 result->setNull();
2000 }
2001
dumpPingLoaderCallbacks(const CppArgumentList &,CppVariant * result)2002 void TestRunner::dumpPingLoaderCallbacks(const CppArgumentList&, CppVariant* result)
2003 {
2004 m_dumpPingLoaderCallbacks = true;
2005 result->setNull();
2006 }
2007
dumpUserGestureInFrameLoadCallbacks(const CppArgumentList &,CppVariant * result)2008 void TestRunner::dumpUserGestureInFrameLoadCallbacks(const CppArgumentList&, CppVariant* result)
2009 {
2010 m_dumpUserGestureInFrameLoadCallbacks = true;
2011 result->setNull();
2012 }
2013
dumpTitleChanges(const CppArgumentList &,CppVariant * result)2014 void TestRunner::dumpTitleChanges(const CppArgumentList&, CppVariant* result)
2015 {
2016 m_dumpTitleChanges = true;
2017 result->setNull();
2018 }
2019
dumpCreateView(const CppArgumentList &,CppVariant * result)2020 void TestRunner::dumpCreateView(const CppArgumentList&, CppVariant* result)
2021 {
2022 m_dumpCreateView = true;
2023 result->setNull();
2024 }
2025
setCanOpenWindows(const CppArgumentList &,CppVariant * result)2026 void TestRunner::setCanOpenWindows(const CppArgumentList&, CppVariant* result)
2027 {
2028 m_canOpenWindows = true;
2029 result->setNull();
2030 }
2031
dumpResourceLoadCallbacks(const CppArgumentList &,CppVariant * result)2032 void TestRunner::dumpResourceLoadCallbacks(const CppArgumentList&, CppVariant* result)
2033 {
2034 m_dumpResourceLoadCallbacks = true;
2035 result->setNull();
2036 }
2037
dumpResourceRequestCallbacks(const CppArgumentList &,CppVariant * result)2038 void TestRunner::dumpResourceRequestCallbacks(const CppArgumentList&, CppVariant* result)
2039 {
2040 m_dumpResourceRequestCallbacks = true;
2041 result->setNull();
2042 }
2043
dumpResourceResponseMIMETypes(const CppArgumentList &,CppVariant * result)2044 void TestRunner::dumpResourceResponseMIMETypes(const CppArgumentList&, CppVariant* result)
2045 {
2046 m_dumpResourceResponseMIMETypes = true;
2047 result->setNull();
2048 }
2049
2050 // Need these conversions because the format of the value for booleans
2051 // may vary - for example, on mac "1" and "0" are used for boolean.
cppVariantToBool(const CppVariant & value)2052 bool TestRunner::cppVariantToBool(const CppVariant& value)
2053 {
2054 if (value.isBool())
2055 return value.toBoolean();
2056 if (value.isNumber())
2057 return value.toInt32();
2058 if (value.isString()) {
2059 string valueString = value.toString();
2060 if (valueString == "true" || valueString == "1")
2061 return true;
2062 if (valueString == "false" || valueString == "0")
2063 return false;
2064 }
2065 printErrorMessage("Invalid value. Expected boolean value.");
2066 return false;
2067 }
2068
cppVariantToInt32(const CppVariant & value)2069 int32_t TestRunner::cppVariantToInt32(const CppVariant& value)
2070 {
2071 if (value.isNumber())
2072 return value.toInt32();
2073 if (value.isString()) {
2074 string stringSource = value.toString();
2075 const char* source = stringSource.data();
2076 char* end;
2077 long number = strtol(source, &end, 10);
2078 if (end == source + stringSource.length() && number >= numeric_limits<int32_t>::min() && number <= numeric_limits<int32_t>::max())
2079 return static_cast<int32_t>(number);
2080 }
2081 printErrorMessage("Invalid value for preference. Expected integer value.");
2082 return 0;
2083 }
2084
cppVariantToWebString(const CppVariant & value)2085 WebString TestRunner::cppVariantToWebString(const CppVariant& value)
2086 {
2087 if (!value.isString()) {
2088 printErrorMessage("Invalid value for preference. Expected string value.");
2089 return WebString();
2090 }
2091 return WebString::fromUTF8(value.toString());
2092 }
2093
printErrorMessage(const string & text)2094 void TestRunner::printErrorMessage(const string& text)
2095 {
2096 m_delegate->printMessage(string("CONSOLE MESSAGE: ") + text + "\n");
2097 }
2098
fallbackMethod(const CppArgumentList &,CppVariant * result)2099 void TestRunner::fallbackMethod(const CppArgumentList&, CppVariant* result)
2100 {
2101 printErrorMessage("JavaScript ERROR: unknown method called on TestRunner");
2102 result->setNull();
2103 }
2104
notImplemented(const CppArgumentList &,CppVariant * result)2105 void TestRunner::notImplemented(const CppArgumentList&, CppVariant* result)
2106 {
2107 result->setNull();
2108 }
2109
didAcquirePointerLock(const CppArgumentList &,CppVariant * result)2110 void TestRunner::didAcquirePointerLock(const CppArgumentList&, CppVariant* result)
2111 {
2112 didAcquirePointerLockInternal();
2113 result->setNull();
2114 }
2115
didNotAcquirePointerLock(const CppArgumentList &,CppVariant * result)2116 void TestRunner::didNotAcquirePointerLock(const CppArgumentList&, CppVariant* result)
2117 {
2118 didNotAcquirePointerLockInternal();
2119 result->setNull();
2120 }
2121
didLosePointerLock(const CppArgumentList &,CppVariant * result)2122 void TestRunner::didLosePointerLock(const CppArgumentList&, CppVariant* result)
2123 {
2124 didLosePointerLockInternal();
2125 result->setNull();
2126 }
2127
setPointerLockWillRespondAsynchronously(const CppArgumentList &,CppVariant * result)2128 void TestRunner::setPointerLockWillRespondAsynchronously(const CppArgumentList&, CppVariant* result)
2129 {
2130 m_pointerLockPlannedResult = PointerLockWillRespondAsync;
2131 result->setNull();
2132 }
2133
setPointerLockWillFailSynchronously(const CppArgumentList &,CppVariant * result)2134 void TestRunner::setPointerLockWillFailSynchronously(const CppArgumentList&, CppVariant* result)
2135 {
2136 m_pointerLockPlannedResult = PointerLockWillFailSync;
2137 result->setNull();
2138 }
2139
2140 }
2141