[GTK] Remove unsupported AC backends
[WebKit-https.git] / Source / WebKit / gtk / webkit / webkitglobals.cpp
1 /*
2  * Copyright (C) 2007 Holger Hans Peter Freyther
3  * Copyright (C) 2008, 2010 Collabora Ltd.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  */
20
21 #include "config.h"
22 #include "webkitglobals.h"
23
24 #include "ApplicationCacheStorage.h"
25 #include "Chrome.h"
26 #include "ContextMenuItem.h"
27 #include "FrameNetworkingContextGtk.h"
28 #include "IconDatabase.h"
29 #include "InitializeLogging.h"
30 #include "MemoryCache.h"
31 #include "Page.h"
32 #include "PageCache.h"
33 #include "PageGroup.h"
34 #include "PlatformStrategiesGtk.h"
35 #include "TextEncodingRegistry.h"
36 #include "Pasteboard.h"
37 #include "PasteboardHelperGtk.h"
38 #include "ResourceHandle.h"
39 #include "ResourceHandleClient.h"
40 #include "ResourceHandleInternal.h"
41 #include "ResourceResponse.h"
42 #include "SchemeRegistry.h"
43 #include "webkitapplicationcache.h"
44 #include "webkitfavicondatabase.h"
45 #include "webkitglobalsprivate.h"
46 #include "webkiticondatabase.h"
47 #include "webkitspellchecker.h"
48 #include "webkitspellcheckerenchant.h"
49 #include "webkitwebdatabase.h"
50 #include "webkitwebplugindatabaseprivate.h"
51 #include <libintl.h>
52 #include <runtime/InitializeThreading.h>
53 #include <stdlib.h>
54 #include <wtf/MainThread.h>
55 #include <wtf/gobject/GOwnPtr.h>
56 #include <wtf/gobject/GRefPtr.h>
57
58 static WebKitCacheModel cacheModel = WEBKIT_CACHE_MODEL_DEFAULT;
59
60 using namespace WebCore;
61
62 /**
63  * SECTION:webkit
64  * @short_description: Global functions controlling WebKit
65  *
66  * WebKit manages many resources which are not related to specific
67  * views. These functions relate to cross-view limits, such as cache
68  * sizes, database quotas, and the HTTP session management.
69  */
70
71 /**
72  * webkit_get_default_session:
73  *
74  * Retrieves the default #SoupSession used by all web views.
75  * Note that the session features are added by WebKit on demand,
76  * so if you insert your own #SoupCookieJar before any network
77  * traffic occurs, WebKit will use it instead of the default.
78  *
79  * Return value: (transfer none): the default #SoupSession
80  *
81  * Since: 1.1.1
82  */
83 SoupSession* webkit_get_default_session ()
84 {
85     webkitInit();
86     return ResourceHandle::defaultSession();
87 }
88
89 /**
90  * webkit_set_cache_model:
91  * @cache_model: a #WebKitCacheModel
92  *
93  * Specifies a usage model for WebViews, which WebKit will use to
94  * determine its caching behavior. All web views follow the cache
95  * model. This cache model determines the RAM and disk space to use
96  * for caching previously viewed content .
97  *
98  * Research indicates that users tend to browse within clusters of
99  * documents that hold resources in common, and to revisit previously
100  * visited documents. WebKit and the frameworks below it include
101  * built-in caches that take advantage of these patterns,
102  * substantially improving document load speed in browsing
103  * situations. The WebKit cache model controls the behaviors of all of
104  * these caches, including various WebCore caches.
105  *
106  * Browsers can improve document load speed substantially by
107  * specifying WEBKIT_CACHE_MODEL_WEB_BROWSER. Applications without a
108  * browsing interface can reduce memory usage substantially by
109  * specifying WEBKIT_CACHE_MODEL_DOCUMENT_VIEWER. Default value is
110  * WEBKIT_CACHE_MODEL_WEB_BROWSER.
111  *
112  * Since: 1.1.18
113  */
114 void webkit_set_cache_model(WebKitCacheModel model)
115 {
116     webkitInit();
117
118     if (cacheModel == model)
119         return;
120
121     // FIXME: Add disk cache handling when soup has the API
122     guint cacheTotalCapacity;
123     guint cacheMinDeadCapacity;
124     guint cacheMaxDeadCapacity;
125     gdouble deadDecodedDataDeletionInterval;
126     guint pageCacheCapacity;
127
128     // FIXME: The Mac port calculates these values based on the amount of physical memory that's
129     // installed on the system. Currently these values match the Mac port for users with more than
130     // 512 MB and less than 1024 MB of physical memory.
131     switch (model) {
132     case WEBKIT_CACHE_MODEL_DOCUMENT_VIEWER:
133         pageCacheCapacity = 0;
134         cacheTotalCapacity = 0; // FIXME: The Mac port actually sets this to larger than 0.
135         cacheMinDeadCapacity = 0;
136         cacheMaxDeadCapacity = 0;
137         deadDecodedDataDeletionInterval = 0;
138         break;
139     case WEBKIT_CACHE_MODEL_DOCUMENT_BROWSER:
140         pageCacheCapacity = 2;
141         cacheTotalCapacity = 16 * 1024 * 1024;
142         cacheMinDeadCapacity = cacheTotalCapacity / 8;
143         cacheMaxDeadCapacity = cacheTotalCapacity / 4;
144         deadDecodedDataDeletionInterval = 0;
145         break;
146     case WEBKIT_CACHE_MODEL_WEB_BROWSER:
147         // Page cache capacity (in pages). Comment from Mac port:
148         // (Research indicates that value / page drops substantially after 3 pages.)
149         pageCacheCapacity = 3;
150         cacheTotalCapacity = 32 * 1024 * 1024;
151         cacheMinDeadCapacity = cacheTotalCapacity / 4;
152         cacheMaxDeadCapacity = cacheTotalCapacity / 2;
153         deadDecodedDataDeletionInterval = 60;
154         break;
155     default:
156         g_return_if_reached();
157     }
158
159     memoryCache()->setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
160     memoryCache()->setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
161     pageCache()->setCapacity(pageCacheCapacity);
162     cacheModel = model;
163 }
164
165 /**
166  * webkit_get_cache_model:
167  *
168  * Returns the current cache model. For more information about this
169  * value check the documentation of the function
170  * webkit_set_cache_model().
171  *
172  * Return value: the current #WebKitCacheModel
173  *
174  * Since: 1.1.18
175  */
176 WebKitCacheModel webkit_get_cache_model()
177 {
178     webkitInit();
179     return cacheModel;
180 }
181
182 /**
183  * webkit_get_web_plugin_database:
184  *
185  * Returns the current #WebKitWebPluginDatabase with information about
186  * all the plugins WebKit knows about in this instance.
187  *
188  * Return value: (transfer none): the current #WebKitWebPluginDatabase
189  *
190  * Since: 1.3.8
191  */
192 WebKitWebPluginDatabase* webkit_get_web_plugin_database()
193 {
194     static WebKitWebPluginDatabase* database = 0;
195
196     webkitInit();
197
198     if (!database)
199         database = webkit_web_plugin_database_new();
200
201     return database;
202 }
203
204 /**
205  * webkit_get_icon_database:
206  *
207  * Returns the #WebKitIconDatabase providing access to website icons.
208  *
209  * Return value: (transfer none): the current #WebKitIconDatabase
210  *
211  * Since: 1.3.13
212  *
213  * Deprecated: 1.8: Use webkit_get_favicon_database() instead
214  */
215 WebKitIconDatabase* webkit_get_icon_database()
216 {
217     webkitInit();
218
219     static WebKitIconDatabase* database = 0;
220     if (!database)
221         database = WEBKIT_ICON_DATABASE(g_object_new(WEBKIT_TYPE_ICON_DATABASE, NULL));
222
223     return database;
224 }
225
226 /**
227  * webkit_get_favicon_database:
228  *
229  * Returns the #WebKitFaviconDatabase providing access to website
230  * icons.
231  *
232  * Return value: (transfer none): the current #WebKitFaviconDatabase
233  *
234  * Since: 1.8
235  */
236 WebKitFaviconDatabase* webkit_get_favicon_database()
237 {
238     webkitInit();
239
240     static WebKitFaviconDatabase* database = 0;
241     if (!database)
242         database = WEBKIT_FAVICON_DATABASE(g_object_new(WEBKIT_TYPE_FAVICON_DATABASE, NULL));
243
244     return database;
245 }
246
247 static GRefPtr<WebKitSpellChecker> textChecker = 0;
248
249 static void webkitExit()
250 {
251     g_object_unref(webkit_get_default_session());
252 #if ENABLE(ICONDATABASE)
253     g_object_unref(webkit_get_favicon_database());
254 #endif
255     textChecker = 0;
256 }
257
258 /**
259  * webkit_get_text_checker:
260  *
261  * Returns: (transfer none): the #WebKitSpellChecker used by WebKit, or %NULL if spell
262  * checking is not enabled
263  *
264  * Since: 1.5.1
265  **/
266 GObject* webkit_get_text_checker()
267 {
268     webkitInit();
269
270 #if ENABLE(SPELLCHECK)
271     if (!textChecker)
272         textChecker = adoptGRef(WEBKIT_SPELL_CHECKER(g_object_new(WEBKIT_TYPE_SPELL_CHECKER_ENCHANT, NULL)));
273 #endif
274
275     return G_OBJECT(textChecker.get());
276 }
277
278 /**
279  * webkit_set_text_checker:
280  * @checker: a #WebKitSpellChecker or %NULL
281  *
282  * Sets @checker as the spell checker to be used by WebKit. The API
283  * accepts GObject since in the future we might accept objects
284  * implementing multiple interfaces (for example, spell checking and
285  * grammar checking).
286  *
287  * Since: 1.5.1
288  **/
289 void webkit_set_text_checker(GObject* checker)
290 {
291     g_return_if_fail(!checker || WEBKIT_IS_SPELL_CHECKER(checker));
292
293     webkitInit();
294
295     // We need to do this because we need the cast, and casting NULL
296     // is not kosher.
297     textChecker = checker ? WEBKIT_SPELL_CHECKER(checker) : 0;
298 }
299
300 /**
301  * webkit_context_menu_item_get_action:
302  * @item: a #GtkMenuItem of the default context menu
303  *
304  * Returns the #WebKitContextMenuAction of the given @item. This function
305  * can be used to determine the items present in the default context menu.
306  * In order to inspect the default context menu, you should connect to
307  * #WebKitWebView::context-menu signal.
308  *
309  * <example>
310  * <title>Inspecting the default context menu</title>
311  * <programlisting>
312  * static gboolean context_menu_cb (WebKitWebView       *webView,
313  *                                  GtkWidget           *default_menu,
314  *                                  WebKitHitTestResult *hit_test_result,
315  *                                  gboolean             triggered_with_keyboard,
316  *                                  gpointer             user_data)
317  * {
318  *     GList *items = gtk_container_get_children (GTK_CONTAINER (default_menu));
319  *     GList *l;
320  *     GtkAction *action;
321  *     GtkWidget *sub_menu;
322  *
323  *     for (l = items; l; l = g_list_next (l)) {
324  *         GtkMenuItem *item = (GtkMenuItem *)l->data;
325  *
326  *         if (GTK_IS_SEPARATOR_MENU_ITEM (item)) {
327  *             /&ast; It's  separator, do nothing &ast;/
328  *             continue;
329  *         }
330  *
331  *         switch (webkit_context_menu_item_get_action (item)) {
332  *         case WEBKIT_CONTEXT_MENU_ACTION_NO_ACTION:
333  *             /&ast; No action for this item &ast;/
334  *             break;
335  *         /&ast; Don't allow to ope links from context menu &ast;/
336  *         case WEBKIT_CONTEXT_MENU_ACTION_OPEN_LINK:
337  *         case WEBKIT_CONTEXT_MENU_ACTION_OPEN_LINK_IN_NEW_WINDOW:
338  *             action = gtk_activatable_get_related_action (GTK_ACTIVATABLE (item));
339  *             gtk_action_set_sensitive (action, FALSE);
340  *             break;
341  *         default:
342  *             break;
343  *         }
344  *
345  *         sub_menu = gtk_menu_item_get_submenu (item);
346  *         if (sub_menu) {
347  *             GtkWidget *menu_item;
348  *
349  *             /&ast; Add custom action to submenu &ast;/
350  *             action = gtk_action_new ("CustomItemName", "Custom Action", NULL, NULL);
351  *             g_signal_connect (action, "activate", G_CALLBACK (custom_menu_item_activated), NULL);
352  *
353  *             menu_item = gtk_action_create_menu_item (action);
354  *             g_object_unref (action);
355  *             gtk_menu_shell_append (GTK_MENU_SHELL (sub_menu), menu_item);
356  *             gtk_widget_show (menu_item);
357  *         }
358  *     }
359  *
360  *     g_list_free(items);
361  * }
362  * </programlisting>
363  * </example>
364  *
365  * Note that you can get the #GtkAction of any item in the default context menu with
366  * gtk_activatable_get_related_action().
367  *
368  * Returns: the #WebKitContextMenuAction of the given @item
369  *
370  * Since: 1.10
371  */
372 WebKitContextMenuAction webkit_context_menu_item_get_action(GtkMenuItem* item)
373 {
374 #if ENABLE(CONTEXT_MENUS)
375     g_return_val_if_fail(GTK_IS_MENU_ITEM(item), WEBKIT_CONTEXT_MENU_ACTION_NO_ACTION);
376
377     ContextMenuItem menuItem(item);
378     switch (menuItem.action()) {
379     case ContextMenuItemTagNoAction:
380         return WEBKIT_CONTEXT_MENU_ACTION_NO_ACTION;
381     case ContextMenuItemTagOpenLink:
382         return WEBKIT_CONTEXT_MENU_ACTION_OPEN_LINK;
383     case ContextMenuItemTagOpenLinkInNewWindow:
384         return WEBKIT_CONTEXT_MENU_ACTION_OPEN_LINK_IN_NEW_WINDOW;
385     case ContextMenuItemTagDownloadLinkToDisk:
386         return WEBKIT_CONTEXT_MENU_ACTION_DOWNLOAD_LINK_TO_DISK;
387     case ContextMenuItemTagCopyLinkToClipboard:
388         return WEBKIT_CONTEXT_MENU_ACTION_COPY_LINK_TO_CLIPBOARD;
389     case ContextMenuItemTagOpenImageInNewWindow:
390         return WEBKIT_CONTEXT_MENU_ACTION_OPEN_IMAGE_IN_NEW_WINDOW;
391     case ContextMenuItemTagDownloadImageToDisk:
392         return WEBKIT_CONTEXT_MENU_ACTION_DOWNLOAD_IMAGE_TO_DISK;
393     case ContextMenuItemTagCopyImageToClipboard:
394         return WEBKIT_CONTEXT_MENU_ACTION_COPY_IMAGE_TO_CLIPBOARD;
395     case ContextMenuItemTagCopyImageUrlToClipboard:
396         return WEBKIT_CONTEXT_MENU_ACTION_COPY_IMAGE_URL_TO_CLIPBOARD;
397     case ContextMenuItemTagOpenFrameInNewWindow:
398         return WEBKIT_CONTEXT_MENU_ACTION_OPEN_FRAME_IN_NEW_WINDOW;
399     case ContextMenuItemTagGoBack:
400         return WEBKIT_CONTEXT_MENU_ACTION_GO_BACK;
401     case ContextMenuItemTagGoForward:
402         return WEBKIT_CONTEXT_MENU_ACTION_GO_FORWARD;
403     case ContextMenuItemTagStop:
404         return WEBKIT_CONTEXT_MENU_ACTION_STOP;
405     case ContextMenuItemTagReload:
406         return WEBKIT_CONTEXT_MENU_ACTION_RELOAD;
407     case ContextMenuItemTagCopy:
408         return WEBKIT_CONTEXT_MENU_ACTION_COPY;
409     case ContextMenuItemTagCut:
410         return WEBKIT_CONTEXT_MENU_ACTION_CUT;
411     case ContextMenuItemTagPaste:
412         return WEBKIT_CONTEXT_MENU_ACTION_PASTE;
413     case ContextMenuItemTagDelete:
414         return WEBKIT_CONTEXT_MENU_ACTION_DELETE;
415     case ContextMenuItemTagSelectAll:
416         return WEBKIT_CONTEXT_MENU_ACTION_SELECT_ALL;
417     case ContextMenuItemTagInputMethods:
418         return WEBKIT_CONTEXT_MENU_ACTION_INPUT_METHODS;
419     case ContextMenuItemTagUnicode:
420         return WEBKIT_CONTEXT_MENU_ACTION_UNICODE;
421     case ContextMenuItemTagSpellingGuess:
422         return WEBKIT_CONTEXT_MENU_ACTION_SPELLING_GUESS;
423     case ContextMenuItemTagIgnoreSpelling:
424         return WEBKIT_CONTEXT_MENU_ACTION_IGNORE_SPELLING;
425     case ContextMenuItemTagLearnSpelling:
426         return WEBKIT_CONTEXT_MENU_ACTION_LEARN_SPELLING;
427     case ContextMenuItemTagIgnoreGrammar:
428         return WEBKIT_CONTEXT_MENU_ACTION_IGNORE_GRAMMAR;
429     case ContextMenuItemTagFontMenu:
430         return WEBKIT_CONTEXT_MENU_ACTION_FONT_MENU;
431     case ContextMenuItemTagBold:
432         return WEBKIT_CONTEXT_MENU_ACTION_BOLD;
433     case ContextMenuItemTagItalic:
434         return WEBKIT_CONTEXT_MENU_ACTION_ITALIC;
435     case ContextMenuItemTagUnderline:
436         return WEBKIT_CONTEXT_MENU_ACTION_UNDERLINE;
437     case ContextMenuItemTagOutline:
438         return WEBKIT_CONTEXT_MENU_ACTION_OUTLINE;
439     case ContextMenuItemTagInspectElement:
440         return WEBKIT_CONTEXT_MENU_ACTION_INSPECT_ELEMENT;
441     case ContextMenuItemTagOpenMediaInNewWindow:
442         return WEBKIT_CONTEXT_MENU_ACTION_OPEN_MEDIA_IN_NEW_WINDOW;
443     case ContextMenuItemTagCopyMediaLinkToClipboard:
444         return WEBKIT_CONTEXT_MENU_ACTION_COPY_MEDIA_LINK_TO_CLIPBOARD;
445     case ContextMenuItemTagToggleMediaControls:
446         return WEBKIT_CONTEXT_MENU_ACTION_TOGGLE_MEDIA_CONTROLS;
447     case ContextMenuItemTagToggleMediaLoop:
448         return WEBKIT_CONTEXT_MENU_ACTION_TOGGLE_MEDIA_LOOP;
449     case ContextMenuItemTagEnterVideoFullscreen:
450         return WEBKIT_CONTEXT_MENU_ACTION_ENTER_VIDEO_FULLSCREEN;
451     case ContextMenuItemTagMediaPlayPause:
452         return WEBKIT_CONTEXT_MENU_ACTION_MEDIA_PLAY_PAUSE;
453     case ContextMenuItemTagMediaMute:
454         return WEBKIT_CONTEXT_MENU_ACTION_MEDIA_MUTE;
455     default:
456         g_assert_not_reached();
457     }
458 #else
459     return WEBKIT_CONTEXT_MENU_ACTION_NO_ACTION;
460 #endif
461 }
462
463 /**
464  * webkit_set_security_policy_for_uri_scheme:
465  * @scheme: a URI scheme
466  * @policy: a #WebKitSecurityPolicy
467  *
468  * Set the security policy for the given URI scheme.
469  *
470  * Since: 2.0
471  */
472 void webkit_set_security_policy_for_uri_scheme(const char *scheme, WebKitSecurityPolicy policy)
473 {
474     g_return_if_fail(scheme);
475
476     if (!policy)
477         return;
478
479     String urlScheme = String::fromUTF8(scheme);
480
481     if (policy & WEBKIT_SECURITY_POLICY_LOCAL)
482         SchemeRegistry::registerURLSchemeAsLocal(urlScheme);
483     if (policy & WEBKIT_SECURITY_POLICY_NO_ACCESS_TO_OTHER_SCHEME)
484         SchemeRegistry::registerURLSchemeAsNoAccess(urlScheme);
485     if (policy & WEBKIT_SECURITY_POLICY_DISPLAY_ISOLATED)
486         SchemeRegistry::registerURLSchemeAsDisplayIsolated(urlScheme);
487     if (policy & WEBKIT_SECURITY_POLICY_SECURE)
488         SchemeRegistry::registerURLSchemeAsSecure(urlScheme);
489     if (policy & WEBKIT_SECURITY_POLICY_CORS_ENABLED)
490         SchemeRegistry::registerURLSchemeAsCORSEnabled(urlScheme);
491     if (policy & WEBKIT_SECURITY_POLICY_EMPTY_DOCUMENT)
492         SchemeRegistry::registerURLSchemeAsEmptyDocument(urlScheme);
493 }
494
495 /**
496  * webkit_get_security_policy_for_uri_scheme:
497  * @scheme: a URI scheme
498  *
499  * Get the security policy for the given URI scheme.
500  *
501  * Returns: a #WebKitSecurityPolicy
502  *
503  * Since: 2.0
504  */
505 WebKitSecurityPolicy webkit_get_security_policy_for_uri_scheme(const char *scheme)
506 {
507     g_return_val_if_fail(scheme, static_cast<WebKitSecurityPolicy>(0));
508
509     guint policy = 0;
510     String urlScheme = String::fromUTF8(scheme);
511
512     if (SchemeRegistry::shouldTreatURLSchemeAsLocal(urlScheme))
513         policy |= WEBKIT_SECURITY_POLICY_LOCAL;
514     if (SchemeRegistry::shouldTreatURLSchemeAsNoAccess(urlScheme))
515         policy |= WEBKIT_SECURITY_POLICY_NO_ACCESS_TO_OTHER_SCHEME;
516     if (SchemeRegistry::shouldTreatURLSchemeAsDisplayIsolated(urlScheme))
517         policy |= WEBKIT_SECURITY_POLICY_DISPLAY_ISOLATED;
518     if (SchemeRegistry::shouldTreatURLSchemeAsSecure(urlScheme))
519         policy |= WEBKIT_SECURITY_POLICY_SECURE;
520     if (SchemeRegistry::shouldTreatURLSchemeAsCORSEnabled(urlScheme))
521         policy |= WEBKIT_SECURITY_POLICY_CORS_ENABLED;
522     if (SchemeRegistry::shouldLoadURLSchemeAsEmptyDocument(urlScheme))
523         policy |= WEBKIT_SECURITY_POLICY_EMPTY_DOCUMENT;
524
525     return static_cast<WebKitSecurityPolicy>(policy);
526 }
527
528 void webkitInit()
529 {
530     static bool isInitialized = false;
531     if (isInitialized)
532         return;
533     isInitialized = true;
534
535     bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
536     bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
537
538     JSC::initializeThreading();
539     WTF::initializeMainThread();
540
541 #if !LOG_DISABLED
542     WebCore::initializeLoggingChannelsIfNecessary();
543 #endif // !LOG_DISABLED
544     PlatformStrategiesGtk::initialize();
545
546     // We make sure the text codecs have been initialized, because
547     // that may only be done by the main thread.
548     atomicCanonicalTextEncodingName("UTF-8");
549
550     GOwnPtr<gchar> databaseDirectory(g_build_filename(g_get_user_data_dir(), "webkit", "databases", NULL));
551     webkit_set_web_database_directory_path(databaseDirectory.get());
552
553     GOwnPtr<gchar> cacheDirectory(g_build_filename(g_get_user_cache_dir(), "webkitgtk", "applications", NULL));
554     WebCore::cacheStorage().setCacheDirectory(cacheDirectory.get());
555
556     PageGroup::setShouldTrackVisitedLinks(true);
557
558     GOwnPtr<gchar> iconDatabasePath(g_build_filename(g_get_user_data_dir(), "webkit", "icondatabase", NULL));
559     webkit_icon_database_set_path(webkit_get_icon_database(), iconDatabasePath.get());
560
561     WebCore::ResourceHandle::setIgnoreSSLErrors(true);
562
563     atexit(webkitExit);
564 }
565
566 const char* webkitPageGroupName()
567 {
568     return "org.webkit.gtk.WebKitGTK";
569 }