c5b8a4e89fa4d7105456951ddd7c0c3fcc7651f6
[WebKit-https.git] / Tools / MiniBrowser / gtk / main.c
1 /*
2  * Copyright (C) 2006, 2007 Apple Inc.
3  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
4  * Copyright (C) 2011 Igalia S.L.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27
28 #include "cmakeconfig.h"
29
30 #include "BrowserWindow.h"
31 #include <JavaScriptCore/JavaScript.h>
32 #include <errno.h>
33 #include <gtk/gtk.h>
34 #include <string.h>
35 #include <webkit2/webkit2.h>
36
37 #define MINI_BROWSER_ERROR (miniBrowserErrorQuark())
38
39 static const gchar **uriArguments = NULL;
40 static const gchar **ignoreHosts = NULL;
41 static GdkRGBA *backgroundColor;
42 static gboolean editorMode;
43 static const char *sessionFile;
44 static char *geometry;
45 static gboolean privateMode;
46 static gboolean automationMode;
47 static gboolean fullScreen;
48 static gboolean enableIntelligentTrackingPrevention;
49 static const char *proxy;
50
51 typedef enum {
52     MINI_BROWSER_ERROR_INVALID_ABOUT_PATH
53 } MiniBrowserError;
54
55 static GQuark miniBrowserErrorQuark()
56 {
57     return g_quark_from_string("minibrowser-quark");
58 }
59
60 static gchar *argumentToURL(const char *filename)
61 {
62     GFile *gfile = g_file_new_for_commandline_arg(filename);
63     gchar *fileURL = g_file_get_uri(gfile);
64     g_object_unref(gfile);
65
66     return fileURL;
67 }
68
69 static WebKitWebView *createBrowserTab(BrowserWindow *window, WebKitSettings *webkitSettings, WebKitUserContentManager *userContentManager)
70 {
71     WebKitWebView *webView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
72         "web-context", browser_window_get_web_context(window),
73         "settings", webkitSettings,
74         "user-content-manager", userContentManager,
75         "is-controlled-by-automation", automationMode,
76         NULL));
77
78     if (editorMode)
79         webkit_web_view_set_editable(webView, TRUE);
80
81     browser_window_append_view(window, webView);
82     return webView;
83 }
84
85 static gboolean parseBackgroundColor(const char *optionName, const char *value, gpointer data, GError **error)
86 {
87     GdkRGBA rgba;
88     if (gdk_rgba_parse(&rgba, value)) {
89         backgroundColor = gdk_rgba_copy(&rgba);
90         return TRUE;
91     }
92
93     g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, "Failed to parse '%s' as RGBA color", value);
94     return FALSE;
95 }
96
97 static const GOptionEntry commandLineOptions[] =
98 {
99     { "bg-color", 0, 0, G_OPTION_ARG_CALLBACK, parseBackgroundColor, "Background color", NULL },
100     { "editor-mode", 'e', 0, G_OPTION_ARG_NONE, &editorMode, "Run in editor mode", NULL },
101     { "session-file", 's', 0, G_OPTION_ARG_FILENAME, &sessionFile, "Session file", "FILE" },
102     { "geometry", 'g', 0, G_OPTION_ARG_STRING, &geometry, "Set the size and position of the window (WIDTHxHEIGHT+X+Y)", "GEOMETRY" },
103     { "full-screen", 'f', 0, G_OPTION_ARG_NONE, &fullScreen, "Set the window to full-screen mode", NULL },
104     { "private", 'p', 0, G_OPTION_ARG_NONE, &privateMode, "Run in private browsing mode", NULL },
105     { "automation", 0, 0, G_OPTION_ARG_NONE, &automationMode, "Run in automation mode", NULL },
106     { "enable-itp", 0, 0, G_OPTION_ARG_NONE, &enableIntelligentTrackingPrevention, "Enable intelligent tracking prevention", NULL },
107     { "proxy", 0, 0, G_OPTION_ARG_STRING, &proxy, "Set proxy", "PROXY" },
108     { "ignore-host", 0, 0, G_OPTION_ARG_STRING_ARRAY, &ignoreHosts, "Set proxy ignore hosts", "HOSTS" },
109     { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &uriArguments, 0, "[URL…]" },
110     { 0, 0, 0, 0, 0, 0, 0 }
111 };
112
113 static gboolean parseOptionEntryCallback(const gchar *optionNameFull, const gchar *value, WebKitSettings *webSettings, GError **error)
114 {
115     if (strlen(optionNameFull) <= 2) {
116         g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, "Invalid option %s", optionNameFull);
117         return FALSE;
118     }
119
120     /* We have two -- in option name so remove them. */
121     const gchar *optionName = optionNameFull + 2;
122     GParamSpec *spec = g_object_class_find_property(G_OBJECT_GET_CLASS(webSettings), optionName);
123     if (!spec) {
124         g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, "Cannot find web settings for option %s", optionNameFull);
125         return FALSE;
126     }
127
128     switch (G_PARAM_SPEC_VALUE_TYPE(spec)) {
129     case G_TYPE_BOOLEAN: {
130         gboolean propertyValue = !(value && g_ascii_strcasecmp(value, "true") && strcmp(value, "1"));
131         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
132         break;
133     }
134     case G_TYPE_STRING:
135         g_object_set(G_OBJECT(webSettings), optionName, value, NULL);
136         break;
137     case G_TYPE_INT: {
138         glong propertyValue;
139         gchar *end;
140
141         errno = 0;
142         propertyValue = g_ascii_strtoll(value, &end, 0);
143         if (errno == ERANGE || propertyValue > G_MAXINT || propertyValue < G_MININT) {
144             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Integer value '%s' for %s out of range", value, optionNameFull);
145             return FALSE;
146         }
147         if (errno || value == end) {
148             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Cannot parse integer value '%s' for %s", value, optionNameFull);
149             return FALSE;
150         }
151         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
152         break;
153     }
154     case G_TYPE_FLOAT: {
155         gdouble propertyValue;
156         gchar *end;
157
158         errno = 0;
159         propertyValue = g_ascii_strtod(value, &end);
160         if (errno == ERANGE || propertyValue > G_MAXFLOAT || propertyValue < G_MINFLOAT) {
161             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Float value '%s' for %s out of range", value, optionNameFull);
162             return FALSE;
163         }
164         if (errno || value == end) {
165             g_set_error(error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Cannot parse float value '%s' for %s", value, optionNameFull);
166             return FALSE;
167         }
168         g_object_set(G_OBJECT(webSettings), optionName, propertyValue, NULL);
169         break;
170     }
171     default:
172         g_assert_not_reached();
173     }
174
175     return TRUE;
176 }
177
178 static gboolean isValidParameterType(GType gParamType)
179 {
180     return (gParamType == G_TYPE_BOOLEAN || gParamType == G_TYPE_STRING || gParamType == G_TYPE_INT
181             || gParamType == G_TYPE_FLOAT);
182 }
183
184 static GOptionEntry* getOptionEntriesFromWebKitSettings(WebKitSettings *webSettings)
185 {
186     GParamSpec **propertySpecs;
187     GOptionEntry *optionEntries;
188     guint numProperties, numEntries, i;
189
190     propertySpecs = g_object_class_list_properties(G_OBJECT_GET_CLASS(webSettings), &numProperties);
191     if (!propertySpecs)
192         return NULL;
193
194     optionEntries = g_new0(GOptionEntry, numProperties + 1);
195     numEntries = 0;
196     for (i = 0; i < numProperties; i++) {
197         GParamSpec *param = propertySpecs[i];
198
199         /* Fill in structures only for writable and not construct-only properties. */
200         if (!param || !(param->flags & G_PARAM_WRITABLE) || (param->flags & G_PARAM_CONSTRUCT_ONLY))
201             continue;
202
203         GType gParamType = G_PARAM_SPEC_VALUE_TYPE(param);
204         if (!isValidParameterType(gParamType))
205             continue;
206
207         GOptionEntry *optionEntry = &optionEntries[numEntries++];
208         optionEntry->long_name = g_param_spec_get_name(param);
209
210         /* There is no easy way to figure our short name for generated option entries.
211            optionEntry.short_name=*/
212         /* For bool arguments "enable" type make option argument not required. */
213         if (gParamType == G_TYPE_BOOLEAN && (strstr(optionEntry->long_name, "enable")))
214             optionEntry->flags = G_OPTION_FLAG_OPTIONAL_ARG;
215         optionEntry->arg = G_OPTION_ARG_CALLBACK;
216         optionEntry->arg_data = parseOptionEntryCallback;
217         optionEntry->description = g_param_spec_get_blurb(param);
218         optionEntry->arg_description = g_type_name(gParamType);
219     }
220     g_free(propertySpecs);
221
222     return optionEntries;
223 }
224
225 static gboolean addSettingsGroupToContext(GOptionContext *context, WebKitSettings* webkitSettings)
226 {
227     GOptionEntry *optionEntries = getOptionEntriesFromWebKitSettings(webkitSettings);
228     if (!optionEntries)
229         return FALSE;
230
231     GOptionGroup *webSettingsGroup = g_option_group_new("websettings",
232                                                         "WebKitSettings writable properties for default WebKitWebView",
233                                                         "WebKitSettings properties",
234                                                         webkitSettings,
235                                                         NULL);
236     g_option_group_add_entries(webSettingsGroup, optionEntries);
237     g_free(optionEntries);
238
239     /* Option context takes ownership of the group. */
240     g_option_context_add_group(context, webSettingsGroup);
241
242     return TRUE;
243 }
244
245 typedef struct {
246     WebKitURISchemeRequest *request;
247     GList *dataList;
248     GHashTable *dataMap;
249 } AboutDataRequest;
250
251 static GHashTable *aboutDataRequestMap;
252
253 static void aboutDataRequestFree(AboutDataRequest *request)
254 {
255     if (!request)
256         return;
257
258     g_list_free_full(request->dataList, g_object_unref);
259
260     if (request->request)
261         g_object_unref(request->request);
262     if (request->dataMap)
263         g_hash_table_destroy(request->dataMap);
264
265     g_slice_free(AboutDataRequest, request);
266 }
267
268 static AboutDataRequest* aboutDataRequestNew(WebKitURISchemeRequest *uriRequest)
269 {
270     if (!aboutDataRequestMap)
271         aboutDataRequestMap = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)aboutDataRequestFree);
272
273     AboutDataRequest *request = g_slice_new0(AboutDataRequest);
274     request->request = g_object_ref(uriRequest);
275     g_hash_table_insert(aboutDataRequestMap, GUINT_TO_POINTER(webkit_web_view_get_page_id(webkit_uri_scheme_request_get_web_view(request->request))), request);
276
277     return request;
278 }
279
280 static AboutDataRequest *aboutDataRequestForView(guint64 pageID)
281 {
282     return aboutDataRequestMap ? g_hash_table_lookup(aboutDataRequestMap, GUINT_TO_POINTER(pageID)) : NULL;
283 }
284
285 static void websiteDataRemovedCallback(WebKitWebsiteDataManager *manager, GAsyncResult *result, AboutDataRequest *dataRequest)
286 {
287     if (webkit_website_data_manager_remove_finish(manager, result, NULL))
288         webkit_web_view_reload(webkit_uri_scheme_request_get_web_view(dataRequest->request));
289 }
290
291 static void websiteDataClearedCallback(WebKitWebsiteDataManager *manager, GAsyncResult *result, AboutDataRequest *dataRequest)
292 {
293     if (webkit_website_data_manager_clear_finish(manager, result, NULL))
294         webkit_web_view_reload(webkit_uri_scheme_request_get_web_view(dataRequest->request));
295 }
296
297 static void aboutDataScriptMessageReceivedCallback(WebKitUserContentManager *userContentManager, WebKitJavascriptResult *message, WebKitWebContext *webContext)
298 {
299     JSValueRef jsValue = webkit_javascript_result_get_value(message);
300     JSStringRef jsString = JSValueToStringCopy(webkit_javascript_result_get_global_context(message), jsValue, NULL);
301     size_t maxSize = JSStringGetMaximumUTF8CStringSize(jsString);
302     if (!maxSize) {
303         JSStringRelease(jsString);
304         return;
305     }
306     char *messageString = g_malloc(maxSize);
307     JSStringGetUTF8CString(jsString, messageString, maxSize);
308     JSStringRelease(jsString);
309
310     char **tokens = g_strsplit(messageString, ":", 3);
311     g_free(messageString);
312
313     unsigned tokenCount = g_strv_length(tokens);
314     if (!tokens || tokenCount < 2) {
315         g_strfreev(tokens);
316         return;
317     }
318
319     guint64 pageID = g_ascii_strtoull(tokens[0], NULL, 10);
320     AboutDataRequest *dataRequest = aboutDataRequestForView(pageID);
321     if (!dataRequest) {
322         g_strfreev(tokens);
323         return;
324     }
325
326     WebKitWebsiteDataManager *manager = webkit_web_context_get_website_data_manager(webContext);
327     guint64 types = g_ascii_strtoull(tokens[1], NULL, 10);
328     if (tokenCount == 2)
329         webkit_website_data_manager_clear(manager, types, 0, NULL, (GAsyncReadyCallback)websiteDataClearedCallback, dataRequest);
330     else {
331         guint64 domainID = g_ascii_strtoull(tokens[2], NULL, 10);
332         GList *dataList = g_hash_table_lookup(dataRequest->dataMap, GUINT_TO_POINTER(types));
333         WebKitWebsiteData *data = g_list_nth_data(dataList, domainID);
334         if (data) {
335             GList dataList = { data, NULL, NULL };
336             webkit_website_data_manager_remove(manager, types, &dataList, NULL, (GAsyncReadyCallback)websiteDataRemovedCallback, dataRequest);
337         }
338     }
339     g_strfreev(tokens);
340 }
341
342 static void domainListFree(GList *domains)
343 {
344     g_list_free_full(domains, (GDestroyNotify)webkit_website_data_unref);
345 }
346
347 static void aboutDataFillTable(GString *result, AboutDataRequest *dataRequest, GList* dataList, const char *title, WebKitWebsiteDataTypes types, const char *dataPath, guint64 pageID)
348 {
349     guint64 totalDataSize = 0;
350     GList *domains = NULL;
351     GList *l;
352     for (l = dataList; l; l = g_list_next(l)) {
353         WebKitWebsiteData *data = (WebKitWebsiteData *)l->data;
354
355         if (webkit_website_data_get_types(data) & types) {
356             domains = g_list_prepend(domains, webkit_website_data_ref(data));
357             totalDataSize += webkit_website_data_get_size(data, types);
358         }
359     }
360     if (!domains)
361         return;
362
363     if (!dataRequest->dataMap)
364         dataRequest->dataMap = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, (GDestroyNotify)domainListFree);
365     g_hash_table_insert(dataRequest->dataMap, GUINT_TO_POINTER(types), domains);
366
367     if (totalDataSize) {
368         char *totalDataSizeStr = g_format_size(totalDataSize);
369         g_string_append_printf(result, "<h1>%s (%s)</h1>\n<table>\n", title, totalDataSizeStr);
370         g_free(totalDataSizeStr);
371     } else
372         g_string_append_printf(result, "<h1>%s</h1>\n<table>\n", title);
373     if (dataPath)
374         g_string_append_printf(result, "<tr><td colspan=\"2\">Path: %s</td></tr>\n", dataPath);
375
376     unsigned index;
377     for (l = domains, index = 0; l; l = g_list_next(l), index++) {
378         WebKitWebsiteData *data = (WebKitWebsiteData *)l->data;
379         const char *displayName = webkit_website_data_get_name(data);
380         guint64 dataSize = webkit_website_data_get_size(data, types);
381         if (dataSize) {
382             char *dataSizeStr = g_format_size(dataSize);
383             g_string_append_printf(result, "<tr><td>%s (%s)</td>", displayName, dataSizeStr);
384             g_free(dataSizeStr);
385         } else
386             g_string_append_printf(result, "<tr><td>%s</td>", displayName);
387         g_string_append_printf(result, "<td><input type=\"button\" value=\"Remove\" onclick=\"removeData('%"G_GUINT64_FORMAT":%u:%u');\"></td></tr>\n",
388             pageID, types, index);
389     }
390     g_string_append_printf(result, "<tr><td><input type=\"button\" value=\"Clear all\" onclick=\"clearData('%"G_GUINT64_FORMAT":%u');\"></td></tr></table>\n",
391         pageID, types);
392 }
393
394 static void gotWebsiteDataCallback(WebKitWebsiteDataManager *manager, GAsyncResult *asyncResult, AboutDataRequest *dataRequest)
395 {
396     GList *dataList = webkit_website_data_manager_fetch_finish(manager, asyncResult, NULL);
397
398     GString *result = g_string_new(
399         "<html><head>"
400         "<script>"
401         "  function removeData(domain) {"
402         "    window.webkit.messageHandlers.aboutData.postMessage(domain);"
403         "  }"
404         "  function clearData(dataType) {"
405         "    window.webkit.messageHandlers.aboutData.postMessage(dataType);"
406         "  }"
407         "</script></head><body>\n");
408
409     guint64 pageID = webkit_web_view_get_page_id(webkit_uri_scheme_request_get_web_view(dataRequest->request));
410     aboutDataFillTable(result, dataRequest, dataList, "Cookies", WEBKIT_WEBSITE_DATA_COOKIES, NULL, pageID);
411     aboutDataFillTable(result, dataRequest, dataList, "Memory Cache", WEBKIT_WEBSITE_DATA_MEMORY_CACHE, NULL, pageID);
412     aboutDataFillTable(result, dataRequest, dataList, "Disk Cache", WEBKIT_WEBSITE_DATA_DISK_CACHE, webkit_website_data_manager_get_disk_cache_directory(manager), pageID);
413     aboutDataFillTable(result, dataRequest, dataList, "Session Storage", WEBKIT_WEBSITE_DATA_SESSION_STORAGE, NULL, pageID);
414     aboutDataFillTable(result, dataRequest, dataList, "Local Storage", WEBKIT_WEBSITE_DATA_LOCAL_STORAGE, webkit_website_data_manager_get_local_storage_directory(manager), pageID);
415     aboutDataFillTable(result, dataRequest, dataList, "WebSQL Databases", WEBKIT_WEBSITE_DATA_WEBSQL_DATABASES, webkit_website_data_manager_get_websql_directory(manager), pageID);
416     aboutDataFillTable(result, dataRequest, dataList, "IndexedDB Databases", WEBKIT_WEBSITE_DATA_INDEXEDDB_DATABASES, webkit_website_data_manager_get_indexeddb_directory(manager), pageID);
417     aboutDataFillTable(result, dataRequest, dataList, "Plugins Data", WEBKIT_WEBSITE_DATA_PLUGIN_DATA, NULL, pageID);
418     aboutDataFillTable(result, dataRequest, dataList, "Offline Web Applications Cache", WEBKIT_WEBSITE_DATA_OFFLINE_APPLICATION_CACHE, webkit_website_data_manager_get_offline_application_cache_directory(manager), pageID);
419
420     result = g_string_append(result, "</body></html>");
421     gsize streamLength = result->len;
422     GInputStream *stream = g_memory_input_stream_new_from_data(g_string_free(result, FALSE), streamLength, g_free);
423     webkit_uri_scheme_request_finish(dataRequest->request, stream, streamLength, "text/html");
424     g_list_free_full(dataList, (GDestroyNotify)webkit_website_data_unref);
425 }
426
427 static void aboutDataHandleRequest(WebKitURISchemeRequest *request, WebKitWebContext *webContext)
428 {
429     AboutDataRequest *dataRequest = aboutDataRequestNew(request);
430     WebKitWebsiteDataManager *manager = webkit_web_context_get_website_data_manager(webContext);
431     webkit_website_data_manager_fetch(manager, WEBKIT_WEBSITE_DATA_ALL, NULL, (GAsyncReadyCallback)gotWebsiteDataCallback, dataRequest);
432 }
433
434 static void aboutURISchemeRequestCallback(WebKitURISchemeRequest *request, WebKitWebContext *webContext)
435 {
436     GInputStream *stream;
437     gsize streamLength;
438     const gchar *path;
439     gchar *contents;
440     GError *error;
441
442     path = webkit_uri_scheme_request_get_path(request);
443     if (!g_strcmp0(path, "minibrowser")) {
444         contents = g_strdup_printf("<html><body><h1>WebKitGTK+ MiniBrowser</h1><p>The WebKit2 test browser of the GTK+ port.</p><p>WebKit version: %d.%d.%d</p></body></html>",
445             webkit_get_major_version(),
446             webkit_get_minor_version(),
447             webkit_get_micro_version());
448         streamLength = strlen(contents);
449         stream = g_memory_input_stream_new_from_data(contents, streamLength, g_free);
450
451         webkit_uri_scheme_request_finish(request, stream, streamLength, "text/html");
452         g_object_unref(stream);
453     } else if (!g_strcmp0(path, "data"))
454         aboutDataHandleRequest(request, webContext);
455     else {
456         error = g_error_new(MINI_BROWSER_ERROR, MINI_BROWSER_ERROR_INVALID_ABOUT_PATH, "Invalid about:%s page.", path);
457         webkit_uri_scheme_request_finish_error(request, error);
458         g_error_free(error);
459     }
460 }
461
462 static GtkWidget *createWebViewForAutomationCallback(WebKitAutomationSession* session)
463 {
464     return GTK_WIDGET(browser_window_get_or_create_web_view_for_automation());
465 }
466
467 static void automationStartedCallback(WebKitWebContext *webContext, WebKitAutomationSession *session)
468 {
469     WebKitApplicationInfo *info = webkit_application_info_new();
470     webkit_application_info_set_version(info, WEBKIT_MAJOR_VERSION, WEBKIT_MINOR_VERSION, WEBKIT_MICRO_VERSION);
471     webkit_automation_session_set_application_info(session, info);
472     webkit_application_info_unref(info);
473
474     g_signal_connect(session, "create-web-view", G_CALLBACK(createWebViewForAutomationCallback), NULL);
475 }
476
477 int main(int argc, char *argv[])
478 {
479     gtk_init(&argc, &argv);
480 #if ENABLE_DEVELOPER_MODE
481     g_setenv("WEBKIT_INJECTED_BUNDLE_PATH", WEBKIT_INJECTED_BUNDLE_PATH, FALSE);
482 #endif
483
484     GOptionContext *context = g_option_context_new(NULL);
485     g_option_context_add_main_entries(context, commandLineOptions, 0);
486     g_option_context_add_group(context, gtk_get_option_group(TRUE));
487
488     WebKitSettings *webkitSettings = webkit_settings_new();
489     webkit_settings_set_enable_developer_extras(webkitSettings, TRUE);
490     webkit_settings_set_enable_webgl(webkitSettings, TRUE);
491     webkit_settings_set_enable_media_stream(webkitSettings, TRUE);
492     if (!addSettingsGroupToContext(context, webkitSettings))
493         g_clear_object(&webkitSettings);
494
495     GError *error = 0;
496     if (!g_option_context_parse(context, &argc, &argv, &error)) {
497         g_printerr("Cannot parse arguments: %s\n", error->message);
498         g_error_free(error);
499         g_option_context_free(context);
500
501         return 1;
502     }
503     g_option_context_free (context);
504
505     WebKitWebContext *webContext = (privateMode || automationMode) ? webkit_web_context_new_ephemeral() : webkit_web_context_get_default();
506
507     if (proxy) {
508         WebKitNetworkProxySettings *webkitProxySettings = webkit_network_proxy_settings_new(proxy, ignoreHosts);
509         webkit_web_context_set_network_proxy_settings(webContext, WEBKIT_NETWORK_PROXY_MODE_CUSTOM, webkitProxySettings);
510         webkit_network_proxy_settings_free(webkitProxySettings);
511     }
512
513     const gchar *singleprocess = g_getenv("MINIBROWSER_SINGLEPROCESS");
514     webkit_web_context_set_process_model(webContext, (singleprocess && *singleprocess) ?
515         WEBKIT_PROCESS_MODEL_SHARED_SECONDARY_PROCESS : WEBKIT_PROCESS_MODEL_MULTIPLE_SECONDARY_PROCESSES);
516
517     // Enable the favicon database, by specifying the default directory.
518     webkit_web_context_set_favicon_database_directory(webContext, NULL);
519
520     WebKitWebsiteDataManager *manager = webkit_web_context_get_website_data_manager(webContext);
521     webkit_website_data_manager_set_resource_load_statistics_enabled(manager, enableIntelligentTrackingPrevention);
522
523     webkit_web_context_register_uri_scheme(webContext, BROWSER_ABOUT_SCHEME, (WebKitURISchemeRequestCallback)aboutURISchemeRequestCallback, webContext, NULL);
524
525     WebKitUserContentManager *userContentManager = webkit_user_content_manager_new();
526     webkit_user_content_manager_register_script_message_handler(userContentManager, "aboutData");
527     g_signal_connect(userContentManager, "script-message-received::aboutData", G_CALLBACK(aboutDataScriptMessageReceivedCallback), webContext);
528
529     webkit_web_context_set_automation_allowed(webContext, automationMode);
530     g_signal_connect(webContext, "automation-started", G_CALLBACK(automationStartedCallback), NULL);
531
532     BrowserWindow *mainWindow = BROWSER_WINDOW(browser_window_new(NULL, webContext));
533     if (fullScreen)
534         gtk_window_fullscreen(GTK_WINDOW(mainWindow));
535     else if (geometry)
536         gtk_window_parse_geometry(GTK_WINDOW(mainWindow), geometry);
537
538     GtkWidget *firstTab = NULL;
539     if (uriArguments) {
540         int i;
541
542         for (i = 0; uriArguments[i]; i++) {
543             WebKitWebView *webView = createBrowserTab(mainWindow, webkitSettings, userContentManager);
544             if (!i)
545                 firstTab = GTK_WIDGET(webView);
546             gchar *url = argumentToURL(uriArguments[i]);
547             webkit_web_view_load_uri(webView, url);
548             g_free(url);
549         }
550     } else {
551         WebKitWebView *webView = createBrowserTab(mainWindow, webkitSettings, userContentManager);
552         firstTab = GTK_WIDGET(webView);
553
554         if (backgroundColor)
555             browser_window_set_background_color(mainWindow, backgroundColor);
556
557         if (!editorMode) {
558             if (sessionFile)
559                 browser_window_load_session(mainWindow, sessionFile);
560             else if (!automationMode)
561                 webkit_web_view_load_uri(webView, BROWSER_DEFAULT_URL);
562         }
563     }
564
565     gtk_widget_grab_focus(firstTab);
566     gtk_widget_show(GTK_WIDGET(mainWindow));
567
568     g_clear_object(&webkitSettings);
569     g_clear_object(&userContentManager);
570
571     gtk_main();
572
573     if (privateMode)
574         g_object_unref(webContext);
575
576     return 0;
577 }