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