static gboolean sendRequestCallback(WebKitWebPage*, WebKitURIRequest* request, WebKitURIResponse* redirectResponse, gpointer)
{
gboolean returnValue = FALSE;
const char* requestURI = webkit_uri_request_get_uri(request);
g_assert(requestURI);
if (const char* suffix = g_strrstr(requestURI, "/remove-this/javascript.js")) {
GUniquePtr<char> prefix(g_strndup(requestURI, strlen(requestURI) - strlen(suffix)));
GUniquePtr<char> newURI(g_strdup_printf("%s/javascript.js", prefix.get()));
webkit_uri_request_set_uri(request, newURI.get());
} else if (const char* suffix = g_strrstr(requestURI, "/remove-this/javascript-after-redirection.js")) {
// Redirected from /redirected.js, redirectResponse should be nullptr.
g_assert(WEBKIT_IS_URI_RESPONSE(redirectResponse));
g_assert(g_str_has_suffix(webkit_uri_response_get_uri(redirectResponse), "/redirected.js"));
GUniquePtr<char> prefix(g_strndup(requestURI, strlen(requestURI) - strlen(suffix)));
GUniquePtr<char> newURI(g_strdup_printf("%s/javascript-after-redirection.js", prefix.get()));
webkit_uri_request_set_uri(request, newURI.get());
} else if (g_str_has_suffix(requestURI, "/redirected.js")) {
// Original request, redirectResponse should be nullptr.
g_assert(!redirectResponse);
} else if (g_str_has_suffix(requestURI, "/add-do-not-track-header")) {
SoupMessageHeaders* headers = webkit_uri_request_get_http_headers(request);
g_assert(headers);
soup_message_headers_append(headers, "DNT", "1");
} else if (g_str_has_suffix(requestURI, "/http-get-method")) {
g_assert_cmpstr(webkit_uri_request_get_http_method(request), ==, "GET");
g_assert(webkit_uri_request_get_http_method(request) == SOUP_METHOD_GET);
} else if (g_str_has_suffix(requestURI, "/http-post-method")) {
void WebViewTest::loadRequest(WebKitURIRequest* request)
{
m_activeURI = webkit_uri_request_get_uri(request);
webkit_web_view_load_request(m_webView, request);
g_assert(webkit_web_view_is_loading(m_webView));
g_assert_cmpstr(webkit_web_view_get_uri(m_webView), ==, m_activeURI.data());
}
static void download_finished(WebKitDownload *download,
gpointer user_data)
{
const gchar * url;
url = webkit_uri_request_get_uri(webkit_download_get_request(download));
const guint64 size = webkit_download_get_received_data_length(download);
printf("!!!!!!!!!!!!!!!%s: %"G_GUINT64_FORMAT"\n", url, size);
}
static void download_proc(WebKitDownload *download,
guint64 data_length,
gpointer user_data)
{
const gchar * url;
printf("dwonload proc\n");
url = webkit_uri_request_get_uri(webkit_download_get_request(download));
printf("%s: %"G_GUINT64_FORMAT"\n", url, data_length);
}
// uri_request_cb is called when a uri request is issued, and determines
// whether to allow it to proceed or not.
static void
uri_request_cb(WebKitWebPage *page,
WebKitURIRequest *req,
WebKitURIResponse *resp,
gpointer exten)
{
const gchar *uri = webkit_uri_request_get_uri(req);
if(uri_is_blocked(uri, ADBLOCK_OTHER, exten)) {
webkit_uri_request_set_uri(req, "about:blank");
}
}
gboolean decideDownloadDestination(WebKitDownload *download, const gchar *suggest, RuskWindow *rusk)
{
GtkWidget *dialog;
dialog = gtk_file_chooser_dialog_new("Save File", rusk->window, GTK_FILE_CHOOSER_ACTION_SAVE,
"_Cancel", GTK_RESPONSE_CANCEL,
"_Save", GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
char *buf = g_strdup_printf("%s%s", g_get_home_dir(), suggest);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), buf);
g_free(buf);
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char *filename;
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
printf("download %s\n", webkit_uri_request_get_uri(webkit_download_get_request(download)));
printf("suggest: %s\n", suggest);
printf("save to: %s\n", filename);
startDownload(
webkit_uri_request_get_uri(webkit_download_get_request(download)),
filename
);
g_free(filename);
}
gtk_widget_destroy(dialog);
return TRUE;
}
/**
* ephy_download_new_for_download:
* @download: a #WebKitDownload to wrap
*
* Wraps @download in an #EphyDownload.
*
* Returns: an #EphyDownload.
**/
EphyDownload *
ephy_download_new_for_download (WebKitDownload *download)
{
EphyDownload *ephy_download;
#ifdef HAVE_WEBKIT2
WebKitURIRequest *request;
#endif
g_return_val_if_fail (WEBKIT_IS_DOWNLOAD (download), NULL);
ephy_download = ephy_download_new ();
#ifdef HAVE_WEBKIT2
g_signal_connect (download, "decide-destination",
G_CALLBACK (download_decide_destination_cb),
ephy_download);
g_signal_connect (download, "created-destination",
G_CALLBACK (download_created_destination_cb),
ephy_download);
g_signal_connect (download, "finished",
G_CALLBACK (download_finished_cb),
ephy_download);
g_signal_connect (download, "failed",
G_CALLBACK (download_failed_cb),
ephy_download);
#else
g_signal_connect (download, "notify::status",
G_CALLBACK (download_status_changed_cb),
ephy_download);
g_signal_connect (download, "error",
G_CALLBACK (download_error_cb),
ephy_download);
#endif
ephy_download->priv->download = g_object_ref (download);
#ifdef HAVE_WEBKIT2
request = webkit_download_get_request (download);
ephy_download->priv->source = g_strdup (webkit_uri_request_get_uri (request));
#else
ephy_download->priv->source = g_strdup (webkit_download_get_uri (download));
#endif
#ifdef HAVE_WEBKIT2
/* In WebKit2 the download has already started */
ephy_embed_shell_add_download (embed_shell, ephy_download);
#endif
return ephy_download;
}
static GtkWidget*
webkit_web_view_create_web_view_cb (GtkWidget* web_view,
WebKitNavigationAction* navigationAction,
MidoriBrowser* browser)
{
WebKitURIRequest *naviationRequest = webkit_navigation_action_get_request(navigationAction);
gchar *destUri = webkit_uri_request_get_uri(naviationRequest);
midori_browser_open_new_tab_from_extension(browser, destUri, false);
if(popup_window)
{
gtk_widget_destroy(popup_window);
popup_window = NULL;
}
return NULL;
}
static void resourceLoadStartedCallback(WebKitWebView* webView, WebKitWebResource* resource, WebKitURIRequest* request, ResourcesTest* test)
{
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(resource));
test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(request));
// Ignore favicons.
if (g_str_has_suffix(webkit_uri_request_get_uri(request), "favicon.ico"))
return;
test->resourceLoadStarted(resource, request);
g_signal_connect(resource, "sent-request", G_CALLBACK(resourceSentRequestCallback), test);
g_signal_connect(resource, "notify::response", G_CALLBACK(resourceReceivedResponseCallback), test);
g_signal_connect(resource, "received-data", G_CALLBACK(resourceReceivedDataCallback), test);
g_signal_connect(resource, "finished", G_CALLBACK(resourceFinishedCallback), test);
g_signal_connect(resource, "failed", G_CALLBACK(resourceFailedCallback), test);
}
static void
wxgtk_webview_webkit_resource_req(WebKitWebView *,
WebKitWebResource *,
WebKitURIRequest *request,
wxWebViewWebKit *webKitCtrl)
{
wxString uri = webkit_uri_request_get_uri(request);
wxSharedPtr<wxWebViewHandler> handler;
wxVector<wxSharedPtr<wxWebViewHandler> > handlers = webKitCtrl->GetHandlers();
//We are not vetoed so see if we match one of the additional handlers
for(wxVector<wxSharedPtr<wxWebViewHandler> >::iterator it = handlers.begin();
it != handlers.end(); ++it)
{
if(uri.substr(0, (*it)->GetName().length()) == (*it)->GetName())
{
handler = (*it);
}
}
//If we found a handler we can then use it to load the file directly
//ourselves
if(handler)
{
//If it is requsting the page itself then return as we have already
//loaded it from the archive
if(webKitCtrl->m_vfsurl == uri)
return;
wxFSFile* file = handler->GetFile(uri);
if(file)
{
//We load the data into a data url to save it being written out again
size_t size = file->GetStream()->GetLength();
char *buffer = new char[size];
file->GetStream()->Read(buffer, size);
wxString data = wxBase64Encode(buffer, size);
delete[] buffer;
wxString mime = file->GetMimeType();
wxString path = "data:" + mime + ";base64," + data;
//Then we can redirect the call
webkit_uri_request_set_uri(request, path.utf8_str());
}
}
}
redirect_cb(WebKitWebView* web_view,
WebKitPolicyDecision* decision,
WebKitPolicyDecisionType type,
gpointer udata)
#endif
{
GtTwitchLoginDlg* self = GT_TWITCH_LOGIN_DLG(udata);
GtTwitchLoginDlgPrivate* priv = gt_twitch_login_dlg_get_instance_private(self);
GMatchInfo* match_info = NULL;
const gchar* uri = NULL;
#ifdef USE_DEPRECATED_WEBKIT
uri = webkit_network_request_get_uri(request);
#else
if (type == WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION)
{
WebKitNavigationAction* action = webkit_navigation_policy_decision_get_navigation_action(
WEBKIT_NAVIGATION_POLICY_DECISION(decision));
WebKitURIRequest* request = webkit_navigation_action_get_request(action);
uri = webkit_uri_request_get_uri(request);
}
#endif
if (uri == NULL || strlen(uri) == 0) return FALSE;
MESSAGE("Redirect uri is '%s'", uri);
g_regex_match(priv->token_redirect_regex, uri, 0, &match_info);
if (g_match_info_matches(match_info))
{
g_autofree gchar* token = g_match_info_fetch(match_info, 1);
MESSAGEF("Successfully got OAuth token '%s'", token);
gt_twitch_fetch_oauth_info_async(main_app->twitch, token, fetch_oauth_info_cb, priv->cancel, self);
}
else if (g_str_has_prefix(uri, "http://localhost/?error=access_denied"))
WARNING("Error logging in or login cancelled");
g_match_info_unref(match_info);
return FALSE;
}
static gboolean sendRequestCallback(WebKitWebPage*, WebKitURIRequest* request, WebKitURIResponse*, gpointer)
{
const char* requestURI = webkit_uri_request_get_uri(request);
g_assert(requestURI);
if (const char* suffix = g_strrstr(requestURI, "/remove-this/javascript.js")) {
GUniquePtr<char> prefix(g_strndup(requestURI, strlen(requestURI) - strlen(suffix)));
GUniquePtr<char> newURI(g_strdup_printf("%s/javascript.js", prefix.get()));
webkit_uri_request_set_uri(request, newURI.get());
} else if (g_str_has_suffix(requestURI, "/add-do-not-track-header")) {
SoupMessageHeaders* headers = webkit_uri_request_get_http_headers(request);
g_assert(headers);
soup_message_headers_append(headers, "DNT", "1");
} else if (g_str_has_suffix(requestURI, "/cancel-this.js"))
return TRUE;
return FALSE;
}
static gboolean
wxgtk_webview_webkit_new_window(WebKitPolicyDecision *decision,
wxWebViewWebKit *webKitCtrl)
{
WebKitNavigationPolicyDecision* navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION(decision);
WebKitNavigationAction* action = webkit_navigation_policy_decision_get_navigation_action(navigation_decision);
WebKitURIRequest* request = webkit_navigation_action_get_request(action);
const gchar* uri = webkit_uri_request_get_uri(request);
wxString target = webkit_navigation_policy_decision_get_frame_name(navigation_decision);
wxWebViewEvent event(wxEVT_WEBVIEW_NEWWINDOW,
webKitCtrl->GetId(),
wxString( uri, wxConvUTF8 ),
target);
if (webKitCtrl && webKitCtrl->GetEventHandler())
webKitCtrl->GetEventHandler()->ProcessEvent(event);
//We always want the user to handle this themselves
webkit_policy_decision_ignore(decision);
return TRUE;
}
static gboolean
policy_cb (WebKitWebView *v, WebKitPolicyDecision *pd, WebKitPolicyDecisionType pt, gpointer d)
{
if (is_loaded && !options.html_data.browser)
{
WebKitNavigationAction *act = webkit_navigation_policy_decision_get_navigation_action (WEBKIT_NAVIGATION_POLICY_DECISION (pd));
webkit_policy_decision_ignore (pd);
if (webkit_navigation_action_get_navigation_type (act) == WEBKIT_NAVIGATION_TYPE_LINK_CLICKED)
{
WebKitURIRequest *r = webkit_navigation_action_get_request (act);
gchar *uri = (gchar *) webkit_uri_request_get_uri (r);
if (options.html_data.print_uri)
g_printf ("%s\n", uri);
else
g_app_info_launch_default_for_uri (uri, NULL, NULL);
}
}
else
return FALSE;
return TRUE;
}
static gboolean webViewDecidePolicy(WebKitWebView *webView, WebKitPolicyDecision *decision, WebKitPolicyDecisionType decisionType, BrowserWindow *window)
{
switch (decisionType) {
case WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION: {
WebKitNavigationAction *navigationAction = webkit_navigation_policy_decision_get_navigation_action(WEBKIT_NAVIGATION_POLICY_DECISION(decision));
if (webkit_navigation_action_get_navigation_type(navigationAction) != WEBKIT_NAVIGATION_TYPE_LINK_CLICKED
|| webkit_navigation_action_get_mouse_button(navigationAction) != GDK_BUTTON_MIDDLE)
return FALSE;
// Opening a new window if link clicked with the middle button.
WebKitWebView *newWebView = WEBKIT_WEB_VIEW(webkit_web_view_new_with_context(webkit_web_view_get_context(webView)));
GtkWidget *newWindow = browser_window_new(newWebView, GTK_WINDOW(window));
webkit_web_view_load_request(newWebView, webkit_navigation_action_get_request(navigationAction));
gtk_widget_show(newWindow);
webkit_policy_decision_ignore(decision);
return TRUE;
}
case WEBKIT_POLICY_DECISION_TYPE_RESPONSE: {
WebKitResponsePolicyDecision *responseDecision = WEBKIT_RESPONSE_POLICY_DECISION(decision);
if (webkit_response_policy_decision_is_mime_type_supported(responseDecision))
return FALSE;
WebKitWebResource *mainResource = webkit_web_view_get_main_resource(webView);
WebKitURIRequest *request = webkit_response_policy_decision_get_request(responseDecision);
const char *requestURI = webkit_uri_request_get_uri(request);
if (g_strcmp0(webkit_web_resource_get_uri(mainResource), requestURI))
return FALSE;
webkit_policy_decision_download(decision);
return TRUE;
}
case WEBKIT_POLICY_DECISION_TYPE_NEW_WINDOW_ACTION:
default:
return FALSE;
}
}
static gboolean
wxgtk_webview_webkit_navigation(WebKitWebView *web_view,
WebKitPolicyDecision *decision,
wxWebViewWebKit *webKitCtrl)
{
WebKitNavigationPolicyDecision* navigation_decision = WEBKIT_NAVIGATION_POLICY_DECISION(decision);
WebKitNavigationAction* action = webkit_navigation_policy_decision_get_navigation_action(navigation_decision);
WebKitURIRequest* request = webkit_navigation_action_get_request(action);
const gchar* uri = webkit_uri_request_get_uri(request);
wxString target = webkit_navigation_policy_decision_get_frame_name(navigation_decision);
//If m_creating is true then we are the result of a new window
//and so we need to send the event and veto the load
if(webKitCtrl->m_creating)
{
webKitCtrl->m_creating = false;
wxWebViewEvent event(wxEVT_WEBVIEW_NEWWINDOW,
webKitCtrl->GetId(),
wxString(uri, wxConvUTF8),
target);
if(webKitCtrl && webKitCtrl->GetEventHandler())
webKitCtrl->GetEventHandler()->ProcessEvent(event);
webkit_policy_decision_ignore(decision);
return TRUE;
}
if(webKitCtrl->m_guard)
{
webKitCtrl->m_guard = false;
//We set this to make sure that we don't try to load the page again from
//the resource request callback
webKitCtrl->m_vfsurl = webkit_web_view_get_uri(web_view);
webkit_policy_decision_use(decision);
return FALSE;
}
webKitCtrl->m_busy = true;
wxWebViewEvent event(wxEVT_WEBVIEW_NAVIGATING,
webKitCtrl->GetId(),
wxString( uri, wxConvUTF8 ),
target);
if (webKitCtrl && webKitCtrl->GetEventHandler())
webKitCtrl->GetEventHandler()->ProcessEvent(event);
if (!event.IsAllowed())
{
webKitCtrl->m_busy = false;
webkit_policy_decision_ignore(decision);
return TRUE;
}
else
{
wxString wxuri = uri;
wxSharedPtr<wxWebViewHandler> handler;
wxVector<wxSharedPtr<wxWebViewHandler> > handlers = webKitCtrl->GetHandlers();
//We are not vetoed so see if we match one of the additional handlers
for(wxVector<wxSharedPtr<wxWebViewHandler> >::iterator it = handlers.begin();
it != handlers.end(); ++it)
{
if(wxuri.substr(0, (*it)->GetName().length()) == (*it)->GetName())
{
handler = (*it);
}
}
//If we found a handler we can then use it to load the file directly
//ourselves
if(handler)
{
webKitCtrl->m_guard = true;
wxFSFile* file = handler->GetFile(wxuri);
if(file)
{
webKitCtrl->SetPage(*file->GetStream(), wxuri);
}
//We need to throw some sort of error here if file is NULL
webkit_policy_decision_ignore(decision);
return TRUE;
}
return FALSE;
}
}
void WebViewTest::loadRequest(WebKitURIRequest* request)
{
m_activeURI = webkit_uri_request_get_uri(request);
webkit_web_view_load_request(m_webView, request);
}
