Name all the GLib timeout sources
[WebKit-https.git] / Tools / DumpRenderTree / gtk / TestRunnerGtk.cpp
1 /*
2  * Copyright (C) 2007, 2012 Apple Inc. All rights reserved.
3  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
4  * Copyright (C) 2008 Nuanti Ltd.
5  * Copyright (C) 2009 Jan Michael Alonzo <jmalonzo@gmail.com>
6  * Copyright (C) 2009,2011 Collabora Ltd.
7  * Copyright (C) 2010 Joone Hur <joone@kldp.org>
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  *
13  * 1.  Redistributions of source code must retain the above copyright
14  *     notice, this list of conditions and the following disclaimer.
15  * 2.  Redistributions in binary form must reproduce the above copyright
16  *     notice, this list of conditions and the following disclaimer in the
17  *     documentation and/or other materials provided with the distribution.
18  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
19  *     its contributors may be used to endorse or promote products derived
20  *     from this software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
23  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
24  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
25  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
26  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
27  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
29  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #include "config.h"
35 #include "TestRunner.h"
36
37 #include "DumpRenderTree.h"
38 #include "WebCoreSupport/DumpRenderTreeSupportGtk.h"
39 #include "WorkQueue.h"
40 #include "WorkQueueItem.h"
41 #include <JavaScriptCore/JSRetainPtr.h>
42 #include <JavaScriptCore/JSStringRef.h>
43 #include <cstring>
44 #include <iostream>
45 #include <sstream>
46 #include <stdio.h>
47 #include <glib.h>
48 #include <libsoup/soup.h>
49 #include <webkit/webkit.h>
50 #include <wtf/gobject/GOwnPtr.h>
51 #include <wtf/text/WTFString.h>
52
53 extern "C" {
54 void webkit_web_inspector_execute_script(WebKitWebInspector* inspector, long callId, const gchar* script);
55 }
56
57 TestRunner::~TestRunner()
58 {
59     // FIXME: implement
60 }
61
62 void TestRunner::addDisallowedURL(JSStringRef url)
63 {
64     // FIXME: implement
65 }
66
67 void TestRunner::clearBackForwardList()
68 {
69     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
70     WebKitWebBackForwardList* list = webkit_web_view_get_back_forward_list(webView);
71     WebKitWebHistoryItem* item = webkit_web_back_forward_list_get_current_item(list);
72     g_object_ref(item);
73
74     // We clear the history by setting the back/forward list's capacity to 0
75     // then restoring it back and adding back the current item.
76     gint limit = webkit_web_back_forward_list_get_limit(list);
77     webkit_web_back_forward_list_set_limit(list, 0);
78     webkit_web_back_forward_list_set_limit(list, limit);
79     webkit_web_back_forward_list_add_item(list, item);
80     webkit_web_back_forward_list_go_to_item(list, item);
81     g_object_unref(item);
82 }
83
84 JSStringRef TestRunner::copyDecodedHostName(JSStringRef name)
85 {
86     // FIXME: implement
87     return 0;
88 }
89
90 JSStringRef TestRunner::copyEncodedHostName(JSStringRef name)
91 {
92     // FIXME: implement
93     return 0;
94 }
95
96 void TestRunner::dispatchPendingLoadRequests()
97 {
98     // FIXME: Implement for testing fix for 6727495
99 }
100
101 void TestRunner::display()
102 {
103     displayWebView();
104 }
105
106 void TestRunner::keepWebHistory()
107 {
108     // FIXME: implement
109 }
110
111 size_t TestRunner::webHistoryItemCount()
112 {
113     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
114     WebKitWebBackForwardList* list = webkit_web_view_get_back_forward_list(webView);
115
116     if (!list)
117         return -1;
118
119     // We do not add the current page to the total count as it's not
120     // considered in DRT tests
121     return webkit_web_back_forward_list_get_back_length(list) +
122             webkit_web_back_forward_list_get_forward_length(list);
123 }
124
125 JSRetainPtr<JSStringRef> TestRunner::platformName() const
126 {
127     JSRetainPtr<JSStringRef> platformName(Adopt, JSStringCreateWithUTF8CString("gtk"));
128     return platformName;
129 }
130
131 void TestRunner::notifyDone()
132 {
133     if (m_waitToDump && !topLoadingFrame && !WorkQueue::shared()->count())
134         dump();
135     m_waitToDump = false;
136     waitForPolicy = false;
137 }
138
139 JSStringRef TestRunner::pathToLocalResource(JSContextRef context, JSStringRef url)
140 {
141     GOwnPtr<char> urlCString(JSStringCopyUTF8CString(url));
142     if (!g_str_has_prefix(urlCString.get(), "file:///tmp/LayoutTests/"))
143         return JSStringRetain(url);
144
145     const char* layoutTestsSuffix = urlCString.get() + strlen("file:///tmp/");
146     GOwnPtr<char> testPath(g_build_filename(getTopLevelPath().data(), layoutTestsSuffix, NULL));
147     GOwnPtr<char> testURI(g_filename_to_uri(testPath.get(), 0, 0));
148     return JSStringCreateWithUTF8CString(testURI.get());
149 }
150
151 void TestRunner::queueLoad(JSStringRef url, JSStringRef target)
152 {
153     GOwnPtr<gchar> relativeURL(JSStringCopyUTF8CString(url));
154     SoupURI* baseURI = soup_uri_new(webkit_web_frame_get_uri(mainFrame));
155     SoupURI* absoluteURI = soup_uri_new_with_base(baseURI, relativeURL.get());
156     soup_uri_free(baseURI);
157
158     if (!absoluteURI) {
159         WorkQueue::shared()->queue(new LoadItem(url, target));
160         return;
161     }
162
163     CString absoluteURIString = soupURIToStringPreservingPassword(absoluteURI);
164     JSRetainPtr<JSStringRef> absoluteURL(Adopt, JSStringCreateWithUTF8CString(absoluteURIString.data()));
165     WorkQueue::shared()->queue(new LoadItem(absoluteURL.get(), target));
166     soup_uri_free(absoluteURI);
167 }
168
169 void TestRunner::setAcceptsEditing(bool acceptsEditing)
170 {
171     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
172     webkit_web_view_set_editable(webView, acceptsEditing);
173 }
174
175 void TestRunner::setAlwaysAcceptCookies(bool alwaysAcceptCookies)
176 {
177     SoupSession* session = webkit_get_default_session();
178     SoupCookieJar* jar = reinterpret_cast<SoupCookieJar*>(soup_session_get_feature(session, SOUP_TYPE_COOKIE_JAR));
179
180     /* If the jar was not created - we create it on demand, i.e, just
181        in case we have HTTP requests - then we must create it here in
182        order to set the proper accept policy */
183     if (!jar) {
184         jar = soup_cookie_jar_new();
185         soup_session_add_feature(session, SOUP_SESSION_FEATURE(jar));
186         g_object_unref(jar);
187     }
188
189     SoupCookieJarAcceptPolicy policy;
190
191     if (alwaysAcceptCookies)
192         policy = SOUP_COOKIE_JAR_ACCEPT_ALWAYS;
193     else
194         policy = SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY;
195
196     g_object_set(G_OBJECT(jar), SOUP_COOKIE_JAR_ACCEPT_POLICY, policy, NULL);
197 }
198
199 void TestRunner::setCustomPolicyDelegate(bool setDelegate, bool permissive)
200 {
201     // FIXME: implement
202 }
203
204 void TestRunner::waitForPolicyDelegate()
205 {
206     waitForPolicy = true;
207     setWaitToDump(true);
208 }
209
210 void TestRunner::setScrollbarPolicy(JSStringRef orientation, JSStringRef policy)
211 {
212     // FIXME: implement
213 }
214
215 void TestRunner::addOriginAccessWhitelistEntry(JSStringRef sourceOrigin, JSStringRef protocol, JSStringRef host, bool includeSubdomains)
216 {
217     gchar* sourceOriginGChar = JSStringCopyUTF8CString(sourceOrigin);
218     gchar* protocolGChar = JSStringCopyUTF8CString(protocol);
219     gchar* hostGChar = JSStringCopyUTF8CString(host);
220     DumpRenderTreeSupportGtk::whiteListAccessFromOrigin(sourceOriginGChar, protocolGChar, hostGChar, includeSubdomains);
221     g_free(sourceOriginGChar);
222     g_free(protocolGChar);
223     g_free(hostGChar);
224 }
225
226 void TestRunner::removeOriginAccessWhitelistEntry(JSStringRef sourceOrigin, JSStringRef protocol, JSStringRef host, bool includeSubdomains)
227 {
228     GOwnPtr<gchar> sourceOriginGChar(JSStringCopyUTF8CString(sourceOrigin));
229     GOwnPtr<gchar> protocolGChar(JSStringCopyUTF8CString(protocol));
230     GOwnPtr<gchar> hostGChar(JSStringCopyUTF8CString(host));
231     DumpRenderTreeSupportGtk::removeWhiteListAccessFromOrigin(sourceOriginGChar.get(), protocolGChar.get(), hostGChar.get(), includeSubdomains);
232 }
233
234 void TestRunner::setMainFrameIsFirstResponder(bool flag)
235 {
236     // FIXME: implement
237 }
238
239 void TestRunner::setTabKeyCyclesThroughElements(bool cycles)
240 {
241     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
242     WebKitWebSettings* settings = webkit_web_view_get_settings(webView);
243     g_object_set(G_OBJECT(settings), "tab-key-cycles-through-elements", cycles, NULL);
244 }
245
246 void TestRunner::setUseDashboardCompatibilityMode(bool flag)
247 {
248     // FIXME: implement
249 }
250
251 static gchar* userStyleSheet = NULL;
252 static gboolean userStyleSheetEnabled = TRUE;
253
254 void TestRunner::setUserStyleSheetEnabled(bool flag)
255 {
256     userStyleSheetEnabled = flag;
257
258     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
259     WebKitWebSettings* settings = webkit_web_view_get_settings(webView);
260     if (flag && userStyleSheet)
261         g_object_set(G_OBJECT(settings), "user-stylesheet-uri", userStyleSheet, NULL);
262     else
263         g_object_set(G_OBJECT(settings), "user-stylesheet-uri", "", NULL);
264 }
265
266 void TestRunner::setUserStyleSheetLocation(JSStringRef path)
267 {
268     g_free(userStyleSheet);
269     userStyleSheet = JSStringCopyUTF8CString(path);
270     if (userStyleSheetEnabled)
271         setUserStyleSheetEnabled(true);
272 }
273
274 void TestRunner::setValueForUser(JSContextRef context, JSValueRef nodeObject, JSStringRef value)
275 {
276     DumpRenderTreeSupportGtk::setValueForUser(context, nodeObject, value);
277 }
278
279 void TestRunner::setViewModeMediaFeature(JSStringRef mode)
280 {
281     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
282     ASSERT(view);
283
284     char* viewMode = JSStringCopyUTF8CString(mode);
285
286     if (!g_strcmp0(viewMode, "windowed"))
287         webkit_web_view_set_view_mode(view, WEBKIT_WEB_VIEW_VIEW_MODE_WINDOWED);
288     else if (!g_strcmp0(viewMode, "floating"))
289         webkit_web_view_set_view_mode(view, WEBKIT_WEB_VIEW_VIEW_MODE_FLOATING);
290     else if (!g_strcmp0(viewMode, "fullscreen"))
291         webkit_web_view_set_view_mode(view, WEBKIT_WEB_VIEW_VIEW_MODE_FULLSCREEN);
292     else if (!g_strcmp0(viewMode, "maximized"))
293         webkit_web_view_set_view_mode(view, WEBKIT_WEB_VIEW_VIEW_MODE_MAXIMIZED);
294     else if (!g_strcmp0(viewMode, "minimized"))
295         webkit_web_view_set_view_mode(view, WEBKIT_WEB_VIEW_VIEW_MODE_MINIMIZED);
296
297     g_free(viewMode);
298 }
299
300 void TestRunner::setWindowIsKey(bool windowIsKey)
301 {
302     // FIXME: implement
303 }
304
305 static gboolean waitToDumpWatchdogFired(void*)
306 {
307     setWaitToDumpWatchdog(0);
308     gTestRunner->waitToDumpWatchdogTimerFired();
309     return FALSE;
310 }
311
312 void TestRunner::setWaitToDump(bool waitUntilDone)
313 {
314     static const int timeoutSeconds = 30;
315
316     m_waitToDump = waitUntilDone;
317     if (m_waitToDump && shouldSetWaitToDumpWatchdog()) {
318         guint id = g_timeout_add_seconds(timeoutSeconds, waitToDumpWatchdogFired, 0);
319         g_source_set_name_by_id(id, "[WebKit] waitToDumpWatchdogFired");
320         setWaitToDumpWatchdog(id);
321     }
322 }
323
324 int TestRunner::windowCount()
325 {
326     // +1 -> including the main view
327     return g_slist_length(webViewList) + 1;
328 }
329
330 void TestRunner::setPrivateBrowsingEnabled(bool flag)
331 {
332     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
333     ASSERT(view);
334
335     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
336     g_object_set(G_OBJECT(settings), "enable-private-browsing", flag, NULL);
337 }
338
339 void TestRunner::setJavaScriptCanAccessClipboard(bool flag)
340 {
341     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
342     ASSERT(view);
343
344     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
345     g_object_set(G_OBJECT(settings), "javascript-can-access-clipboard", flag, NULL);
346 }
347
348 void TestRunner::setXSSAuditorEnabled(bool flag)
349 {
350     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
351     ASSERT(view);
352
353     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
354     g_object_set(G_OBJECT(settings), "enable-xss-auditor", flag, NULL);
355 }
356
357 void TestRunner::setSpatialNavigationEnabled(bool flag)
358 {
359     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
360     ASSERT(view);
361
362     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
363     g_object_set(G_OBJECT(settings), "enable-spatial-navigation", flag, NULL);
364 }
365
366 void TestRunner::setAllowUniversalAccessFromFileURLs(bool flag)
367 {
368     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
369     ASSERT(view);
370
371     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
372     g_object_set(G_OBJECT(settings), "enable-universal-access-from-file-uris", flag, NULL);
373 }
374
375 void TestRunner::setAllowFileAccessFromFileURLs(bool flag)
376 {
377     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
378     ASSERT(view);
379
380     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
381     g_object_set(G_OBJECT(settings), "enable-file-access-from-file-uris", flag, NULL);
382 }
383
384 void TestRunner::setAuthorAndUserStylesEnabled(bool flag)
385 {
386     // FIXME: implement
387 }
388
389 void TestRunner::setMockDeviceOrientation(bool canProvideAlpha, double alpha, bool canProvideBeta, double beta, bool canProvideGamma, double gamma)
390 {
391     // FIXME: Implement for DeviceOrientation layout tests.
392     // See https://bugs.webkit.org/show_bug.cgi?id=30335.
393 }
394
395 void TestRunner::setMockGeolocationPosition(double latitude, double longitude, double accuracy, bool, double, bool, double, bool, double, bool, double)
396 {
397     WebKitWebView* view = WEBKIT_WEB_VIEW(g_slist_nth_data(webViewList, 0));
398     if (!view)
399         view = webkit_web_frame_get_web_view(mainFrame);
400     ASSERT(view);
401
402     DumpRenderTreeSupportGtk::setMockGeolocationPosition(view, latitude, longitude, accuracy);
403 }
404
405 void TestRunner::setMockGeolocationPositionUnavailableError(JSStringRef message)
406 {
407     WebKitWebView* view = WEBKIT_WEB_VIEW(g_slist_nth_data(webViewList, 0));
408     if (!view)
409         view = webkit_web_frame_get_web_view(mainFrame);
410     ASSERT(view);
411
412     GOwnPtr<gchar> cMessage(JSStringCopyUTF8CString(message));
413     DumpRenderTreeSupportGtk::setMockGeolocationPositionUnavailableError(view, cMessage.get());
414 }
415
416 void TestRunner::setGeolocationPermission(bool allow)
417 {
418     setGeolocationPermissionCommon(allow);
419     WebKitWebView* view = WEBKIT_WEB_VIEW(g_slist_nth_data(webViewList, 0));
420     if (!view)
421         view = webkit_web_frame_get_web_view(mainFrame);
422     ASSERT(view);
423
424     DumpRenderTreeSupportGtk::setMockGeolocationPermission(view, allow);
425 }
426
427 int TestRunner::numberOfPendingGeolocationPermissionRequests()
428 {
429     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
430     if (!view)
431         view = webkit_web_frame_get_web_view(mainFrame);
432     ASSERT(view);
433
434     return DumpRenderTreeSupportGtk::numberOfPendingGeolocationPermissionRequests(view);
435 }
436
437 void TestRunner::addMockSpeechInputResult(JSStringRef result, double confidence, JSStringRef language)
438 {
439     // FIXME: Implement for speech input layout tests.
440     // See https://bugs.webkit.org/show_bug.cgi?id=39485.
441 }
442
443 void TestRunner::setMockSpeechInputDumpRect(bool flag)
444 {
445     // FIXME: Implement for speech input layout tests.
446     // See https://bugs.webkit.org/show_bug.cgi?id=39485.
447 }
448
449 void TestRunner::startSpeechInput(JSContextRef inputElement)
450 {
451     // FIXME: Implement for speech input layout tests.
452     // See https://bugs.webkit.org/show_bug.cgi?id=39485.
453 }
454
455 void TestRunner::setIconDatabaseEnabled(bool enabled)
456 {
457     WebKitIconDatabase* database = webkit_get_icon_database();
458     if (enabled) {
459         GOwnPtr<gchar> iconDatabasePath(g_build_filename(g_get_tmp_dir(), "DumpRenderTree", "icondatabase", NULL));
460         webkit_icon_database_set_path(database, iconDatabasePath.get());
461     } else
462         webkit_icon_database_set_path(database, 0);
463 }
464
465 void TestRunner::setPopupBlockingEnabled(bool flag)
466 {
467     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
468     ASSERT(view);
469
470     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
471     g_object_set(G_OBJECT(settings), "javascript-can-open-windows-automatically", !flag, NULL);
472
473 }
474
475 void TestRunner::setPluginsEnabled(bool flag)
476 {
477     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
478     ASSERT(view);
479
480     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
481     g_object_set(G_OBJECT(settings), "enable-plugins", flag, NULL);
482 }
483
484 void TestRunner::execCommand(JSStringRef name, JSStringRef value)
485 {
486     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
487     ASSERT(view);
488
489     gchar* cName = JSStringCopyUTF8CString(name);
490     gchar* cValue = JSStringCopyUTF8CString(value);
491     DumpRenderTreeSupportGtk::executeCoreCommandByName(view, cName, cValue);
492     g_free(cName);
493     g_free(cValue);
494 }
495
496 bool TestRunner::findString(JSContextRef context, JSStringRef target, JSObjectRef optionsArray)
497 {
498     WebKitFindOptions findOptions = 0;
499     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
500     ASSERT(webView);
501
502     JSRetainPtr<JSStringRef> lengthPropertyName(Adopt, JSStringCreateWithUTF8CString("length"));
503     JSValueRef lengthValue = JSObjectGetProperty(context, optionsArray, lengthPropertyName.get(), 0); 
504     if (!JSValueIsNumber(context, lengthValue))
505         return false;
506
507     GOwnPtr<gchar> targetString(JSStringCopyUTF8CString(target));
508
509     size_t length = static_cast<size_t>(JSValueToNumber(context, lengthValue, 0));
510     for (size_t i = 0; i < length; ++i) {
511         JSValueRef value = JSObjectGetPropertyAtIndex(context, optionsArray, i, 0); 
512         if (!JSValueIsString(context, value))
513             continue;
514     
515         JSRetainPtr<JSStringRef> optionName(Adopt, JSValueToStringCopy(context, value, 0));
516
517         if (JSStringIsEqualToUTF8CString(optionName.get(), "CaseInsensitive"))
518             findOptions |= WebKit::WebFindOptionsCaseInsensitive;
519         else if (JSStringIsEqualToUTF8CString(optionName.get(), "AtWordStarts"))
520             findOptions |= WebKit::WebFindOptionsAtWordStarts;
521         else if (JSStringIsEqualToUTF8CString(optionName.get(), "TreatMedialCapitalAsWordStart"))
522             findOptions |= WebKit::WebFindOptionsTreatMedialCapitalAsWordStart;
523         else if (JSStringIsEqualToUTF8CString(optionName.get(), "Backwards"))
524             findOptions |= WebKit::WebFindOptionsBackwards;
525         else if (JSStringIsEqualToUTF8CString(optionName.get(), "WrapAround"))
526             findOptions |= WebKit::WebFindOptionsWrapAround;
527         else if (JSStringIsEqualToUTF8CString(optionName.get(), "StartInSelection"))
528             findOptions |= WebKit::WebFindOptionsStartInSelection;
529     }   
530
531     return DumpRenderTreeSupportGtk::findString(webView, targetString.get(), findOptions); 
532 }
533
534 bool TestRunner::isCommandEnabled(JSStringRef name)
535 {
536     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
537     ASSERT(view);
538
539     gchar* cName = JSStringCopyUTF8CString(name);
540     bool result = DumpRenderTreeSupportGtk::isCommandEnabled(view, cName);
541     g_free(cName);
542     return result;
543 }
544
545 void TestRunner::setCacheModel(int cacheModel)
546 {
547     // These constants are derived from the Mac cache model enum in Source/WebKit/mac/WebView/WebPreferences.h.
548     switch (cacheModel) {
549     case 0:
550         webkit_set_cache_model(WEBKIT_CACHE_MODEL_DOCUMENT_VIEWER);
551         break;
552     case 1:
553         webkit_set_cache_model(WEBKIT_CACHE_MODEL_DOCUMENT_BROWSER);
554         break;
555     case 2:
556         webkit_set_cache_model(WEBKIT_CACHE_MODEL_WEB_BROWSER);
557         break;
558     default:
559         ASSERT_NOT_REACHED();
560     }
561 }
562
563 void TestRunner::setPersistentUserStyleSheetLocation(JSStringRef jsURL)
564 {
565     // FIXME: implement
566 }
567
568 void TestRunner::clearPersistentUserStyleSheet()
569 {
570     // FIXME: implement
571 }
572
573 void TestRunner::clearAllApplicationCaches()
574 {
575     // FIXME: Implement to support application cache quotas.
576 }
577
578 void TestRunner::setApplicationCacheOriginQuota(unsigned long long quota)
579 {
580     // FIXME: Implement to support application cache quotas.
581 }
582
583 void TestRunner::clearApplicationCacheForOrigin(OpaqueJSString*)
584 {
585     // FIXME: Implement to support deleting all application caches for an origin.
586 }
587
588 long long TestRunner::localStorageDiskUsageForOrigin(JSStringRef originIdentifier)
589 {
590     // FIXME: Implement to support getting disk usage in bytes for an origin.
591     return 0;
592 }
593
594 JSValueRef TestRunner::originsWithApplicationCache(JSContextRef context)
595 {
596     // FIXME: Implement to get origins that contain application caches.
597     return JSValueMakeUndefined(context);
598 }
599
600 long long TestRunner::applicationCacheDiskUsageForOrigin(JSStringRef name)
601 {
602     // FIXME: implement
603     return 0;
604 }
605
606 void TestRunner::clearAllDatabases()
607 {
608     webkit_remove_all_web_databases();
609 }
610  
611 void TestRunner::setDatabaseQuota(unsigned long long quota)
612 {
613     WebKitSecurityOrigin* origin = webkit_web_frame_get_security_origin(mainFrame);
614     webkit_security_origin_set_web_database_quota(origin, quota);
615 }
616
617 JSValueRef TestRunner::originsWithLocalStorage(JSContextRef context)
618 {
619     // FIXME: implement
620     return JSValueMakeUndefined(context);
621 }
622
623 void TestRunner::deleteAllLocalStorage()
624 {
625         // FIXME: implement
626 }
627
628 void TestRunner::deleteLocalStorageForOrigin(JSStringRef originIdentifier)
629 {
630         // FIXME: implement
631 }
632
633 void TestRunner::observeStorageTrackerNotifications(unsigned number)
634 {
635         // FIXME: implement
636 }
637
638 void TestRunner::syncLocalStorage()
639 {
640     // FIXME: implement
641 }
642
643 void TestRunner::setDomainRelaxationForbiddenForURLScheme(bool forbidden, JSStringRef scheme)
644 {
645     GOwnPtr<gchar> urlScheme(JSStringCopyUTF8CString(scheme));
646     DumpRenderTreeSupportGtk::setDomainRelaxationForbiddenForURLScheme(forbidden, urlScheme.get());
647 }
648
649 void TestRunner::goBack()
650 {
651     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
652     webkit_web_view_go_back(webView);
653 }
654
655 void TestRunner::setDefersLoading(bool defers)
656 {
657     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
658     DumpRenderTreeSupportGtk::setDefersLoading(webView, defers);
659 }
660
661 void TestRunner::setAppCacheMaximumSize(unsigned long long size)
662 {
663     webkit_application_cache_set_maximum_size(size);
664 }
665
666 static gboolean booleanFromValue(gchar* value)
667 {
668     return !g_ascii_strcasecmp(value, "true") || !g_ascii_strcasecmp(value, "1");
669 }
670
671 void TestRunner::overridePreference(JSStringRef key, JSStringRef value)
672 {
673     GOwnPtr<gchar> originalName(JSStringCopyUTF8CString(key));
674     GOwnPtr<gchar> valueAsString(JSStringCopyUTF8CString(value));
675
676     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
677     ASSERT(view);
678
679     // This transformation could be handled by a hash table (and it once was), but
680     // having it prominent, makes it easier for people from other ports to keep the
681     // list up to date.
682     const gchar* propertyName = 0;
683     if (g_str_equal(originalName.get(), "WebKitJavaScriptEnabled"))
684         propertyName = "enable-scripts";
685     else if (g_str_equal(originalName.get(), "WebKitDefaultFontSize"))
686         propertyName = "default-font-size";
687     else if (g_str_equal(originalName.get(), "WebKitEnableCaretBrowsing"))
688         propertyName = "enable-caret-browsing";
689     else if (g_str_equal(originalName.get(), "WebKitUsesPageCachePreferenceKey"))
690         propertyName = "enable-page-cache";
691     else if (g_str_equal(originalName.get(), "WebKitPluginsEnabled"))
692         propertyName = "enable-plugins";
693     else if (g_str_equal(originalName.get(), "WebKitHyperlinkAuditingEnabled"))
694         propertyName = "enable-hyperlink-auditing";
695     else if (g_str_equal(originalName.get(), "WebKitWebGLEnabled"))
696         propertyName = "enable-webgl";
697     else if (g_str_equal(originalName.get(), "WebKitWebAudioEnabled"))
698         propertyName = "enable-webaudio";
699     else if (g_str_equal(originalName.get(), "WebKitDisplayImagesKey"))
700         propertyName = "auto-load-images";
701     else if (g_str_equal(originalName.get(), "WebKitShouldRespectImageOrientation"))
702         propertyName = "respect-image-orientation";
703     else if (g_str_equal(originalName.get(), "WebKitTabToLinksPreferenceKey")) {
704         DumpRenderTreeSupportGtk::setLinksIncludedInFocusChain(booleanFromValue(valueAsString.get()));
705         return;
706     } else if (g_str_equal(originalName.get(), "WebKitPageCacheSupportsPluginsPreferenceKey")) {
707         DumpRenderTreeSupportGtk::setPageCacheSupportsPlugins(webkit_web_frame_get_web_view(mainFrame), booleanFromValue(valueAsString.get()));
708         return;
709     } else if (g_str_equal(originalName.get(), "WebKitCSSGridLayoutEnabled")) {
710         DumpRenderTreeSupportGtk::setCSSGridLayoutEnabled(webkit_web_frame_get_web_view(mainFrame), booleanFromValue(valueAsString.get()));
711         return;
712     } else if (g_str_equal(originalName.get(), "WebKitCSSRegionsEnabled")) {
713         DumpRenderTreeSupportGtk::setCSSRegionsEnabled(webkit_web_frame_get_web_view(mainFrame), booleanFromValue(valueAsString.get()));
714         return;
715     } else if (g_str_equal(originalName.get(), "WebKitCSSCustomFilterEnabled")) {
716         DumpRenderTreeSupportGtk::setCSSCustomFilterEnabled(webkit_web_frame_get_web_view(mainFrame), booleanFromValue(valueAsString.get()));
717         return;
718     } else {
719         fprintf(stderr, "TestRunner::overridePreference tried to override "
720                 "unknown preference '%s'.\n", originalName.get());
721         return;
722     }
723
724     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
725     GParamSpec* pspec = g_object_class_find_property(G_OBJECT_CLASS(
726         WEBKIT_WEB_SETTINGS_GET_CLASS(settings)), propertyName);
727     GValue currentPropertyValue = { 0, { { 0 } } };
728     g_value_init(&currentPropertyValue, pspec->value_type);
729
730     if (G_VALUE_HOLDS_STRING(&currentPropertyValue))
731         g_object_set(settings, propertyName, valueAsString.get(), NULL);
732     else if (G_VALUE_HOLDS_BOOLEAN(&currentPropertyValue))
733         g_object_set(G_OBJECT(settings), propertyName, booleanFromValue(valueAsString.get()), NULL);
734     else if (G_VALUE_HOLDS_INT(&currentPropertyValue))
735         g_object_set(G_OBJECT(settings), propertyName, atoi(valueAsString.get()), NULL);
736     else if (G_VALUE_HOLDS_FLOAT(&currentPropertyValue)) {
737         gfloat newValue = g_ascii_strtod(valueAsString.get(), 0);
738         g_object_set(G_OBJECT(settings), propertyName, newValue, NULL);
739     } else
740         fprintf(stderr, "TestRunner::overridePreference failed to override "
741                 "preference '%s'.\n", originalName.get());
742 }
743
744 void TestRunner::addUserScript(JSStringRef source, bool runAtStart, bool allFrames)
745 {
746     GOwnPtr<gchar> sourceCode(JSStringCopyUTF8CString(source));
747     DumpRenderTreeSupportGtk::addUserScript(mainFrame, sourceCode.get(), runAtStart, allFrames);
748 }
749
750 void TestRunner::addUserStyleSheet(JSStringRef source, bool allFrames)
751 {
752     GOwnPtr<gchar> sourceCode(JSStringCopyUTF8CString(source));
753     DumpRenderTreeSupportGtk::addUserStyleSheet(mainFrame, sourceCode.get(), allFrames);
754     // FIXME: needs more investigation why userscripts/user-style-top-frame-only.html fails when allFrames is false.
755
756 }
757
758 void TestRunner::setDeveloperExtrasEnabled(bool enabled)
759 {
760     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
761     WebKitWebSettings* webSettings = webkit_web_view_get_settings(webView);
762
763     g_object_set(webSettings, "enable-developer-extras", enabled, NULL);
764 }
765
766 void TestRunner::showWebInspector()
767 {
768     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
769     WebKitWebInspector* inspector = webkit_web_view_get_inspector(webView);
770
771     webkit_web_inspector_show(inspector);
772 }
773
774 void TestRunner::closeWebInspector()
775 {
776     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
777     WebKitWebInspector* inspector = webkit_web_view_get_inspector(webView);
778
779     webkit_web_inspector_close(inspector);
780 }
781
782 void TestRunner::evaluateInWebInspector(long callId, JSStringRef script)
783 {
784     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
785     WebKitWebInspector* inspector = webkit_web_view_get_inspector(webView);
786     char* scriptString = JSStringCopyUTF8CString(script);
787
788     webkit_web_inspector_execute_script(inspector, callId, scriptString);
789     g_free(scriptString);
790 }
791
792 void TestRunner::evaluateScriptInIsolatedWorldAndReturnValue(unsigned worldID, JSObjectRef globalObject, JSStringRef script)
793 {
794     // FIXME: Implement this.
795 }
796
797 void TestRunner::evaluateScriptInIsolatedWorld(unsigned worldID, JSObjectRef globalObject, JSStringRef script)
798 {
799     // FIXME: Implement this.
800 }
801
802 void TestRunner::removeAllVisitedLinks()
803 {
804     // FIXME: Implement this.
805 }
806
807 bool TestRunner::callShouldCloseOnWebView()
808 {
809     return DumpRenderTreeSupportGtk::shouldClose(mainFrame);
810 }
811
812 void TestRunner::apiTestNewWindowDataLoadBaseURL(JSStringRef utf8Data, JSStringRef baseURL)
813 {
814
815 }
816
817 void TestRunner::apiTestGoToCurrentBackForwardItem()
818 {
819
820 }
821
822 void TestRunner::setWebViewEditable(bool)
823 {
824 }
825
826 void TestRunner::authenticateSession(JSStringRef, JSStringRef, JSStringRef)
827 {
828 }
829
830 void TestRunner::abortModal()
831 {
832 }
833
834 void TestRunner::setSerializeHTTPLoads(bool serialize)
835 {
836     DumpRenderTreeSupportGtk::setSerializeHTTPLoads(serialize);
837 }
838
839 void TestRunner::setTextDirection(JSStringRef direction)
840 {
841     GOwnPtr<gchar> writingDirection(JSStringCopyUTF8CString(direction));
842
843     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
844     ASSERT(view);
845
846     if (g_str_equal(writingDirection.get(), "auto"))
847         gtk_widget_set_direction(GTK_WIDGET(view), GTK_TEXT_DIR_NONE);
848     else if (g_str_equal(writingDirection.get(), "ltr"))
849         gtk_widget_set_direction(GTK_WIDGET(view), GTK_TEXT_DIR_LTR);
850     else if (g_str_equal(writingDirection.get(), "rtl"))
851         gtk_widget_set_direction(GTK_WIDGET(view), GTK_TEXT_DIR_RTL);
852     else
853         fprintf(stderr, "TestRunner::setTextDirection called with unknown direction: '%s'.\n", writingDirection.get());
854 }
855
856 void TestRunner::addChromeInputField()
857 {
858 }
859
860 void TestRunner::removeChromeInputField()
861 {
862 }
863
864 void TestRunner::focusWebView()
865 {
866 }
867
868 void TestRunner::setBackingScaleFactor(double)
869 {
870 }
871
872 void TestRunner::grantWebNotificationPermission(JSStringRef origin)
873 {
874 }
875
876 void TestRunner::denyWebNotificationPermission(JSStringRef jsOrigin)
877 {
878 }
879
880 void TestRunner::removeAllWebNotificationPermissions()
881 {
882 }
883
884 void TestRunner::simulateWebNotificationClick(JSValueRef jsNotification)
885 {
886 }
887
888 void TestRunner::simulateLegacyWebNotificationClick(JSStringRef title)
889 {
890 }
891
892 void TestRunner::resetPageVisibility()
893 {
894     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
895     DumpRenderTreeSupportGtk::setPageVisibility(webView, WebCore::PageVisibilityStateVisible, true);
896 }
897
898 void TestRunner::setPageVisibility(const char* visibility)
899 {
900     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
901     String visibilityString(visibility);
902     WebCore::PageVisibilityState visibilityState = WebCore::PageVisibilityStateVisible;
903
904     if (visibilityString == "visible")
905         visibilityState = WebCore::PageVisibilityStateVisible;
906     else if (visibilityString == "hidden")
907         visibilityState = WebCore::PageVisibilityStateHidden;
908     else
909         return;
910
911     DumpRenderTreeSupportGtk::setPageVisibility(webView, visibilityState, false);
912 }
913
914 void TestRunner::setAutomaticLinkDetectionEnabled(bool)
915 {
916     // FIXME: Implement this.
917 }
918
919 void TestRunner::setStorageDatabaseIdleInterval(double)
920 {
921     // FIXME: Implement this.
922 }
923
924 void TestRunner::closeIdleLocalStorageDatabases()
925 {
926 }