ea57d23452a0ab92f44fc96e01fdbffc7fdfed84
[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 void TestRunner::notifyDone()
126 {
127     if (m_waitToDump && !topLoadingFrame && !WorkQueue::shared()->count())
128         dump();
129     m_waitToDump = false;
130     waitForPolicy = false;
131 }
132
133 JSStringRef TestRunner::pathToLocalResource(JSContextRef context, JSStringRef url)
134 {
135     GOwnPtr<char> urlCString(JSStringCopyUTF8CString(url));
136     if (!g_str_has_prefix(urlCString.get(), "file:///tmp/LayoutTests/"))
137         return JSStringRetain(url);
138
139     const char* layoutTestsSuffix = urlCString.get() + strlen("file:///tmp/");
140     GOwnPtr<char> testPath(g_build_filename(getTopLevelPath().data(), layoutTestsSuffix, NULL));
141     GOwnPtr<char> testURI(g_filename_to_uri(testPath.get(), 0, 0));
142     return JSStringCreateWithUTF8CString(testURI.get());
143 }
144
145 void TestRunner::queueLoad(JSStringRef url, JSStringRef target)
146 {
147     GOwnPtr<gchar> relativeURL(JSStringCopyUTF8CString(url));
148     SoupURI* baseURI = soup_uri_new(webkit_web_frame_get_uri(mainFrame));
149     SoupURI* absoluteURI = soup_uri_new_with_base(baseURI, relativeURL.get());
150     soup_uri_free(baseURI);
151
152     if (!absoluteURI) {
153         WorkQueue::shared()->queue(new LoadItem(url, target));
154         return;
155     }
156
157     CString absoluteURIString = soupURIToStringPreservingPassword(absoluteURI);
158     JSRetainPtr<JSStringRef> absoluteURL(Adopt, JSStringCreateWithUTF8CString(absoluteURIString.data()));
159     WorkQueue::shared()->queue(new LoadItem(absoluteURL.get(), target));
160     soup_uri_free(absoluteURI);
161 }
162
163 void TestRunner::setAcceptsEditing(bool acceptsEditing)
164 {
165     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
166     webkit_web_view_set_editable(webView, acceptsEditing);
167 }
168
169 void TestRunner::setAlwaysAcceptCookies(bool alwaysAcceptCookies)
170 {
171     SoupSession* session = webkit_get_default_session();
172     SoupCookieJar* jar = reinterpret_cast<SoupCookieJar*>(soup_session_get_feature(session, SOUP_TYPE_COOKIE_JAR));
173
174     /* If the jar was not created - we create it on demand, i.e, just
175        in case we have HTTP requests - then we must create it here in
176        order to set the proper accept policy */
177     if (!jar) {
178         jar = soup_cookie_jar_new();
179         soup_session_add_feature(session, SOUP_SESSION_FEATURE(jar));
180         g_object_unref(jar);
181     }
182
183     SoupCookieJarAcceptPolicy policy;
184
185     if (alwaysAcceptCookies)
186         policy = SOUP_COOKIE_JAR_ACCEPT_ALWAYS;
187     else
188         policy = SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY;
189
190     g_object_set(G_OBJECT(jar), SOUP_COOKIE_JAR_ACCEPT_POLICY, policy, NULL);
191 }
192
193 void TestRunner::setCustomPolicyDelegate(bool setDelegate, bool permissive)
194 {
195     // FIXME: implement
196 }
197
198 void TestRunner::waitForPolicyDelegate()
199 {
200     waitForPolicy = true;
201     setWaitToDump(true);
202 }
203
204 void TestRunner::setScrollbarPolicy(JSStringRef orientation, JSStringRef policy)
205 {
206     // FIXME: implement
207 }
208
209 void TestRunner::addOriginAccessWhitelistEntry(JSStringRef sourceOrigin, JSStringRef protocol, JSStringRef host, bool includeSubdomains)
210 {
211     gchar* sourceOriginGChar = JSStringCopyUTF8CString(sourceOrigin);
212     gchar* protocolGChar = JSStringCopyUTF8CString(protocol);
213     gchar* hostGChar = JSStringCopyUTF8CString(host);
214     DumpRenderTreeSupportGtk::whiteListAccessFromOrigin(sourceOriginGChar, protocolGChar, hostGChar, includeSubdomains);
215     g_free(sourceOriginGChar);
216     g_free(protocolGChar);
217     g_free(hostGChar);
218 }
219
220 void TestRunner::removeOriginAccessWhitelistEntry(JSStringRef sourceOrigin, JSStringRef protocol, JSStringRef host, bool includeSubdomains)
221 {
222     GOwnPtr<gchar> sourceOriginGChar(JSStringCopyUTF8CString(sourceOrigin));
223     GOwnPtr<gchar> protocolGChar(JSStringCopyUTF8CString(protocol));
224     GOwnPtr<gchar> hostGChar(JSStringCopyUTF8CString(host));
225     DumpRenderTreeSupportGtk::removeWhiteListAccessFromOrigin(sourceOriginGChar.get(), protocolGChar.get(), hostGChar.get(), includeSubdomains);
226 }
227
228 void TestRunner::setMainFrameIsFirstResponder(bool flag)
229 {
230     // FIXME: implement
231 }
232
233 void TestRunner::setTabKeyCyclesThroughElements(bool cycles)
234 {
235     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
236     WebKitWebSettings* settings = webkit_web_view_get_settings(webView);
237     g_object_set(G_OBJECT(settings), "tab-key-cycles-through-elements", cycles, NULL);
238 }
239
240 void TestRunner::setUseDashboardCompatibilityMode(bool flag)
241 {
242     // FIXME: implement
243 }
244
245 static gchar* userStyleSheet = NULL;
246 static gboolean userStyleSheetEnabled = TRUE;
247
248 void TestRunner::setUserStyleSheetEnabled(bool flag)
249 {
250     userStyleSheetEnabled = flag;
251
252     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
253     WebKitWebSettings* settings = webkit_web_view_get_settings(webView);
254     if (flag && userStyleSheet)
255         g_object_set(G_OBJECT(settings), "user-stylesheet-uri", userStyleSheet, NULL);
256     else
257         g_object_set(G_OBJECT(settings), "user-stylesheet-uri", "", NULL);
258 }
259
260 void TestRunner::setUserStyleSheetLocation(JSStringRef path)
261 {
262     g_free(userStyleSheet);
263     userStyleSheet = JSStringCopyUTF8CString(path);
264     if (userStyleSheetEnabled)
265         setUserStyleSheetEnabled(true);
266 }
267
268 void TestRunner::setValueForUser(JSContextRef context, JSValueRef nodeObject, JSStringRef value)
269 {
270     DumpRenderTreeSupportGtk::setValueForUser(context, nodeObject, value);
271 }
272
273 void TestRunner::setViewModeMediaFeature(JSStringRef mode)
274 {
275     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
276     ASSERT(view);
277
278     char* viewMode = JSStringCopyUTF8CString(mode);
279
280     if (!g_strcmp0(viewMode, "windowed"))
281         webkit_web_view_set_view_mode(view, WEBKIT_WEB_VIEW_VIEW_MODE_WINDOWED);
282     else if (!g_strcmp0(viewMode, "floating"))
283         webkit_web_view_set_view_mode(view, WEBKIT_WEB_VIEW_VIEW_MODE_FLOATING);
284     else if (!g_strcmp0(viewMode, "fullscreen"))
285         webkit_web_view_set_view_mode(view, WEBKIT_WEB_VIEW_VIEW_MODE_FULLSCREEN);
286     else if (!g_strcmp0(viewMode, "maximized"))
287         webkit_web_view_set_view_mode(view, WEBKIT_WEB_VIEW_VIEW_MODE_MAXIMIZED);
288     else if (!g_strcmp0(viewMode, "minimized"))
289         webkit_web_view_set_view_mode(view, WEBKIT_WEB_VIEW_VIEW_MODE_MINIMIZED);
290
291     g_free(viewMode);
292 }
293
294 void TestRunner::setWindowIsKey(bool windowIsKey)
295 {
296     // FIXME: implement
297 }
298
299 static gboolean waitToDumpWatchdogFired(void*)
300 {
301     setWaitToDumpWatchdog(0);
302     gTestRunner->waitToDumpWatchdogTimerFired();
303     return FALSE;
304 }
305
306 void TestRunner::setWaitToDump(bool waitUntilDone)
307 {
308     static const int timeoutSeconds = 30;
309
310     m_waitToDump = waitUntilDone;
311     if (m_waitToDump && shouldSetWaitToDumpWatchdog()) {
312         guint id = g_timeout_add_seconds(timeoutSeconds, waitToDumpWatchdogFired, 0);
313         g_source_set_name_by_id(id, "[WebKit] waitToDumpWatchdogFired");
314         setWaitToDumpWatchdog(id);
315     }
316 }
317
318 int TestRunner::windowCount()
319 {
320     // +1 -> including the main view
321     return g_slist_length(webViewList) + 1;
322 }
323
324 void TestRunner::setPrivateBrowsingEnabled(bool flag)
325 {
326     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
327     ASSERT(view);
328
329     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
330     g_object_set(G_OBJECT(settings), "enable-private-browsing", flag, NULL);
331 }
332
333 void TestRunner::setJavaScriptCanAccessClipboard(bool flag)
334 {
335     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
336     ASSERT(view);
337
338     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
339     g_object_set(G_OBJECT(settings), "javascript-can-access-clipboard", flag, NULL);
340 }
341
342 void TestRunner::setXSSAuditorEnabled(bool flag)
343 {
344     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
345     ASSERT(view);
346
347     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
348     g_object_set(G_OBJECT(settings), "enable-xss-auditor", flag, NULL);
349 }
350
351 void TestRunner::setSpatialNavigationEnabled(bool flag)
352 {
353     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
354     ASSERT(view);
355
356     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
357     g_object_set(G_OBJECT(settings), "enable-spatial-navigation", flag, NULL);
358 }
359
360 void TestRunner::setAllowUniversalAccessFromFileURLs(bool flag)
361 {
362     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
363     ASSERT(view);
364
365     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
366     g_object_set(G_OBJECT(settings), "enable-universal-access-from-file-uris", flag, NULL);
367 }
368
369 void TestRunner::setAllowFileAccessFromFileURLs(bool flag)
370 {
371     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
372     ASSERT(view);
373
374     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
375     g_object_set(G_OBJECT(settings), "enable-file-access-from-file-uris", flag, NULL);
376 }
377
378 void TestRunner::setAuthorAndUserStylesEnabled(bool flag)
379 {
380     // FIXME: implement
381 }
382
383 void TestRunner::setMockDeviceOrientation(bool canProvideAlpha, double alpha, bool canProvideBeta, double beta, bool canProvideGamma, double gamma)
384 {
385     // FIXME: Implement for DeviceOrientation layout tests.
386     // See https://bugs.webkit.org/show_bug.cgi?id=30335.
387 }
388
389 void TestRunner::setMockGeolocationPosition(double latitude, double longitude, double accuracy, bool, double, bool, double, bool, double, bool, double)
390 {
391     WebKitWebView* view = WEBKIT_WEB_VIEW(g_slist_nth_data(webViewList, 0));
392     if (!view)
393         view = webkit_web_frame_get_web_view(mainFrame);
394     ASSERT(view);
395
396     DumpRenderTreeSupportGtk::setMockGeolocationPosition(view, latitude, longitude, accuracy);
397 }
398
399 void TestRunner::setMockGeolocationPositionUnavailableError(JSStringRef message)
400 {
401     WebKitWebView* view = WEBKIT_WEB_VIEW(g_slist_nth_data(webViewList, 0));
402     if (!view)
403         view = webkit_web_frame_get_web_view(mainFrame);
404     ASSERT(view);
405
406     GOwnPtr<gchar> cMessage(JSStringCopyUTF8CString(message));
407     DumpRenderTreeSupportGtk::setMockGeolocationPositionUnavailableError(view, cMessage.get());
408 }
409
410 void TestRunner::setGeolocationPermission(bool allow)
411 {
412     setGeolocationPermissionCommon(allow);
413     WebKitWebView* view = WEBKIT_WEB_VIEW(g_slist_nth_data(webViewList, 0));
414     if (!view)
415         view = webkit_web_frame_get_web_view(mainFrame);
416     ASSERT(view);
417
418     DumpRenderTreeSupportGtk::setMockGeolocationPermission(view, allow);
419 }
420
421 int TestRunner::numberOfPendingGeolocationPermissionRequests()
422 {
423     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
424     if (!view)
425         view = webkit_web_frame_get_web_view(mainFrame);
426     ASSERT(view);
427
428     return DumpRenderTreeSupportGtk::numberOfPendingGeolocationPermissionRequests(view);
429 }
430
431 void TestRunner::addMockSpeechInputResult(JSStringRef result, double confidence, JSStringRef language)
432 {
433     // FIXME: Implement for speech input layout tests.
434     // See https://bugs.webkit.org/show_bug.cgi?id=39485.
435 }
436
437 void TestRunner::setMockSpeechInputDumpRect(bool flag)
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::startSpeechInput(JSContextRef inputElement)
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::setIconDatabaseEnabled(bool enabled)
450 {
451     WebKitIconDatabase* database = webkit_get_icon_database();
452     if (enabled) {
453         GOwnPtr<gchar> iconDatabasePath(g_build_filename(g_get_tmp_dir(), "DumpRenderTree", "icondatabase", NULL));
454         webkit_icon_database_set_path(database, iconDatabasePath.get());
455     } else
456         webkit_icon_database_set_path(database, 0);
457 }
458
459 void TestRunner::setPopupBlockingEnabled(bool flag)
460 {
461     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
462     ASSERT(view);
463
464     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
465     g_object_set(G_OBJECT(settings), "javascript-can-open-windows-automatically", !flag, NULL);
466
467 }
468
469 void TestRunner::setPluginsEnabled(bool flag)
470 {
471     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
472     ASSERT(view);
473
474     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
475     g_object_set(G_OBJECT(settings), "enable-plugins", flag, NULL);
476 }
477
478 void TestRunner::execCommand(JSStringRef name, JSStringRef value)
479 {
480     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
481     ASSERT(view);
482
483     gchar* cName = JSStringCopyUTF8CString(name);
484     gchar* cValue = JSStringCopyUTF8CString(value);
485     DumpRenderTreeSupportGtk::executeCoreCommandByName(view, cName, cValue);
486     g_free(cName);
487     g_free(cValue);
488 }
489
490 bool TestRunner::findString(JSContextRef context, JSStringRef target, JSObjectRef optionsArray)
491 {
492     WebKitFindOptions findOptions = 0;
493     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
494     ASSERT(webView);
495
496     JSRetainPtr<JSStringRef> lengthPropertyName(Adopt, JSStringCreateWithUTF8CString("length"));
497     JSValueRef lengthValue = JSObjectGetProperty(context, optionsArray, lengthPropertyName.get(), 0); 
498     if (!JSValueIsNumber(context, lengthValue))
499         return false;
500
501     GOwnPtr<gchar> targetString(JSStringCopyUTF8CString(target));
502
503     size_t length = static_cast<size_t>(JSValueToNumber(context, lengthValue, 0));
504     for (size_t i = 0; i < length; ++i) {
505         JSValueRef value = JSObjectGetPropertyAtIndex(context, optionsArray, i, 0); 
506         if (!JSValueIsString(context, value))
507             continue;
508     
509         JSRetainPtr<JSStringRef> optionName(Adopt, JSValueToStringCopy(context, value, 0));
510
511         if (JSStringIsEqualToUTF8CString(optionName.get(), "CaseInsensitive"))
512             findOptions |= WebKit::WebFindOptionsCaseInsensitive;
513         else if (JSStringIsEqualToUTF8CString(optionName.get(), "AtWordStarts"))
514             findOptions |= WebKit::WebFindOptionsAtWordStarts;
515         else if (JSStringIsEqualToUTF8CString(optionName.get(), "TreatMedialCapitalAsWordStart"))
516             findOptions |= WebKit::WebFindOptionsTreatMedialCapitalAsWordStart;
517         else if (JSStringIsEqualToUTF8CString(optionName.get(), "Backwards"))
518             findOptions |= WebKit::WebFindOptionsBackwards;
519         else if (JSStringIsEqualToUTF8CString(optionName.get(), "WrapAround"))
520             findOptions |= WebKit::WebFindOptionsWrapAround;
521         else if (JSStringIsEqualToUTF8CString(optionName.get(), "StartInSelection"))
522             findOptions |= WebKit::WebFindOptionsStartInSelection;
523     }   
524
525     return DumpRenderTreeSupportGtk::findString(webView, targetString.get(), findOptions); 
526 }
527
528 bool TestRunner::isCommandEnabled(JSStringRef name)
529 {
530     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
531     ASSERT(view);
532
533     gchar* cName = JSStringCopyUTF8CString(name);
534     bool result = DumpRenderTreeSupportGtk::isCommandEnabled(view, cName);
535     g_free(cName);
536     return result;
537 }
538
539 void TestRunner::setCacheModel(int cacheModel)
540 {
541     // These constants are derived from the Mac cache model enum in Source/WebKit/mac/WebView/WebPreferences.h.
542     switch (cacheModel) {
543     case 0:
544         webkit_set_cache_model(WEBKIT_CACHE_MODEL_DOCUMENT_VIEWER);
545         break;
546     case 1:
547         webkit_set_cache_model(WEBKIT_CACHE_MODEL_DOCUMENT_BROWSER);
548         break;
549     case 2:
550         webkit_set_cache_model(WEBKIT_CACHE_MODEL_WEB_BROWSER);
551         break;
552     default:
553         ASSERT_NOT_REACHED();
554     }
555 }
556
557 void TestRunner::setPersistentUserStyleSheetLocation(JSStringRef jsURL)
558 {
559     // FIXME: implement
560 }
561
562 void TestRunner::clearPersistentUserStyleSheet()
563 {
564     // FIXME: implement
565 }
566
567 void TestRunner::clearAllApplicationCaches()
568 {
569     // FIXME: Implement to support application cache quotas.
570 }
571
572 void TestRunner::clearApplicationCacheForOrigin(OpaqueJSString*)
573 {
574     // FIXME: Implement to support deleting all application caches for an origin.
575 }
576
577 long long TestRunner::localStorageDiskUsageForOrigin(JSStringRef originIdentifier)
578 {
579     // FIXME: Implement to support getting disk usage in bytes for an origin.
580     return 0;
581 }
582
583 JSValueRef TestRunner::originsWithApplicationCache(JSContextRef context)
584 {
585     // FIXME: Implement to get origins that contain application caches.
586     return JSValueMakeUndefined(context);
587 }
588
589 long long TestRunner::applicationCacheDiskUsageForOrigin(JSStringRef name)
590 {
591     // FIXME: implement
592     return 0;
593 }
594
595 void TestRunner::clearAllDatabases()
596 {
597     webkit_remove_all_web_databases();
598 }
599  
600 void TestRunner::setDatabaseQuota(unsigned long long quota)
601 {
602     WebKitSecurityOrigin* origin = webkit_web_frame_get_security_origin(mainFrame);
603     webkit_security_origin_set_web_database_quota(origin, quota);
604 }
605
606 JSValueRef TestRunner::originsWithLocalStorage(JSContextRef context)
607 {
608     // FIXME: implement
609     return JSValueMakeUndefined(context);
610 }
611
612 void TestRunner::deleteAllLocalStorage()
613 {
614         // FIXME: implement
615 }
616
617 void TestRunner::deleteLocalStorageForOrigin(JSStringRef originIdentifier)
618 {
619         // FIXME: implement
620 }
621
622 void TestRunner::observeStorageTrackerNotifications(unsigned number)
623 {
624         // FIXME: implement
625 }
626
627 void TestRunner::syncLocalStorage()
628 {
629     // FIXME: implement
630 }
631
632 void TestRunner::setDomainRelaxationForbiddenForURLScheme(bool forbidden, JSStringRef scheme)
633 {
634     GOwnPtr<gchar> urlScheme(JSStringCopyUTF8CString(scheme));
635     DumpRenderTreeSupportGtk::setDomainRelaxationForbiddenForURLScheme(forbidden, urlScheme.get());
636 }
637
638 void TestRunner::goBack()
639 {
640     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
641     webkit_web_view_go_back(webView);
642 }
643
644 void TestRunner::setDefersLoading(bool defers)
645 {
646     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
647     DumpRenderTreeSupportGtk::setDefersLoading(webView, defers);
648 }
649
650 void TestRunner::setAppCacheMaximumSize(unsigned long long size)
651 {
652     webkit_application_cache_set_maximum_size(size);
653 }
654
655 static gboolean booleanFromValue(gchar* value)
656 {
657     return !g_ascii_strcasecmp(value, "true") || !g_ascii_strcasecmp(value, "1");
658 }
659
660 void TestRunner::overridePreference(JSStringRef key, JSStringRef value)
661 {
662     GOwnPtr<gchar> originalName(JSStringCopyUTF8CString(key));
663     GOwnPtr<gchar> valueAsString(JSStringCopyUTF8CString(value));
664
665     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
666     ASSERT(view);
667
668     // This transformation could be handled by a hash table (and it once was), but
669     // having it prominent, makes it easier for people from other ports to keep the
670     // list up to date.
671     const gchar* propertyName = 0;
672     if (g_str_equal(originalName.get(), "WebKitJavaScriptEnabled"))
673         propertyName = "enable-scripts";
674     else if (g_str_equal(originalName.get(), "WebKitDefaultFontSize"))
675         propertyName = "default-font-size";
676     else if (g_str_equal(originalName.get(), "WebKitEnableCaretBrowsing"))
677         propertyName = "enable-caret-browsing";
678     else if (g_str_equal(originalName.get(), "WebKitUsesPageCachePreferenceKey"))
679         propertyName = "enable-page-cache";
680     else if (g_str_equal(originalName.get(), "WebKitPluginsEnabled"))
681         propertyName = "enable-plugins";
682     else if (g_str_equal(originalName.get(), "WebKitHyperlinkAuditingEnabled"))
683         propertyName = "enable-hyperlink-auditing";
684     else if (g_str_equal(originalName.get(), "WebKitWebGLEnabled"))
685         propertyName = "enable-webgl";
686     else if (g_str_equal(originalName.get(), "WebKitWebAudioEnabled"))
687         propertyName = "enable-webaudio";
688     else if (g_str_equal(originalName.get(), "WebKitDisplayImagesKey"))
689         propertyName = "auto-load-images";
690     else if (g_str_equal(originalName.get(), "WebKitShouldRespectImageOrientation"))
691         propertyName = "respect-image-orientation";
692     else if (g_str_equal(originalName.get(), "WebKitMediaSourceEnabled"))
693         propertyName = "enable-mediasource";
694     else if (g_str_equal(originalName.get(), "WebKitTabToLinksPreferenceKey")) {
695         DumpRenderTreeSupportGtk::setLinksIncludedInFocusChain(booleanFromValue(valueAsString.get()));
696         return;
697     } else if (g_str_equal(originalName.get(), "WebKitPageCacheSupportsPluginsPreferenceKey")) {
698         DumpRenderTreeSupportGtk::setPageCacheSupportsPlugins(webkit_web_frame_get_web_view(mainFrame), booleanFromValue(valueAsString.get()));
699         return;
700     } else if (g_str_equal(originalName.get(), "WebKitCSSGridLayoutEnabled")) {
701         DumpRenderTreeSupportGtk::setCSSGridLayoutEnabled(webkit_web_frame_get_web_view(mainFrame), booleanFromValue(valueAsString.get()));
702         return;
703     } else if (g_str_equal(originalName.get(), "WebKitCSSRegionsEnabled")) {
704         DumpRenderTreeSupportGtk::setCSSRegionsEnabled(webkit_web_frame_get_web_view(mainFrame), booleanFromValue(valueAsString.get()));
705         return;
706     } else if (g_str_equal(originalName.get(), "WebKitCSSCustomFilterEnabled")) {
707         DumpRenderTreeSupportGtk::setCSSCustomFilterEnabled(webkit_web_frame_get_web_view(mainFrame), booleanFromValue(valueAsString.get()));
708         return;
709     } else {
710         fprintf(stderr, "TestRunner::overridePreference tried to override "
711                 "unknown preference '%s'.\n", originalName.get());
712         return;
713     }
714
715     WebKitWebSettings* settings = webkit_web_view_get_settings(view);
716     GParamSpec* pspec = g_object_class_find_property(G_OBJECT_CLASS(
717         WEBKIT_WEB_SETTINGS_GET_CLASS(settings)), propertyName);
718     GValue currentPropertyValue = { 0, { { 0 } } };
719     g_value_init(&currentPropertyValue, pspec->value_type);
720
721     if (G_VALUE_HOLDS_STRING(&currentPropertyValue))
722         g_object_set(settings, propertyName, valueAsString.get(), NULL);
723     else if (G_VALUE_HOLDS_BOOLEAN(&currentPropertyValue))
724         g_object_set(G_OBJECT(settings), propertyName, booleanFromValue(valueAsString.get()), NULL);
725     else if (G_VALUE_HOLDS_INT(&currentPropertyValue))
726         g_object_set(G_OBJECT(settings), propertyName, atoi(valueAsString.get()), NULL);
727     else if (G_VALUE_HOLDS_FLOAT(&currentPropertyValue)) {
728         gfloat newValue = g_ascii_strtod(valueAsString.get(), 0);
729         g_object_set(G_OBJECT(settings), propertyName, newValue, NULL);
730     } else
731         fprintf(stderr, "TestRunner::overridePreference failed to override "
732                 "preference '%s'.\n", originalName.get());
733 }
734
735 void TestRunner::addUserScript(JSStringRef source, bool runAtStart, bool allFrames)
736 {
737     GOwnPtr<gchar> sourceCode(JSStringCopyUTF8CString(source));
738     DumpRenderTreeSupportGtk::addUserScript(mainFrame, sourceCode.get(), runAtStart, allFrames);
739 }
740
741 void TestRunner::addUserStyleSheet(JSStringRef source, bool allFrames)
742 {
743     GOwnPtr<gchar> sourceCode(JSStringCopyUTF8CString(source));
744     DumpRenderTreeSupportGtk::addUserStyleSheet(mainFrame, sourceCode.get(), allFrames);
745     // FIXME: needs more investigation why userscripts/user-style-top-frame-only.html fails when allFrames is false.
746
747 }
748
749 void TestRunner::setDeveloperExtrasEnabled(bool enabled)
750 {
751     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
752     WebKitWebSettings* webSettings = webkit_web_view_get_settings(webView);
753
754     g_object_set(webSettings, "enable-developer-extras", enabled, NULL);
755 }
756
757 void TestRunner::showWebInspector()
758 {
759     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
760     WebKitWebInspector* inspector = webkit_web_view_get_inspector(webView);
761
762     webkit_web_inspector_show(inspector);
763 }
764
765 void TestRunner::closeWebInspector()
766 {
767     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
768     WebKitWebInspector* inspector = webkit_web_view_get_inspector(webView);
769
770     webkit_web_inspector_close(inspector);
771 }
772
773 void TestRunner::evaluateInWebInspector(long callId, JSStringRef script)
774 {
775     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
776     WebKitWebInspector* inspector = webkit_web_view_get_inspector(webView);
777     char* scriptString = JSStringCopyUTF8CString(script);
778
779     webkit_web_inspector_execute_script(inspector, callId, scriptString);
780     g_free(scriptString);
781 }
782
783 void TestRunner::evaluateScriptInIsolatedWorldAndReturnValue(unsigned worldID, JSObjectRef globalObject, JSStringRef script)
784 {
785     // FIXME: Implement this.
786 }
787
788 void TestRunner::evaluateScriptInIsolatedWorld(unsigned worldID, JSObjectRef globalObject, JSStringRef script)
789 {
790     // FIXME: Implement this.
791 }
792
793 void TestRunner::removeAllVisitedLinks()
794 {
795     // FIXME: Implement this.
796 }
797
798 bool TestRunner::callShouldCloseOnWebView()
799 {
800     return DumpRenderTreeSupportGtk::shouldClose(mainFrame);
801 }
802
803 void TestRunner::apiTestNewWindowDataLoadBaseURL(JSStringRef utf8Data, JSStringRef baseURL)
804 {
805
806 }
807
808 void TestRunner::apiTestGoToCurrentBackForwardItem()
809 {
810
811 }
812
813 void TestRunner::setWebViewEditable(bool)
814 {
815 }
816
817 void TestRunner::authenticateSession(JSStringRef, JSStringRef, JSStringRef)
818 {
819 }
820
821 void TestRunner::abortModal()
822 {
823 }
824
825 void TestRunner::setSerializeHTTPLoads(bool serialize)
826 {
827     DumpRenderTreeSupportGtk::setSerializeHTTPLoads(serialize);
828 }
829
830 void TestRunner::setTextDirection(JSStringRef direction)
831 {
832     GOwnPtr<gchar> writingDirection(JSStringCopyUTF8CString(direction));
833
834     WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
835     ASSERT(view);
836
837     if (g_str_equal(writingDirection.get(), "auto"))
838         gtk_widget_set_direction(GTK_WIDGET(view), GTK_TEXT_DIR_NONE);
839     else if (g_str_equal(writingDirection.get(), "ltr"))
840         gtk_widget_set_direction(GTK_WIDGET(view), GTK_TEXT_DIR_LTR);
841     else if (g_str_equal(writingDirection.get(), "rtl"))
842         gtk_widget_set_direction(GTK_WIDGET(view), GTK_TEXT_DIR_RTL);
843     else
844         fprintf(stderr, "TestRunner::setTextDirection called with unknown direction: '%s'.\n", writingDirection.get());
845 }
846
847 void TestRunner::addChromeInputField()
848 {
849 }
850
851 void TestRunner::removeChromeInputField()
852 {
853 }
854
855 void TestRunner::focusWebView()
856 {
857 }
858
859 void TestRunner::setBackingScaleFactor(double)
860 {
861 }
862
863 void TestRunner::grantWebNotificationPermission(JSStringRef origin)
864 {
865 }
866
867 void TestRunner::denyWebNotificationPermission(JSStringRef jsOrigin)
868 {
869 }
870
871 void TestRunner::removeAllWebNotificationPermissions()
872 {
873 }
874
875 void TestRunner::simulateWebNotificationClick(JSValueRef jsNotification)
876 {
877 }
878
879 void TestRunner::simulateLegacyWebNotificationClick(JSStringRef title)
880 {
881 }
882
883 void TestRunner::resetPageVisibility()
884 {
885     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
886     DumpRenderTreeSupportGtk::setPageVisibility(webView, WebCore::PageVisibilityStateVisible, true);
887 }
888
889 void TestRunner::setPageVisibility(const char* visibility)
890 {
891     WebKitWebView* webView = webkit_web_frame_get_web_view(mainFrame);
892     String visibilityString(visibility);
893     WebCore::PageVisibilityState visibilityState = WebCore::PageVisibilityStateVisible;
894
895     if (visibilityString == "visible")
896         visibilityState = WebCore::PageVisibilityStateVisible;
897     else if (visibilityString == "hidden")
898         visibilityState = WebCore::PageVisibilityStateHidden;
899     else
900         return;
901
902     DumpRenderTreeSupportGtk::setPageVisibility(webView, visibilityState, false);
903 }
904
905 void TestRunner::setAutomaticLinkDetectionEnabled(bool)
906 {
907     // FIXME: Implement this.
908 }
909
910 void TestRunner::setStorageDatabaseIdleInterval(double)
911 {
912     // FIXME: Implement this.
913 }
914
915 void TestRunner::closeIdleLocalStorageDatabases()
916 {
917 }