2010-05-06 Anders Carlsson <andersca@apple.com>
[WebKit.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 extern void qt_dump_editing_callbacks(bool b);
41 extern void qt_dump_frame_loader(bool b);
42 extern void qt_dump_resource_load_callbacks(bool b);
43 extern void qt_set_will_send_request_returns_null_on_redirect(bool b);
44 extern void qt_set_will_send_request_returns_null(bool b);
45 extern void qt_set_will_send_request_clear_headers(const QStringList& headers);
46
47 extern void qt_dump_notification(bool b);
48
49 LayoutTestController::LayoutTestController(WebCore::DumpRenderTree* drt)
50     : QObject()
51     , m_drt(drt)
52 {
53     qRegisterMetaType<QWebElement>("QWebElement");
54     reset();
55     qt_dump_notification(true);
56 }
57
58 void LayoutTestController::reset()
59 {
60     m_hasDumped = false;
61     m_loadFinished = false;
62     m_textDump = false;
63     m_dumpBackForwardList = false;
64     m_dumpChildrenAsText = false;
65     m_canOpenWindows = false;
66     m_waitForDone = false;
67     m_dumpTitleChanges = false;
68     m_dumpDatabaseCallbacks = false;
69     m_dumpStatusCallbacks = false;
70     m_timeoutTimer.stop();
71     m_topLoadingFrame = 0;
72     m_waitForPolicy = false;
73     m_handleErrorPages = false;
74     m_webHistory = 0;
75     m_globalFlag = false;
76     qt_dump_editing_callbacks(false);
77     qt_dump_frame_loader(false);
78     qt_dump_resource_load_callbacks(false);
79     qt_set_will_send_request_returns_null_on_redirect(false);
80     qt_set_will_send_request_returns_null(false);
81     qt_set_will_send_request_clear_headers(QStringList());
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     // FIXME: Implement for notification security
193 }
194
195 bool LayoutTestController::checkDesktopNotificationPermission(const QString& origin)
196 {
197     // FIXME: Implement for notification security
198     return true;
199 }
200
201 void LayoutTestController::display()
202 {
203     emit showPage();
204 }
205
206 void LayoutTestController::clearBackForwardList()
207 {
208     m_drt->webPage()->history()->clear();
209 }
210
211 QString LayoutTestController::pathToLocalResource(const QString& url)
212 {
213     // Function introduced in r28690.
214     return QDir::toNativeSeparators(url);
215 }
216
217 void LayoutTestController::dumpEditingCallbacks()
218 {
219     qDebug() << ">>>dumpEditingCallbacks";
220     qt_dump_editing_callbacks(true);
221 }
222
223 void LayoutTestController::dumpFrameLoadCallbacks()
224 {
225     qt_dump_frame_loader(true);
226 }
227
228 void LayoutTestController::dumpResourceLoadCallbacks()
229 {
230     qt_dump_resource_load_callbacks(true);
231 }
232
233 void LayoutTestController::setWillSendRequestReturnsNullOnRedirect(bool enabled)
234 {
235     qt_set_will_send_request_returns_null_on_redirect(enabled);
236 }
237
238 void LayoutTestController::setWillSendRequestReturnsNull(bool enabled)
239 {
240     qt_set_will_send_request_returns_null(enabled);
241 }
242
243 void LayoutTestController::setWillSendRequestClearHeader(const QStringList& headers)
244 {
245     qt_set_will_send_request_clear_headers(headers);
246 }
247
248 void LayoutTestController::queueBackNavigation(int howFarBackward)
249 {
250     //qDebug() << ">>>queueBackNavigation" << howFarBackward;
251     WorkQueue::shared()->queue(new BackItem(howFarBackward, m_drt->webPage()));
252 }
253
254 void LayoutTestController::queueForwardNavigation(int howFarForward)
255 {
256     //qDebug() << ">>>queueForwardNavigation" << howFarForward;
257     WorkQueue::shared()->queue(new ForwardItem(howFarForward, m_drt->webPage()));
258 }
259
260 void LayoutTestController::queueLoad(const QString& url, const QString& target)
261 {
262     //qDebug() << ">>>queueLoad" << url << target;
263     QUrl mainResourceUrl = m_drt->webPage()->mainFrame()->url();
264     QString absoluteUrl = mainResourceUrl.resolved(QUrl(url)).toEncoded();
265     WorkQueue::shared()->queue(new LoadItem(absoluteUrl, target, m_drt->webPage()));
266 }
267
268 void LayoutTestController::queueReload()
269 {
270     //qDebug() << ">>>queueReload";
271     WorkQueue::shared()->queue(new ReloadItem(m_drt->webPage()));
272 }
273
274 void LayoutTestController::queueLoadingScript(const QString& script)
275 {
276     //qDebug() << ">>>queueLoadingScript" << script;
277     WorkQueue::shared()->queue(new LoadingScriptItem(script, m_drt->webPage()));
278 }
279
280 void LayoutTestController::queueNonLoadingScript(const QString& script)
281 {
282     //qDebug() << ">>>queueNonLoadingScript" << script;
283     WorkQueue::shared()->queue(new NonLoadingScriptItem(script, m_drt->webPage()));
284 }
285
286 void LayoutTestController::provisionalLoad()
287 {
288     QWebFrame* frame = qobject_cast<QWebFrame*>(sender());
289     if (!m_topLoadingFrame && !m_hasDumped)
290         m_topLoadingFrame = frame;
291 }
292
293 void LayoutTestController::timerEvent(QTimerEvent *ev)
294 {
295     if (ev->timerId() == m_timeoutTimer.timerId()) {
296         const char* message = "FAIL: Timed out waiting for notifyDone to be called\n";
297         fprintf(stderr, "%s", message);
298         fprintf(stdout, "%s", message);
299         notifyDone();
300     } else
301         QObject::timerEvent(ev);
302 }
303
304 QString LayoutTestController::encodeHostName(const QString& host)
305 {
306     QString encoded = QString::fromLatin1(QUrl::toAce(host + QLatin1String(".no")));
307     encoded.truncate(encoded.length() - 3); // strip .no
308     return encoded;
309 }
310
311 QString LayoutTestController::decodeHostName(const QString& host)
312 {
313     QString decoded = QUrl::fromAce(host.toLatin1() + QByteArray(".no"));
314     decoded.truncate(decoded.length() - 3);
315     return decoded;
316 }
317
318 void LayoutTestController::setMediaType(const QString& type)
319 {
320     DumpRenderTreeSupportQt::setMediaType(m_drt->webPage()->mainFrame(), type);
321 }
322
323 void LayoutTestController::closeWebInspector()
324 {
325     DumpRenderTreeSupportQt::webInspectorClose(m_drt->webPage());
326     m_drt->webPage()->settings()->setAttribute(QWebSettings::DeveloperExtrasEnabled, false);
327 }
328
329 void LayoutTestController::setDeveloperExtrasEnabled(bool enabled)
330 {
331     m_drt->webPage()->settings()->setAttribute(QWebSettings::DeveloperExtrasEnabled, enabled);
332 }
333
334 void LayoutTestController::showWebInspector()
335 {
336     m_drt->webPage()->settings()->setAttribute(QWebSettings::DeveloperExtrasEnabled, true);
337     DumpRenderTreeSupportQt::webInspectorShow(m_drt->webPage());
338 }
339
340 void LayoutTestController::evaluateInWebInspector(long callId, const QString& script)
341 {
342     DumpRenderTreeSupportQt::webInspectorExecuteScript(m_drt->webPage(), callId, script);
343 }
344
345 void LayoutTestController::setFrameFlatteningEnabled(bool enabled)
346 {
347     DumpRenderTreeSupportQt::setFrameFlatteningEnabled(m_drt->webPage(), enabled);
348 }
349
350 void LayoutTestController::setAllowUniversalAccessFromFileURLs(bool enabled)
351 {
352     m_drt->webPage()->settings()->setAttribute(QWebSettings::LocalContentCanAccessRemoteUrls, enabled);
353 }
354
355 void LayoutTestController::setAllowFileAccessFromFileURLs(bool enabled)
356 {
357     m_drt->webPage()->settings()->setAttribute(QWebSettings::LocalContentCanAccessFileUrls, enabled);
358 }
359
360 void LayoutTestController::setAppCacheMaximumSize(unsigned long long quota)
361 {
362     m_drt->webPage()->settings()->setOfflineWebApplicationCacheQuota(quota);
363 }
364
365 void LayoutTestController::setJavaScriptProfilingEnabled(bool enable)
366 {
367     setDeveloperExtrasEnabled(enable);
368     DumpRenderTreeSupportQt::setJavaScriptProfilingEnabled(m_topLoadingFrame, enable);
369 }
370
371 void LayoutTestController::setTimelineProfilingEnabled(bool enable)
372 {
373     DumpRenderTreeSupportQt::setTimelineProfilingEnabled(m_drt->webPage(), enable);
374 }
375
376 void LayoutTestController::setFixedContentsSize(int width, int height)
377 {
378     m_topLoadingFrame->page()->setPreferredContentsSize(QSize(width, height));
379 }
380
381 void LayoutTestController::setPrivateBrowsingEnabled(bool enable)
382 {
383     m_drt->webPage()->settings()->setAttribute(QWebSettings::PrivateBrowsingEnabled, enable);
384 }
385
386 void LayoutTestController::setSpatialNavigationEnabled(bool enable)
387 {
388     m_drt->webPage()->settings()->setAttribute(QWebSettings::SpatialNavigationEnabled, enable);
389 }
390
391 void LayoutTestController::setPopupBlockingEnabled(bool enable)
392 {
393     m_drt->webPage()->settings()->setAttribute(QWebSettings::JavascriptCanOpenWindows, !enable);
394 }
395
396 void LayoutTestController::setPluginsEnabled(bool flag)
397 {
398     // FIXME: Implement
399 }
400
401 void LayoutTestController::setPOSIXLocale(const QString& locale)
402 {
403     QLocale qlocale(locale);
404     QLocale::setDefault(qlocale);
405
406
407 void LayoutTestController::setWindowIsKey(bool isKey)
408 {
409     m_drt->switchFocus(isKey);
410 }
411
412 void LayoutTestController::setMainFrameIsFirstResponder(bool isFirst)
413 {
414     //FIXME: only need this for the moment: https://bugs.webkit.org/show_bug.cgi?id=32990
415 }
416
417 void LayoutTestController::setJavaScriptCanAccessClipboard(bool enable)
418 {
419     m_drt->webPage()->settings()->setAttribute(QWebSettings::JavaScriptCanAccessClipboard, enable);
420 }
421
422 void LayoutTestController::setXSSAuditorEnabled(bool enable)
423 {
424     // Set XSSAuditingEnabled globally so that windows created by the test inherit it too.
425     // resetSettings() will call this to reset the page and global setting to false again.
426     // Needed by http/tests/security/xssAuditor/link-opens-new-window.html
427     QWebSettings* globalSettings = QWebSettings::globalSettings();
428     globalSettings->setAttribute(QWebSettings::XSSAuditingEnabled, enable);
429     m_drt->webPage()->settings()->setAttribute(QWebSettings::XSSAuditingEnabled, enable);
430 }
431
432 bool LayoutTestController::pauseAnimationAtTimeOnElementWithId(const QString& animationName,
433                                                                double time,
434                                                                const QString& elementId)
435 {
436     QWebFrame* frame = m_drt->webPage()->mainFrame();
437     Q_ASSERT(frame);
438     return DumpRenderTreeSupportQt::pauseAnimation(frame, animationName, time, elementId);
439 }
440
441 bool LayoutTestController::pauseTransitionAtTimeOnElementWithId(const QString& propertyName,
442                                                                 double time,
443                                                                 const QString& elementId)
444 {
445     QWebFrame* frame = m_drt->webPage()->mainFrame();
446     Q_ASSERT(frame);
447     return DumpRenderTreeSupportQt::pauseTransitionOfProperty(frame, propertyName, time, elementId);
448 }
449
450 bool LayoutTestController::sampleSVGAnimationForElementAtTime(const QString& animationId,
451                                                               double time,
452                                                               const QString& elementId)
453 {
454     QWebFrame* frame = m_drt->webPage()->mainFrame();
455     Q_ASSERT(frame);
456     return DumpRenderTreeSupportQt::pauseSVGAnimation(frame, animationId, time, elementId);
457 }
458
459 unsigned LayoutTestController::numberOfActiveAnimations() const
460 {
461     QWebFrame* frame = m_drt->webPage()->mainFrame();
462     Q_ASSERT(frame);
463     return DumpRenderTreeSupportQt::numberOfActiveAnimations(frame);
464 }
465
466 void LayoutTestController::disableImageLoading()
467 {
468     // FIXME: Implement for testing fix for https://bugs.webkit.org/show_bug.cgi?id=27896
469     // Also need to make sure image loading is re-enabled for each new test.
470 }
471
472 void LayoutTestController::dispatchPendingLoadRequests()
473 {
474     // FIXME: Implement for testing fix for 6727495
475 }
476
477 void LayoutTestController::setDatabaseQuota(int size)
478 {
479     if (!m_topLoadingFrame)
480         return;
481     m_topLoadingFrame->securityOrigin().setDatabaseQuota(size);
482 }
483
484 void LayoutTestController::clearAllDatabases()
485 {
486     QWebDatabase::removeAllDatabases();
487 }
488
489 void LayoutTestController::addOriginAccessWhitelistEntry(const QString& sourceOrigin, const QString& destinationProtocol, const QString& destinationHost, bool allowDestinationSubdomains)
490 {
491     DumpRenderTreeSupportQt::whiteListAccessFromOrigin(sourceOrigin, destinationProtocol, destinationHost, allowDestinationSubdomains);
492 }
493
494 void LayoutTestController::removeOriginAccessWhitelistEntry(const QString& sourceOrigin, const QString& destinationProtocol, const QString& destinationHost, bool allowDestinationSubdomains)
495 {
496     // FIXME: Implement.
497 }
498
499 void LayoutTestController::waitForPolicyDelegate()
500 {
501     m_waitForPolicy = true;
502     waitUntilDone();
503 }
504
505 void LayoutTestController::overridePreference(const QString& name, const QVariant& value)
506 {
507     QWebSettings* settings = m_topLoadingFrame->page()->settings();
508
509     if (name == "WebKitJavaScriptEnabled")
510         settings->setAttribute(QWebSettings::JavascriptEnabled, value.toBool());
511     else if (name == "WebKitTabToLinksPreferenceKey")
512         settings->setAttribute(QWebSettings::LinksIncludedInFocusChain, value.toBool());
513     else if (name == "WebKitOfflineWebApplicationCacheEnabled")
514         settings->setAttribute(QWebSettings::OfflineWebApplicationCacheEnabled, value.toBool());
515     else if (name == "WebKitDefaultFontSize")
516         settings->setFontSize(QWebSettings::DefaultFontSize, value.toInt());
517     else if (name == "WebKitUsesPageCachePreferenceKey")
518         QWebSettings::setMaximumPagesInCache(value.toInt());
519     else if (name == "WebKitEnableCaretBrowsing")
520         setCaretBrowsingEnabled(value.toBool());
521     else if (name == "WebKitPluginsEnabled")
522         settings->setAttribute(QWebSettings::PluginsEnabled, value.toBool());
523     else
524         printf("ERROR: LayoutTestController::overridePreference() does not support the '%s' preference\n",
525             name.toLatin1().data());
526 }
527
528 void LayoutTestController::setUserStyleSheetLocation(const QString& url)
529 {
530     m_userStyleSheetLocation = QUrl(url);
531 }
532
533 void LayoutTestController::setCaretBrowsingEnabled(bool value)
534 {
535     DumpRenderTreeSupportQt::setCaretBrowsingEnabled(m_drt->webPage(), value);
536 }
537
538 void LayoutTestController::setUserStyleSheetEnabled(bool enabled)
539 {
540     if (enabled)
541         m_drt->webPage()->settings()->setUserStyleSheetUrl(m_userStyleSheetLocation);
542     else
543         m_drt->webPage()->settings()->setUserStyleSheetUrl(QUrl());
544 }
545
546 void LayoutTestController::setDomainRelaxationForbiddenForURLScheme(bool forbidden, const QString& scheme)
547 {
548     DumpRenderTreeSupportQt::setDomainRelaxationForbiddenForURLScheme(forbidden, scheme);
549 }
550
551 int LayoutTestController::workerThreadCount()
552 {
553     return DumpRenderTreeSupportQt::workerThreadCount();
554 }
555
556 int LayoutTestController::pageNumberForElementById(const QString& id, float width, float height)
557 {
558     // If no size specified, webpage viewport size is used
559     if (!width && !height) {
560         width = m_drt->webPage()->viewportSize().width();
561         height = m_drt->webPage()->viewportSize().height();
562     }
563
564     return DumpRenderTreeSupportQt::pageNumberForElementById(m_drt->webPage()->mainFrame(), id, width, height);
565 }
566
567 int LayoutTestController::numberOfPages(float width, float height)
568 {
569     return DumpRenderTreeSupportQt::numberOfPages(m_drt->webPage()->mainFrame(), width, height);
570 }
571
572 bool LayoutTestController::callShouldCloseOnWebView()
573 {
574     // FIXME: Implement for testing fix for https://bugs.webkit.org/show_bug.cgi?id=27481
575     return false;
576 }
577
578 void LayoutTestController::setScrollbarPolicy(const QString& orientation, const QString& policy)
579 {
580     Qt::Orientation o;
581     Qt::ScrollBarPolicy p;
582
583     if (orientation == "vertical")
584         o = Qt::Vertical;
585     else if (orientation == "horizontal")
586         o = Qt::Horizontal;
587     else
588         return;
589
590     if (policy == "on")
591         p = Qt::ScrollBarAlwaysOn;
592     else if (policy == "auto")
593         p = Qt::ScrollBarAsNeeded;
594     else if (policy == "off")
595         p = Qt::ScrollBarAlwaysOff;
596     else
597         return;
598
599     m_drt->webPage()->mainFrame()->setScrollBarPolicy(o, p);
600 }
601
602 void LayoutTestController::setSmartInsertDeleteEnabled(bool enable)
603 {
604     DumpRenderTreeSupportQt::setSmartInsertDeleteEnabled(m_drt->webPage(), enable);
605 }
606
607 void LayoutTestController::setSelectTrailingWhitespaceEnabled(bool enable)
608 {
609     DumpRenderTreeSupportQt::setSelectTrailingWhitespaceEnabled(m_drt->webPage(), enable);
610 }
611
612 void LayoutTestController::execCommand(const QString& name, const QString& value)
613 {
614     DumpRenderTreeSupportQt::executeCoreCommandByName(m_drt->webPage(), name, value);
615 }
616
617 bool LayoutTestController::isCommandEnabled(const QString& name) const
618 {
619     return DumpRenderTreeSupportQt::isCommandEnabled(m_drt->webPage(), name);
620 }
621
622 QString LayoutTestController::markerTextForListItem(const QWebElement& listItem)
623 {
624     return DumpRenderTreeSupportQt::markerTextForListItem(listItem);
625 }
626
627 void LayoutTestController::authenticateSession(const QString&, const QString&, const QString&)
628 {
629     // FIXME: If there is a concept per-session (per-process) credential storage, the credentials should be added to it for later use.
630 }
631
632
633 const unsigned LayoutTestController::maxViewWidth = 800;
634 const unsigned LayoutTestController::maxViewHeight = 600;