[WPE][GTK] API documentation is unclear about how to modify requests before sending...
[WebKit-https.git] / Source / WebKit / UIProcess / API / glib / WebKitWebView.cpp
1 /*
2  * Copyright (C) 2011 Igalia S.L.
3  * Portions Copyright (c) 2011 Motorola Mobility, Inc.  All rights reserved.
4  * Copyright (C) 2014 Collabora Ltd.
5  * Copyright (C) 2017 Igalia S.L.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  */
22
23 #include "config.h"
24 #include "WebKitWebView.h"
25
26 #include "APIData.h"
27 #include "APINavigation.h"
28 #include "APISerializedScriptValue.h"
29 #include "DataReference.h"
30 #include "ImageOptions.h"
31 #include "WebCertificateInfo.h"
32 #include "WebContextMenuItem.h"
33 #include "WebContextMenuItemData.h"
34 #include "WebKitAuthenticationRequestPrivate.h"
35 #include "WebKitBackForwardListPrivate.h"
36 #include "WebKitContextMenuClient.h"
37 #include "WebKitContextMenuItemPrivate.h"
38 #include "WebKitContextMenuPrivate.h"
39 #include "WebKitDownloadPrivate.h"
40 #include "WebKitEditingCommands.h"
41 #include "WebKitEditorStatePrivate.h"
42 #include "WebKitEnumTypes.h"
43 #include "WebKitError.h"
44 #include "WebKitFaviconDatabasePrivate.h"
45 #include "WebKitFormClient.h"
46 #include "WebKitHitTestResultPrivate.h"
47 #include "WebKitIconLoadingClient.h"
48 #include "WebKitInstallMissingMediaPluginsPermissionRequestPrivate.h"
49 #include "WebKitJavascriptResultPrivate.h"
50 #include "WebKitNavigationClient.h"
51 #include "WebKitNotificationPrivate.h"
52 #include "WebKitPrivate.h"
53 #include "WebKitResponsePolicyDecision.h"
54 #include "WebKitScriptDialogPrivate.h"
55 #include "WebKitSettingsPrivate.h"
56 #include "WebKitUIClient.h"
57 #include "WebKitURIRequestPrivate.h"
58 #include "WebKitURIResponsePrivate.h"
59 #include "WebKitWebContextPrivate.h"
60 #include "WebKitWebResourcePrivate.h"
61 #include "WebKitWebViewPrivate.h"
62 #include "WebKitWebViewSessionStatePrivate.h"
63 #include "WebKitWebsiteDataManagerPrivate.h"
64 #include "WebKitWindowPropertiesPrivate.h"
65 #include <JavaScriptCore/APICast.h>
66 #include <JavaScriptCore/JSRetainPtr.h>
67 #include <jsc/JSCContextPrivate.h>
68 #include <WebCore/CertificateInfo.h>
69 #include <WebCore/GUniquePtrSoup.h>
70 #include <WebCore/JSDOMExceptionHandling.h>
71 #include <WebCore/RefPtrCairo.h>
72 #include <WebCore/URL.h>
73 #include <glib/gi18n-lib.h>
74 #include <wtf/SetForScope.h>
75 #include <wtf/glib/GRefPtr.h>
76 #include <wtf/glib/WTFGType.h>
77 #include <wtf/text/CString.h>
78 #include <wtf/text/StringBuilder.h>
79
80 #if PLATFORM(GTK)
81 #include "WebKitPrintOperationPrivate.h"
82 #include "WebKitWebInspectorPrivate.h"
83 #include "WebKitWebViewBasePrivate.h"
84 #include <WebCore/GUniquePtrGtk.h>
85 #endif
86
87 #if PLATFORM(WPE)
88 #include "APIViewClient.h"
89 #include "WPEView.h"
90 #include "WebKitWebViewBackendPrivate.h"
91 #endif
92
93 #if USE(LIBNOTIFY)
94 #include <libnotify/notify.h>
95 #endif
96
97 using namespace WebKit;
98 using namespace WebCore;
99
100 /**
101  * SECTION: WebKitWebView
102  * @Short_description: The central class of the WebKit2GTK+ API
103  * @Title: WebKitWebView
104  *
105  * #WebKitWebView is the central class of the WebKit2GTK+ API. It is
106  * responsible for managing the drawing of the content and forwarding
107  * of events. You can load any URI into the #WebKitWebView or a data
108  * string. With #WebKitSettings you can control various aspects of the
109  * rendering and loading of the content.
110  *
111  * Note that #WebKitWebView is scrollable by itself, so you don't need
112  * to embed it in a #GtkScrolledWindow.
113  */
114
115 enum {
116     LOAD_CHANGED,
117     LOAD_FAILED,
118     LOAD_FAILED_WITH_TLS_ERRORS,
119
120     CREATE,
121     READY_TO_SHOW,
122     RUN_AS_MODAL,
123     CLOSE,
124
125     SCRIPT_DIALOG,
126
127     DECIDE_POLICY,
128     PERMISSION_REQUEST,
129
130     MOUSE_TARGET_CHANGED,
131
132 #if PLATFORM(GTK)
133     PRINT,
134 #endif
135
136     RESOURCE_LOAD_STARTED,
137
138     ENTER_FULLSCREEN,
139     LEAVE_FULLSCREEN,
140
141     RUN_FILE_CHOOSER,
142
143     CONTEXT_MENU,
144     CONTEXT_MENU_DISMISSED,
145
146     SUBMIT_FORM,
147
148     INSECURE_CONTENT_DETECTED,
149
150 #if PLATFORM(GTK)
151     WEB_PROCESS_CRASHED,
152 #endif
153     WEB_PROCESS_TERMINATED,
154
155     AUTHENTICATE,
156
157     SHOW_NOTIFICATION,
158
159 #if PLATFORM(GTK)
160     RUN_COLOR_CHOOSER,
161
162     SHOW_OPTION_MENU,
163 #endif
164
165     LAST_SIGNAL
166 };
167
168 enum {
169     PROP_0,
170
171 #if PLATFORM(WPE)
172     PROP_BACKEND,
173 #endif
174
175     PROP_WEB_CONTEXT,
176     PROP_RELATED_VIEW,
177     PROP_SETTINGS,
178     PROP_USER_CONTENT_MANAGER,
179     PROP_TITLE,
180     PROP_ESTIMATED_LOAD_PROGRESS,
181
182 #if PLATFORM(GTK)
183     PROP_FAVICON,
184 #endif
185
186     PROP_URI,
187     PROP_ZOOM_LEVEL,
188     PROP_IS_LOADING,
189     PROP_IS_PLAYING_AUDIO,
190     PROP_IS_EPHEMERAL,
191     PROP_IS_CONTROLLED_BY_AUTOMATION,
192     PROP_EDITABLE
193 };
194
195 typedef HashMap<uint64_t, GRefPtr<WebKitWebResource> > LoadingResourcesMap;
196 typedef HashMap<uint64_t, GRefPtr<GTask> > SnapshotResultsMap;
197
198 class PageLoadStateObserver;
199
200 struct _WebKitWebViewPrivate {
201     ~_WebKitWebViewPrivate()
202     {
203         // For modal dialogs, make sure the main loop is stopped when finalizing the webView.
204         if (modalLoop && g_main_loop_is_running(modalLoop.get()))
205             g_main_loop_quit(modalLoop.get());
206     }
207
208 #if PLATFORM(WPE)
209     GRefPtr<WebKitWebViewBackend> backend;
210     std::unique_ptr<WKWPE::View> view;
211 #endif
212
213     WebKitWebView* relatedView;
214     CString title;
215     CString customTextEncoding;
216     CString activeURI;
217     bool isLoading;
218     bool isEphemeral;
219     bool isControlledByAutomation;
220
221     std::unique_ptr<PageLoadStateObserver> loadObserver;
222
223     GRefPtr<WebKitBackForwardList> backForwardList;
224     GRefPtr<WebKitSettings> settings;
225     GRefPtr<WebKitUserContentManager> userContentManager;
226     GRefPtr<WebKitWebContext> context;
227     GRefPtr<WebKitWindowProperties> windowProperties;
228     GRefPtr<WebKitEditorState> editorState;
229
230     GRefPtr<GMainLoop> modalLoop;
231
232     GRefPtr<WebKitHitTestResult> mouseTargetHitTestResult;
233     WebEvent::Modifiers mouseTargetModifiers;
234
235     GRefPtr<WebKitFindController> findController;
236
237     GRefPtr<WebKitWebResource> mainResource;
238     LoadingResourcesMap loadingResourcesMap;
239
240     WebKitScriptDialog* currentScriptDialog;
241
242 #if PLATFORM(GTK)
243     GRefPtr<JSCContext> jsContext;
244
245     GRefPtr<WebKitWebInspector> inspector;
246
247     RefPtr<cairo_surface_t> favicon;
248     GRefPtr<GCancellable> faviconCancellable;
249
250     CString faviconURI;
251     unsigned long faviconChangedHandlerID;
252
253     SnapshotResultsMap snapshotResultsMap;
254 #endif
255
256     GRefPtr<WebKitAuthenticationRequest> authenticationRequest;
257
258     GRefPtr<WebKitWebsiteDataManager> websiteDataManager;
259 };
260
261 static guint signals[LAST_SIGNAL] = { 0, };
262
263 #if PLATFORM(GTK)
264 WEBKIT_DEFINE_TYPE(WebKitWebView, webkit_web_view, WEBKIT_TYPE_WEB_VIEW_BASE)
265 #elif PLATFORM(WPE)
266 WEBKIT_DEFINE_TYPE(WebKitWebView, webkit_web_view, G_TYPE_OBJECT)
267 #endif
268
269 static inline WebPageProxy& getPage(WebKitWebView* webView)
270 {
271 #if PLATFORM(GTK)
272     auto* page = webkitWebViewBaseGetPage(reinterpret_cast<WebKitWebViewBase*>(webView));
273     ASSERT(page);
274     return *page;
275 #elif PLATFORM(WPE)
276     ASSERT(webView->priv->view);
277     return webView->priv->view->page();
278 #endif
279 }
280
281 static void webkitWebViewSetIsLoading(WebKitWebView* webView, bool isLoading)
282 {
283     if (webView->priv->isLoading == isLoading)
284         return;
285
286     webView->priv->isLoading = isLoading;
287     g_object_notify(G_OBJECT(webView), "is-loading");
288 }
289
290 void webkitWebViewIsPlayingAudioChanged(WebKitWebView* webView)
291 {
292     g_object_notify(G_OBJECT(webView), "is-playing-audio");
293 }
294
295 class PageLoadStateObserver final : public PageLoadState::Observer {
296 public:
297     PageLoadStateObserver(WebKitWebView* webView)
298         : m_webView(webView)
299     {
300     }
301
302 private:
303     void willChangeIsLoading() override
304     {
305         g_object_freeze_notify(G_OBJECT(m_webView));
306     }
307     void didChangeIsLoading() override
308     {
309         webkitWebViewSetIsLoading(m_webView, getPage(m_webView).pageLoadState().isLoading());
310         g_object_thaw_notify(G_OBJECT(m_webView));
311     }
312
313     void willChangeTitle() override
314     {
315         g_object_freeze_notify(G_OBJECT(m_webView));
316     }
317     void didChangeTitle() override
318     {
319         m_webView->priv->title = getPage(m_webView).pageLoadState().title().utf8();
320         g_object_notify(G_OBJECT(m_webView), "title");
321         g_object_thaw_notify(G_OBJECT(m_webView));
322     }
323
324     void willChangeActiveURL() override
325     {
326         g_object_freeze_notify(G_OBJECT(m_webView));
327     }
328     void didChangeActiveURL() override
329     {
330         m_webView->priv->activeURI = getPage(m_webView).pageLoadState().activeURL().utf8();
331         g_object_notify(G_OBJECT(m_webView), "uri");
332         g_object_thaw_notify(G_OBJECT(m_webView));
333     }
334
335     void willChangeHasOnlySecureContent() override { }
336     void didChangeHasOnlySecureContent() override { }
337
338     void willChangeEstimatedProgress() override
339     {
340         g_object_freeze_notify(G_OBJECT(m_webView));
341     }
342     void didChangeEstimatedProgress() override
343     {
344         g_object_notify(G_OBJECT(m_webView), "estimated-load-progress");
345         g_object_thaw_notify(G_OBJECT(m_webView));
346     }
347
348     void willChangeCanGoBack() override { }
349     void didChangeCanGoBack() override { }
350     void willChangeCanGoForward() override { }
351     void didChangeCanGoForward() override { }
352     void willChangeNetworkRequestsInProgress() override { }
353     void didChangeNetworkRequestsInProgress() override { }
354     void willChangeCertificateInfo() override { }
355     void didChangeCertificateInfo() override { }
356     void willChangeWebProcessIsResponsive() override { }
357     void didChangeWebProcessIsResponsive() override { }
358
359     WebKitWebView* m_webView;
360 };
361
362 #if PLATFORM(WPE)
363 class WebViewClient final : public API::ViewClient {
364 public:
365     explicit WebViewClient(WebKitWebView* webView)
366         : m_webView(webView)
367     {
368     }
369
370 private:
371     void handleDownloadRequest(WKWPE::View&, DownloadProxy& downloadProxy) override
372     {
373         webkitWebViewHandleDownloadRequest(m_webView, &downloadProxy);
374     }
375
376     WebKitWebView* m_webView;
377 };
378 #endif
379
380 static gboolean webkitWebViewLoadFail(WebKitWebView* webView, WebKitLoadEvent, const char* failingURI, GError* error)
381 {
382     if (g_error_matches(error, WEBKIT_NETWORK_ERROR, WEBKIT_NETWORK_ERROR_CANCELLED)
383         || g_error_matches(error, WEBKIT_POLICY_ERROR, WEBKIT_POLICY_ERROR_FRAME_LOAD_INTERRUPTED_BY_POLICY_CHANGE)
384         || g_error_matches(error, WEBKIT_PLUGIN_ERROR, WEBKIT_PLUGIN_ERROR_WILL_HANDLE_LOAD))
385         return FALSE;
386
387     GUniquePtr<char> htmlString(g_strdup_printf("<html><body>%s</body></html>", error->message));
388     webkit_web_view_load_alternate_html(webView, htmlString.get(), failingURI, 0);
389
390     return TRUE;
391 }
392
393 #if PLATFORM(GTK)
394 static GtkWidget* webkitWebViewCreate(WebKitWebView*, WebKitNavigationAction*)
395 {
396     return nullptr;
397 }
398 #else
399 static WebKitWebView* webkitWebViewCreate(WebKitWebView*, WebKitNavigationAction*)
400 {
401     return nullptr;
402 }
403 #endif
404
405 static gboolean webkitWebViewDecidePolicy(WebKitWebView*, WebKitPolicyDecision* decision, WebKitPolicyDecisionType decisionType)
406 {
407     if (decisionType != WEBKIT_POLICY_DECISION_TYPE_RESPONSE) {
408         webkit_policy_decision_use(decision);
409         return TRUE;
410     }
411
412     WebKitURIResponse* response = webkit_response_policy_decision_get_response(WEBKIT_RESPONSE_POLICY_DECISION(decision));
413     const ResourceResponse& resourceResponse = webkitURIResponseGetResourceResponse(response);
414     if (resourceResponse.isAttachment()) {
415         webkit_policy_decision_download(decision);
416         return TRUE;
417     }
418
419     if (webkit_response_policy_decision_is_mime_type_supported(WEBKIT_RESPONSE_POLICY_DECISION(decision)))
420         webkit_policy_decision_use(decision);
421     else
422         webkit_policy_decision_ignore(decision);
423
424     return TRUE;
425 }
426
427 static gboolean webkitWebViewPermissionRequest(WebKitWebView*, WebKitPermissionRequest* request)
428 {
429     webkit_permission_request_deny(request);
430     return TRUE;
431 }
432
433 static void allowModalDialogsChanged(WebKitSettings* settings, GParamSpec*, WebKitWebView* webView)
434 {
435     getPage(webView).setCanRunModal(webkit_settings_get_allow_modal_dialogs(settings));
436 }
437
438 static void zoomTextOnlyChanged(WebKitSettings* settings, GParamSpec*, WebKitWebView* webView)
439 {
440     auto& page = getPage(webView);
441     gboolean zoomTextOnly = webkit_settings_get_zoom_text_only(settings);
442     gdouble pageZoomLevel = zoomTextOnly ? 1 : page.textZoomFactor();
443     gdouble textZoomLevel = zoomTextOnly ? page.pageZoomFactor() : 1;
444     page.setPageAndTextZoomFactors(pageZoomLevel, textZoomLevel);
445 }
446
447 static void userAgentChanged(WebKitSettings* settings, GParamSpec*, WebKitWebView* webView)
448 {
449     getPage(webView).setCustomUserAgent(String::fromUTF8(webkit_settings_get_user_agent(settings)));
450 }
451
452 #if PLATFORM(GTK)
453 static void webkitWebViewUpdateFavicon(WebKitWebView* webView, cairo_surface_t* favicon)
454 {
455     WebKitWebViewPrivate* priv = webView->priv;
456     if (priv->favicon.get() == favicon)
457         return;
458
459     priv->favicon = favicon;
460     g_object_notify(G_OBJECT(webView), "favicon");
461 }
462
463 static void webkitWebViewCancelFaviconRequest(WebKitWebView* webView)
464 {
465     if (!webView->priv->faviconCancellable)
466         return;
467
468     g_cancellable_cancel(webView->priv->faviconCancellable.get());
469     webView->priv->faviconCancellable = 0;
470 }
471
472 static void gotFaviconCallback(GObject* object, GAsyncResult* result, gpointer userData)
473 {
474     GUniqueOutPtr<GError> error;
475     RefPtr<cairo_surface_t> favicon = adoptRef(webkit_favicon_database_get_favicon_finish(WEBKIT_FAVICON_DATABASE(object), result, &error.outPtr()));
476     if (g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED))
477         return;
478
479     WebKitWebView* webView = WEBKIT_WEB_VIEW(userData);
480     webkitWebViewUpdateFavicon(webView, favicon.get());
481     webView->priv->faviconCancellable = 0;
482 }
483
484 static void webkitWebViewRequestFavicon(WebKitWebView* webView)
485 {
486     webkitWebViewCancelFaviconRequest(webView);
487
488     WebKitWebViewPrivate* priv = webView->priv;
489     priv->faviconCancellable = adoptGRef(g_cancellable_new());
490     WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context.get());
491     webkit_favicon_database_get_favicon(database, priv->activeURI.data(), priv->faviconCancellable.get(), gotFaviconCallback, webView);
492 }
493
494 static void webkitWebViewUpdateFaviconURI(WebKitWebView* webView, const char* faviconURI)
495 {
496     if (webView->priv->faviconURI == faviconURI)
497         return;
498
499     webView->priv->faviconURI = faviconURI;
500     webkitWebViewRequestFavicon(webView);
501 }
502
503 static void faviconChangedCallback(WebKitFaviconDatabase*, const char* pageURI, const char* faviconURI, WebKitWebView* webView)
504 {
505     if (webView->priv->activeURI != pageURI)
506         return;
507
508     webkitWebViewUpdateFaviconURI(webView, faviconURI);
509 }
510 #endif
511
512 static bool webkitWebViewIsConstructed(WebKitWebView* webView)
513 {
514     // The loadObserver is set in webkitWebViewConstructed, right after the
515     // WebPageProxy is created, so we use it to check if the view has been
516     // constructed instead of adding a boolean member only for that.
517     return !!webView->priv->loadObserver;
518 }
519
520 static void webkitWebViewUpdateSettings(WebKitWebView* webView)
521 {
522     // The "settings" property is set on construction, and in that
523     // case webkit_web_view_set_settings() will be called *before* the
524     // WebPageProxy has been created so we should do an early return.
525     if (!webkitWebViewIsConstructed(webView))
526         return;
527
528     auto& page = getPage(webView);
529     WebKitSettings* settings = webView->priv->settings.get();
530     page.setPreferences(*webkitSettingsGetPreferences(settings));
531     page.setCanRunModal(webkit_settings_get_allow_modal_dialogs(settings));
532     page.setCustomUserAgent(String::fromUTF8(webkit_settings_get_user_agent(settings)));
533
534     g_signal_connect(settings, "notify::allow-modal-dialogs", G_CALLBACK(allowModalDialogsChanged), webView);
535     g_signal_connect(settings, "notify::zoom-text-only", G_CALLBACK(zoomTextOnlyChanged), webView);
536     g_signal_connect(settings, "notify::user-agent", G_CALLBACK(userAgentChanged), webView);
537 }
538
539 static void webkitWebViewDisconnectSettingsSignalHandlers(WebKitWebView* webView)
540 {
541     if (!webkitWebViewIsConstructed(webView))
542         return;
543
544     WebKitSettings* settings = webView->priv->settings.get();
545     g_signal_handlers_disconnect_by_func(settings, reinterpret_cast<gpointer>(allowModalDialogsChanged), webView);
546     g_signal_handlers_disconnect_by_func(settings, reinterpret_cast<gpointer>(zoomTextOnlyChanged), webView);
547     g_signal_handlers_disconnect_by_func(settings, reinterpret_cast<gpointer>(userAgentChanged), webView);
548 }
549
550 #if PLATFORM(GTK)
551 static void webkitWebViewWatchForChangesInFavicon(WebKitWebView* webView)
552 {
553     WebKitWebViewPrivate* priv = webView->priv;
554     if (priv->faviconChangedHandlerID)
555         return;
556
557     WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context.get());
558     priv->faviconChangedHandlerID = g_signal_connect(database, "favicon-changed", G_CALLBACK(faviconChangedCallback), webView);
559 }
560
561 static void webkitWebViewDisconnectFaviconDatabaseSignalHandlers(WebKitWebView* webView)
562 {
563     WebKitWebViewPrivate* priv = webView->priv;
564     if (priv->faviconChangedHandlerID)
565         g_signal_handler_disconnect(webkit_web_context_get_favicon_database(priv->context.get()), priv->faviconChangedHandlerID);
566     priv->faviconChangedHandlerID = 0;
567 }
568 #endif
569
570 #if USE(LIBNOTIFY)
571 static const char* gNotifyNotificationID = "wk-notify-notification";
572
573 static void notifyNotificationClosed(NotifyNotification*, WebKitNotification* webNotification)
574 {
575     g_object_set_data(G_OBJECT(webNotification), gNotifyNotificationID, nullptr);
576     webkit_notification_close(webNotification);
577 }
578
579 static void notifyNotificationClicked(NotifyNotification*, char*, WebKitNotification* webNotification)
580 {
581     webkit_notification_clicked(webNotification);
582 }
583
584 static void webNotificationClosed(WebKitNotification* webNotification)
585 {
586     NotifyNotification* notification = NOTIFY_NOTIFICATION(g_object_get_data(G_OBJECT(webNotification), gNotifyNotificationID));
587     if (!notification)
588         return;
589
590     notify_notification_close(notification, nullptr);
591     g_object_set_data(G_OBJECT(webNotification), gNotifyNotificationID, nullptr);
592 }
593 #endif // USE(LIBNOTIFY)
594
595 static gboolean webkitWebViewShowNotification(WebKitWebView*, WebKitNotification* webNotification)
596 {
597 #if USE(LIBNOTIFY)
598     if (!notify_is_initted())
599         notify_init(g_get_prgname());
600
601     NotifyNotification* notification = NOTIFY_NOTIFICATION(g_object_get_data(G_OBJECT(webNotification), gNotifyNotificationID));
602     if (!notification) {
603         notification = notify_notification_new(webkit_notification_get_title(webNotification),
604             webkit_notification_get_body(webNotification), nullptr);
605
606         notify_notification_add_action(notification, "default", _("Acknowledge"), NOTIFY_ACTION_CALLBACK(notifyNotificationClicked), webNotification, nullptr);
607
608         g_signal_connect_object(notification, "closed", G_CALLBACK(notifyNotificationClosed), webNotification, static_cast<GConnectFlags>(0));
609         g_signal_connect(webNotification, "closed", G_CALLBACK(webNotificationClosed), nullptr);
610         g_object_set_data_full(G_OBJECT(webNotification), gNotifyNotificationID, notification, static_cast<GDestroyNotify>(g_object_unref));
611     } else {
612         notify_notification_update(notification, webkit_notification_get_title(webNotification),
613             webkit_notification_get_body(webNotification), nullptr);
614     }
615
616     notify_notification_show(notification, nullptr);
617     return TRUE;
618 #else
619     UNUSED_PARAM(webNotification);
620     return FALSE;
621 #endif
622 }
623
624 static void webkitWebViewConstructed(GObject* object)
625 {
626     G_OBJECT_CLASS(webkit_web_view_parent_class)->constructed(object);
627
628     WebKitWebView* webView = WEBKIT_WEB_VIEW(object);
629     WebKitWebViewPrivate* priv = webView->priv;
630     if (priv->relatedView) {
631         priv->context = webkit_web_view_get_context(priv->relatedView);
632         priv->isEphemeral = webkit_web_view_is_ephemeral(priv->relatedView);
633         priv->isControlledByAutomation = webkit_web_view_is_controlled_by_automation(priv->relatedView);
634     } else if (!priv->context)
635         priv->context = webkit_web_context_get_default();
636     else if (!priv->isEphemeral)
637         priv->isEphemeral = webkit_web_context_is_ephemeral(priv->context.get());
638
639     if (!priv->settings)
640         priv->settings = adoptGRef(webkit_settings_new());
641
642     if (!priv->userContentManager)
643         priv->userContentManager = adoptGRef(webkit_user_content_manager_new());
644
645     if (priv->isEphemeral && !webkit_web_context_is_ephemeral(priv->context.get())) {
646         priv->websiteDataManager = adoptGRef(webkit_website_data_manager_new_ephemeral());
647         webkitWebsiteDataManagerAddProcessPool(priv->websiteDataManager.get(), webkitWebContextGetProcessPool(priv->context.get()));
648     }
649
650     webkitWebContextCreatePageForWebView(priv->context.get(), webView, priv->userContentManager.get(), priv->relatedView);
651
652     priv->loadObserver = std::make_unique<PageLoadStateObserver>(webView);
653     getPage(webView).pageLoadState().addObserver(*priv->loadObserver);
654
655     // The related view is only valid during the construction.
656     priv->relatedView = nullptr;
657
658     attachNavigationClientToView(webView);
659     attachUIClientToView(webView);
660     attachContextMenuClientToView(webView);
661     attachFormClientToView(webView);
662
663 #if PLATFORM(GTK)
664     attachIconLoadingClientToView(webView);
665 #endif
666
667 #if PLATFORM(WPE)
668     priv->view->setClient(std::make_unique<WebViewClient>(webView));
669 #endif
670
671     // This needs to be after attachUIClientToView() because WebPageProxy::setUIClient() calls setCanRunModal() with true.
672     // See https://bugs.webkit.org/show_bug.cgi?id=135412.
673     webkitWebViewUpdateSettings(webView);
674
675     priv->backForwardList = adoptGRef(webkitBackForwardListCreate(&getPage(webView).backForwardList()));
676     priv->windowProperties = adoptGRef(webkitWindowPropertiesCreate());
677 }
678
679 static void webkitWebViewSetProperty(GObject* object, guint propId, const GValue* value, GParamSpec* paramSpec)
680 {
681     WebKitWebView* webView = WEBKIT_WEB_VIEW(object);
682
683     switch (propId) {
684 #if PLATFORM(WPE)
685     case PROP_BACKEND: {
686         gpointer backend = g_value_get_boxed(value);
687         webView->priv->backend = backend ? adoptGRef(static_cast<WebKitWebViewBackend*>(backend)) : nullptr;
688         break;
689     }
690 #endif
691     case PROP_WEB_CONTEXT: {
692         gpointer webContext = g_value_get_object(value);
693         webView->priv->context = webContext ? WEBKIT_WEB_CONTEXT(webContext) : nullptr;
694         break;
695     }
696     case PROP_RELATED_VIEW: {
697         gpointer relatedView = g_value_get_object(value);
698         webView->priv->relatedView = relatedView ? WEBKIT_WEB_VIEW(relatedView) : nullptr;
699         break;
700     }
701     case PROP_SETTINGS: {
702         if (gpointer settings = g_value_get_object(value))
703             webkit_web_view_set_settings(webView, WEBKIT_SETTINGS(settings));
704         break;
705     }
706     case PROP_USER_CONTENT_MANAGER: {
707         gpointer userContentManager = g_value_get_object(value);
708         webView->priv->userContentManager = userContentManager ? WEBKIT_USER_CONTENT_MANAGER(userContentManager) : nullptr;
709         break;
710     }
711     case PROP_ZOOM_LEVEL:
712         webkit_web_view_set_zoom_level(webView, g_value_get_double(value));
713         break;
714     case PROP_IS_EPHEMERAL:
715         webView->priv->isEphemeral = g_value_get_boolean(value);
716         break;
717     case PROP_IS_CONTROLLED_BY_AUTOMATION:
718         webView->priv->isControlledByAutomation = g_value_get_boolean(value);
719         break;
720     case PROP_EDITABLE:
721         webkit_web_view_set_editable(webView, g_value_get_boolean(value));
722         break;
723     default:
724         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, paramSpec);
725     }
726 }
727
728 static void webkitWebViewGetProperty(GObject* object, guint propId, GValue* value, GParamSpec* paramSpec)
729 {
730     WebKitWebView* webView = WEBKIT_WEB_VIEW(object);
731
732     switch (propId) {
733 #if PLATFORM(WPE)
734     case PROP_BACKEND:
735         g_value_set_static_boxed(value, webView->priv->backend.get());
736         break;
737 #endif
738     case PROP_WEB_CONTEXT:
739         g_value_set_object(value, webView->priv->context.get());
740         break;
741     case PROP_SETTINGS:
742         g_value_set_object(value, webkit_web_view_get_settings(webView));
743         break;
744     case PROP_USER_CONTENT_MANAGER:
745         g_value_set_object(value, webkit_web_view_get_user_content_manager(webView));
746         break;
747     case PROP_TITLE:
748         g_value_set_string(value, webView->priv->title.data());
749         break;
750     case PROP_ESTIMATED_LOAD_PROGRESS:
751         g_value_set_double(value, webkit_web_view_get_estimated_load_progress(webView));
752         break;
753 #if PLATFORM(GTK)
754     case PROP_FAVICON:
755         g_value_set_pointer(value, webkit_web_view_get_favicon(webView));
756         break;
757 #endif
758     case PROP_URI:
759         g_value_set_string(value, webkit_web_view_get_uri(webView));
760         break;
761     case PROP_ZOOM_LEVEL:
762         g_value_set_double(value, webkit_web_view_get_zoom_level(webView));
763         break;
764     case PROP_IS_LOADING:
765         g_value_set_boolean(value, webkit_web_view_is_loading(webView));
766         break;
767     case PROP_IS_PLAYING_AUDIO:
768         g_value_set_boolean(value, webkit_web_view_is_playing_audio(webView));
769         break;
770     case PROP_IS_EPHEMERAL:
771         g_value_set_boolean(value, webkit_web_view_is_ephemeral(webView));
772         break;
773     case PROP_IS_CONTROLLED_BY_AUTOMATION:
774         g_value_set_boolean(value, webkit_web_view_is_controlled_by_automation(webView));
775         break;
776     case PROP_EDITABLE:
777         g_value_set_boolean(value, webkit_web_view_is_editable(webView));
778         break;
779     default:
780         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, paramSpec);
781     }
782 }
783
784 static void webkitWebViewDispose(GObject* object)
785 {
786     WebKitWebView* webView = WEBKIT_WEB_VIEW(object);
787
788 #if PLATFORM(GTK)
789     webkitWebViewCancelFaviconRequest(webView);
790     webkitWebViewDisconnectFaviconDatabaseSignalHandlers(webView);
791 #endif
792
793     webkitWebViewDisconnectSettingsSignalHandlers(webView);
794
795     if (webView->priv->loadObserver) {
796         getPage(webView).pageLoadState().removeObserver(*webView->priv->loadObserver);
797         webView->priv->loadObserver.reset();
798
799         // We notify the context here to ensure it's called only once. Ideally we should
800         // call this in finalize, not dispose, but finalize is used internally and we don't
801         // have access to the instance pointer from the private struct destructor.
802         webkitWebContextWebViewDestroyed(webView->priv->context.get(), webView);
803     }
804
805     if (webView->priv->websiteDataManager) {
806         webkitWebsiteDataManagerRemoveProcessPool(webView->priv->websiteDataManager.get(), webkitWebContextGetProcessPool(webView->priv->context.get()));
807         webView->priv->websiteDataManager = nullptr;
808     }
809
810 #if PLATFORM(WPE)
811     webView->priv->view->close();
812 #endif
813
814     G_OBJECT_CLASS(webkit_web_view_parent_class)->dispose(object);
815 }
816
817 static gboolean webkitWebViewAccumulatorObjectHandled(GSignalInvocationHint*, GValue* returnValue, const GValue* handlerReturn, gpointer)
818 {
819     void* object = g_value_get_object(handlerReturn);
820     if (object)
821         g_value_set_object(returnValue, object);
822
823     return !object;
824 }
825
826 static void webkit_web_view_class_init(WebKitWebViewClass* webViewClass)
827 {
828     GObjectClass* gObjectClass = G_OBJECT_CLASS(webViewClass);
829
830     gObjectClass->constructed = webkitWebViewConstructed;
831     gObjectClass->set_property = webkitWebViewSetProperty;
832     gObjectClass->get_property = webkitWebViewGetProperty;
833     gObjectClass->dispose = webkitWebViewDispose;
834
835     webViewClass->load_failed = webkitWebViewLoadFail;
836     webViewClass->create = webkitWebViewCreate;
837     webViewClass->script_dialog = webkitWebViewScriptDialog;
838     webViewClass->decide_policy = webkitWebViewDecidePolicy;
839     webViewClass->permission_request = webkitWebViewPermissionRequest;
840     webViewClass->run_file_chooser = webkitWebViewRunFileChooser;
841     webViewClass->authenticate = webkitWebViewAuthenticate;
842     webViewClass->show_notification = webkitWebViewShowNotification;
843
844 #if PLATFORM(WPE)
845     /**
846      * WebKitWebView:backend:
847      *
848      * The #WebKitWebViewBackend of the view.
849      *
850      * since: 2.20
851      */
852     g_object_class_install_property(
853         gObjectClass,
854         PROP_BACKEND,
855         g_param_spec_boxed(
856             "backend",
857             _("Backend"),
858             _("The backend for the web view"),
859             WEBKIT_TYPE_WEB_VIEW_BACKEND,
860             static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
861 #endif
862
863     /**
864      * WebKitWebView:web-context:
865      *
866      * The #WebKitWebContext of the view.
867      */
868     g_object_class_install_property(gObjectClass,
869                                     PROP_WEB_CONTEXT,
870                                     g_param_spec_object("web-context",
871                                                         _("Web Context"),
872                                                         _("The web context for the view"),
873                                                         WEBKIT_TYPE_WEB_CONTEXT,
874                                                         static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
875     /**
876      * WebKitWebView:related-view:
877      *
878      * The related #WebKitWebView used when creating the view to share the
879      * same web process. This property is not readable because the related
880      * web view is only valid during the object construction.
881      *
882      * Since: 2.4
883      */
884     g_object_class_install_property(
885         gObjectClass,
886         PROP_RELATED_VIEW,
887         g_param_spec_object(
888             "related-view",
889             _("Related WebView"),
890             _("The related WebKitWebView used when creating the view to share the same web process"),
891             WEBKIT_TYPE_WEB_VIEW,
892             static_cast<GParamFlags>(WEBKIT_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY)));
893
894     /**
895      * WebKitWebView:settings:
896      *
897      * The #WebKitSettings of the view.
898      *
899      * Since: 2.6
900      */
901     g_object_class_install_property(
902         gObjectClass,
903         PROP_SETTINGS,
904         g_param_spec_object(
905             "settings",
906             _("WebView settings"),
907             _("The WebKitSettings of the view"),
908             WEBKIT_TYPE_SETTINGS,
909             static_cast<GParamFlags>(WEBKIT_PARAM_WRITABLE | G_PARAM_CONSTRUCT)));
910
911     /**
912      * WebKitWebView:user-content-manager:
913      *
914      * The #WebKitUserContentManager of the view.
915      *
916      * Since: 2.6
917      */
918     g_object_class_install_property(
919         gObjectClass,
920         PROP_USER_CONTENT_MANAGER,
921         g_param_spec_object(
922             "user-content-manager",
923             _("WebView user content manager"),
924             _("The WebKitUserContentManager of the view"),
925             WEBKIT_TYPE_USER_CONTENT_MANAGER,
926             static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
927
928     /**
929      * WebKitWebView:title:
930      *
931      * The main frame document title of this #WebKitWebView. If
932      * the title has not been received yet, it will be %NULL.
933      */
934     g_object_class_install_property(gObjectClass,
935                                     PROP_TITLE,
936                                     g_param_spec_string("title",
937                                                         _("Title"),
938                                                         _("Main frame document title"),
939                                                         0,
940                                                         WEBKIT_PARAM_READABLE));
941
942     /**
943      * WebKitWebView:estimated-load-progress:
944      *
945      * An estimate of the percent completion for the current loading operation.
946      * This value will range from 0.0 to 1.0 and, once a load completes,
947      * will remain at 1.0 until a new load starts, at which point it
948      * will be reset to 0.0.
949      * The value is an estimate based on the total number of bytes expected
950      * to be received for a document, including all its possible subresources
951      * and child documents.
952      */
953     g_object_class_install_property(gObjectClass,
954                                     PROP_ESTIMATED_LOAD_PROGRESS,
955                                     g_param_spec_double("estimated-load-progress",
956                                                         _("Estimated Load Progress"),
957                                                         _("An estimate of the percent completion for a document load"),
958                                                         0.0, 1.0, 0.0,
959                                                         WEBKIT_PARAM_READABLE));
960 #if PLATFORM(GTK)
961     /**
962      * WebKitWebView:favicon:
963      *
964      * The favicon currently associated to the #WebKitWebView.
965      * See webkit_web_view_get_favicon() for more details.
966      */
967     g_object_class_install_property(gObjectClass,
968                                     PROP_FAVICON,
969                                     g_param_spec_pointer("favicon",
970                                                          _("Favicon"),
971                                                          _("The favicon associated to the view, if any"),
972                                                          WEBKIT_PARAM_READABLE));
973 #endif
974
975     /**
976      * WebKitWebView:uri:
977      *
978      * The current active URI of the #WebKitWebView.
979      * See webkit_web_view_get_uri() for more details.
980      */
981     g_object_class_install_property(gObjectClass,
982                                     PROP_URI,
983                                     g_param_spec_string("uri",
984                                                         _("URI"),
985                                                         _("The current active URI of the view"),
986                                                         0,
987                                                         WEBKIT_PARAM_READABLE));
988
989     /**
990      * WebKitWebView:zoom-level:
991      *
992      * The zoom level of the #WebKitWebView content.
993      * See webkit_web_view_set_zoom_level() for more details.
994      */
995     g_object_class_install_property(
996         gObjectClass,
997         PROP_ZOOM_LEVEL,
998         g_param_spec_double(
999             "zoom-level",
1000             _("Zoom level"),
1001             _("The zoom level of the view content"),
1002             0, G_MAXDOUBLE, 1,
1003             WEBKIT_PARAM_READWRITE));
1004
1005     /**
1006      * WebKitWebView:is-loading:
1007      *
1008      * Whether the #WebKitWebView is currently loading a page. This property becomes
1009      * %TRUE as soon as a new load operation is requested and before the
1010      * #WebKitWebView::load-changed signal is emitted with %WEBKIT_LOAD_STARTED and
1011      * at that point the active URI is the requested one.
1012      * When the load operation finishes the property is set to %FALSE before
1013      * #WebKitWebView::load-changed is emitted with %WEBKIT_LOAD_FINISHED.
1014      */
1015     g_object_class_install_property(
1016         gObjectClass,
1017         PROP_IS_LOADING,
1018         g_param_spec_boolean(
1019             "is-loading",
1020             _("Is Loading"),
1021             _("Whether the view is loading a page"),
1022             FALSE,
1023             WEBKIT_PARAM_READABLE));
1024
1025     /**
1026      * WebKitWebView:is-playing-audio:
1027      *
1028      * Whether the #WebKitWebView is currently playing audio from a page.
1029      * This property becomes %TRUE as soon as web content starts playing any
1030      * kind of audio. When a page is no longer playing any kind of sound,
1031      * the property is set back to %FALSE.
1032      *
1033      * Since: 2.8
1034      */
1035     g_object_class_install_property(
1036         gObjectClass,
1037         PROP_IS_PLAYING_AUDIO,
1038         g_param_spec_boolean(
1039             "is-playing-audio",
1040             "Is Playing Audio",
1041             _("Whether the view is playing audio"),
1042             FALSE,
1043             WEBKIT_PARAM_READABLE));
1044
1045     /**
1046      * WebKitWebView:is-ephemeral:
1047      *
1048      * Whether the #WebKitWebView is ephemeral. An ephemeral web view never writes
1049      * website data to the client storage, no matter what #WebKitWebsiteDataManager
1050      * its context is using. This is normally used to implement private browsing mode.
1051      * This is a %G_PARAM_CONSTRUCT_ONLY property, so you have to create a ephemeral
1052      * #WebKitWebView and it can't be changed. Note that all #WebKitWebView<!-- -->s
1053      * created with an ephemeral #WebKitWebContext will be ephemeral automatically.
1054      * See also webkit_web_context_new_ephemeral().
1055      *
1056      * Since: 2.16
1057      */
1058     g_object_class_install_property(
1059         gObjectClass,
1060         PROP_IS_EPHEMERAL,
1061         g_param_spec_boolean(
1062             "is-ephemeral",
1063             "Is Ephemeral",
1064             _("Whether the web view is ephemeral"),
1065             FALSE,
1066             static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
1067
1068     /**
1069      * WebKitWebView:is-controlled-by-automation:
1070      *
1071      * Whether the #WebKitWebView is controlled by automation. This should only be used when
1072      * creating a new #WebKitWebView as a response to #WebKitAutomationSession::create-web-view
1073      * signal request.
1074      *
1075      * Since: 2.18
1076      */
1077     g_object_class_install_property(
1078         gObjectClass,
1079         PROP_IS_CONTROLLED_BY_AUTOMATION,
1080         g_param_spec_boolean(
1081             "is-controlled-by-automation",
1082             "Is Controlled By Automation",
1083             _("Whether the web view is controlled by automation"),
1084             FALSE,
1085             static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
1086
1087     /**
1088      * WebKitWebView:editable:
1089      *
1090      * Whether the pages loaded inside #WebKitWebView are editable. For more
1091      * information see webkit_web_view_set_editable().
1092      *
1093      * Since: 2.8
1094      */
1095     g_object_class_install_property(
1096         gObjectClass,
1097         PROP_EDITABLE,
1098         g_param_spec_boolean(
1099             "editable",
1100             _("Editable"),
1101             _("Whether the content can be modified by the user."),
1102             FALSE,
1103             WEBKIT_PARAM_READWRITE));
1104
1105     /**
1106      * WebKitWebView::load-changed:
1107      * @web_view: the #WebKitWebView on which the signal is emitted
1108      * @load_event: the #WebKitLoadEvent
1109      *
1110      * Emitted when a load operation in @web_view changes.
1111      * The signal is always emitted with %WEBKIT_LOAD_STARTED when a
1112      * new load request is made and %WEBKIT_LOAD_FINISHED when the load
1113      * finishes successfully or due to an error. When the ongoing load
1114      * operation fails #WebKitWebView::load-failed signal is emitted
1115      * before #WebKitWebView::load-changed is emitted with
1116      * %WEBKIT_LOAD_FINISHED.
1117      * If a redirection is received from the server, this signal is emitted
1118      * with %WEBKIT_LOAD_REDIRECTED after the initial emission with
1119      * %WEBKIT_LOAD_STARTED and before %WEBKIT_LOAD_COMMITTED.
1120      * When the page content starts arriving the signal is emitted with
1121      * %WEBKIT_LOAD_COMMITTED event.
1122      *
1123      * You can handle this signal and use a switch to track any ongoing
1124      * load operation.
1125      *
1126      * <informalexample><programlisting>
1127      * static void web_view_load_changed (WebKitWebView  *web_view,
1128      *                                    WebKitLoadEvent load_event,
1129      *                                    gpointer        user_data)
1130      * {
1131      *     switch (load_event) {
1132      *     case WEBKIT_LOAD_STARTED:
1133      *         /<!-- -->* New load, we have now a provisional URI *<!-- -->/
1134      *         provisional_uri = webkit_web_view_get_uri (web_view);
1135      *         /<!-- -->* Here we could start a spinner or update the
1136      *          <!-- -->* location bar with the provisional URI *<!-- -->/
1137      *         break;
1138      *     case WEBKIT_LOAD_REDIRECTED:
1139      *         redirected_uri = webkit_web_view_get_uri (web_view);
1140      *         break;
1141      *     case WEBKIT_LOAD_COMMITTED:
1142      *         /<!-- -->* The load is being performed. Current URI is
1143      *          <!-- -->* the final one and it won't change unless a new
1144      *          <!-- -->* load is requested or a navigation within the
1145      *          <!-- -->* same page is performed *<!-- -->/
1146      *         uri = webkit_web_view_get_uri (web_view);
1147      *         break;
1148      *     case WEBKIT_LOAD_FINISHED:
1149      *         /<!-- -->* Load finished, we can now stop the spinner *<!-- -->/
1150      *         break;
1151      *     }
1152      * }
1153      * </programlisting></informalexample>
1154      */
1155     signals[LOAD_CHANGED] =
1156         g_signal_new("load-changed",
1157                      G_TYPE_FROM_CLASS(webViewClass),
1158                      G_SIGNAL_RUN_LAST,
1159                      G_STRUCT_OFFSET(WebKitWebViewClass, load_changed),
1160                      0, 0,
1161                      g_cclosure_marshal_VOID__ENUM,
1162                      G_TYPE_NONE, 1,
1163                      WEBKIT_TYPE_LOAD_EVENT);
1164
1165     /**
1166      * WebKitWebView::load-failed:
1167      * @web_view: the #WebKitWebView on which the signal is emitted
1168      * @load_event: the #WebKitLoadEvent of the load operation
1169      * @failing_uri: the URI that failed to load
1170      * @error: the #GError that was triggered
1171      *
1172      * Emitted when an error occurs during a load operation.
1173      * If the error happened when starting to load data for a page
1174      * @load_event will be %WEBKIT_LOAD_STARTED. If it happened while
1175      * loading a committed data source @load_event will be %WEBKIT_LOAD_COMMITTED.
1176      * Since a load error causes the load operation to finish, the signal
1177      * WebKitWebView::load-changed will always be emitted with
1178      * %WEBKIT_LOAD_FINISHED event right after this one.
1179      *
1180      * By default, if the signal is not handled, a stock error page will be displayed.
1181      * You need to handle the signal if you want to provide your own error page.
1182      *
1183      * Returns: %TRUE to stop other handlers from being invoked for the event.
1184      *    %FALSE to propagate the event further.
1185      */
1186     signals[LOAD_FAILED] =
1187         g_signal_new(
1188             "load-failed",
1189             G_TYPE_FROM_CLASS(webViewClass),
1190             G_SIGNAL_RUN_LAST,
1191             G_STRUCT_OFFSET(WebKitWebViewClass, load_failed),
1192             g_signal_accumulator_true_handled, 0,
1193             g_cclosure_marshal_generic,
1194             G_TYPE_BOOLEAN, 3,
1195             WEBKIT_TYPE_LOAD_EVENT,
1196             G_TYPE_STRING,
1197             G_TYPE_ERROR | G_SIGNAL_TYPE_STATIC_SCOPE);
1198
1199     /**
1200      * WebKitWebView::load-failed-with-tls-errors:
1201      * @web_view: the #WebKitWebView on which the signal is emitted
1202      * @failing_uri: the URI that failed to load
1203      * @certificate: a #GTlsCertificate
1204      * @errors: a #GTlsCertificateFlags with the verification status of @certificate
1205      *
1206      * Emitted when a TLS error occurs during a load operation.
1207      * To allow an exception for this @certificate
1208      * and the host of @failing_uri use webkit_web_context_allow_tls_certificate_for_host().
1209      *
1210      * To handle this signal asynchronously you should call g_object_ref() on @certificate
1211      * and return %TRUE.
1212      *
1213      * If %FALSE is returned, #WebKitWebView::load-failed will be emitted. The load
1214      * will finish regardless of the returned value.
1215      *
1216      * Returns: %TRUE to stop other handlers from being invoked for the event.
1217      *   %FALSE to propagate the event further.
1218      *
1219      * Since: 2.6
1220      */
1221     signals[LOAD_FAILED_WITH_TLS_ERRORS] =
1222         g_signal_new("load-failed-with-tls-errors",
1223             G_TYPE_FROM_CLASS(webViewClass),
1224             G_SIGNAL_RUN_LAST,
1225             G_STRUCT_OFFSET(WebKitWebViewClass, load_failed_with_tls_errors),
1226             g_signal_accumulator_true_handled, 0 /* accumulator data */,
1227             g_cclosure_marshal_generic,
1228             G_TYPE_BOOLEAN, 3,
1229             G_TYPE_STRING,
1230             G_TYPE_TLS_CERTIFICATE,
1231             G_TYPE_TLS_CERTIFICATE_FLAGS);
1232
1233     /**
1234      * WebKitWebView::create:
1235      * @web_view: the #WebKitWebView on which the signal is emitted
1236      * @navigation_action: a #WebKitNavigationAction
1237      *
1238      * Emitted when the creation of a new #WebKitWebView is requested.
1239      * If this signal is handled the signal handler should return the
1240      * newly created #WebKitWebView.
1241      *
1242      * The #WebKitNavigationAction parameter contains information about the
1243      * navigation action that triggered this signal.
1244      *
1245      * When using %WEBKIT_PROCESS_MODEL_MULTIPLE_SECONDARY_PROCESSES
1246      * process model, the new #WebKitWebView should be related to
1247      * @web_view to share the same web process, see webkit_web_view_new_with_related_view()
1248      * for more details.
1249      *
1250      * The new #WebKitWebView should not be displayed to the user
1251      * until the #WebKitWebView::ready-to-show signal is emitted.
1252      *
1253      * Returns: (transfer full): a newly allocated #WebKitWebView widget
1254      *    or %NULL to propagate the event further.
1255      */
1256     signals[CREATE] = g_signal_new(
1257         "create",
1258         G_TYPE_FROM_CLASS(webViewClass),
1259         G_SIGNAL_RUN_LAST,
1260         G_STRUCT_OFFSET(WebKitWebViewClass, create),
1261         webkitWebViewAccumulatorObjectHandled, 0,
1262         g_cclosure_marshal_generic,
1263 #if PLATFORM(GTK)
1264         GTK_TYPE_WIDGET,
1265 #else
1266         WEBKIT_TYPE_WEB_VIEW,
1267 #endif
1268         1,
1269         WEBKIT_TYPE_NAVIGATION_ACTION | G_SIGNAL_TYPE_STATIC_SCOPE);
1270
1271     /**
1272      * WebKitWebView::ready-to-show:
1273      * @web_view: the #WebKitWebView on which the signal is emitted
1274      *
1275      * Emitted after #WebKitWebView::create on the newly created #WebKitWebView
1276      * when it should be displayed to the user. When this signal is emitted
1277      * all the information about how the window should look, including
1278      * size, position, whether the location, status and scrollbars
1279      * should be displayed, is already set on the #WebKitWindowProperties
1280      * of @web_view. See also webkit_web_view_get_window_properties().
1281      */
1282     signals[READY_TO_SHOW] =
1283         g_signal_new("ready-to-show",
1284                      G_TYPE_FROM_CLASS(webViewClass),
1285                      G_SIGNAL_RUN_LAST,
1286                      G_STRUCT_OFFSET(WebKitWebViewClass, ready_to_show),
1287                      0, 0,
1288                      g_cclosure_marshal_VOID__VOID,
1289                      G_TYPE_NONE, 0);
1290
1291      /**
1292      * WebKitWebView::run-as-modal:
1293      * @web_view: the #WebKitWebView on which the signal is emitted
1294      *
1295      * Emitted after #WebKitWebView::ready-to-show on the newly
1296      * created #WebKitWebView when JavaScript code calls
1297      * <function>window.showModalDialog</function>. The purpose of
1298      * this signal is to allow the client application to prepare the
1299      * new view to behave as modal. Once the signal is emitted a new
1300      * main loop will be run to block user interaction in the parent
1301      * #WebKitWebView until the new dialog is closed.
1302      */
1303     signals[RUN_AS_MODAL] =
1304             g_signal_new("run-as-modal",
1305                          G_TYPE_FROM_CLASS(webViewClass),
1306                          G_SIGNAL_RUN_LAST,
1307                          G_STRUCT_OFFSET(WebKitWebViewClass, run_as_modal),
1308                          0, 0,
1309                          g_cclosure_marshal_VOID__VOID,
1310                          G_TYPE_NONE, 0);
1311
1312     /**
1313      * WebKitWebView::close:
1314      * @web_view: the #WebKitWebView on which the signal is emitted
1315      *
1316      * Emitted when closing a #WebKitWebView is requested. This occurs when a
1317      * call is made from JavaScript's <function>window.close</function> function or
1318      * after trying to close the @web_view with webkit_web_view_try_close().
1319      * It is the owner's responsibility to handle this signal to hide or
1320      * destroy the #WebKitWebView, if necessary.
1321      */
1322     signals[CLOSE] =
1323         g_signal_new("close",
1324                      G_TYPE_FROM_CLASS(webViewClass),
1325                      G_SIGNAL_RUN_LAST,
1326                      G_STRUCT_OFFSET(WebKitWebViewClass, close),
1327                      0, 0,
1328                      g_cclosure_marshal_VOID__VOID,
1329                      G_TYPE_NONE, 0);
1330
1331     /**
1332      * WebKitWebView::script-dialog:
1333      * @web_view: the #WebKitWebView on which the signal is emitted
1334      * @dialog: the #WebKitScriptDialog to show
1335      *
1336      * Emitted when JavaScript code calls <function>window.alert</function>,
1337      * <function>window.confirm</function> or <function>window.prompt</function>,
1338      * or when <function>onbeforeunload</function> event is fired.
1339      * The @dialog parameter should be used to build the dialog.
1340      * If the signal is not handled a different dialog will be built and shown depending
1341      * on the dialog type:
1342      * <itemizedlist>
1343      * <listitem><para>
1344      *  %WEBKIT_SCRIPT_DIALOG_ALERT: message dialog with a single Close button.
1345      * </para></listitem>
1346      * <listitem><para>
1347      *  %WEBKIT_SCRIPT_DIALOG_CONFIRM: message dialog with OK and Cancel buttons.
1348      * </para></listitem>
1349      * <listitem><para>
1350      *  %WEBKIT_SCRIPT_DIALOG_PROMPT: message dialog with OK and Cancel buttons and
1351      *  a text entry with the default text.
1352      * </para></listitem>
1353      * <listitem><para>
1354      *  %WEBKIT_SCRIPT_DIALOG_BEFORE_UNLOAD_CONFIRM: message dialog with Stay and Leave buttons.
1355      * </para></listitem>
1356      * </itemizedlist>
1357      *
1358      * Returns: %TRUE to stop other handlers from being invoked for the event.
1359      *    %FALSE to propagate the event further.
1360      */
1361     signals[SCRIPT_DIALOG] = g_signal_new(
1362         "script-dialog",
1363         G_TYPE_FROM_CLASS(webViewClass),
1364         G_SIGNAL_RUN_LAST,
1365         G_STRUCT_OFFSET(WebKitWebViewClass, script_dialog),
1366         g_signal_accumulator_true_handled, nullptr,
1367         g_cclosure_marshal_generic,
1368         G_TYPE_BOOLEAN, 1,
1369         WEBKIT_TYPE_SCRIPT_DIALOG | G_SIGNAL_TYPE_STATIC_SCOPE);
1370
1371     /**
1372      * WebKitWebView::decide-policy:
1373      * @web_view: the #WebKitWebView on which the signal is emitted
1374      * @decision: the #WebKitPolicyDecision
1375      * @decision_type: a #WebKitPolicyDecisionType denoting the type of @decision
1376      *
1377      * This signal is emitted when WebKit is requesting the client to decide a policy
1378      * decision, such as whether to navigate to a page, open a new window or whether or
1379      * not to download a resource. The #WebKitNavigationPolicyDecision passed in the
1380      * @decision argument is a generic type, but should be casted to a more
1381      * specific type when making the decision. For example:
1382      *
1383      * <informalexample><programlisting>
1384      * static gboolean
1385      * decide_policy_cb (WebKitWebView *web_view,
1386      *                   WebKitPolicyDecision *decision,
1387      *                   WebKitPolicyDecisionType type)
1388      * {
1389      *     switch (type) {
1390      *     case WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION: {
1391      *         WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision);
1392      *         /<!-- -->* Make a policy decision here. *<!-- -->/
1393      *         break;
1394      *     }
1395      *     case WEBKIT_POLICY_DECISION_TYPE_NEW_WINDOW_ACTION: {
1396      *         WebKitNavigationPolicyDecision *navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION (decision);
1397      *         /<!-- -->* Make a policy decision here. *<!-- -->/
1398      *         break;
1399      *     }
1400      *     case WEBKIT_POLICY_DECISION_TYPE_RESPONSE:
1401      *         WebKitResponsePolicyDecision *response = WEBKIT_RESPONSE_POLICY_DECISION (decision);
1402      *         /<!-- -->* Make a policy decision here. *<!-- -->/
1403      *         break;
1404      *     default:
1405      *         /<!-- -->* Making no decision results in webkit_policy_decision_use(). *<!-- -->/
1406      *         return FALSE;
1407      *     }
1408      *     return TRUE;
1409      * }
1410      * </programlisting></informalexample>
1411      *
1412      * It is possible to make policy decision asynchronously, by simply calling g_object_ref()
1413      * on the @decision argument and returning %TRUE to block the default signal handler.
1414      * If the last reference is removed on a #WebKitPolicyDecision and no decision has been
1415      * made explicitly, webkit_policy_decision_use() will be the default policy decision. The
1416      * default signal handler will simply call webkit_policy_decision_use(). Only the first
1417      * policy decision chosen for a given #WebKitPolicyDecision will have any affect.
1418      *
1419      * Returns: %TRUE to stop other handlers from being invoked for the event.
1420      *   %FALSE to propagate the event further.
1421      *
1422      */
1423     signals[DECIDE_POLICY] = g_signal_new(
1424         "decide-policy",
1425         G_TYPE_FROM_CLASS(webViewClass),
1426         G_SIGNAL_RUN_LAST,
1427         G_STRUCT_OFFSET(WebKitWebViewClass, decide_policy),
1428         g_signal_accumulator_true_handled, nullptr /* accumulator data */,
1429         g_cclosure_marshal_generic,
1430         G_TYPE_BOOLEAN, 2, /* number of parameters */
1431         WEBKIT_TYPE_POLICY_DECISION,
1432         WEBKIT_TYPE_POLICY_DECISION_TYPE);
1433
1434     /**
1435      * WebKitWebView::permission-request:
1436      * @web_view: the #WebKitWebView on which the signal is emitted
1437      * @request: the #WebKitPermissionRequest
1438      *
1439      * This signal is emitted when WebKit is requesting the client to
1440      * decide about a permission request, such as allowing the browser
1441      * to switch to fullscreen mode, sharing its location or similar
1442      * operations.
1443      *
1444      * A possible way to use this signal could be through a dialog
1445      * allowing the user decide what to do with the request:
1446      *
1447      * <informalexample><programlisting>
1448      * static gboolean permission_request_cb (WebKitWebView *web_view,
1449      *                                        WebKitPermissionRequest *request,
1450      *                                        GtkWindow *parent_window)
1451      * {
1452      *     GtkWidget *dialog = gtk_message_dialog_new (parent_window,
1453      *                                                 GTK_DIALOG_MODAL,
1454      *                                                 GTK_MESSAGE_QUESTION,
1455      *                                                 GTK_BUTTONS_YES_NO,
1456      *                                                 "Allow Permission Request?");
1457      *     gtk_widget_show (dialog);
1458      *     gint result = gtk_dialog_run (GTK_DIALOG (dialog));
1459      *
1460      *     switch (result) {
1461      *     case GTK_RESPONSE_YES:
1462      *         webkit_permission_request_allow (request);
1463      *         break;
1464      *     default:
1465      *         webkit_permission_request_deny (request);
1466      *         break;
1467      *     }
1468      *     gtk_widget_destroy (dialog);
1469      *
1470      *     return TRUE;
1471      * }
1472      * </programlisting></informalexample>
1473      *
1474      * It is possible to handle permission requests asynchronously, by
1475      * simply calling g_object_ref() on the @request argument and
1476      * returning %TRUE to block the default signal handler.  If the
1477      * last reference is removed on a #WebKitPermissionRequest and the
1478      * request has not been handled, webkit_permission_request_deny()
1479      * will be the default action.
1480      *
1481      * If the signal is not handled, the @request will be completed automatically
1482      * by the specific #WebKitPermissionRequest that could allow or deny it. Check the
1483      * documentation of classes implementing #WebKitPermissionRequest interface to know
1484      * their default action.
1485      *
1486      * Returns: %TRUE to stop other handlers from being invoked for the event.
1487      *   %FALSE to propagate the event further.
1488      *
1489      */
1490     signals[PERMISSION_REQUEST] = g_signal_new(
1491         "permission-request",
1492         G_TYPE_FROM_CLASS(webViewClass),
1493         G_SIGNAL_RUN_LAST,
1494         G_STRUCT_OFFSET(WebKitWebViewClass, permission_request),
1495         g_signal_accumulator_true_handled, nullptr /* accumulator data */,
1496         g_cclosure_marshal_generic,
1497         G_TYPE_BOOLEAN, 1, /* number of parameters */
1498         WEBKIT_TYPE_PERMISSION_REQUEST);
1499     /**
1500      * WebKitWebView::mouse-target-changed:
1501      * @web_view: the #WebKitWebView on which the signal is emitted
1502      * @hit_test_result: a #WebKitHitTestResult
1503      * @modifiers: a bitmask of #GdkModifierType
1504      *
1505      * This signal is emitted when the mouse cursor moves over an
1506      * element such as a link, image or a media element. To determine
1507      * what type of element the mouse cursor is over, a Hit Test is performed
1508      * on the current mouse coordinates and the result is passed in the
1509      * @hit_test_result argument. The @modifiers argument is a bitmask of
1510      * #GdkModifierType flags indicating the state of modifier keys.
1511      * The signal is emitted again when the mouse is moved out of the
1512      * current element with a new @hit_test_result.
1513      */
1514     signals[MOUSE_TARGET_CHANGED] = g_signal_new(
1515         "mouse-target-changed",
1516         G_TYPE_FROM_CLASS(webViewClass),
1517         G_SIGNAL_RUN_LAST,
1518         G_STRUCT_OFFSET(WebKitWebViewClass, mouse_target_changed),
1519         nullptr, nullptr,
1520         g_cclosure_marshal_generic,
1521         G_TYPE_NONE, 2,
1522         WEBKIT_TYPE_HIT_TEST_RESULT,
1523         G_TYPE_UINT);
1524
1525 #if PLATFORM(GTK)
1526     /**
1527      * WebKitWebView::print:
1528      * @web_view: the #WebKitWebView on which the signal is emitted
1529      * @print_operation: the #WebKitPrintOperation that will handle the print request
1530      *
1531      * Emitted when printing is requested on @web_view, usually by a JavaScript call,
1532      * before the print dialog is shown. This signal can be used to set the initial
1533      * print settings and page setup of @print_operation to be used as default values in
1534      * the print dialog. You can call webkit_print_operation_set_print_settings() and
1535      * webkit_print_operation_set_page_setup() and then return %FALSE to propagate the
1536      * event so that the print dialog is shown.
1537      *
1538      * You can connect to this signal and return %TRUE to cancel the print operation
1539      * or implement your own print dialog.
1540      *
1541      * Returns: %TRUE to stop other handlers from being invoked for the event.
1542      *    %FALSE to propagate the event further.
1543      */
1544     signals[PRINT] = g_signal_new(
1545         "print",
1546         G_TYPE_FROM_CLASS(webViewClass),
1547         G_SIGNAL_RUN_LAST,
1548         G_STRUCT_OFFSET(WebKitWebViewClass, print),
1549         g_signal_accumulator_true_handled, nullptr,
1550         g_cclosure_marshal_generic,
1551         G_TYPE_BOOLEAN, 1,
1552         WEBKIT_TYPE_PRINT_OPERATION);
1553 #endif // PLATFORM(GTK)
1554
1555     /**
1556      * WebKitWebView::resource-load-started:
1557      * @web_view: the #WebKitWebView on which the signal is emitted
1558      * @resource: a #WebKitWebResource
1559      * @request: a #WebKitURIRequest
1560      *
1561      * Emitted when a new resource is going to be loaded. The @request parameter
1562      * contains the #WebKitURIRequest that will be sent to the server.
1563      * You can monitor the load operation by connecting to the different signals
1564      * of @resource.
1565      */
1566     signals[RESOURCE_LOAD_STARTED] = g_signal_new(
1567         "resource-load-started",
1568         G_TYPE_FROM_CLASS(webViewClass),
1569         G_SIGNAL_RUN_LAST,
1570         G_STRUCT_OFFSET(WebKitWebViewClass, resource_load_started),
1571         nullptr, nullptr,
1572         g_cclosure_marshal_generic,
1573         G_TYPE_NONE, 2,
1574         WEBKIT_TYPE_WEB_RESOURCE,
1575                      WEBKIT_TYPE_URI_REQUEST);
1576
1577     /**
1578      * WebKitWebView::enter-fullscreen:
1579      * @web_view: the #WebKitWebView on which the signal is emitted.
1580      *
1581      * Emitted when JavaScript code calls
1582      * <function>element.webkitRequestFullScreen</function>. If the
1583      * signal is not handled the #WebKitWebView will proceed to full screen
1584      * its top level window. This signal can be used by client code to
1585      * request permission to the user prior doing the full screen
1586      * transition and eventually prepare the top-level window
1587      * (e.g. hide some widgets that would otherwise be part of the
1588      * full screen window).
1589      *
1590      * Returns: %TRUE to stop other handlers from being invoked for the event.
1591      *    %FALSE to continue emission of the event.
1592      */
1593     signals[ENTER_FULLSCREEN] = g_signal_new(
1594         "enter-fullscreen",
1595         G_TYPE_FROM_CLASS(webViewClass),
1596         G_SIGNAL_RUN_LAST,
1597         G_STRUCT_OFFSET(WebKitWebViewClass, enter_fullscreen),
1598         g_signal_accumulator_true_handled, nullptr,
1599         g_cclosure_marshal_generic,
1600         G_TYPE_BOOLEAN, 0);
1601
1602     /**
1603      * WebKitWebView::leave-fullscreen:
1604      * @web_view: the #WebKitWebView on which the signal is emitted.
1605      *
1606      * Emitted when the #WebKitWebView is about to restore its top level
1607      * window out of its full screen state. This signal can be used by
1608      * client code to restore widgets hidden during the
1609      * #WebKitWebView::enter-fullscreen stage for instance.
1610      *
1611      * Returns: %TRUE to stop other handlers from being invoked for the event.
1612      *    %FALSE to continue emission of the event.
1613      */
1614     signals[LEAVE_FULLSCREEN] = g_signal_new(
1615         "leave-fullscreen",
1616         G_TYPE_FROM_CLASS(webViewClass),
1617         G_SIGNAL_RUN_LAST,
1618         G_STRUCT_OFFSET(WebKitWebViewClass, leave_fullscreen),
1619         g_signal_accumulator_true_handled, nullptr,
1620         g_cclosure_marshal_generic,
1621         G_TYPE_BOOLEAN, 0);
1622
1623      /**
1624      * WebKitWebView::run-file-chooser:
1625      * @web_view: the #WebKitWebView on which the signal is emitted
1626      * @request: a #WebKitFileChooserRequest
1627      *
1628      * This signal is emitted when the user interacts with a &lt;input
1629      * type='file' /&gt; HTML element, requesting from WebKit to show
1630      * a dialog to select one or more files to be uploaded. To let the
1631      * application know the details of the file chooser, as well as to
1632      * allow the client application to either cancel the request or
1633      * perform an actual selection of files, the signal will pass an
1634      * instance of the #WebKitFileChooserRequest in the @request
1635      * argument.
1636      *
1637      * The default signal handler will asynchronously run a regular
1638      * #GtkFileChooserDialog for the user to interact with.
1639      *
1640      * Returns: %TRUE to stop other handlers from being invoked for the event.
1641      *   %FALSE to propagate the event further.
1642      *
1643      */
1644     signals[RUN_FILE_CHOOSER] = g_signal_new(
1645         "run-file-chooser",
1646         G_TYPE_FROM_CLASS(webViewClass),
1647         G_SIGNAL_RUN_LAST,
1648         G_STRUCT_OFFSET(WebKitWebViewClass, run_file_chooser),
1649         g_signal_accumulator_true_handled, nullptr /* accumulator data */,
1650         g_cclosure_marshal_generic,
1651         G_TYPE_BOOLEAN, 1, /* number of parameters */
1652         WEBKIT_TYPE_FILE_CHOOSER_REQUEST);
1653
1654     /**
1655      * WebKitWebView::context-menu:
1656      * @web_view: the #WebKitWebView on which the signal is emitted
1657      * @context_menu: the proposed #WebKitContextMenu
1658      * @event: the #GdkEvent that triggered the context menu
1659      * @hit_test_result: a #WebKitHitTestResult
1660      *
1661      * Emitted when a context menu is about to be displayed to give the application
1662      * a chance to customize the proposed menu, prevent the menu from being displayed,
1663      * or build its own context menu.
1664      * <itemizedlist>
1665      * <listitem><para>
1666      *  To customize the proposed menu you can use webkit_context_menu_prepend(),
1667      *  webkit_context_menu_append() or webkit_context_menu_insert() to add new
1668      *  #WebKitContextMenuItem<!-- -->s to @context_menu, webkit_context_menu_move_item()
1669      *  to reorder existing items, or webkit_context_menu_remove() to remove an
1670      *  existing item. The signal handler should return %FALSE, and the menu represented
1671      *  by @context_menu will be shown.
1672      * </para></listitem>
1673      * <listitem><para>
1674      *  To prevent the menu from being displayed you can just connect to this signal
1675      *  and return %TRUE so that the proposed menu will not be shown.
1676      * </para></listitem>
1677      * <listitem><para>
1678      *  To build your own menu, you can remove all items from the proposed menu with
1679      *  webkit_context_menu_remove_all(), add your own items and return %FALSE so
1680      *  that the menu will be shown. You can also ignore the proposed #WebKitContextMenu,
1681      *  build your own #GtkMenu and return %TRUE to prevent the proposed menu from being shown.
1682      * </para></listitem>
1683      * <listitem><para>
1684      *  If you just want the default menu to be shown always, simply don't connect to this
1685      *  signal because showing the proposed context menu is the default behaviour.
1686      * </para></listitem>
1687      * </itemizedlist>
1688      *
1689      * The @event is expected to be one of the following types:
1690      * <itemizedlist>
1691      * <listitem><para>
1692      * a #GdkEventButton of type %GDK_BUTTON_PRESS when the context menu
1693      * was triggered with mouse.
1694      * </para></listitem>
1695      * <listitem><para>
1696      * a #GdkEventKey of type %GDK_KEY_PRESS if the keyboard was used to show
1697      * the menu.
1698      * </para></listitem>
1699      * <listitem><para>
1700      * a generic #GdkEvent of type %GDK_NOTHING when the #GtkWidget::popup-menu
1701      * signal was used to show the context menu.
1702      * </para></listitem>
1703      * </itemizedlist>
1704      *
1705      * If the signal handler returns %FALSE the context menu represented by @context_menu
1706      * will be shown, if it return %TRUE the context menu will not be shown.
1707      *
1708      * The proposed #WebKitContextMenu passed in @context_menu argument is only valid
1709      * during the signal emission.
1710      *
1711      * Returns: %TRUE to stop other handlers from being invoked for the event.
1712      *    %FALSE to propagate the event further.
1713      */
1714     signals[CONTEXT_MENU] = g_signal_new(
1715         "context-menu",
1716         G_TYPE_FROM_CLASS(webViewClass),
1717         G_SIGNAL_RUN_LAST,
1718         G_STRUCT_OFFSET(WebKitWebViewClass, context_menu),
1719         g_signal_accumulator_true_handled, nullptr,
1720         g_cclosure_marshal_generic,
1721         G_TYPE_BOOLEAN, 3,
1722         WEBKIT_TYPE_CONTEXT_MENU,
1723 #if PLATFORM(GTK)
1724         GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE,
1725 #elif PLATFORM(WPE)
1726         G_TYPE_POINTER, // FIXME: use a wpe thing here. I'm not sure we want to expose libwpe in the API.
1727 #endif
1728         WEBKIT_TYPE_HIT_TEST_RESULT);
1729
1730     /**
1731      * WebKitWebView::context-menu-dismissed:
1732      * @web_view: the #WebKitWebView on which the signal is emitted
1733      *
1734      * Emitted after #WebKitWebView::context-menu signal, if the context menu is shown,
1735      * to notify that the context menu is dismissed.
1736      */
1737     signals[CONTEXT_MENU_DISMISSED] =
1738         g_signal_new("context-menu-dismissed",
1739                      G_TYPE_FROM_CLASS(webViewClass),
1740                      G_SIGNAL_RUN_LAST,
1741                      G_STRUCT_OFFSET(WebKitWebViewClass, context_menu_dismissed),
1742                      0, 0,
1743                      g_cclosure_marshal_VOID__VOID,
1744                      G_TYPE_NONE, 0);
1745
1746     /**
1747      * WebKitWebView::submit-form:
1748      * @web_view: the #WebKitWebView on which the signal is emitted
1749      * @request: a #WebKitFormSubmissionRequest
1750      *
1751      * This signal is emitted when a form is about to be submitted. The @request
1752      * argument passed contains information about the text fields of the form. This
1753      * is typically used to store login information that can be used later to
1754      * pre-fill the form.
1755      * The form will not be submitted until webkit_form_submission_request_submit() is called.
1756      *
1757      * It is possible to handle the form submission request asynchronously, by
1758      * simply calling g_object_ref() on the @request argument and calling
1759      * webkit_form_submission_request_submit() when done to continue with the form submission.
1760      * If the last reference is removed on a #WebKitFormSubmissionRequest and the
1761      * form has not been submitted, webkit_form_submission_request_submit() will be called.
1762      */
1763     signals[SUBMIT_FORM] =
1764         g_signal_new("submit-form",
1765                      G_TYPE_FROM_CLASS(webViewClass),
1766                      G_SIGNAL_RUN_LAST,
1767                      G_STRUCT_OFFSET(WebKitWebViewClass, submit_form),
1768                      0, 0,
1769                      g_cclosure_marshal_VOID__OBJECT,
1770                      G_TYPE_NONE, 1,
1771                      WEBKIT_TYPE_FORM_SUBMISSION_REQUEST);
1772
1773     /**
1774      * WebKitWebView::insecure-content-detected:
1775      * @web_view: the #WebKitWebView on which the signal is emitted
1776      * @event: the #WebKitInsecureContentEvent
1777      *
1778      * This signal is emitted when insecure content has been detected
1779      * in a page loaded through a secure connection. This typically
1780      * means that a external resource from an unstrusted source has
1781      * been run or displayed, resulting in a mix of HTTPS and
1782      * non-HTTPS content.
1783      *
1784      * You can check the @event parameter to know exactly which kind
1785      * of event has been detected (see #WebKitInsecureContentEvent).
1786      */
1787     signals[INSECURE_CONTENT_DETECTED] =
1788         g_signal_new("insecure-content-detected",
1789             G_TYPE_FROM_CLASS(webViewClass),
1790             G_SIGNAL_RUN_LAST,
1791             G_STRUCT_OFFSET(WebKitWebViewClass, insecure_content_detected),
1792             0, 0,
1793             g_cclosure_marshal_VOID__ENUM,
1794             G_TYPE_NONE, 1,
1795             WEBKIT_TYPE_INSECURE_CONTENT_EVENT);
1796
1797 #if PLATFORM(GTK)
1798     /**
1799      * WebKitWebView::web-process-crashed:
1800      * @web_view: the #WebKitWebView
1801      *
1802      * This signal is emitted when the web process crashes.
1803      *
1804      * Returns: %TRUE to stop other handlers from being invoked for the event.
1805      *    %FALSE to propagate the event further.
1806      *
1807      * Deprecated: 2.20: Use WebKitWebView::web-process-terminated instead.
1808      */
1809     signals[WEB_PROCESS_CRASHED] = g_signal_new(
1810         "web-process-crashed",
1811         G_TYPE_FROM_CLASS(webViewClass),
1812         G_SIGNAL_RUN_LAST,
1813         G_STRUCT_OFFSET(WebKitWebViewClass, web_process_crashed),
1814         g_signal_accumulator_true_handled, nullptr,
1815         g_cclosure_marshal_generic,
1816         G_TYPE_BOOLEAN, 0);
1817 #endif
1818
1819     /**
1820      * WebKitWebView::web-process-terminated:
1821      * @web_view: the #WebKitWebView
1822      * @reason: the a #WebKitWebProcessTerminationReason
1823      *
1824      * This signal is emitted when the web process terminates abnormally due
1825      * to @reason.
1826      *
1827      * Since: 2.20
1828      */
1829     signals[WEB_PROCESS_TERMINATED] = g_signal_new(
1830         "web-process-terminated",
1831         G_TYPE_FROM_CLASS(webViewClass),
1832         G_SIGNAL_RUN_LAST,
1833         G_STRUCT_OFFSET(WebKitWebViewClass, web_process_terminated),
1834         0, 0,
1835         g_cclosure_marshal_VOID__ENUM,
1836         G_TYPE_NONE, 1,
1837         WEBKIT_TYPE_WEB_PROCESS_TERMINATION_REASON);
1838
1839     /**
1840      * WebKitWebView::authenticate:
1841      * @web_view: the #WebKitWebView on which the signal is emitted
1842      * @request: a #WebKitAuthenticationRequest
1843      *
1844      * This signal is emitted when the user is challenged with HTTP
1845      * authentication. To let the  application access or supply
1846      * the credentials as well as to allow the client application
1847      * to either cancel the request or perform the authentication,
1848      * the signal will pass an instance of the
1849      * #WebKitAuthenticationRequest in the @request argument.
1850      * To handle this signal asynchronously you should keep a ref
1851      * of the request and return %TRUE. To disable HTTP authentication
1852      * entirely, connect to this signal and simply return %TRUE.
1853      *
1854      * The default signal handler will run a default authentication
1855      * dialog asynchronously for the user to interact with.
1856      *
1857      * Returns: %TRUE to stop other handlers from being invoked for the event.
1858      *   %FALSE to propagate the event further.
1859      *
1860      * Since: 2.2
1861      */
1862     signals[AUTHENTICATE] = g_signal_new(
1863         "authenticate",
1864         G_TYPE_FROM_CLASS(webViewClass),
1865         G_SIGNAL_RUN_LAST,
1866         G_STRUCT_OFFSET(WebKitWebViewClass, authenticate),
1867         g_signal_accumulator_true_handled, nullptr /* accumulator data */,
1868         g_cclosure_marshal_generic,
1869         G_TYPE_BOOLEAN, 1, /* number of parameters */
1870         WEBKIT_TYPE_AUTHENTICATION_REQUEST);
1871
1872     /**
1873      * WebKitWebView::show-notification:
1874      * @web_view: the #WebKitWebView
1875      * @notification: a #WebKitNotification
1876      *
1877      * This signal is emitted when a notification should be presented to the
1878      * user. The @notification is kept alive until either: 1) the web page cancels it
1879      * or 2) a navigation happens.
1880      *
1881      * The default handler will emit a notification using libnotify, if built with
1882      * support for it.
1883      *
1884      * Returns: %TRUE to stop other handlers from being invoked. %FALSE otherwise.
1885      *
1886      * Since: 2.8
1887      */
1888     signals[SHOW_NOTIFICATION] = g_signal_new(
1889         "show-notification",
1890         G_TYPE_FROM_CLASS(gObjectClass),
1891         G_SIGNAL_RUN_LAST,
1892         G_STRUCT_OFFSET(WebKitWebViewClass, show_notification),
1893         g_signal_accumulator_true_handled, nullptr /* accumulator data */,
1894         g_cclosure_marshal_generic,
1895         G_TYPE_BOOLEAN, 1,
1896         WEBKIT_TYPE_NOTIFICATION);
1897
1898 #if PLATFORM(GTK)
1899      /**
1900       * WebKitWebView::run-color-chooser:
1901       * @web_view: the #WebKitWebView on which the signal is emitted
1902       * @request: a #WebKitColorChooserRequest
1903       *
1904       * This signal is emitted when the user interacts with a &lt;input
1905       * type='color' /&gt; HTML element, requesting from WebKit to show
1906       * a dialog to select a color. To let the application know the details of
1907       * the color chooser, as well as to allow the client application to either
1908       * cancel the request or perform an actual color selection, the signal will
1909       * pass an instance of the #WebKitColorChooserRequest in the @request
1910       * argument.
1911       *
1912       * It is possible to handle this request asynchronously by increasing the
1913       * reference count of the request.
1914       *
1915       * The default signal handler will asynchronously run a regular
1916       * #GtkColorChooser for the user to interact with.
1917       *
1918       * Returns: %TRUE to stop other handlers from being invoked for the event.
1919       *   %FALSE to propagate the event further.
1920       *
1921       * Since: 2.8
1922       */
1923     signals[RUN_COLOR_CHOOSER] = g_signal_new(
1924         "run-color-chooser",
1925         G_TYPE_FROM_CLASS(webViewClass),
1926         G_SIGNAL_RUN_LAST,
1927         G_STRUCT_OFFSET(WebKitWebViewClass, run_color_chooser),
1928         g_signal_accumulator_true_handled, nullptr,
1929         g_cclosure_marshal_generic,
1930         G_TYPE_BOOLEAN, 1,
1931         WEBKIT_TYPE_COLOR_CHOOSER_REQUEST);
1932
1933     /**
1934      * WebKitWebView::show-option-menu:
1935      * @web_view: the #WebKitWebView on which the signal is emitted
1936      * @menu: the #WebKitOptionMenu
1937      * @event: the #GdkEvent that triggered the menu, or %NULL
1938      * @rectangle: the option element area
1939      *
1940      * This signal is emitted when a select element in @web_view needs to display a
1941      * dropdown menu. This signal can be used to show a custom menu, using @menu to get
1942      * the details of all items that should be displayed. The area of the element in the
1943      * #WebKitWebView is given as @rectangle parameter, it can be used to position the
1944      * menu. If this was triggered by a user interaction, like a mouse click,
1945      * @event parameter provides the #GdkEvent.
1946      * To handle this signal asynchronously you should keep a ref of the @menu.
1947      *
1948      * The default signal handler will pop up a #GtkMenu.
1949      *
1950      * Returns: %TRUE to stop other handlers from being invoked for the event.
1951      *   %FALSE to propagate the event further.
1952      *
1953      * Since: 2.18
1954      */
1955     signals[SHOW_OPTION_MENU] = g_signal_new(
1956         "show-option-menu",
1957         G_TYPE_FROM_CLASS(webViewClass),
1958         G_SIGNAL_RUN_LAST,
1959         G_STRUCT_OFFSET(WebKitWebViewClass, show_option_menu),
1960         g_signal_accumulator_true_handled, nullptr,
1961         g_cclosure_marshal_generic,
1962         G_TYPE_BOOLEAN, 3,
1963         WEBKIT_TYPE_OPTION_MENU,
1964         GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE,
1965         GDK_TYPE_RECTANGLE | G_SIGNAL_TYPE_STATIC_SCOPE);
1966 #endif // PLATFORM(GTK)
1967 }
1968
1969 static void webkitWebViewCancelAuthenticationRequest(WebKitWebView* webView)
1970 {
1971     if (!webView->priv->authenticationRequest)
1972         return;
1973
1974     webkit_authentication_request_cancel(webView->priv->authenticationRequest.get());
1975     webView->priv->authenticationRequest.clear();
1976 }
1977
1978 void webkitWebViewCreatePage(WebKitWebView* webView, Ref<API::PageConfiguration>&& configuration)
1979 {
1980 #if PLATFORM(GTK)
1981     webkitWebViewBaseCreateWebPage(WEBKIT_WEB_VIEW_BASE(webView), WTFMove(configuration));
1982 #elif PLATFORM(WPE)
1983     webView->priv->view.reset(WKWPE::View::create(webkit_web_view_backend_get_wpe_backend(webView->priv->backend.get()), configuration.get()));
1984 #endif
1985 }
1986
1987 WebPageProxy& webkitWebViewGetPage(WebKitWebView* webView)
1988 {
1989     return getPage(webView);
1990 }
1991
1992 void webkitWebViewLoadChanged(WebKitWebView* webView, WebKitLoadEvent loadEvent)
1993 {
1994     WebKitWebViewPrivate* priv = webView->priv;
1995     switch (loadEvent) {
1996     case WEBKIT_LOAD_STARTED:
1997 #if PLATFORM(GTK)
1998         webkitWebViewCancelFaviconRequest(webView);
1999         webkitWebViewWatchForChangesInFavicon(webView);
2000 #endif
2001         webkitWebViewCancelAuthenticationRequest(webView);
2002         priv->loadingResourcesMap.clear();
2003         priv->mainResource = nullptr;
2004         break;
2005 #if PLATFORM(GTK)
2006     case WEBKIT_LOAD_COMMITTED: {
2007         WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context.get());
2008         GUniquePtr<char> faviconURI(webkit_favicon_database_get_favicon_uri(database, priv->activeURI.data()));
2009         webkitWebViewUpdateFaviconURI(webView, faviconURI.get());
2010         break;
2011     }
2012 #endif
2013     case WEBKIT_LOAD_FINISHED:
2014         webkitWebViewCancelAuthenticationRequest(webView);
2015         break;
2016     default:
2017         break;
2018     }
2019
2020     g_signal_emit(webView, signals[LOAD_CHANGED], 0, loadEvent);
2021 }
2022
2023 void webkitWebViewLoadFailed(WebKitWebView* webView, WebKitLoadEvent loadEvent, const char* failingURI, GError *error)
2024 {
2025     webkitWebViewCancelAuthenticationRequest(webView);
2026
2027     gboolean returnValue;
2028     g_signal_emit(webView, signals[LOAD_FAILED], 0, loadEvent, failingURI, error, &returnValue);
2029     g_signal_emit(webView, signals[LOAD_CHANGED], 0, WEBKIT_LOAD_FINISHED);
2030 }
2031
2032 void webkitWebViewLoadFailedWithTLSErrors(WebKitWebView* webView, const char* failingURI, GError* error, GTlsCertificateFlags tlsErrors, GTlsCertificate* certificate)
2033 {
2034     webkitWebViewCancelAuthenticationRequest(webView);
2035
2036     WebKitTLSErrorsPolicy tlsErrorsPolicy = webkit_web_context_get_tls_errors_policy(webView->priv->context.get());
2037     if (tlsErrorsPolicy == WEBKIT_TLS_ERRORS_POLICY_FAIL) {
2038         gboolean returnValue;
2039         g_signal_emit(webView, signals[LOAD_FAILED_WITH_TLS_ERRORS], 0, failingURI, certificate, tlsErrors, &returnValue);
2040         if (!returnValue)
2041             g_signal_emit(webView, signals[LOAD_FAILED], 0, WEBKIT_LOAD_STARTED, failingURI, error, &returnValue);
2042     }
2043
2044     g_signal_emit(webView, signals[LOAD_CHANGED], 0, WEBKIT_LOAD_FINISHED);
2045 }
2046
2047 #if PLATFORM(GTK)
2048 void webkitWebViewGetLoadDecisionForIcon(WebKitWebView* webView, const LinkIcon& icon, Function<void(bool)>&& completionHandler)
2049 {
2050     WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(webView->priv->context.get());
2051     webkitFaviconDatabaseGetLoadDecisionForIcon(database, icon, getPage(webView).pageLoadState().activeURL(), WTFMove(completionHandler));
2052 }
2053
2054 void webkitWebViewSetIcon(WebKitWebView* webView, const LinkIcon& icon, API::Data& iconData)
2055 {
2056     WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(webView->priv->context.get());
2057     webkitFaviconDatabaseSetIconForPageURL(database, icon, iconData, getPage(webView).pageLoadState().activeURL());
2058 }
2059 #endif
2060
2061 WebPageProxy* webkitWebViewCreateNewPage(WebKitWebView* webView, const WindowFeatures& windowFeatures, WebKitNavigationAction* navigationAction)
2062 {
2063     WebKitWebView* newWebView;
2064     g_signal_emit(webView, signals[CREATE], 0, navigationAction, &newWebView);
2065     if (!newWebView)
2066         return 0;
2067
2068     webkitWindowPropertiesUpdateFromWebWindowFeatures(newWebView->priv->windowProperties.get(), windowFeatures);
2069
2070     RefPtr<WebPageProxy> newPage = &getPage(newWebView);
2071     return newPage.leakRef();
2072 }
2073
2074 void webkitWebViewReadyToShowPage(WebKitWebView* webView)
2075 {
2076     g_signal_emit(webView, signals[READY_TO_SHOW], 0, NULL);
2077 }
2078
2079 void webkitWebViewRunAsModal(WebKitWebView* webView)
2080 {
2081     g_signal_emit(webView, signals[RUN_AS_MODAL], 0, NULL);
2082
2083     webView->priv->modalLoop = adoptGRef(g_main_loop_new(0, FALSE));
2084
2085 #if PLATFORM(GTK)
2086 // This is to suppress warnings about gdk_threads_leave and gdk_threads_enter.
2087 #pragma GCC diagnostic push
2088 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
2089     gdk_threads_leave();
2090 #endif
2091
2092     g_main_loop_run(webView->priv->modalLoop.get());
2093
2094 #if PLATFORM(GTK)
2095     gdk_threads_enter();
2096 #pragma GCC diagnostic pop
2097 #endif
2098 }
2099
2100 void webkitWebViewClosePage(WebKitWebView* webView)
2101 {
2102     g_signal_emit(webView, signals[CLOSE], 0, NULL);
2103 }
2104
2105 void webkitWebViewRunJavaScriptAlert(WebKitWebView* webView, const CString& message)
2106 {
2107     WebKitScriptDialog dialog(WEBKIT_SCRIPT_DIALOG_ALERT, message);
2108     SetForScope<WebKitScriptDialog*> change(webView->priv->currentScriptDialog, &dialog);
2109     gboolean returnValue;
2110     g_signal_emit(webView, signals[SCRIPT_DIALOG], 0, &dialog, &returnValue);
2111 }
2112
2113 bool webkitWebViewRunJavaScriptConfirm(WebKitWebView* webView, const CString& message)
2114 {
2115     WebKitScriptDialog dialog(WEBKIT_SCRIPT_DIALOG_CONFIRM, message);
2116     SetForScope<WebKitScriptDialog*> change(webView->priv->currentScriptDialog, &dialog);
2117     gboolean returnValue;
2118     g_signal_emit(webView, signals[SCRIPT_DIALOG], 0, &dialog, &returnValue);
2119     return dialog.confirmed;
2120 }
2121
2122 CString webkitWebViewRunJavaScriptPrompt(WebKitWebView* webView, const CString& message, const CString& defaultText)
2123 {
2124     WebKitScriptDialog dialog(WEBKIT_SCRIPT_DIALOG_PROMPT, message, defaultText);
2125     SetForScope<WebKitScriptDialog*> change(webView->priv->currentScriptDialog, &dialog);
2126     gboolean returnValue;
2127     g_signal_emit(webView, signals[SCRIPT_DIALOG], 0, &dialog, &returnValue);
2128     return dialog.text;
2129 }
2130
2131 bool webkitWebViewRunJavaScriptBeforeUnloadConfirm(WebKitWebView* webView, const CString& message)
2132 {
2133     WebKitScriptDialog dialog(WEBKIT_SCRIPT_DIALOG_BEFORE_UNLOAD_CONFIRM, message);
2134     SetForScope<WebKitScriptDialog*> change(webView->priv->currentScriptDialog, &dialog);
2135     gboolean returnValue;
2136     g_signal_emit(webView, signals[SCRIPT_DIALOG], 0, &dialog, &returnValue);
2137     return dialog.confirmed;
2138 }
2139
2140 bool webkitWebViewIsShowingScriptDialog(WebKitWebView* webView)
2141 {
2142     if (!webView->priv->currentScriptDialog)
2143         return false;
2144
2145     // FIXME: Add API to ask the user in case default implementation is not being used.
2146     return webkitScriptDialogIsRunning(webView->priv->currentScriptDialog);
2147 }
2148
2149 String webkitWebViewGetCurrentScriptDialogMessage(WebKitWebView* webView)
2150 {
2151     if (!webView->priv->currentScriptDialog)
2152         return { };
2153
2154     return String::fromUTF8(webView->priv->currentScriptDialog->message);
2155 }
2156
2157 void webkitWebViewSetCurrentScriptDialogUserInput(WebKitWebView* webView, const String& userInput)
2158 {
2159     if (!webView->priv->currentScriptDialog)
2160         return;
2161
2162     // FIXME: Add API to ask the user in case default implementation is not being used.
2163     if (webkitScriptDialogIsRunning(webView->priv->currentScriptDialog))
2164         webkitScriptDialogSetUserInput(webView->priv->currentScriptDialog, userInput);
2165 }
2166
2167 void webkitWebViewAcceptCurrentScriptDialog(WebKitWebView* webView)
2168 {
2169     if (!webView->priv->currentScriptDialog)
2170         return;
2171
2172     // FIXME: Add API to ask the user in case default implementation is not being used.
2173     if (webkitScriptDialogIsRunning(webView->priv->currentScriptDialog))
2174         webkitScriptDialogAccept(webView->priv->currentScriptDialog);
2175 }
2176
2177 void webkitWebViewDismissCurrentScriptDialog(WebKitWebView* webView)
2178 {
2179     if (!webView->priv->currentScriptDialog)
2180         return;
2181
2182     // FIXME: Add API to ask the user in case default implementation is not being used.
2183     if (webkitScriptDialogIsRunning(webView->priv->currentScriptDialog))
2184         webkitScriptDialogDismiss(webView->priv->currentScriptDialog);
2185 }
2186
2187 std::optional<WebKitScriptDialogType> webkitWebViewGetCurrentScriptDialogType(WebKitWebView* webView)
2188 {
2189     if (!webView->priv->currentScriptDialog)
2190         return std::nullopt;
2191
2192     return static_cast<WebKitScriptDialogType>(webView->priv->currentScriptDialog->type);
2193 }
2194
2195 void webkitWebViewMakePolicyDecision(WebKitWebView* webView, WebKitPolicyDecisionType type, WebKitPolicyDecision* decision)
2196 {
2197     gboolean returnValue;
2198     g_signal_emit(webView, signals[DECIDE_POLICY], 0, decision, type, &returnValue);
2199 }
2200
2201 void webkitWebViewMakePermissionRequest(WebKitWebView* webView, WebKitPermissionRequest* request)
2202 {
2203     gboolean returnValue;
2204     g_signal_emit(webView, signals[PERMISSION_REQUEST], 0, request, &returnValue);
2205 }
2206
2207 void webkitWebViewMouseTargetChanged(WebKitWebView* webView, const WebHitTestResultData& hitTestResult, WebEvent::Modifiers modifiers)
2208 {
2209 #if PLATFORM(GTK)
2210     webkitWebViewBaseSetTooltipArea(WEBKIT_WEB_VIEW_BASE(webView), hitTestResult.elementBoundingBox);
2211 #endif
2212
2213     WebKitWebViewPrivate* priv = webView->priv;
2214     if (priv->mouseTargetHitTestResult
2215         && priv->mouseTargetModifiers == modifiers
2216         && webkitHitTestResultCompare(priv->mouseTargetHitTestResult.get(), hitTestResult))
2217         return;
2218
2219     priv->mouseTargetModifiers = modifiers;
2220     priv->mouseTargetHitTestResult = adoptGRef(webkitHitTestResultCreate(hitTestResult));
2221     g_signal_emit(webView, signals[MOUSE_TARGET_CHANGED], 0, priv->mouseTargetHitTestResult.get(), toPlatformModifiers(modifiers));
2222 }
2223
2224 void webkitWebViewHandleDownloadRequest(WebKitWebView* webView, DownloadProxy* downloadProxy)
2225 {
2226     ASSERT(downloadProxy);
2227     GRefPtr<WebKitDownload> download = webkitWebContextGetOrCreateDownload(downloadProxy);
2228     webkitDownloadSetWebView(download.get(), webView);
2229 }
2230
2231 #if PLATFORM(GTK)
2232 void webkitWebViewPrintFrame(WebKitWebView* webView, WebFrameProxy* frame)
2233 {
2234     auto printOperation = adoptGRef(webkit_print_operation_new(webView));
2235     webkitPrintOperationSetPrintMode(printOperation.get(), PrintInfo::PrintModeSync);
2236     gboolean returnValue;
2237     g_signal_emit(webView, signals[PRINT], 0, printOperation.get(), &returnValue);
2238     if (returnValue)
2239         return;
2240
2241     WebKitPrintOperationResponse response = webkitPrintOperationRunDialogForFrame(printOperation.get(), 0, frame);
2242     if (response == WEBKIT_PRINT_OPERATION_RESPONSE_CANCEL)
2243         return;
2244     g_signal_connect(printOperation.leakRef(), "finished", G_CALLBACK(g_object_unref), 0);
2245 }
2246 #endif
2247
2248 void webkitWebViewResourceLoadStarted(WebKitWebView* webView, WebFrameProxy* frame, uint64_t resourceIdentifier, WebKitURIRequest* request)
2249 {
2250     WebKitWebViewPrivate* priv = webView->priv;
2251     bool isMainResource = frame->isMainFrame() && !priv->mainResource;
2252     WebKitWebResource* resource = webkitWebResourceCreate(frame, request, isMainResource);
2253     if (isMainResource)
2254         priv->mainResource = resource;
2255     priv->loadingResourcesMap.set(resourceIdentifier, adoptGRef(resource));
2256     g_signal_emit(webView, signals[RESOURCE_LOAD_STARTED], 0, resource, request);
2257 }
2258
2259 WebKitWebResource* webkitWebViewGetLoadingWebResource(WebKitWebView* webView, uint64_t resourceIdentifier)
2260 {
2261     GRefPtr<WebKitWebResource> resource = webView->priv->loadingResourcesMap.get(resourceIdentifier);
2262     return resource.get();
2263 }
2264
2265 void webkitWebViewRemoveLoadingWebResource(WebKitWebView* webView, uint64_t resourceIdentifier)
2266 {
2267     WebKitWebViewPrivate* priv = webView->priv;
2268     ASSERT(priv->loadingResourcesMap.contains(resourceIdentifier));
2269     priv->loadingResourcesMap.remove(resourceIdentifier);
2270 }
2271
2272 void webkitWebViewEnterFullScreen(WebKitWebView* webView)
2273 {
2274 #if ENABLE(FULLSCREEN_API)
2275     gboolean returnValue;
2276     g_signal_emit(webView, signals[ENTER_FULLSCREEN], 0, &returnValue);
2277 #if PLATFORM(GTK)
2278     if (!returnValue)
2279         webkitWebViewBaseEnterFullScreen(WEBKIT_WEB_VIEW_BASE(webView));
2280 #endif
2281 #endif
2282 }
2283
2284 void webkitWebViewExitFullScreen(WebKitWebView* webView)
2285 {
2286 #if ENABLE(FULLSCREEN_API)
2287     gboolean returnValue;
2288     g_signal_emit(webView, signals[LEAVE_FULLSCREEN], 0, &returnValue);
2289 #if PLATFORM(GTK)
2290     if (!returnValue)
2291         webkitWebViewBaseExitFullScreen(WEBKIT_WEB_VIEW_BASE(webView));
2292 #endif
2293 #endif
2294 }
2295
2296 void webkitWebViewRunFileChooserRequest(WebKitWebView* webView, WebKitFileChooserRequest* request)
2297 {
2298     gboolean returnValue;
2299     g_signal_emit(webView, signals[RUN_FILE_CHOOSER], 0, request, &returnValue);
2300 }
2301
2302 #if PLATFORM(GTK)
2303 static void contextMenuDismissed(GtkMenuShell*, WebKitWebView* webView)
2304 {
2305     g_signal_emit(webView, signals[CONTEXT_MENU_DISMISSED], 0, NULL);
2306 }
2307
2308 void webkitWebViewPopulateContextMenu(WebKitWebView* webView, const Vector<WebContextMenuItemData>& proposedMenu, const WebHitTestResultData& hitTestResultData, GVariant* userData)
2309 {
2310     WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(webView);
2311     WebContextMenuProxyGtk* contextMenuProxy = webkitWebViewBaseGetActiveContextMenuProxy(webViewBase);
2312     ASSERT(contextMenuProxy);
2313
2314     GRefPtr<WebKitContextMenu> contextMenu = adoptGRef(webkitContextMenuCreate(proposedMenu));
2315     if (userData)
2316         webkit_context_menu_set_user_data(WEBKIT_CONTEXT_MENU(contextMenu.get()), userData);
2317
2318     GRefPtr<WebKitHitTestResult> hitTestResult = adoptGRef(webkitHitTestResultCreate(hitTestResultData));
2319     GUniquePtr<GdkEvent> contextMenuEvent(webkitWebViewBaseTakeContextMenuEvent(webViewBase));
2320     gboolean returnValue;
2321     g_signal_emit(webView, signals[CONTEXT_MENU], 0, contextMenu.get(), contextMenuEvent.get(), hitTestResult.get(), &returnValue);
2322     if (returnValue)
2323         return;
2324
2325     Vector<WebContextMenuItemGlib> contextMenuItems;
2326     webkitContextMenuPopulate(contextMenu.get(), contextMenuItems);
2327     contextMenuProxy->populate(contextMenuItems);
2328
2329     g_signal_connect(contextMenuProxy->gtkMenu(), "deactivate", G_CALLBACK(contextMenuDismissed), webView);
2330
2331     // Clear the menu to make sure it's useless after signal emission.
2332     webkit_context_menu_remove_all(contextMenu.get());
2333 }
2334 #elif PLATFORM(WPE)
2335 void webkitWebViewPopulateContextMenu(WebKitWebView* webView, const Vector<WebContextMenuItemData>& proposedMenu, const WebHitTestResultData& hitTestResultData, GVariant* userData)
2336 {
2337     GRefPtr<WebKitContextMenu> contextMenu = adoptGRef(webkitContextMenuCreate(proposedMenu));
2338     if (userData)
2339         webkit_context_menu_set_user_data(WEBKIT_CONTEXT_MENU(contextMenu.get()), userData);
2340     GRefPtr<WebKitHitTestResult> hitTestResult = adoptGRef(webkitHitTestResultCreate(hitTestResultData));
2341     gboolean returnValue;
2342     g_signal_emit(webView, signals[CONTEXT_MENU], 0, contextMenu.get(), nullptr, hitTestResult.get(), &returnValue);
2343 }
2344 #endif
2345
2346 void webkitWebViewSubmitFormRequest(WebKitWebView* webView, WebKitFormSubmissionRequest* request)
2347 {
2348     g_signal_emit(webView, signals[SUBMIT_FORM], 0, request);
2349 }
2350
2351 void webkitWebViewHandleAuthenticationChallenge(WebKitWebView* webView, AuthenticationChallengeProxy* authenticationChallenge)
2352 {
2353 #if PLATFORM(GTK)
2354     G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
2355     gboolean privateBrowsingEnabled = webView->priv->isEphemeral || webkit_settings_get_enable_private_browsing(webView->priv->settings.get());
2356     G_GNUC_END_IGNORE_DEPRECATIONS;
2357 #else
2358     gboolean privateBrowsingEnabled = webView->priv->isEphemeral;
2359 #endif
2360     webView->priv->authenticationRequest = adoptGRef(webkitAuthenticationRequestCreate(authenticationChallenge, privateBrowsingEnabled));
2361     gboolean returnValue;
2362     g_signal_emit(webView, signals[AUTHENTICATE], 0, webView->priv->authenticationRequest.get(), &returnValue);
2363 }
2364
2365 void webkitWebViewInsecureContentDetected(WebKitWebView* webView, WebKitInsecureContentEvent type)
2366 {
2367     g_signal_emit(webView, signals[INSECURE_CONTENT_DETECTED], 0, type);
2368 }
2369
2370 bool webkitWebViewEmitShowNotification(WebKitWebView* webView, WebKitNotification* webNotification)
2371 {
2372     gboolean handled;
2373     g_signal_emit(webView, signals[SHOW_NOTIFICATION], 0, webNotification, &handled);
2374     return handled;
2375 }
2376
2377 #if PLATFORM(GTK)
2378 bool webkitWebViewEmitRunColorChooser(WebKitWebView* webView, WebKitColorChooserRequest* request)
2379 {
2380     gboolean handled;
2381     g_signal_emit(webView, signals[RUN_COLOR_CHOOSER], 0, request, &handled);
2382     return handled;
2383 }
2384 #endif
2385
2386 void webkitWebViewSelectionDidChange(WebKitWebView* webView)
2387 {
2388     if (!webView->priv->editorState)
2389         return;
2390
2391     webkitEditorStateChanged(webView->priv->editorState.get(), getPage(webView).editorState());
2392 }
2393
2394 void webkitWebViewRequestInstallMissingMediaPlugins(WebKitWebView* webView, InstallMissingMediaPluginsPermissionRequest& request)
2395 {
2396 #if ENABLE(VIDEO)
2397     GRefPtr<WebKitInstallMissingMediaPluginsPermissionRequest> installMediaPluginsPermissionRequest = adoptGRef(webkitInstallMissingMediaPluginsPermissionRequestCreate(request));
2398     webkitWebViewMakePermissionRequest(webView, WEBKIT_PERMISSION_REQUEST(installMediaPluginsPermissionRequest.get()));
2399 #else
2400     ASSERT_NOT_REACHED();
2401 #endif
2402 }
2403
2404 WebKitWebsiteDataManager* webkitWebViewGetWebsiteDataManager(WebKitWebView* webView)
2405 {
2406     return webView->priv->websiteDataManager.get();
2407 }
2408
2409 #if PLATFORM(GTK)
2410 bool webkitWebViewShowOptionMenu(WebKitWebView* webView, const IntRect& rect, WebKitOptionMenu* menu, const GdkEvent* event)
2411 {
2412     GdkRectangle menuRect = rect;
2413     gboolean handled;
2414     g_signal_emit(webView, signals[SHOW_OPTION_MENU], 0, menu, event, &menuRect, &handled);
2415     return handled;
2416 }
2417 #endif
2418
2419 #if PLATFORM(WPE)
2420 /**
2421  * webkit_web_view_get_backend:
2422  * @web_view: a #WebKitWebView
2423  *
2424  * Get the #WebKitWebViewBackend of @web_view
2425  *
2426  * Returns: (transfer none): the #WebKitWebViewBackend of @web_view
2427  *
2428  * Since: 2.20
2429  */
2430 WebKitWebViewBackend* webkit_web_view_get_backend(WebKitWebView* webView)
2431 {
2432     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), nullptr);
2433
2434     return webView->priv->backend.get();
2435 }
2436 #endif
2437
2438 /**
2439  * webkit_web_view_get_context:
2440  * @web_view: a #WebKitWebView
2441  *
2442  * Gets the web context of @web_view.
2443  *
2444  * Returns: (transfer none): the #WebKitWebContext of the view
2445  */
2446 WebKitWebContext* webkit_web_view_get_context(WebKitWebView *webView)
2447 {
2448     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
2449
2450     return webView->priv->context.get();
2451 }
2452
2453 /**
2454  * webkit_web_view_get_user_content_manager:
2455  * @web_view: a #WebKitWebView
2456  *
2457  * Gets the user content manager associated to @web_view.
2458  *
2459  * Returns: (transfer none): the #WebKitUserContentManager associated with the view
2460  *
2461  * Since: 2.6
2462  */
2463 WebKitUserContentManager* webkit_web_view_get_user_content_manager(WebKitWebView* webView)
2464 {
2465     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), nullptr);
2466
2467     return webView->priv->userContentManager.get();
2468 }
2469
2470 /**
2471  * webkit_web_view_is_ephemeral:
2472  * @web_view: a #WebKitWebView
2473  *
2474  * Get whether a #WebKitWebView is ephemeral. To create an ephemeral #WebKitWebView you need to
2475  * use g_object_new() and pass is-ephemeral property with %TRUE value. See
2476  * #WebKitWebView:is-ephemeral for more details.
2477  * If @web_view was created with a ephemeral #WebKitWebView:related-view or an
2478  * ephemeral #WebKitWebView:web-context it will also be ephemeral.
2479  *
2480  * Returns: %TRUE if @web_view is ephemeral or %FALSE otherwise.
2481  *
2482  * Since: 2.16
2483  */
2484 gboolean webkit_web_view_is_ephemeral(WebKitWebView* webView)
2485 {
2486     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
2487
2488     return webView->priv->isEphemeral;
2489 }
2490
2491 /**
2492  * webkit_web_view_is_controlled_by_automation:
2493  * @web_view: a #WebKitWebView
2494  *
2495  * Get whether a #WebKitWebView was created with #WebKitWebView:is-controlled-by-automation
2496  * property enabled. Only #WebKitWebView<!-- -->s controlled by automation can be used in an
2497  * automation session.
2498  *
2499  * Returns: %TRUE if @web_view is controlled by automation, or %FALSE otherwise.
2500  *
2501  * Since: 2.18
2502  */
2503 gboolean webkit_web_view_is_controlled_by_automation(WebKitWebView* webView)
2504 {
2505     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
2506
2507     return webView->priv->isControlledByAutomation;
2508 }
2509
2510 /**
2511  * webkit_web_view_get_website_data_manager:
2512  * @web_view: a #WebKitWebView
2513  *
2514  * Get the #WebKitWebsiteDataManager associated to @web_view. If @web_view is not ephemeral,
2515  * the returned #WebKitWebsiteDataManager will be the same as the #WebKitWebsiteDataManager
2516  * of @web_view's #WebKitWebContext.
2517  *
2518  * Returns: (transfer none): a #WebKitWebsiteDataManager
2519  *
2520  * Since: 2.16
2521  */
2522 WebKitWebsiteDataManager* webkit_web_view_get_website_data_manager(WebKitWebView* webView)
2523 {
2524     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), nullptr);
2525
2526     if (webView->priv->websiteDataManager)
2527         return webView->priv->websiteDataManager.get();
2528
2529     return webkit_web_context_get_website_data_manager(webView->priv->context.get());
2530 }
2531
2532 /**
2533  * webkit_web_view_try_close:
2534  * @web_view: a #WebKitWebView
2535  *
2536  * Tries to close the @web_view. This will fire the onbeforeunload event
2537  * to ask the user for confirmation to close the page. If there isn't an
2538  * onbeforeunload event handler or the user confirms to close the page,
2539  * the #WebKitWebView::close signal is emitted, otherwise nothing happens.
2540  *
2541  * Since: 2.12
2542  */
2543 void webkit_web_view_try_close(WebKitWebView *webView)
2544 {
2545     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
2546     if (getPage(webView).tryClose())
2547         webkitWebViewClosePage(webView);
2548 }
2549
2550 /**
2551  * webkit_web_view_load_uri:
2552  * @web_view: a #WebKitWebView
2553  * @uri: an URI string
2554  *
2555  * Requests loading of the specified URI string.
2556  * You can monitor the load operation by connecting to
2557  * #WebKitWebView::load-changed signal.
2558  */
2559 void webkit_web_view_load_uri(WebKitWebView* webView, const gchar* uri)
2560 {
2561     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
2562     g_return_if_fail(uri);
2563
2564     GUniquePtr<SoupURI> soupURI(soup_uri_new(uri));
2565     getPage(webView).loadRequest(URL(soupURI.get()));
2566 }
2567
2568 /**
2569  * webkit_web_view_load_html:
2570  * @web_view: a #WebKitWebView
2571  * @content: The HTML string to load
2572  * @base_uri: (allow-none): The base URI for relative locations or %NULL
2573  *
2574  * Load the given @content string with the specified @base_uri.
2575  * If @base_uri is not %NULL, relative URLs in the @content will be
2576  * resolved against @base_uri and absolute local paths must be children of the @base_uri.
2577  * For security reasons absolute local paths that are not children of @base_uri
2578  * will cause the web process to terminate.
2579  * If you need to include URLs in @content that are local paths in a different
2580  * directory than @base_uri you can build a data URI for them. When @base_uri is %NULL,
2581  * it defaults to "about:blank". The mime type of the document will be "text/html".
2582  * You can monitor the load operation by connecting to #WebKitWebView::load-changed signal.
2583  */
2584 void webkit_web_view_load_html(WebKitWebView* webView, const gchar* content, const gchar* baseURI)
2585 {
2586     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
2587     g_return_if_fail(content);
2588
2589     getPage(webView).loadData({ reinterpret_cast<const uint8_t*>(content), content ? strlen(content) : 0 }, "text/html"_s, "UTF-8"_s, String::fromUTF8(baseURI));
2590 }
2591
2592 /**
2593  * webkit_web_view_load_alternate_html:
2594  * @web_view: a #WebKitWebView
2595  * @content: the new content to display as the main page of the @web_view
2596  * @content_uri: the URI for the alternate page content
2597  * @base_uri: (allow-none): the base URI for relative locations or %NULL
2598  *
2599  * Load the given @content string for the URI @content_uri.
2600  * This allows clients to display page-loading errors in the #WebKitWebView itself.
2601  * When this method is called from #WebKitWebView::load-failed signal to show an
2602  * error page, then the back-forward list is maintained appropriately.
2603  * For everything else this method works the same way as webkit_web_view_load_html().
2604  */
2605 void webkit_web_view_load_alternate_html(WebKitWebView* webView, const gchar* content, const gchar* contentURI, const gchar* baseURI)
2606 {
2607     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
2608     g_return_if_fail(content);
2609     g_return_if_fail(contentURI);
2610
2611     getPage(webView).loadAlternateHTML({ reinterpret_cast<const uint8_t*>(content), content ? strlen(content) : 0 }, "UTF-8"_s, URL(URL(), String::fromUTF8(baseURI)), URL(URL(), String::fromUTF8(contentURI)));
2612 }
2613
2614 /**
2615  * webkit_web_view_load_plain_text:
2616  * @web_view: a #WebKitWebView
2617  * @plain_text: The plain text to load
2618  *
2619  * Load the specified @plain_text string into @web_view. The mime type of
2620  * document will be "text/plain". You can monitor the load
2621  * operation by connecting to #WebKitWebView::load-changed signal.
2622  */
2623 void webkit_web_view_load_plain_text(WebKitWebView* webView, const gchar* plainText)
2624 {
2625     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
2626     g_return_if_fail(plainText);
2627
2628     getPage(webView).loadData({ reinterpret_cast<const uint8_t*>(plainText), plainText ? strlen(plainText) : 0 }, "text/plain"_s, "UTF-8"_s, blankURL().string());
2629 }
2630
2631 /**
2632  * webkit_web_view_load_bytes:
2633  * @web_view: a #WebKitWebView
2634  * @bytes: input data to load
2635  * @mime_type: (allow-none): the MIME type of @bytes, or %NULL
2636  * @encoding: (allow-none): the character encoding of @bytes, or %NULL
2637  * @base_uri: (allow-none): the base URI for relative locations or %NULL
2638  *
2639  * Load the specified @bytes into @web_view using the given @mime_type and @encoding.
2640  * When @mime_type is %NULL, it defaults to "text/html".
2641  * When @encoding is %NULL, it defaults to "UTF-8".
2642  * When @base_uri is %NULL, it defaults to "about:blank".
2643  * You can monitor the load operation by connecting to #WebKitWebView::load-changed signal.
2644  *
2645  * Since: 2.6
2646  */
2647 void webkit_web_view_load_bytes(WebKitWebView* webView, GBytes* bytes, const char* mimeType, const char* encoding, const char* baseURI)
2648 {
2649     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
2650     g_return_if_fail(bytes);
2651
2652     gsize bytesDataSize;
2653     gconstpointer bytesData = g_bytes_get_data(bytes, &bytesDataSize);
2654     g_return_if_fail(bytesDataSize);
2655
2656     getPage(webView).loadData({ reinterpret_cast<const uint8_t*>(bytesData), bytesDataSize }, mimeType ? String::fromUTF8(mimeType) : String::fromUTF8("text/html"),
2657         encoding ? String::fromUTF8(encoding) : String::fromUTF8("UTF-8"), String::fromUTF8(baseURI));
2658 }
2659
2660 /**
2661  * webkit_web_view_load_request:
2662  * @web_view: a #WebKitWebView
2663  * @request: a #WebKitURIRequest to load
2664  *
2665  * Requests loading of the specified #WebKitURIRequest.
2666  * You can monitor the load operation by connecting to
2667  * #WebKitWebView::load-changed signal.
2668  */
2669 void webkit_web_view_load_request(WebKitWebView* webView, WebKitURIRequest* request)
2670 {
2671     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
2672     g_return_if_fail(WEBKIT_IS_URI_REQUEST(request));
2673
2674     ResourceRequest resourceRequest;
2675     webkitURIRequestGetResourceRequest(request, resourceRequest);
2676     getPage(webView).loadRequest(WTFMove(resourceRequest));
2677 }
2678
2679 /**
2680  * webkit_web_view_get_page_id:
2681  * @web_view: a #WebKitWebView
2682  *
2683  * Get the identifier of the #WebKitWebPage corresponding to
2684  * the #WebKitWebView
2685  *
2686  * Returns: the page ID of @web_view.
2687  */
2688 guint64 webkit_web_view_get_page_id(WebKitWebView* webView)
2689 {
2690     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
2691
2692     return getPage(webView).pageID();
2693 }
2694
2695 /**
2696  * webkit_web_view_get_title:
2697  * @web_view: a #WebKitWebView
2698  *
2699  * Gets the value of the #WebKitWebView:title property.
2700  * You can connect to notify::title signal of @web_view to
2701  * be notified when the title has been received.
2702  *
2703  * Returns: The main frame document title of @web_view.
2704  */
2705 const gchar* webkit_web_view_get_title(WebKitWebView* webView)
2706 {
2707     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
2708
2709     return webView->priv->title.data();
2710 }
2711
2712 /**
2713  * webkit_web_view_reload:
2714  * @web_view: a #WebKitWebView
2715  *
2716  * Reloads the current contents of @web_view.
2717  * See also webkit_web_view_reload_bypass_cache().
2718  */
2719 void webkit_web_view_reload(WebKitWebView* webView)
2720 {
2721     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
2722
2723     getPage(webView).reload({ });
2724 }
2725
2726 /**
2727  * webkit_web_view_reload_bypass_cache:
2728  * @web_view: a #WebKitWebView
2729  *
2730  * Reloads the current contents of @web_view without
2731  * using any cached data.
2732  */
2733 void webkit_web_view_reload_bypass_cache(WebKitWebView* webView)
2734 {
2735     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
2736
2737     getPage(webView).reload(ReloadOption::FromOrigin);
2738 }
2739
2740 /**
2741  * webkit_web_view_stop_loading:
2742  * @web_view: a #WebKitWebView
2743  *
2744  * Stops any ongoing loading operation in @web_view.
2745  * This method does nothing if no content is being loaded.
2746  * If there is a loading operation in progress, it will be cancelled and
2747  * #WebKitWebView::load-failed signal will be emitted with
2748  * %WEBKIT_NETWORK_ERROR_CANCELLED error.
2749  */
2750 void webkit_web_view_stop_loading(WebKitWebView* webView)
2751 {
2752     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
2753
2754     getPage(webView).stopLoading();
2755 }
2756
2757 /**
2758  * webkit_web_view_is_loading:
2759  * @web_view: a #WebKitWebView
2760  *
2761  * Gets the value of the #WebKitWebView:is-loading property.
2762  * You can monitor when a #WebKitWebView is loading a page by connecting to
2763  * notify::is-loading signal of @web_view. This is useful when you are
2764  * interesting in knowing when the view is loading something but not in the
2765  * details about the status of the load operation, for example to start a spinner
2766  * when the view is loading a page and stop it when it finishes.
2767  *
2768  * Returns: %TRUE if @web_view is loading a page or %FALSE otherwise.
2769  */
2770 gboolean webkit_web_view_is_loading(WebKitWebView* webView)
2771 {
2772     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
2773
2774     return webView->priv->isLoading;
2775 }
2776
2777 /**
2778  * webkit_web_view_is_playing_audio:
2779  * @web_view: a #WebKitWebView
2780  *
2781  * Gets the value of the #WebKitWebView:is-playing-audio property.
2782  * You can monitor when a page in a #WebKitWebView is playing audio by
2783  * connecting to the notify::is-playing-audio signal of @web_view. This
2784  * is useful when the application wants to provide visual feedback when a
2785  * page is producing sound.
2786  *
2787  * Returns: %TRUE if a page in @web_view is playing audio or %FALSE otherwise.
2788  *
2789  * Since: 2.8
2790  */
2791 gboolean webkit_web_view_is_playing_audio(WebKitWebView* webView)
2792 {
2793     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
2794
2795     return getPage(webView).isPlayingAudio();
2796 }
2797
2798 /**
2799  * webkit_web_view_go_back:
2800  * @web_view: a #WebKitWebView
2801  *
2802  * Loads the previous history item.
2803  * You can monitor the load operation by connecting to
2804  * #WebKitWebView::load-changed signal.
2805  */
2806 void webkit_web_view_go_back(WebKitWebView* webView)
2807 {
2808     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
2809
2810     getPage(webView).goBack();
2811 }
2812
2813 /**
2814  * webkit_web_view_can_go_back:
2815  * @web_view: a #WebKitWebView
2816  *
2817  * Determines whether @web_view has a previous history item.
2818  *
2819  * Returns: %TRUE if able to move back or %FALSE otherwise.
2820  */
2821 gboolean webkit_web_view_can_go_back(WebKitWebView* webView)
2822 {
2823     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
2824
2825     return !!getPage(webView).backForwardList().backItem();
2826 }
2827
2828 /**
2829  * webkit_web_view_go_forward:
2830  * @web_view: a #WebKitWebView
2831  *
2832  * Loads the next history item.
2833  * You can monitor the load operation by connecting to
2834  * #WebKitWebView::load-changed signal.
2835  */
2836 void webkit_web_view_go_forward(WebKitWebView* webView)
2837 {
2838     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
2839
2840     getPage(webView).goForward();
2841 }
2842
2843 /**
2844  * webkit_web_view_can_go_forward:
2845  * @web_view: a #WebKitWebView
2846  *
2847  * Determines whether @web_view has a next history item.
2848  *
2849  * Returns: %TRUE if able to move forward or %FALSE otherwise.
2850  */
2851 gboolean webkit_web_view_can_go_forward(WebKitWebView* webView)
2852 {
2853     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
2854
2855     return !!getPage(webView).backForwardList().forwardItem();
2856 }
2857
2858 /**
2859  * webkit_web_view_get_uri:
2860  * @web_view: a #WebKitWebView
2861  *
2862  * Returns the current active URI of @web_view. The active URI might change during
2863  * a load operation:
2864  *
2865  * <orderedlist>
2866  * <listitem><para>
2867  *   When nothing has been loaded yet on @web_view the active URI is %NULL.
2868  * </para></listitem>
2869  * <listitem><para>
2870  *   When a new load operation starts the active URI is the requested URI:
2871  *   <itemizedlist>
2872  *   <listitem><para>
2873  *     If the load operation was started by webkit_web_view_load_uri(),
2874  *     the requested URI is the given one.
2875  *   </para></listitem>
2876  *   <listitem><para>
2877  *     If the load operation was started by webkit_web_view_load_html(),
2878  *     the requested URI is "about:blank".
2879  *   </para></listitem>
2880  *   <listitem><para>
2881  *     If the load operation was started by webkit_web_view_load_alternate_html(),
2882  *     the requested URI is content URI provided.
2883  *   </para></listitem>
2884  *   <listitem><para>
2885  *     If the load operation was started by webkit_web_view_go_back() or
2886  *     webkit_web_view_go_forward(), the requested URI is the original URI
2887  *     of the previous/next item in the #WebKitBackForwardList of @web_view.
2888  *   </para></listitem>
2889  *   <listitem><para>
2890  *     If the load operation was started by
2891  *     webkit_web_view_go_to_back_forward_list_item(), the requested URI
2892  *     is the opriginal URI of the given #WebKitBackForwardListItem.
2893  *   </para></listitem>
2894  *   </itemizedlist>
2895  * </para></listitem>
2896  * <listitem><para>
2897  *   If there is a server redirection during the load operation,
2898  *   the active URI is the redirected URI. When the signal
2899  *   #WebKitWebView::load-changed is emitted with %WEBKIT_LOAD_REDIRECTED
2900  *   event, the active URI is already updated to the redirected URI.
2901  * </para></listitem>
2902  * <listitem><para>
2903  *   When the signal #WebKitWebView::load-changed is emitted
2904  *   with %WEBKIT_LOAD_COMMITTED event, the active URI is the final
2905  *   one and it will not change unless a new load operation is started
2906  *   or a navigation action within the same page is performed.
2907  * </para></listitem>
2908  * </orderedlist>
2909  *
2910  * You can monitor the active URI by connecting to the notify::uri
2911  * signal of @web_view.
2912  *
2913  * Returns: the current active URI of @web_view or %NULL
2914  *    if nothing has been loaded yet.
2915  */
2916 const gchar* webkit_web_view_get_uri(WebKitWebView* webView)
2917 {
2918     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
2919
2920     return webView->priv->activeURI.data();
2921 }
2922
2923 #if PLATFORM(GTK)
2924 /**
2925  * webkit_web_view_get_favicon:
2926  * @web_view: a #WebKitWebView
2927  *
2928  * Returns favicon currently associated to @web_view, if any. You can
2929  * connect to notify::favicon signal of @web_view to be notified when
2930  * the favicon is available.
2931  *
2932  * Returns: (transfer none): a pointer to a #cairo_surface_t with the
2933  *    favicon or %NULL if there's no icon associated with @web_view.
2934  */
2935 cairo_surface_t* webkit_web_view_get_favicon(WebKitWebView* webView)
2936 {
2937     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
2938     if (webView->priv->activeURI.isNull())
2939         return 0;
2940
2941     return webView->priv->favicon.get();
2942 }
2943 #endif
2944
2945 /**
2946  * webkit_web_view_get_custom_charset:
2947  * @web_view: a #WebKitWebView
2948  *
2949  * Returns the current custom character encoding name of @web_view.
2950  *
2951  * Returns: the current custom character encoding name or %NULL if no
2952  *    custom character encoding has been set.
2953  */
2954 const gchar* webkit_web_view_get_custom_charset(WebKitWebView* webView)
2955 {
2956     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
2957
2958     String customTextEncoding = getPage(webView).customTextEncodingName();
2959     if (customTextEncoding.isEmpty())
2960         return 0;
2961
2962     webView->priv->customTextEncoding = customTextEncoding.utf8();
2963     return webView->priv->customTextEncoding.data();
2964 }
2965
2966 /**
2967  * webkit_web_view_set_custom_charset:
2968  * @web_view: a #WebKitWebView
2969  * @charset: (allow-none): a character encoding name or %NULL
2970  *
2971  * Sets the current custom character encoding override of @web_view. The custom
2972  * character encoding will override any text encoding detected via HTTP headers or
2973  * META tags. Calling this method will stop any current load operation and reload the
2974  * current page. Setting the custom character encoding to %NULL removes the character
2975  * encoding override.
2976  */
2977 void webkit_web_view_set_custom_charset(WebKitWebView* webView, const gchar* charset)
2978 {
2979     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
2980
2981     getPage(webView).setCustomTextEncodingName(String::fromUTF8(charset));
2982 }
2983
2984 /**
2985  * webkit_web_view_get_estimated_load_progress:
2986  * @web_view: a #WebKitWebView
2987  *
2988  * Gets the value of the #WebKitWebView:estimated-load-progress property.
2989  * You can monitor the estimated progress of a load operation by
2990  * connecting to the notify::estimated-load-progress signal of @web_view.
2991  *
2992  * Returns: an estimate of the of the percent complete for a document
2993  *     load as a range from 0.0 to 1.0.
2994  */
2995 gdouble webkit_web_view_get_estimated_load_progress(WebKitWebView* webView)
2996 {
2997     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
2998     return getPage(webView).pageLoadState().estimatedProgress();
2999 }
3000
3001 /**
3002  * webkit_web_view_get_back_forward_list:
3003  * @web_view: a #WebKitWebView
3004  *
3005  * Obtains the #WebKitBackForwardList associated with the given #WebKitWebView. The
3006  * #WebKitBackForwardList is owned by the #WebKitWebView.
3007  *
3008  * Returns: (transfer none): the #WebKitBackForwardList
3009  */
3010 WebKitBackForwardList* webkit_web_view_get_back_forward_list(WebKitWebView* webView)
3011 {
3012     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
3013
3014     return webView->priv->backForwardList.get();
3015 }
3016
3017 /**
3018  * webkit_web_view_go_to_back_forward_list_item:
3019  * @web_view: a #WebKitWebView
3020  * @list_item: a #WebKitBackForwardListItem
3021  *
3022  * Loads the specific history item @list_item.
3023  * You can monitor the load operation by connecting to
3024  * #WebKitWebView::load-changed signal.
3025  */
3026 void webkit_web_view_go_to_back_forward_list_item(WebKitWebView* webView, WebKitBackForwardListItem* listItem)
3027 {
3028     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
3029     g_return_if_fail(WEBKIT_IS_BACK_FORWARD_LIST_ITEM(listItem));
3030
3031     getPage(webView).goToBackForwardItem(*webkitBackForwardListItemGetItem(listItem));
3032 }
3033
3034 /**
3035  * webkit_web_view_set_settings:
3036  * @web_view: a #WebKitWebView
3037  * @settings: a #WebKitSettings
3038  *
3039  * Sets the #WebKitSettings to be applied to @web_view. The
3040  * existing #WebKitSettings of @web_view will be replaced by
3041  * @settings. New settings are applied immediately on @web_view.
3042  * The same #WebKitSettings object can be shared
3043  * by multiple #WebKitWebView<!-- -->s.
3044  */
3045 void webkit_web_view_set_settings(WebKitWebView* webView, WebKitSettings* settings)
3046 {
3047     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
3048     g_return_if_fail(WEBKIT_IS_SETTINGS(settings));
3049
3050     if (webView->priv->settings == settings)
3051         return;
3052
3053     // The "settings" property is set on construction, and in that
3054     // case webkit_web_view_set_settings() will be called *before*
3055     // any settings have been assigned. In that case there are no
3056     // signal handlers to disconnect.
3057     if (webView->priv->settings)
3058         webkitWebViewDisconnectSettingsSignalHandlers(webView);
3059
3060     webView->priv->settings = settings;
3061     webkitWebViewUpdateSettings(webView);
3062     g_object_notify(G_OBJECT(webView), "settings");
3063 }
3064
3065 /**
3066  * webkit_web_view_get_settings:
3067  * @web_view: a #WebKitWebView
3068  *
3069  * Gets the #WebKitSettings currently applied to @web_view.
3070  * If no other #WebKitSettings have been explicitly applied to
3071  * @web_view with webkit_web_view_set_settings(), the default
3072  * #WebKitSettings will be returned. This method always returns
3073  * a valid #WebKitSettings object.
3074  * To modify any of the @web_view settings, you can either create
3075  * a new #WebKitSettings object with webkit_settings_new(), setting
3076  * the desired preferences, and then replace the existing @web_view
3077  * settings with webkit_web_view_set_settings() or get the existing
3078  * @web_view settings and update it directly. #WebKitSettings objects
3079  * can be shared by multiple #WebKitWebView<!-- -->s, so modifying
3080  * the settings of a #WebKitWebView would affect other
3081  * #WebKitWebView<!-- -->s using the same #WebKitSettings.
3082  *
3083  * Returns: (transfer none): the #WebKitSettings attached to @web_view
3084  */
3085 WebKitSettings* webkit_web_view_get_settings(WebKitWebView* webView)
3086 {
3087     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), nullptr);
3088     return webView->priv->settings.get();
3089 }
3090
3091 /**
3092  * webkit_web_view_get_window_properties:
3093  * @web_view: a #WebKitWebView
3094  *
3095  * Get the #WebKitWindowProperties object containing the properties
3096  * that the window containing @web_view should have.
3097  *
3098  * Returns: (transfer none): the #WebKitWindowProperties of @web_view
3099  */
3100 WebKitWindowProperties* webkit_web_view_get_window_properties(WebKitWebView* webView)
3101 {
3102     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
3103
3104     return webView->priv->windowProperties.get();
3105 }
3106
3107 /**
3108  * webkit_web_view_set_zoom_level:
3109  * @web_view: a #WebKitWebView
3110  * @zoom_level: the zoom level
3111  *
3112  * Set the zoom level of @web_view, i.e. the factor by which the
3113  * view contents are scaled with respect to their original size.
3114  */
3115 void webkit_web_view_set_zoom_level(WebKitWebView* webView, gdouble zoomLevel)
3116 {
3117     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
3118
3119     if (webkit_web_view_get_zoom_level(webView) == zoomLevel)
3120         return;
3121
3122     auto& page = getPage(webView);
3123     page.scalePage(1.0, IntPoint()); // Reset page scale when zoom level is changed
3124     if (webkit_settings_get_zoom_text_only(webView->priv->settings.get()))
3125         page.setTextZoomFactor(zoomLevel);
3126     else
3127         page.setPageZoomFactor(zoomLevel);
3128     g_object_notify(G_OBJECT(webView), "zoom-level");
3129 }
3130
3131 /**
3132  * webkit_web_view_get_zoom_level:
3133  * @web_view: a #WebKitWebView
3134  *
3135  * Get the zoom level of @web_view, i.e. the factor by which the
3136  * view contents are scaled with respect to their original size.
3137  *
3138  * Returns: the current zoom level of @web_view
3139  */
3140 gdouble webkit_web_view_get_zoom_level(WebKitWebView* webView)
3141 {
3142     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 1);
3143
3144     auto& page = getPage(webView);
3145     gboolean zoomTextOnly = webkit_settings_get_zoom_text_only(webView->priv->settings.get());
3146     return zoomTextOnly ? page.textZoomFactor() : page.pageZoomFactor();
3147 }
3148
3149 /**
3150  * webkit_web_view_can_execute_editing_command:
3151  * @web_view: a #WebKitWebView
3152  * @command: the command to check
3153  * @cancellable: (allow-none): a #GCancellable or %NULL to ignore
3154  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
3155  * @user_data: (closure): the data to pass to callback function
3156  *
3157  * Asynchronously check if it is possible to execute the given editing command.
3158  *
3159  * When the operation is finished, @callback will be called. You can then call
3160  * webkit_web_view_can_execute_editing_command_finish() to get the result of the operation.
3161  */
3162 void webkit_web_view_can_execute_editing_command(WebKitWebView* webView, const char* command, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
3163 {
3164     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
3165     g_return_if_fail(command);
3166
3167     GRefPtr<GTask> task = adoptGRef(g_task_new(webView, cancellable, callback, userData));
3168     getPage(webView).validateCommand(String::fromUTF8(command), [task = WTFMove(task)](const String&, bool isEnabled, int32_t, WebKit::CallbackBase::Error) {
3169         g_task_return_boolean(task.get(), isEnabled);
3170     });
3171 }
3172
3173 /**
3174  * webkit_web_view_can_execute_editing_command_finish:
3175  * @web_view: a #WebKitWebView
3176  * @result: a #GAsyncResult
3177  * @error: return location for error or %NULL to ignore
3178  *
3179  * Finish an asynchronous operation started with webkit_web_view_can_execute_editing_command().
3180  *
3181  * Returns: %TRUE if the editing command can be executed or %FALSE otherwise
3182  */
3183 gboolean webkit_web_view_can_execute_editing_command_finish(WebKitWebView* webView, GAsyncResult* result, GError** error)
3184 {
3185     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), FALSE);
3186     g_return_val_if_fail(g_task_is_valid(result, webView), FALSE);
3187
3188     return g_task_propagate_boolean(G_TASK(result), error);
3189 }
3190
3191 /**
3192  * webkit_web_view_execute_editing_command:
3193  * @web_view: a #WebKitWebView
3194  * @command: the command to execute
3195  *
3196  * Request to execute the given @command for @web_view. You can use
3197  * webkit_web_view_can_execute_editing_command() to check whether
3198  * it's possible to execute the command.
3199  */
3200 void webkit_web_view_execute_editing_command(WebKitWebView* webView, const char* command)
3201 {
3202     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
3203     g_return_if_fail(command);
3204
3205     getPage(webView).executeEditCommand(String::fromUTF8(command));
3206 }
3207
3208 /**
3209  * webkit_web_view_execute_editing_command_with_argument:
3210  * @web_view: a #WebKitWebView
3211  * @command: the command to execute
3212  * @argument: the command argument
3213  *
3214  * Request to execute the given @command with @argument for @web_view. You can use
3215  * webkit_web_view_can_execute_editing_command() to check whether
3216  * it's possible to execute the command.
3217  *
3218  * Since: 2.10
3219  */
3220 void webkit_web_view_execute_editing_command_with_argument(WebKitWebView* webView, const char* command, const char* argument)
3221 {
3222     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
3223     g_return_if_fail(command);
3224     g_return_if_fail(argument);
3225
3226     getPage(webView).executeEditCommand(String::fromUTF8(command), String::fromUTF8(argument));
3227 }
3228
3229 /**
3230  * webkit_web_view_get_find_controller:
3231  * @web_view: the #WebKitWebView
3232  *
3233  * Gets the #WebKitFindController that will allow the caller to query
3234  * the #WebKitWebView for the text to look for.
3235  *
3236  * Returns: (transfer none): the #WebKitFindController associated to
3237  * this particular #WebKitWebView.
3238  */
3239 WebKitFindController* webkit_web_view_get_find_controller(WebKitWebView* webView)
3240 {
3241     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), 0);
3242
3243     if (!webView->priv->findController)
3244         webView->priv->findController = adoptGRef(WEBKIT_FIND_CONTROLLER(g_object_new(WEBKIT_TYPE_FIND_CONTROLLER, "web-view", webView, NULL)));
3245
3246     return webView->priv->findController.get();
3247 }
3248
3249 #if PLATFORM(GTK)
3250 /**
3251  * webkit_web_view_get_javascript_global_context: (skip)
3252  * @web_view: a #WebKitWebView
3253  *
3254  * Get the global JavaScript context used by @web_view to deserialize the
3255  * result values of scripts executed with webkit_web_view_run_javascript().
3256  *
3257  * Returns: the <function>JSGlobalContextRef</function> used by @web_view to deserialize
3258  *    the result values of scripts.
3259  *
3260  * Deprecated: 2.22: Use jsc_value_get_context() instead.
3261  */
3262 JSGlobalContextRef webkit_web_view_get_javascript_global_context(WebKitWebView* webView)
3263 {
3264     g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), nullptr);
3265
3266     // We keep a reference to the js context in the view only when this method is called
3267     // for backwards compatibility.
3268     if (!webView->priv->jsContext)
3269         webView->priv->jsContext = SharedJavascriptContext::singleton().getOrCreateContext();
3270     return jscContextGetJSContext(webView->priv->jsContext.get());
3271 }
3272 #endif
3273
3274 static void webkitWebViewRunJavaScriptCallback(API::SerializedScriptValue* wkSerializedScriptValue, const ExceptionDetails& exceptionDetails, GTask* task)
3275 {
3276     if (g_task_return_error_if_cancelled(task))
3277         return;
3278
3279     if (!wkSerializedScriptValue) {
3280         StringBuilder builder;
3281         if (!exceptionDetails.sourceURL.isEmpty()) {
3282             builder.append(exceptionDetails.sourceURL);
3283             if (exceptionDetails.lineNumber > 0) {
3284                 builder.append(':');
3285                 builder.appendNumber(exceptionDetails.lineNumber);
3286             }
3287             if (exceptionDetails.columnNumber > 0) {
3288                 builder.append(':');
3289                 builder.appendNumber(exceptionDetails.columnNumber);
3290             }
3291             builder.appendLiteral(": ");
3292         }
3293         builder.append(exceptionDetails.message);
3294         g_task_return_new_error(task, WEBKIT_JAVASCRIPT_ERROR, WEBKIT_JAVASCRIPT_ERROR_SCRIPT_FAILED,
3295             "%s", builder.toString().utf8().data());
3296         return;
3297     }
3298
3299     g_task_return_pointer(task, webkitJavascriptResultCreate(wkSerializedScriptValue->internalRepresentation()),
3300         reinterpret_cast<GDestroyNotify>(webkit_javascript_result_unref));
3301 }
3302
3303 /**
3304  * webkit_web_view_run_javascript:
3305  * @web_view: a #WebKitWebView
3306  * @script: the script to run
3307  * @cancellable: (allow-none): a #GCancellable or %NULL to ignore
3308  * @callback: (scope async): a #GAsyncReadyCallback to call when the script finished
3309  * @user_data: (closure): the data to pass to callback function
3310  *
3311  * Asynchronously run @script in the context of the current page in @web_view. If
3312  * WebKitSettings:enable-javascript is FALSE, this method will do nothing.
3313  *
3314  * When the operation is finished, @callback will be called. You can then call
3315  * webkit_web_view_run_javascript_finish() to get the result of the operation.
3316  */
3317 void webkit_web_view_run_javascript(WebKitWebView* webView, const gchar* script, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
3318 {
3319     g_return_if_fail(WEBKIT_IS_WEB_VIEW(webView));
3320     g_return_if_fail(script);
3321
3322     GRefPtr<GTask> task = adoptGRef(g_task_new(webView, cancellable, callback, userData));
3323     getPage(webView).runJavaScriptInMainFrame(String::fromUTF8(script), true, [task = WTFMove(task)](API::SerializedScriptValue* serializedScriptValue, bool, const ExceptionDetails& exceptionDetails, WebKit::CallbackBase::Error) {
3324         webkitWebViewRunJavaScriptCallback(serializedScriptValue, exceptionDetails, task.get());
3325     });
3326 }
3327
3328 /**
3329  * webkit_web_view_run_javascript_finish:
3330  * @web_view: a #WebKitWebView
3331  * @result: a #GAsyncResult
3332  * @error: return location for error or %NULL to ignore
3333  *