dd11428f2850a0b43deac242f624d8ef16a9a3af
[WebKit-https.git] / WebKitTools / DumpRenderTree / qt / LayoutTestControllerQt.cpp
1 /*
2  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
3  * Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer.
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution.
14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29 #include "config.h"
30 #include "LayoutTestControllerQt.h"
31 #include "../../../WebKit/qt/WebCoreSupport/DumpRenderTreeSupportQt.h"
32
33 #include "DumpRenderTreeQt.h"
34 #include "WorkQueue.h"
35 #include "WorkQueueItemQt.h"
36 #include <QDir>
37 #include <QLocale>
38 #include <qwebsettings.h>
39
40 LayoutTestController::LayoutTestController(WebCore::DumpRenderTree* drt)
41     : QObject()
42     , m_drt(drt)
43 {
44     qRegisterMetaType<QWebElement>("QWebElement");
45     reset();
46     DumpRenderTreeSupportQt::dumpNotification(true);
47 }
48
49 void LayoutTestController::reset()
50 {
51     m_hasDumped = false;
52     m_loadFinished = false;
53     m_textDump = false;
54     m_dumpBackForwardList = false;
55     m_dumpChildrenAsText = false;
56     m_dumpChildFrameScrollPositions = false;
57     m_canOpenWindows = false;
58     m_waitForDone = false;
59     m_dumpTitleChanges = false;
60     m_dumpDatabaseCallbacks = false;
61     m_dumpStatusCallbacks = false;
62     m_timeoutTimer.stop();
63     m_topLoadingFrame = 0;
64     m_waitForPolicy = false;
65     m_handleErrorPages = false;
66     m_webHistory = 0;
67     m_globalFlag = false;
68     m_userStyleSheetEnabled = false;
69     m_desktopNotificationAllowedOrigins.clear();
70
71     DumpRenderTreeSupportQt::dumpEditingCallbacks(false);
72     DumpRenderTreeSupportQt::dumpFrameLoader(false);
73     DumpRenderTreeSupportQt::dumpResourceLoadCallbacks(false);
74     DumpRenderTreeSupportQt::dumpResourceResponseMIMETypes(false);
75     DumpRenderTreeSupportQt::setWillSendRequestReturnsNullOnRedirect(false);
76     DumpRenderTreeSupportQt::setWillSendRequestReturnsNull(false);
77     DumpRenderTreeSupportQt::setWillSendRequestClearHeaders(QStringList());
78     DumpRenderTreeSupportQt::clearScriptWorlds();
79     DumpRenderTreeSupportQt::setCustomPolicyDelegate(false, false);
80     setIconDatabaseEnabled(false);
81
82     emit hidePage();
83 }
84
85 void LayoutTestController::processWork()
86 {
87     // qDebug() << ">>>processWork";
88
89     // if we didn't start a new load, then we finished all the commands, so we're ready to dump state
90     if (WorkQueue::shared()->processWork() && !shouldWaitUntilDone()) {
91         emit done();
92         m_hasDumped = true;
93     }
94 }
95
96 // Called on loadFinished on WebPage
97 void LayoutTestController::maybeDump(bool success)
98 {
99
100     // This can happen on any of the http/tests/security/window-events-*.html tests, where the test opens
101     // a new window, calls the unload and load event handlers on the window's page, and then immediately
102     // issues a notifyDone. Needs investigation.
103     if (!m_topLoadingFrame)
104         return;
105
106     // It is possible that we get called by windows created from the main page that have finished
107     // loading, so we don't ASSERT here. At the moment we do not gather results from such windows,
108     // but may need to in future.
109     if (sender() != m_topLoadingFrame->page())
110         return;
111
112     m_loadFinished = true;
113     // as the function is called on loadFinished, the test might
114     // already have dumped and thus no longer be active, thus
115     // bail out here.
116     if (m_hasDumped)
117         return;
118
119     WorkQueue::shared()->setFrozen(true); // first complete load freezes the queue for the rest of this test
120     if (WorkQueue::shared()->count())
121         QTimer::singleShot(0, this, SLOT(processWork()));
122     else if (!shouldWaitUntilDone()) {
123         if (success)
124             emit done();
125         m_hasDumped = true;
126     }
127 }
128
129 void LayoutTestController::waitUntilDone()
130 {
131     //qDebug() << ">>>>waitForDone";
132     m_waitForDone = true;
133     m_timeoutTimer.start(30000, this);
134 }
135
136 QString LayoutTestController::counterValueForElementById(const QString& id)
137 {
138     return DumpRenderTreeSupportQt::counterValueForElementById(m_drt->webPage()->mainFrame(), id);
139 }
140
141 void LayoutTestController::setViewModeMediaFeature(const QString& mode)
142 {
143     m_drt->webPage()->setProperty("_q_viewMode", mode);
144 }
145
146 int LayoutTestController::webHistoryItemCount()
147 {
148     if (!m_webHistory)
149         return -1;
150
151     // Subtract one here as our QWebHistory::count() includes the actual page,
152     // which is not considered in the DRT tests.
153     return m_webHistory->count() - 1;
154 }
155
156 void LayoutTestController::keepWebHistory()
157 {
158     m_webHistory = m_drt->webPage()->history();
159 }
160
161 void LayoutTestController::notifyDone()
162 {
163     qDebug() << ">>>>notifyDone";
164
165     if (!m_timeoutTimer.isActive())
166         return;
167
168     m_timeoutTimer.stop();
169     m_waitForDone = false;
170
171     // If the page has not finished loading (i.e. loadFinished() has not been emitted) then
172     // content created by the likes of document.write() JS methods will not be available yet.
173     // When the page has finished loading, maybeDump above will dump the results now that we have
174     // just set shouldWaitUntilDone to false.
175     if (!m_loadFinished)
176         return;
177
178     emit done();
179
180     // FIXME: investigate why always resetting these result in timeouts
181     m_hasDumped = true;
182     m_waitForPolicy = false;
183 }
184
185 int LayoutTestController::windowCount()
186 {
187     return m_drt->windowCount();
188 }
189
190 void LayoutTestController::grantDesktopNotificationPermission(const QString& origin)
191 {
192     m_desktopNotificationAllowedOrigins.append(origin);
193 }
194
195 bool LayoutTestController::checkDesktopNotificationPermission(const QString& origin)
196 {
197     return m_desktopNotificationAllowedOrigins.contains(origin);
198 }
199
200 void LayoutTestController::display()
201 {
202     emit showPage();
203 }
204
205 void LayoutTestController::clearBackForwardList()
206 {
207     m_drt->webPage()->history()->clear();
208 }
209
210 QString LayoutTestController::pathToLocalResource(const QString& url)
211 {
212     // Function introduced in r28690.
213     return QDir::toNativeSeparators(url);
214 }
215
216 void LayoutTestController::dumpEditingCallbacks()
217 {
218     qDebug() << ">>>dumpEditingCallbacks";
219     DumpRenderTreeSupportQt::dumpEditingCallbacks(true);
220 }
221
222 void LayoutTestController::dumpFrameLoadCallbacks()
223 {
224     DumpRenderTreeSupportQt::dumpFrameLoader(true);
225 }
226
227 void LayoutTestController::dumpResourceLoadCallbacks()
228 {
229     DumpRenderTreeSupportQt::dumpResourceLoadCallbacks(true);
230 }
231
232 void LayoutTestController::dumpResourceResponseMIMETypes()
233 {
234     DumpRenderTreeSupportQt::dumpResourceResponseMIMETypes(true);
235 }
236
237 void LayoutTestController::setWillSendRequestReturnsNullOnRedirect(bool enabled)
238 {
239     DumpRenderTreeSupportQt::setWillSendRequestReturnsNullOnRedirect(enabled);
240 }
241
242 void LayoutTestController::setWillSendRequestReturnsNull(bool enabled)
243 {
244     DumpRenderTreeSupportQt::setWillSendRequestReturnsNull(enabled);
245 }
246
247 void LayoutTestController::setWillSendRequestClearHeader(const QStringList& headers)
248 {
249     DumpRenderTreeSupportQt::setWillSendRequestClearHeaders(headers);
250 }
251
252 void LayoutTestController::queueBackNavigation(int howFarBackward)
253 {
254     //qDebug() << ">>>queueBackNavigation" << howFarBackward;
255     WorkQueue::shared()->queue(new BackItem(howFarBackward, m_drt->webPage()));
256 }
257
258 void LayoutTestController::queueForwardNavigation(int howFarForward)
259 {
260     //qDebug() << ">>>queueForwardNavigation" << howFarForward;
261     WorkQueue::shared()->queue(new ForwardItem(howFarForward, m_drt->webPage()));
262 }
263
264 void LayoutTestController::queueLoad(const QString& url, const QString& target)
265 {
266     //qDebug() << ">>>queueLoad" << url << target;
267     QUrl mainResourceUrl = m_drt->webPage()->mainFrame()->url();
268     QString absoluteUrl = mainResourceUrl.resolved(QUrl(url)).toEncoded();
269     WorkQueue::shared()->queue(new LoadItem(absoluteUrl, target, m_drt->webPage()));
270 }
271
272 void LayoutTestController::queueReload()
273 {
274     //qDebug() << ">>>queueReload";
275     WorkQueue::shared()->queue(new ReloadItem(m_drt->webPage()));
276 }
277
278 void LayoutTestController::queueLoadingScript(const QString& script)
279 {
280     //qDebug() << ">>>queueLoadingScript" << script;
281     WorkQueue::shared()->queue(new LoadingScriptItem(script, m_drt->webPage()));
282 }
283
284 void LayoutTestController::queueNonLoadingScript(const QString& script)
285 {
286     //qDebug() << ">>>queueNonLoadingScript" << script;
287     WorkQueue::shared()->queue(new NonLoadingScriptItem(script, m_drt->webPage()));
288 }
289
290 void LayoutTestController::provisionalLoad()
291 {
292     QWebFrame* frame = qobject_cast<QWebFrame*>(sender());
293     if (!m_topLoadingFrame && !m_hasDumped)
294         m_topLoadingFrame = frame;
295 }
296
297 void LayoutTestController::timerEvent(QTimerEvent *ev)
298 {
299     if (ev->timerId() == m_timeoutTimer.timerId()) {
300         const char* message = "FAIL: Timed out waiting for notifyDone to be called\n";
301         fprintf(stderr, "%s", message);
302         fprintf(stdout, "%s", message);
303         notifyDone();
304     } else
305         QObject::timerEvent(ev);
306 }
307
308 QString LayoutTestController::encodeHostName(const QString& host)
309 {
310     QString encoded = QString::fromLatin1(QUrl::toAce(host + QLatin1String(".no")));
311     encoded.truncate(encoded.length() - 3); // strip .no
312     return encoded;
313 }
314
315 QString LayoutTestController::decodeHostName(const QString& host)
316 {
317     QString decoded = QUrl::fromAce(host.toLatin1() + QByteArray(".no"));
318     decoded.truncate(decoded.length() - 3);
319     return decoded;
320 }
321
322 void LayoutTestController::setMediaType(const QString& type)
323 {
324     DumpRenderTreeSupportQt::setMediaType(m_drt->webPage()->mainFrame(), type);
325 }
326
327 void LayoutTestController::closeWebInspector()
328 {
329     DumpRenderTreeSupportQt::webInspectorClose(m_drt->webPage());
330     m_drt->webPage()->settings()->setAttribute(QWebSettings::DeveloperExtrasEnabled, false);
331 }
332
333 void LayoutTestController::setDeveloperExtrasEnabled(bool enabled)
334 {
335     m_drt->webPage()->settings()->setAttribute(QWebSettings::DeveloperExtrasEnabled, enabled);
336 }
337
338 void LayoutTestController::showWebInspector()
339 {
340     m_drt->webPage()->settings()->setAttribute(QWebSettings::DeveloperExtrasEnabled, true);
341     DumpRenderTreeSupportQt::webInspectorShow(m_drt->webPage());
342 }
343
344 void LayoutTestController::evaluateInWebInspector(long callId, const QString& script)
345 {
346     DumpRenderTreeSupportQt::webInspectorExecuteScript(m_drt->webPage(), callId, script);
347 }
348
349 void LayoutTestController::setFrameFlatteningEnabled(bool enabled)
350 {
351     DumpRenderTreeSupportQt::setFrameFlatteningEnabled(m_drt->webPage(), enabled);
352 }
353
354 void LayoutTestController::setAllowUniversalAccessFromFileURLs(bool enabled)
355 {
356     m_drt->webPage()->settings()->setAttribute(QWebSettings::LocalContentCanAccessRemoteUrls, enabled);
357 }
358
359 void LayoutTestController::setAllowFileAccessFromFileURLs(bool enabled)
360 {
361     m_drt->webPage()->settings()->setAttribute(QWebSettings::LocalContentCanAccessFileUrls, enabled);
362 }
363
364 void LayoutTestController::setAppCacheMaximumSize(unsigned long long quota)
365 {
366     m_drt->webPage()->settings()->setOfflineWebApplicationCacheQuota(quota);
367 }
368
369 void LayoutTestController::setJavaScriptProfilingEnabled(bool enable)
370 {
371     setDeveloperExtrasEnabled(enable);
372     DumpRenderTreeSupportQt::setJavaScriptProfilingEnabled(m_topLoadingFrame, enable);
373 }
374
375 void LayoutTestController::setTimelineProfilingEnabled(bool enable)
376 {
377     DumpRenderTreeSupportQt::setTimelineProfilingEnabled(m_drt->webPage(), enable);
378 }
379
380 void LayoutTestController::setFixedContentsSize(int width, int height)
381 {
382     m_topLoadingFrame->page()->setPreferredContentsSize(QSize(width, height));
383 }
384
385 void LayoutTestController::setPrivateBrowsingEnabled(bool enable)
386 {
387     m_drt->webPage()->settings()->setAttribute(QWebSettings::PrivateBrowsingEnabled, enable);
388 }
389
390 void LayoutTestController::setSpatialNavigationEnabled(bool enable)
391 {
392     m_drt->webPage()->settings()->setAttribute(QWebSettings::SpatialNavigationEnabled, enable);
393 }
394
395 void LayoutTestController::setPopupBlockingEnabled(bool enable)
396 {
397     m_drt->webPage()->settings()->setAttribute(QWebSettings::JavascriptCanOpenWindows, !enable);
398 }
399
400 void LayoutTestController::setPluginsEnabled(bool flag)
401 {
402     // FIXME: Implement
403 }
404
405 void LayoutTestController::setPOSIXLocale(const QString& locale)
406 {
407     QLocale qlocale(locale);
408     QLocale::setDefault(qlocale);
409
410
411 void LayoutTestController::setWindowIsKey(bool isKey)
412 {
413     m_drt->switchFocus(isKey);
414 }
415
416 void LayoutTestController::setMainFrameIsFirstResponder(bool isFirst)
417 {
418     //FIXME: only need this for the moment: https://bugs.webkit.org/show_bug.cgi?id=32990
419 }
420
421 void LayoutTestController::setJavaScriptCanAccessClipboard(bool enable)
422 {
423     m_drt->webPage()->settings()->setAttribute(QWebSettings::JavascriptCanAccessClipboard, enable);
424 }
425
426 void LayoutTestController::setXSSAuditorEnabled(bool enable)
427 {
428     // Set XSSAuditingEnabled globally so that windows created by the test inherit it too.
429     // resetSettings() will call this to reset the page and global setting to false again.
430     // Needed by http/tests/security/xssAuditor/link-opens-new-window.html
431     QWebSettings* globalSettings = QWebSettings::globalSettings();
432     globalSettings->setAttribute(QWebSettings::XSSAuditingEnabled, enable);
433     m_drt->webPage()->settings()->setAttribute(QWebSettings::XSSAuditingEnabled, enable);
434 }
435
436 bool LayoutTestController::pauseAnimationAtTimeOnElementWithId(const QString& animationName,
437                                                                double time,
438                                                                const QString& elementId)
439 {
440     QWebFrame* frame = m_drt->webPage()->mainFrame();
441     Q_ASSERT(frame);
442     return DumpRenderTreeSupportQt::pauseAnimation(frame, animationName, time, elementId);
443 }
444
445 bool LayoutTestController::pauseTransitionAtTimeOnElementWithId(const QString& propertyName,
446                                                                 double time,
447                                                                 const QString& elementId)
448 {
449     QWebFrame* frame = m_drt->webPage()->mainFrame();
450     Q_ASSERT(frame);
451     return DumpRenderTreeSupportQt::pauseTransitionOfProperty(frame, propertyName, time, elementId);
452 }
453
454 bool LayoutTestController::sampleSVGAnimationForElementAtTime(const QString& animationId,
455                                                               double time,
456                                                               const QString& elementId)
457 {
458     QWebFrame* frame = m_drt->webPage()->mainFrame();
459     Q_ASSERT(frame);
460     return DumpRenderTreeSupportQt::pauseSVGAnimation(frame, animationId, time, elementId);
461 }
462
463 unsigned LayoutTestController::numberOfActiveAnimations() const
464 {
465     QWebFrame* frame = m_drt->webPage()->mainFrame();
466     Q_ASSERT(frame);
467     return DumpRenderTreeSupportQt::numberOfActiveAnimations(frame);
468 }
469
470 void LayoutTestController::disableImageLoading()
471 {
472     m_drt->webPage()->settings()->setAttribute(QWebSettings::AutoLoadImages, false);
473 }
474
475 void LayoutTestController::dispatchPendingLoadRequests()
476 {
477     // FIXME: Implement for testing fix for 6727495
478 }
479
480 void LayoutTestController::setDatabaseQuota(int size)
481 {
482     if (!m_topLoadingFrame)
483         return;
484     m_topLoadingFrame->securityOrigin().setDatabaseQuota(size);
485 }
486
487 void LayoutTestController::clearAllDatabases()
488 {
489     QWebDatabase::removeAllDatabases();
490 }
491
492 void LayoutTestController::addOriginAccessWhitelistEntry(const QString& sourceOrigin, const QString& destinationProtocol, const QString& destinationHost, bool allowDestinationSubdomains)
493 {
494     DumpRenderTreeSupportQt::whiteListAccessFromOrigin(sourceOrigin, destinationProtocol, destinationHost, allowDestinationSubdomains);
495 }
496
497 void LayoutTestController::removeOriginAccessWhitelistEntry(const QString& sourceOrigin, const QString& destinationProtocol, const QString& destinationHost, bool allowDestinationSubdomains)
498 {
499     DumpRenderTreeSupportQt::removeWhiteListAccessFromOrigin(sourceOrigin, destinationProtocol, destinationHost, allowDestinationSubdomains);
500 }
501
502 void LayoutTestController::setCustomPolicyDelegate(bool enabled, bool permissive)
503 {
504     DumpRenderTreeSupportQt::setCustomPolicyDelegate(enabled, permissive);
505 }
506
507 void LayoutTestController::waitForPolicyDelegate()
508 {
509     m_waitForPolicy = true;
510     waitUntilDone();
511 }
512
513 void LayoutTestController::overridePreference(const QString& name, const QVariant& value)
514 {
515     QWebSettings* settings = m_topLoadingFrame->page()->settings();
516
517     if (name == "WebKitJavaScriptEnabled")
518         settings->setAttribute(QWebSettings::JavascriptEnabled, value.toBool());
519     else if (name == "WebKitTabToLinksPreferenceKey")
520         settings->setAttribute(QWebSettings::LinksIncludedInFocusChain, value.toBool());
521     else if (name == "WebKitOfflineWebApplicationCacheEnabled")
522         settings->setAttribute(QWebSettings::OfflineWebApplicationCacheEnabled, value.toBool());
523     else if (name == "WebKitDefaultFontSize")
524         settings->setFontSize(QWebSettings::DefaultFontSize, value.toInt());
525     else if (name == "WebKitUsesPageCachePreferenceKey")
526         QWebSettings::setMaximumPagesInCache(value.toInt());
527     else if (name == "WebKitEnableCaretBrowsing")
528         setCaretBrowsingEnabled(value.toBool());
529     else if (name == "WebKitPluginsEnabled")
530         settings->setAttribute(QWebSettings::PluginsEnabled, value.toBool());
531     else if (name == "WebKitWebGLEnabled")
532         settings->setAttribute(QWebSettings::WebGLEnabled, value.toBool());
533     else
534         printf("ERROR: LayoutTestController::overridePreference() does not support the '%s' preference\n",
535             name.toLatin1().data());
536 }
537
538 void LayoutTestController::setUserStyleSheetLocation(const QString& url)
539 {
540     m_userStyleSheetLocation = QUrl(url);
541
542     if (m_userStyleSheetEnabled)
543         setUserStyleSheetEnabled(true);
544 }
545
546 void LayoutTestController::setCaretBrowsingEnabled(bool value)
547 {
548     DumpRenderTreeSupportQt::setCaretBrowsingEnabled(m_drt->webPage(), value);
549 }
550
551 void LayoutTestController::setUserStyleSheetEnabled(bool enabled)
552 {
553     m_userStyleSheetEnabled = enabled;
554
555     if (enabled)
556         m_drt->webPage()->settings()->setUserStyleSheetUrl(m_userStyleSheetLocation);
557     else
558         m_drt->webPage()->settings()->setUserStyleSheetUrl(QUrl());
559 }
560
561 void LayoutTestController::setDomainRelaxationForbiddenForURLScheme(bool forbidden, const QString& scheme)
562 {
563     DumpRenderTreeSupportQt::setDomainRelaxationForbiddenForURLScheme(forbidden, scheme);
564 }
565
566 int LayoutTestController::workerThreadCount()
567 {
568     return DumpRenderTreeSupportQt::workerThreadCount();
569 }
570
571 int LayoutTestController::pageNumberForElementById(const QString& id, float width, float height)
572 {
573     // If no size specified, webpage viewport size is used
574     if (!width && !height) {
575         width = m_drt->webPage()->viewportSize().width();
576         height = m_drt->webPage()->viewportSize().height();
577     }
578
579     return DumpRenderTreeSupportQt::pageNumberForElementById(m_drt->webPage()->mainFrame(), id, width, height);
580 }
581
582 int LayoutTestController::numberOfPages(float width, float height)
583 {
584     return DumpRenderTreeSupportQt::numberOfPages(m_drt->webPage()->mainFrame(), width, height);
585 }
586
587 bool LayoutTestController::callShouldCloseOnWebView()
588 {
589     return DumpRenderTreeSupportQt::shouldClose(m_drt->webPage()->mainFrame());
590 }
591
592 void LayoutTestController::setScrollbarPolicy(const QString& orientation, const QString& policy)
593 {
594     Qt::Orientation o;
595     Qt::ScrollBarPolicy p;
596
597     if (orientation == "vertical")
598         o = Qt::Vertical;
599     else if (orientation == "horizontal")
600         o = Qt::Horizontal;
601     else
602         return;
603
604     if (policy == "on")
605         p = Qt::ScrollBarAlwaysOn;
606     else if (policy == "auto")
607         p = Qt::ScrollBarAsNeeded;
608     else if (policy == "off")
609         p = Qt::ScrollBarAlwaysOff;
610     else
611         return;
612
613     m_drt->webPage()->mainFrame()->setScrollBarPolicy(o, p);
614 }
615
616 void LayoutTestController::setSmartInsertDeleteEnabled(bool enable)
617 {
618     DumpRenderTreeSupportQt::setSmartInsertDeleteEnabled(m_drt->webPage(), enable);
619 }
620
621 void LayoutTestController::setSelectTrailingWhitespaceEnabled(bool enable)
622 {
623     DumpRenderTreeSupportQt::setSelectTrailingWhitespaceEnabled(m_drt->webPage(), enable);
624 }
625
626 void LayoutTestController::execCommand(const QString& name, const QString& value)
627 {
628     DumpRenderTreeSupportQt::executeCoreCommandByName(m_drt->webPage(), name, value);
629 }
630
631 bool LayoutTestController::isCommandEnabled(const QString& name) const
632 {
633     return DumpRenderTreeSupportQt::isCommandEnabled(m_drt->webPage(), name);
634 }
635
636 QString LayoutTestController::markerTextForListItem(const QWebElement& listItem)
637 {
638     return DumpRenderTreeSupportQt::markerTextForListItem(listItem);
639 }
640
641 QVariantMap LayoutTestController::computedStyleIncludingVisitedInfo(const QWebElement& element) const
642 {
643     return DumpRenderTreeSupportQt::computedStyleIncludingVisitedInfo(element);
644 }
645
646 bool LayoutTestController::elementDoesAutoCompleteForElementWithId(const QString& elementId)
647 {
648     return DumpRenderTreeSupportQt::elementDoesAutoCompleteForElementWithId(m_drt->webPage()->mainFrame(), elementId);
649 }
650
651 void LayoutTestController::authenticateSession(const QString&, const QString&, const QString&)
652 {
653     // FIXME: If there is a concept per-session (per-process) credential storage, the credentials should be added to it for later use.
654 }
655
656 void LayoutTestController::setIconDatabaseEnabled(bool enable)
657 {
658     if (enable && !m_drt->persistentStoragePath().isEmpty())
659         QWebSettings::setIconDatabasePath(m_drt->persistentStoragePath());
660     else
661         QWebSettings::setIconDatabasePath(QString());
662 }
663
664 void LayoutTestController::setEditingBehavior(const QString& editingBehavior)
665 {
666     DumpRenderTreeSupportQt::setEditingBehavior(m_drt->webPage(), editingBehavior);
667 }
668
669 void LayoutTestController::setGeolocationPermission(bool allow)
670 {
671      m_isGeolocationPermissionSet = true;
672      m_geolocationPermission = allow;
673 }
674
675 void LayoutTestController::setMockGeolocationError(int code, const QString& message)
676 {
677     DumpRenderTreeSupportQt::setMockGeolocationError(code, message);
678 }
679
680 void LayoutTestController::setMockGeolocationPosition(double latitude, double longitude, double accuracy)
681 {
682     DumpRenderTreeSupportQt::setMockGeolocationPosition(latitude, longitude, accuracy);
683 }
684
685 void LayoutTestController::evaluateScriptInIsolatedWorld(int worldID, const QString& script)
686 {
687     DumpRenderTreeSupportQt::evaluateScriptInIsolatedWorld(m_drt->webPage()->mainFrame(), worldID, script);
688 }
689
690 bool LayoutTestController::isPageBoxVisible(int pageIndex)
691 {
692     return DumpRenderTreeSupportQt::isPageBoxVisible(m_drt->webPage()->mainFrame(), pageIndex);
693 }
694
695 QString LayoutTestController::pageSizeAndMarginsInPixels(int pageIndex, int width, int height, int marginTop, int marginRight, int marginBottom, int marginLeft)
696 {
697     return DumpRenderTreeSupportQt::pageSizeAndMarginsInPixels(m_drt->webPage()->mainFrame(), pageIndex,
698                                                                width, height, marginTop, marginRight, marginBottom, marginLeft);
699 }
700
701 QString LayoutTestController::pageProperty(const QString& propertyName, int pageNumber)
702 {
703     return DumpRenderTreeSupportQt::pageProperty(m_drt->webPage()->mainFrame(), propertyName, pageNumber);
704 }
705
706 void LayoutTestController::addUserStyleSheet(const QString& sourceCode)
707 {
708     DumpRenderTreeSupportQt::addUserStyleSheet(m_drt->webPage(), sourceCode);
709 }
710
711 const unsigned LayoutTestController::maxViewWidth = 800;
712 const unsigned LayoutTestController::maxViewHeight = 600;