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