/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* * Copyright © 2002 Jorn Baayen * Copyright © 2003, 2004 Marco Pesenti Gritti * Copyright © 2003, 2004, 2005, 2006, 2008 Christian Persch * Copyright © 2012 Igalia S.L. * * This file is part of Epiphany. * * Epiphany is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Epiphany is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Epiphany. If not, see . */ #include "config.h" #include "ephy-session.h" #include "ephy-about-handler.h" #include "ephy-debug.h" #include "ephy-embed-container.h" #include "ephy-embed-utils.h" #include "ephy-embed.h" #include "ephy-file-helpers.h" #include "ephy-gui.h" #include "ephy-link.h" #include "ephy-tab-view.h" #include "ephy-prefs.h" #include "ephy-settings.h" #include "ephy-shell.h" #include "ephy-string.h" #include "ephy-tab-view.h" #include "ephy-window.h" #include #include #include #include typedef struct { EphyTabView *tab_view; gint ref_count; } TabViewTracker; typedef struct { TabViewTracker *tab_view_tracker; int position; char *url; WebKitWebViewSessionState *state; } ClosedTab; struct _EphySession { GObject parent_instance; GQueue *closed_tabs; guint save_source_id; guint closing : 1; guint dont_save : 1; guint loaded_page : 1; }; #define SESSION_STATE "type:session_state" enum { PROP_0, PROP_CAN_UNDO_TAB_CLOSED, LAST_PROP }; static GParamSpec *obj_properties[LAST_PROP]; static void ephy_session_save_now (EphySession *session); G_DEFINE_TYPE (EphySession, ephy_session, G_TYPE_OBJECT) /* Helper functions */ static GFile * get_session_file (const char *filename) { GFile *file; char *path; if (filename == NULL) { return NULL; } if (strcmp (filename, SESSION_STATE) == 0) { path = g_build_filename (ephy_profile_dir (), "session_state.xml", NULL); } else { path = g_strdup (filename); } file = g_file_new_for_path (path); g_free (path); return file; } static void session_delete (EphySession *session) { GFile *file; file = get_session_file (SESSION_STATE); g_file_delete (file, NULL, NULL); g_object_unref (file); } static void load_changed_cb (WebKitWebView *view, WebKitLoadEvent load_event, EphySession *session) { if (ephy_web_view_load_failed (EPHY_WEB_VIEW (view))) return; if (load_event == WEBKIT_LOAD_FINISHED) session->loaded_page = TRUE; ephy_session_save (session); } static void tab_view_tracker_set_tab_view (TabViewTracker *tracker, EphyTabView *tab_view) { if (tracker->tab_view == tab_view) return; if (tracker->tab_view) g_object_remove_weak_pointer (G_OBJECT (tracker->tab_view), (gpointer *)&tracker->tab_view); tracker->tab_view = tab_view; if (tracker->tab_view) g_object_add_weak_pointer (G_OBJECT (tracker->tab_view), (gpointer *)&tracker->tab_view); } static TabViewTracker * tab_view_tracker_new (EphyTabView *tab_view) { TabViewTracker *tracker = g_new0 (TabViewTracker, 1); tracker->ref_count = 1; tab_view_tracker_set_tab_view (tracker, tab_view); return tracker; } static TabViewTracker * tab_view_tracker_ref (TabViewTracker *tracker) { g_atomic_int_inc (&tracker->ref_count); return tracker; } static void tab_view_tracker_unref (TabViewTracker *tracker) { if (!g_atomic_int_dec_and_test (&tracker->ref_count)) return; tab_view_tracker_set_tab_view (tracker, NULL); g_free (tracker); } static EphyTabView * closed_tab_get_tab_view (ClosedTab *tab) { return tab->tab_view_tracker->tab_view; } static int compare_func (ClosedTab *iter, EphyTabView *tab_view) { return (gpointer)closed_tab_get_tab_view (iter) - (gpointer)tab_view; } static TabViewTracker * ephy_session_ref_or_create_tab_view_tracker (EphySession *session, EphyTabView *tab_view) { GList *item = g_queue_find_custom (session->closed_tabs, tab_view, (GCompareFunc)compare_func); return item ? tab_view_tracker_ref (((ClosedTab *)item->data)->tab_view_tracker) : tab_view_tracker_new (tab_view); } static void closed_tab_free (ClosedTab *tab) { g_free (tab->url); tab_view_tracker_unref (tab->tab_view_tracker); webkit_web_view_session_state_unref (tab->state); g_free (tab); } static ClosedTab * closed_tab_new (EphyWebView *web_view, int position, TabViewTracker *tab_view_tracker) { ClosedTab *tab = g_new0 (ClosedTab, 1); tab->url = g_strdup (ephy_web_view_get_address (web_view)); tab->position = position; /* Takes the ownership of the tracker */ tab->tab_view_tracker = tab_view_tracker; tab->state = webkit_web_view_get_session_state (WEBKIT_WEB_VIEW (web_view)); return tab; } void ephy_session_undo_close_tab (EphySession *session) { EphyEmbed *embed, *new_tab; WebKitWebView *web_view; WebKitBackForwardList *bf_list; WebKitBackForwardListItem *item; ClosedTab *tab; EphyWindow *window; EphyTabView *tab_view; EphyNewTabFlags flags = EPHY_NEW_TAB_JUMP; g_assert (EPHY_IS_SESSION (session)); tab = g_queue_pop_head (session->closed_tabs); if (tab == NULL) return; LOG ("UNDO CLOSE TAB: %s", tab->url); tab_view = closed_tab_get_tab_view (tab); if (tab_view) { if (tab->position > 0) { /* Append in the n-th position. */ embed = EPHY_EMBED (ephy_tab_view_get_nth_page (tab_view, tab->position - 1)); flags |= EPHY_NEW_TAB_APPEND_AFTER; } else { /* Just prepend in the first position. */ embed = NULL; flags |= EPHY_NEW_TAB_FIRST; } window = EPHY_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (tab_view))); new_tab = ephy_shell_new_tab (ephy_shell_get_default (), window, embed, flags); } else { window = ephy_window_new (); new_tab = ephy_shell_new_tab (ephy_shell_get_default (), window, NULL, flags); tab_view_tracker_set_tab_view (tab->tab_view_tracker, ephy_window_get_tab_view (window)); } web_view = WEBKIT_WEB_VIEW (ephy_embed_get_web_view (new_tab)); webkit_web_view_restore_session_state (web_view, tab->state); bf_list = webkit_web_view_get_back_forward_list (web_view); item = webkit_back_forward_list_get_current_item (bf_list); if (item) { webkit_web_view_go_to_back_forward_list_item (web_view, item); } else { ephy_web_view_load_url (ephy_embed_get_web_view (new_tab), tab->url); } gtk_widget_grab_focus (GTK_WIDGET (new_tab)); gtk_window_present_with_time (GTK_WINDOW (window), gtk_get_current_event_time ()); closed_tab_free (tab); if (g_queue_is_empty (session->closed_tabs)) g_object_notify_by_pspec (G_OBJECT (session), obj_properties[PROP_CAN_UNDO_TAB_CLOSED]); } static void ephy_session_tab_closed (EphySession *session, EphyTabView *tab_view, EphyEmbed *embed, gint position) { EphyWebView *view; WebKitWebView *wk_view; ClosedTab *tab; view = ephy_embed_get_web_view (embed); wk_view = WEBKIT_WEB_VIEW (view); if (!webkit_web_view_can_go_back (wk_view) && !webkit_web_view_can_go_forward (wk_view) && (ephy_web_view_get_is_blank (view) || ephy_web_view_is_overview (view))) { return; } tab = closed_tab_new (view, position, ephy_session_ref_or_create_tab_view_tracker (session, tab_view)); g_queue_push_head (session->closed_tabs, tab); if (g_queue_get_length (session->closed_tabs) == 1) g_object_notify_by_pspec (G_OBJECT (session), obj_properties[PROP_CAN_UNDO_TAB_CLOSED]); LOG ("Added: %s to the list (%d elements)", ephy_web_view_get_address (view), g_queue_get_length (session->closed_tabs)); } gboolean ephy_session_get_can_undo_tab_closed (EphySession *session) { g_assert (EPHY_IS_SESSION (session)); return g_queue_is_empty (session->closed_tabs) == FALSE; } static void tab_view_page_attached_cb (HdyTabView *tab_view, HdyTabPage *page, guint position, EphySession *session) { EphyEmbed *embed = EPHY_EMBED (hdy_tab_page_get_child (page)); g_signal_connect (ephy_embed_get_web_view (embed), "load-changed", G_CALLBACK (load_changed_cb), session); } static void tab_view_page_detached_cb (HdyTabView *tab_view, HdyTabPage *page, gint position, EphySession *session) { EphyEmbed *embed = EPHY_EMBED (hdy_tab_page_get_child (page)); EphyTabView *ephy_tab_view = EPHY_TAB_VIEW (g_object_get_data (G_OBJECT (tab_view), "ephy-tab-view")); ephy_session_save (session); g_signal_handlers_disconnect_by_func (ephy_embed_get_web_view (embed), G_CALLBACK (load_changed_cb), session); ephy_session_tab_closed (session, ephy_tab_view, embed, position); } static void tab_view_page_reordered_cb (HdyTabView *tab_view, HdyTabPage *page, guint position, EphySession *session) { ephy_session_save (session); } static void tab_view_notify_selected_page_cb (HdyTabView *tab_view, GParamSpec *pspec, EphySession *session) { ephy_session_save (session); } static void session_maybe_open_window (EphySession *session, guint32 user_time) { EphyShell *shell = ephy_shell_get_default (); /* FIXME: maybe just check for normal windows? */ if (ephy_shell_get_n_windows (shell) == 0) { EphyWindow *window = ephy_window_new (); ephy_link_open (EPHY_LINK (window), NULL, NULL, EPHY_LINK_HOME_PAGE); } } static void window_added_cb (GtkApplication *application, GtkWindow *window, EphySession *session) { EphyWindow *ephy_window; HdyTabView *tab_view; ephy_session_save (session); if (!EPHY_IS_WINDOW (window)) return; ephy_window = EPHY_WINDOW (window); tab_view = ephy_tab_view_get_tab_view (ephy_window_get_tab_view (ephy_window)); g_signal_connect_object (tab_view, "page-attached", G_CALLBACK (tab_view_page_attached_cb), session, 0); g_signal_connect_object (tab_view, "page-detached", G_CALLBACK (tab_view_page_detached_cb), session, 0); g_signal_connect_object (tab_view, "page-reordered", G_CALLBACK (tab_view_page_reordered_cb), session, 0); g_signal_connect_object (tab_view, "notify::selected-page", G_CALLBACK (tab_view_notify_selected_page_cb), session, G_CONNECT_AFTER); } static void window_removed_cb (GtkApplication *application, GtkWindow *window, EphySession *session) { ephy_session_save (session); /* NOTE: since the window will be destroyed anyway, we don't need to * disconnect our signal handlers from its components. */ } /* Class implementation */ static void ephy_session_init (EphySession *session) { EphyShell *shell; LOG ("EphySession initialising"); session->closed_tabs = g_queue_new (); shell = ephy_shell_get_default (); g_signal_connect (shell, "window-added", G_CALLBACK (window_added_cb), session); g_signal_connect (shell, "window-removed", G_CALLBACK (window_removed_cb), session); } static void ephy_session_dispose (GObject *object) { EphySession *session = EPHY_SESSION (object); LOG ("EphySession disposing"); g_queue_free_full (session->closed_tabs, (GDestroyNotify)closed_tab_free); G_OBJECT_CLASS (ephy_session_parent_class)->dispose (object); } static void ephy_session_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { EphySession *session = EPHY_SESSION (object); switch (property_id) { case PROP_CAN_UNDO_TAB_CLOSED: g_value_set_boolean (value, ephy_session_get_can_undo_tab_closed (session)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } } static void ephy_session_class_init (EphySessionClass *class) { GObjectClass *object_class = G_OBJECT_CLASS (class); object_class->dispose = ephy_session_dispose; object_class->get_property = ephy_session_get_property; obj_properties[PROP_CAN_UNDO_TAB_CLOSED] = g_param_spec_boolean ("can-undo-tab-closed", "Can undo tab close", "Session can undo a tab closure", FALSE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); g_object_class_install_properties (object_class, LAST_PROP, obj_properties); } /* Implementation */ void ephy_session_close (EphySession *session) { g_assert (EPHY_IS_SESSION (session)); LOG ("ephy_session_close"); /* If there's a save pending, cancel it and save the session now since * after closing the session the saving is no longer allowed. */ g_clear_handle_id (&session->save_source_id, g_source_remove); if (session->closing) return; session->closing = TRUE; ephy_session_save_now (session); session->dont_save = TRUE; } typedef struct { GdkRectangle geometry; gboolean is_maximized; gboolean is_fullscreen; GList *tabs; gint active_tab; } SessionWindow; static void get_window_geometry (EphyWindow *window, SessionWindow *session_window) { session_window->is_maximized = ephy_window_is_maximized (window); session_window->is_fullscreen = ephy_window_is_fullscreen (window); ephy_window_get_geometry (window, &session_window->geometry); } typedef struct { char *url; char *title; gboolean loading; gboolean crashed; gboolean pinned; WebKitWebViewSessionState *state; } SessionTab; static SessionTab * session_tab_new (EphyEmbed *embed, EphySession *session, EphyTabView *tab_view) { SessionTab *session_tab; const char *address; EphyWebView *web_view = ephy_embed_get_web_view (embed); EphyWebViewErrorPage error_page = ephy_web_view_get_error_page (web_view); session_tab = g_new (SessionTab, 1); address = ephy_web_view_get_address (web_view); /* Do not store ephy-about: URIs, they are not valid for loading. */ if (g_str_has_prefix (address, EPHY_ABOUT_SCHEME)) { session_tab->url = g_strconcat ("about", address + EPHY_ABOUT_SCHEME_LEN, NULL); } else if (!strcmp (address, "about:blank")) { /* EphyWebView address is NULL between load_uri() and WEBKIT_LOAD_STARTED, * but WebKitWebView knows the pending API request URL, so use that instead of about:blank. */ session_tab->url = g_strdup (webkit_web_view_get_uri (WEBKIT_WEB_VIEW (web_view))); } else { session_tab->url = g_strdup (address); } session_tab->title = g_strdup (ephy_embed_get_title (embed)); session_tab->loading = (ephy_web_view_is_loading (web_view) && !ephy_embed_has_load_pending (embed) && !session->closing); session_tab->crashed = (error_page == EPHY_WEB_VIEW_ERROR_PAGE_CRASH || error_page == EPHY_WEB_VIEW_ERROR_PROCESS_CRASH); session_tab->state = webkit_web_view_get_session_state (WEBKIT_WEB_VIEW (web_view)); session_tab->pinned = ephy_tab_view_get_is_pinned (tab_view, GTK_WIDGET (embed)); return session_tab; } static void session_tab_free (SessionTab *tab) { g_free (tab->url); g_free (tab->title); g_clear_pointer (&tab->state, webkit_web_view_session_state_unref); g_free (tab); } static SessionWindow * session_window_new (EphyWindow *window, EphySession *session) { SessionWindow *session_window; GList *tabs, *l; EphyTabView *tab_view; tabs = ephy_embed_container_get_children (EPHY_EMBED_CONTAINER (window)); /* Do not save an empty EphyWindow. * This only happens when the window was newly opened. */ if (!tabs) { return NULL; } session_window = g_new0 (SessionWindow, 1); get_window_geometry (window, session_window); tab_view = ephy_window_get_tab_view (window); for (l = tabs; l != NULL; l = l->next) { SessionTab *tab; tab = session_tab_new (EPHY_EMBED (l->data), session, tab_view); session_window->tabs = g_list_prepend (session_window->tabs, tab); } g_list_free (tabs); session_window->tabs = g_list_reverse (session_window->tabs); session_window->active_tab = ephy_tab_view_get_selected_index (tab_view); return session_window; } static void session_window_free (SessionWindow *session_window) { g_list_free_full (session_window->tabs, (GDestroyNotify)session_tab_free); g_free (session_window); } typedef struct { EphySession *session; GList *windows; } SaveData; static SaveData * save_data_new (EphySession *session) { SaveData *data; EphyShell *shell = ephy_shell_get_default (); GList *windows, *w; data = g_new0 (SaveData, 1); data->session = g_object_ref (session); windows = gtk_application_get_windows (GTK_APPLICATION (shell)); for (w = windows; w != NULL; w = w->next) { SessionWindow *session_window; session_window = session_window_new (EPHY_WINDOW (w->data), session); if (session_window) data->windows = g_list_prepend (data->windows, session_window); } data->windows = g_list_reverse (data->windows); return data; } static void save_data_free (SaveData *data) { g_list_free_full (data->windows, (GDestroyNotify)session_window_free); g_object_unref (data->session); g_free (data); } static int write_tab (xmlTextWriterPtr writer, SessionTab *tab) { int ret; ret = xmlTextWriterStartElement (writer, (xmlChar *)"embed"); if (ret < 0) return ret; ret = xmlTextWriterWriteAttribute (writer, (xmlChar *)"url", (const xmlChar *)tab->url); if (ret < 0) return ret; ret = xmlTextWriterWriteAttribute (writer, (xmlChar *)"title", (const xmlChar *)tab->title); if (ret < 0) return ret; if (tab->loading) { ret = xmlTextWriterWriteAttribute (writer, (const xmlChar *)"loading", (const xmlChar *)"true"); if (ret < 0) return ret; } if (tab->pinned) { ret = xmlTextWriterWriteAttribute (writer, (const xmlChar *)"pinned", (const xmlChar *)"true"); if (ret < 0) return ret; } if (tab->crashed) { ret = xmlTextWriterWriteAttribute (writer, (const xmlChar *)"crashed", (const xmlChar *)"true"); if (ret < 0) return ret; } if (tab->state) { GBytes *bytes; bytes = webkit_web_view_session_state_serialize (tab->state); if (bytes) { gchar *base64; gconstpointer data; gsize data_length; data = g_bytes_get_data (bytes, &data_length); base64 = g_base64_encode (data, data_length); xmlTextWriterWriteAttribute (writer, (const xmlChar *)"history", (const xmlChar *)base64); g_free (base64); g_bytes_unref (bytes); } } ret = xmlTextWriterEndElement (writer); /* embed */ return ret; } static int write_window_geometry (xmlTextWriterPtr writer, GdkRectangle *geometry, gboolean is_maximized, gboolean is_fullscreen) { int ret; /* set window properties */ ret = xmlTextWriterWriteFormatAttribute (writer, (const xmlChar *)"x", "%d", geometry->x); if (ret < 0) return ret; ret = xmlTextWriterWriteFormatAttribute (writer, (const xmlChar *)"y", "%d", geometry->y); if (ret < 0) return ret; ret = xmlTextWriterWriteFormatAttribute (writer, (const xmlChar *)"width", "%d", geometry->width); if (ret < 0) return ret; ret = xmlTextWriterWriteFormatAttribute (writer, (const xmlChar *)"height", "%d", geometry->height); if (ret < 0) return ret; ret = xmlTextWriterWriteFormatAttribute (writer, (const xmlChar *)"is-maximized", "%d", is_maximized); if (ret < 0) return ret; ret = xmlTextWriterWriteFormatAttribute (writer, (const xmlChar *)"is-fullscreen", "%d", is_fullscreen); return ret; } static int write_ephy_window (xmlTextWriterPtr writer, SessionWindow *window) { GList *l; int ret; EphyPrefsRestoreSessionPolicy policy; int last_pinned_tab = -1; gboolean only_pinned_tabs = FALSE; policy = g_settings_get_enum (EPHY_SETTINGS_MAIN, EPHY_PREFS_RESTORE_SESSION_POLICY); only_pinned_tabs = policy == EPHY_PREFS_RESTORE_SESSION_POLICY_CRASHED; if (only_pinned_tabs) { for (l = window->tabs; l != NULL; l = l->next, last_pinned_tab++) { SessionTab *tab = (SessionTab *)l->data; if (!tab->pinned) break; } if (last_pinned_tab == -1) return 0; } ret = xmlTextWriterStartElement (writer, (xmlChar *)"window"); if (ret < 0) return ret; ret = write_window_geometry (writer, &window->geometry, window->is_maximized, window->is_fullscreen); if (ret < 0) return ret; if (last_pinned_tab != -1 && window->active_tab >= last_pinned_tab) window->active_tab = last_pinned_tab + 1; ret = xmlTextWriterWriteFormatAttribute (writer, (const xmlChar *)"active-tab", "%d", window->active_tab); if (ret < 0) return ret; for (l = window->tabs; l != NULL; l = l->next) { SessionTab *tab = (SessionTab *)l->data; if (only_pinned_tabs && !tab->pinned) break; ret = write_tab (writer, tab); if (ret < 0) break; } if (ret < 0) return ret; if (only_pinned_tabs && last_pinned_tab != -1) { /* We are in EPHY_PREFS_RESTORE_SESSION_POLICY_NEVER with pinned tabs * Create a new overview page after the pinned tab */ SessionTab *new_session_tab = g_new0 (SessionTab, 1); new_session_tab->url = g_strdup ("about:overview"); new_session_tab->title = g_strdup (""); write_tab (writer, new_session_tab); session_tab_free (new_session_tab); } ret = xmlTextWriterEndElement (writer); /* window */ return ret; } static void save_session_in_thread_finished_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { g_object_unref (EPHY_SESSION (source_object)); g_application_release (G_APPLICATION (ephy_shell_get_default ())); /* FIXME: this is a workaround for https://gitlab.gnome.org/GNOME/glib/-/issues/1346. * After this GLib issue is fixed, we should instead pass save_data_free() as the * GDestroyNotify parameter to g_task_set_task_data(). */ save_data_free (g_task_get_task_data (G_TASK (res))); } static gboolean session_seems_reasonable (GList *windows) { for (GList *w = windows; w != NULL; w = w->next) { for (GList *t = ((SessionWindow *)w->data)->tabs; t != NULL; t = t->next) { const char *url = ((SessionTab *)t->data)->url; g_autoptr (GUri) uri = NULL; gboolean sane = FALSE; /* NULL URLs are possible when an invalid URL is opened by JS. * E.g. */ if (url == NULL) continue; /* Blank URLs can occur in some situations. Just ignore these, as they * are harmless and not an indicator of a corrupted session. */ if (strcmp (url, "") == 0) continue; /* Ignore fake about "URLs." */ if (g_str_has_prefix (url, "about:")) continue; uri = g_uri_parse (url, G_URI_FLAGS_NONE, NULL); if (uri) { if (g_uri_get_host (uri) != NULL || strcmp (g_uri_get_scheme (uri), "data") == 0 || strcmp (g_uri_get_scheme (uri), "file") == 0 || strcmp (g_uri_get_scheme (uri), "ephy-reader") == 0 || strcmp (g_uri_get_scheme (uri), "ephy-pdf") == 0) sane = TRUE; } if (!sane) { g_critical ("Refusing to save session due to invalid URL %s", url); return FALSE; } } } return TRUE; } static void save_session_sync (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { SaveData *data = (SaveData *)g_task_get_task_data (task); xmlBufferPtr buffer; xmlTextWriterPtr writer; GList *w; int ret = -1; buffer = xmlBufferCreate (); writer = xmlNewTextWriterMemory (buffer, 0); if (writer == NULL) goto out; ret = xmlTextWriterSetIndent (writer, 1); if (ret < 0) goto out; ret = xmlTextWriterSetIndentString (writer, (const xmlChar *)" "); if (ret < 0) goto out; START_PROFILER ("Saving session") ret = xmlTextWriterStartDocument (writer, "1.0", NULL, NULL); if (ret < 0) goto out; /* create and set the root node for the session */ ret = xmlTextWriterStartElement (writer, (const xmlChar *)"session"); if (ret < 0) goto out; /* iterate through all the windows */ for (w = data->windows; w != NULL && ret >= 0; w = w->next) { ret = write_ephy_window (writer, (SessionWindow *)w->data); } if (ret < 0) goto out; ret = xmlTextWriterEndElement (writer); /* session */ if (ret < 0) goto out; ret = xmlTextWriterEndDocument (writer); out: if (writer) xmlFreeTextWriter (writer); if (ret >= 0) { GError *error = NULL; GFile *session_file; session_file = get_session_file (SESSION_STATE); if (!g_file_replace_contents (session_file, (const char *)buffer->content, buffer->use, NULL, TRUE, 0, NULL, NULL, &error)) { g_warning ("Error saving session: %s", error->message); g_error_free (error); } g_object_unref (session_file); } xmlBufferFree (buffer); g_task_return_boolean (task, TRUE); STOP_PROFILER ("Saving session") } static EphySession * ephy_session_save_timeout_started (EphySession *session) { g_application_hold (G_APPLICATION (ephy_shell_get_default ())); return g_object_ref (session); } static void ephy_session_save_timeout_finished (EphySession *session) { g_application_release (G_APPLICATION (ephy_shell_get_default ())); g_object_unref (session); } static gboolean ephy_session_save_timeout_cb (EphySession *session) { EphyShell *shell = ephy_shell_get_default (); SaveData *data; GTask *task; session->save_source_id = 0; if (!session->loaded_page) return G_SOURCE_REMOVE; /* If we have never successfully loaded any page, or any web view has an * insane URL, then something has probably gone wrong inside WebKit. For * instance, if the web process is nonfunctional, the UI process could have * an invalid URI property. Yes, this would be a WebKit bug, but Epiphany * should be robust to such issues. Do not clobber an existing good session * file with our new bogus state. Bug #768250. */ data = save_data_new (session); if (!session_seems_reasonable (data->windows)) { save_data_free (data); return G_SOURCE_REMOVE; } LOG ("ephy_sesion_save"); if (ephy_shell_get_n_windows (shell) == 0) { session_delete (session); save_data_free (data); return G_SOURCE_REMOVE; } g_application_hold (G_APPLICATION (ephy_shell_get_default ())); g_object_ref (session); task = g_task_new (session, NULL, save_session_in_thread_finished_cb, NULL); g_task_set_task_data (task, data, NULL); g_task_run_in_thread (task, save_session_sync); g_object_unref (task); return G_SOURCE_REMOVE; } void ephy_session_save (EphySession *session) { g_assert (EPHY_IS_SESSION (session)); if (session->save_source_id) return; if (session->dont_save) return; /* Schedule the save to occur one second in the future to ensure we don't * repeatedly write to disk when opening or closing many tabs at once. */ session->save_source_id = g_timeout_add_seconds_full (G_PRIORITY_DEFAULT_IDLE, 1, (GSourceFunc)ephy_session_save_timeout_cb, ephy_session_save_timeout_started (session), (GDestroyNotify)ephy_session_save_timeout_finished); } static void ephy_session_save_now (EphySession *session) { ephy_session_save_timeout_cb (session); } static void confirm_before_recover (EphyWindow *window, const char *url, const char *title) { EphyEmbed *embed; embed = ephy_shell_new_tab_full (ephy_shell_get_default (), title, NULL, window, NULL, EPHY_NEW_TAB_APPEND_LAST, 0); ephy_web_view_load_error_page (ephy_embed_get_web_view (embed), url, EPHY_WEB_VIEW_ERROR_PAGE_CRASH, NULL, NULL); } static void restore_geometry (GtkWindow *window, GdkRectangle *geometry) { if (geometry->x >= 0 && geometry->y >= 0) ephy_window_set_default_position (EPHY_WINDOW (window), geometry->x, geometry->y); if (geometry->width > 0 && geometry->height > 0) ephy_window_set_default_size (EPHY_WINDOW (window), geometry->width, geometry->height); } typedef struct { EphySession *session; guint32 user_time; EphyWindow *window; gulong destroy_id; gboolean is_first_window; gint active_tab; gboolean is_first_tab; } SessionParserContext; static SessionParserContext * session_parser_context_new (EphySession *session, guint32 user_time) { SessionParserContext *context; context = g_new0 (SessionParserContext, 1); context->session = g_object_ref (session); context->user_time = user_time; context->is_first_window = TRUE; return context; } static void session_parser_context_free (SessionParserContext *context) { g_object_unref (context->session); if (context->window) { /* This can only happen if the session state is malformed. */ g_signal_handler_disconnect (context->window, context->destroy_id); } g_free (context); } static void session_parse_window (SessionParserContext *context, const gchar **names, const gchar **values) { GdkRectangle geometry = { -1, -1, 0, 0 }; gboolean is_maximized = FALSE; gboolean is_fullscreen = FALSE; guint i; if (context->window) { /* This should only happen if the session state is malformed. */ return; } context->window = ephy_window_new (); context->destroy_id = g_signal_connect (context->window, "destroy", G_CALLBACK (gtk_widget_destroyed), &context->window); for (i = 0; names[i]; i++) { gulong int_value; if (strcmp (names[i], "x") == 0) { ephy_string_to_int (values[i], &int_value); geometry.x = int_value; } else if (strcmp (names[i], "y") == 0) { ephy_string_to_int (values[i], &int_value); geometry.y = int_value; } else if (strcmp (names[i], "width") == 0) { ephy_string_to_int (values[i], &int_value); geometry.width = int_value; } else if (strcmp (names[i], "height") == 0) { ephy_string_to_int (values[i], &int_value); geometry.height = int_value; } else if (strcmp (names[i], "is-maximized") == 0) { ephy_string_to_int (values[i], &int_value); is_maximized = int_value != 0; } else if (strcmp (names[i], "is-fullscreen") == 0) { ephy_string_to_int (values[i], &int_value); is_fullscreen = int_value != 0; } else if (strcmp (names[i], "active-tab") == 0) { ephy_string_to_int (values[i], &int_value); context->active_tab = int_value; } } restore_geometry (GTK_WINDOW (context->window), &geometry); if (is_maximized) gtk_window_maximize (GTK_WINDOW (context->window)); if (is_fullscreen) { /* Treat fullscreen on session restore same as fullscreen action */ ephy_window_show_fullscreen_header_bar (context->window); gtk_window_fullscreen (GTK_WINDOW (context->window)); } } static void session_parse_embed (SessionParserContext *context, const gchar **names, const gchar **values) { HdyTabView *tab_view; const char *url = NULL; const char *title = NULL; const char *history = NULL; gboolean was_loading = FALSE; gboolean crashed = FALSE; gboolean is_blank_page = FALSE; gboolean is_pin = FALSE; guint i; if (!context->window) { /* This can happen if the session is malformed, or if the window is * destroyed before the session finishes loading. */ return; } tab_view = ephy_tab_view_get_tab_view (ephy_window_get_tab_view (context->window)); for (i = 0; names[i]; i++) { if (strcmp (names[i], "url") == 0) { url = values[i]; is_blank_page = (strcmp (url, "about:blank") == 0 || strcmp (url, "about:overview") == 0); } else if (strcmp (names[i], "title") == 0) { title = values[i]; } else if (strcmp (names[i], "loading") == 0) { was_loading = strcmp (values[i], "true") == 0; } else if (strcmp (names[i], "crashed") == 0) { crashed = strcmp (values[i], "true") == 0; } else if (strcmp (names[i], "history") == 0) { history = values[i]; } else if (strcmp (names[i], "pinned") == 0) { is_pin = strcmp (values[i], "true") == 0; } } /* In the case that crash happens before we receive the URL from the server, * this will open an about:blank tab. * See http://bugzilla.gnome.org/show_bug.cgi?id=591294 * Otherwise, if the web was fully loaded, it is reloaded again. */ if ((!was_loading || is_blank_page) && !crashed) { EphyNewTabFlags flags; EphyEmbedShell *shell; EphyEmbedShellMode mode; EphyEmbed *embed; EphyWebView *web_view; gboolean delay_loading = FALSE; WebKitWebViewSessionState *state = NULL; shell = ephy_embed_shell_get_default (); mode = ephy_embed_shell_get_mode (shell); if (mode == EPHY_EMBED_SHELL_MODE_BROWSER || mode == EPHY_EMBED_SHELL_MODE_STANDALONE) { delay_loading = g_settings_get_boolean (EPHY_SETTINGS_MAIN, EPHY_PREFS_RESTORE_SESSION_DELAYING_LOADS); } flags = EPHY_NEW_TAB_APPEND_LAST; embed = ephy_shell_new_tab_full (ephy_shell_get_default (), title, NULL, context->window, NULL, flags, 0); hdy_tab_view_set_page_pinned (tab_view, hdy_tab_view_get_page (tab_view, GTK_WIDGET (embed)), is_pin); web_view = ephy_embed_get_web_view (embed); if (history) { guchar *data; gsize data_length; GBytes *history_data; data = g_base64_decode (history, &data_length); history_data = g_bytes_new_take (data, data_length); state = webkit_web_view_session_state_new (history_data); g_bytes_unref (history_data); } if (delay_loading) { WebKitURIRequest *request = webkit_uri_request_new (url); ephy_embed_set_delayed_load_request (embed, request, state); ephy_web_view_set_placeholder (web_view, url, title); g_object_unref (request); } else { WebKitBackForwardList *bf_list; WebKitBackForwardListItem *item; if (state) { webkit_web_view_restore_session_state (WEBKIT_WEB_VIEW (web_view), state); } bf_list = webkit_web_view_get_back_forward_list (WEBKIT_WEB_VIEW (web_view)); item = webkit_back_forward_list_get_current_item (bf_list); if (item) { webkit_web_view_go_to_back_forward_list_item (WEBKIT_WEB_VIEW (web_view), item); } else { ephy_web_view_load_url (web_view, url); } } if (state) { webkit_web_view_session_state_unref (state); } } else if (url && (was_loading || crashed)) { /* This page was loading during a UI process crash * (was_loading == TRUE) or a web process crash * (crashed == TRUE) and might make Epiphany crash again. */ confirm_before_recover (context->window, url, title); } } static void session_start_element (GMarkupParseContext *ctx, const gchar *element_name, const gchar **names, const gchar **values, gpointer user_data, GError **error) { SessionParserContext *context = (SessionParserContext *)user_data; if (strcmp (element_name, "window") == 0) { session_parse_window (context, names, values); context->is_first_tab = TRUE; } else if (strcmp (element_name, "embed") == 0) { session_parse_embed (context, names, values); } } static void session_end_element (GMarkupParseContext *ctx, const gchar *element_name, gpointer user_data, GError **error) { SessionParserContext *context = (SessionParserContext *)user_data; if (strcmp (element_name, "window") == 0) { EphyTabView *tab_view; EphyEmbedShell *shell = ephy_embed_shell_get_default (); if (!context->window) { /* This can happen if the session is malformed, or if the window is * destroyed before the session finishes loading. */ return; } tab_view = ephy_window_get_tab_view (context->window); ephy_tab_view_select_nth_page (tab_view, context->active_tab); if (ephy_embed_shell_get_mode (ephy_embed_shell_get_default ()) != EPHY_EMBED_SHELL_MODE_TEST) { EphyEmbed *active_child; active_child = ephy_embed_container_get_active_child (EPHY_EMBED_CONTAINER (context->window)); gtk_widget_grab_focus (GTK_WIDGET (active_child)); ephy_window_update_entry_focus (context->window, ephy_embed_get_web_view (active_child)); gtk_widget_show (GTK_WIDGET (context->window)); } ephy_embed_shell_restored_window (shell); g_clear_signal_handler (&context->destroy_id, context->window); context->window = NULL; context->active_tab = 0; context->is_first_window = FALSE; } else if (strcmp (element_name, "embed") == 0) { context->is_first_tab = FALSE; } } static const GMarkupParser session_parser = { session_start_element, session_end_element, NULL, NULL, NULL }; typedef struct { EphyShell *shell; GMarkupParseContext *parser; char buffer[1024]; } LoadFromStreamAsyncData; static LoadFromStreamAsyncData * load_from_stream_async_data_new (GMarkupParseContext *parser) { LoadFromStreamAsyncData *data; data = g_new (LoadFromStreamAsyncData, 1); data->shell = g_object_ref (ephy_shell_get_default ()); data->parser = parser; return data; } static void load_from_stream_async_data_free (LoadFromStreamAsyncData *data) { g_object_unref (data->shell); g_markup_parse_context_free (data->parser); g_free (data); } static void load_stream_complete (GTask *task) { EphySession *session; g_task_return_boolean (task, TRUE); session = EPHY_SESSION (g_task_get_source_object (task)); session->dont_save = FALSE; ephy_session_save (session); g_object_unref (task); g_application_release (G_APPLICATION (ephy_shell_get_default ())); } static void load_stream_complete_error (GTask *task, GError *error) { EphySession *session; LoadFromStreamAsyncData *data; SessionParserContext *context; g_task_return_error (task, error); session = EPHY_SESSION (g_task_get_source_object (task)); session->dont_save = FALSE; /* If the session fails to load for whatever reason, * delete the file and open an empty window. */ session_delete (session); data = g_task_get_task_data (task); context = (SessionParserContext *)g_markup_parse_context_get_user_data (data->parser); session_maybe_open_window (session, context->user_time); g_object_unref (task); g_application_release (G_APPLICATION (ephy_shell_get_default ())); } static void load_stream_read_cb (GObject *object, GAsyncResult *result, gpointer user_data) { GInputStream *stream = G_INPUT_STREAM (object); GTask *task = G_TASK (user_data); LoadFromStreamAsyncData *data; gssize bytes_read; GError *error = NULL; bytes_read = g_input_stream_read_finish (stream, result, &error); if (bytes_read < 0) { load_stream_complete_error (task, error); return; } data = g_task_get_task_data (task); if (bytes_read == 0) { if (!g_markup_parse_context_end_parse (data->parser, &error)) { load_stream_complete_error (task, error); } else { load_stream_complete (task); } return; } if (!g_markup_parse_context_parse (data->parser, data->buffer, bytes_read, &error)) { load_stream_complete_error (task, error); return; } g_input_stream_read_async (stream, data->buffer, sizeof (data->buffer), g_task_get_priority (task), g_task_get_cancellable (task), load_stream_read_cb, task); } /** * ephy_session_load_from_stream: * @session: an #EphySession * @stream: a #GInputStream to read the session data from * @user_time: a user time, or 0 * @cancellable: (allow-none): optional #GCancellable object, or %NULL * @callback: (scope async): a #GAsyncReadyCallback to call when the * request is satisfied * @user_data: (closure): the data to pass to callback function * * Asynchronously loads the session reading the session data from @stream, * restoring windows and their state. * * When the operation is finished, @callback will be called. You can * then call ephy_session_load_from_stream_finish() to get the result of * the operation. **/ void ephy_session_load_from_stream (EphySession *session, GInputStream *stream, guint32 user_time, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GTask *task; SessionParserContext *context; GMarkupParseContext *parser; LoadFromStreamAsyncData *data; g_assert (EPHY_IS_SESSION (session)); g_assert (G_IS_INPUT_STREAM (stream)); g_application_hold (G_APPLICATION (ephy_shell_get_default ())); session->dont_save = TRUE; task = g_task_new (session, cancellable, callback, user_data); /* Use a priority lower than drawing events (HIGH_IDLE + 20) to make sure * the main window is shown as soon as possible at startup */ g_task_set_priority (task, G_PRIORITY_HIGH_IDLE + 30); context = session_parser_context_new (session, user_time); parser = g_markup_parse_context_new (&session_parser, 0, context, (GDestroyNotify)session_parser_context_free); data = load_from_stream_async_data_new (parser); g_task_set_task_data (task, data, (GDestroyNotify)load_from_stream_async_data_free); g_input_stream_read_async (stream, data->buffer, sizeof (data->buffer), g_task_get_priority (task), cancellable, load_stream_read_cb, task); } /** * ephy_session_load_from_stream_finish: * @session: an #EphySession * @result: a #GAsyncResult * @error: a #GError * * Finishes an async session load operation started with * ephy_session_load_from_stream(). * * Returns: %TRUE if at least a window has been opened **/ gboolean ephy_session_load_from_stream_finish (EphySession *session, GAsyncResult *result, GError **error) { g_assert (g_task_is_valid (result, session)); return g_task_propagate_boolean (G_TASK (result), error); } typedef struct { guint32 user_time; } LoadAsyncData; static LoadAsyncData * load_async_data_new (guint32 user_time) { LoadAsyncData *data; data = g_new (LoadAsyncData, 1); data->user_time = user_time; return data; } static void load_async_data_free (LoadAsyncData *data) { g_free (data); } static void load_from_stream_cb (GObject *object, GAsyncResult *result, gpointer user_data) { EphySession *session = EPHY_SESSION (object); GTask *task = G_TASK (user_data); GError *error = NULL; if (!ephy_session_load_from_stream_finish (session, result, &error)) { g_task_return_error (task, error); } else { g_task_return_boolean (task, TRUE); } g_object_unref (task); } static void session_read_cb (GObject *object, GAsyncResult *result, gpointer user_data) { GFileInputStream *stream; GTask *task = G_TASK (user_data); GError *error = NULL; stream = g_file_read_finish (G_FILE (object), result, &error); if (stream) { EphySession *session; LoadAsyncData *data; session = EPHY_SESSION (g_task_get_source_object (task)); data = g_task_get_task_data (task); ephy_session_load_from_stream (session, G_INPUT_STREAM (stream), data->user_time, g_task_get_cancellable (task), load_from_stream_cb, task); g_object_unref (stream); } else { g_task_return_error (task, error); g_object_unref (task); } g_application_release (G_APPLICATION (ephy_shell_get_default ())); } /** * ephy_session_load: * @session: an #EphySession * @filename: the path of the source file * @user_time: a user time, or 0 * @cancellable: (allow-none): optional #GCancellable object, or %NULL * @callback: (scope async): a #GAsyncReadyCallback to call when the * request is satisfied * @user_data: (closure): the data to pass to callback function * * Asynchronously loads the session reading the session data from @filename, * restoring windows and their state. * * When the operation is finished, @callback will be called. You can * then call ephy_session_load_finish() to get the result of * the operation. **/ void ephy_session_load (EphySession *session, const char *filename, guint32 user_time, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GFile *save_to_file; GTask *task; LoadAsyncData *data; g_assert (EPHY_IS_SESSION (session)); g_assert (filename); LOG ("ephy_sesion_load %s", filename); g_application_hold (G_APPLICATION (ephy_shell_get_default ())); task = g_task_new (session, cancellable, callback, user_data); /* Use a priority lower than drawing events (HIGH_IDLE + 20) to make sure * the main window is shown as soon as possible at startup */ g_task_set_priority (task, G_PRIORITY_HIGH_IDLE + 30); save_to_file = get_session_file (filename); data = load_async_data_new (user_time); g_task_set_task_data (task, data, (GDestroyNotify)load_async_data_free); g_file_read_async (save_to_file, g_task_get_priority (task), cancellable, session_read_cb, task); g_object_unref (save_to_file); } /** * ephy_session_load_finish: * @session: an #EphySession * @result: a #GAsyncResult * @error: a #GError * * Finishes an async session load operation started with * ephy_session_load(). * * Returns: %TRUE if at least a window has been opened **/ gboolean ephy_session_load_finish (EphySession *session, GAsyncResult *result, GError **error) { g_assert (g_task_is_valid (result, session)); return g_task_propagate_boolean (G_TASK (result), error); } static gboolean session_state_file_exists (EphySession *session) { GFile *saved_session_file; char *saved_session_file_path; gboolean retval; saved_session_file = get_session_file (SESSION_STATE); saved_session_file_path = g_file_get_path (saved_session_file); g_object_unref (saved_session_file); retval = g_file_test (saved_session_file_path, G_FILE_TEST_EXISTS); g_free (saved_session_file_path); return retval; } static void session_resumed_cb (GObject *object, GAsyncResult *result, gpointer user_data) { EphySession *session = EPHY_SESSION (object); GTask *task = G_TASK (user_data); GError *error = NULL; if (!ephy_session_load_finish (session, result, &error)) { g_task_return_error (task, error); } else { g_task_return_boolean (task, TRUE); } g_object_unref (task); } void ephy_session_resume (EphySession *session, guint32 user_time, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GTask *task; gboolean has_session_state; EphyShell *shell; LOG ("ephy_session_resume"); task = g_task_new (session, cancellable, callback, user_data); has_session_state = session_state_file_exists (session); shell = ephy_shell_get_default (); /* If we are auto-resuming, and we never want to * restore the session, clobber the session state * file. */ if (has_session_state == FALSE) { session_maybe_open_window (session, user_time); } else if (ephy_shell_get_n_windows (shell) == 0) { ephy_session_load (session, SESSION_STATE, user_time, cancellable, session_resumed_cb, task); return; } g_task_return_boolean (task, TRUE); g_object_unref (task); } gboolean ephy_session_resume_finish (EphySession *session, GAsyncResult *result, GError **error) { g_assert (g_task_is_valid (result, session)); return g_task_propagate_boolean (G_TASK (result), error); } void ephy_session_clear (EphySession *session) { EphyShell *shell; GList *windows, *p; g_assert (EPHY_IS_SESSION (session)); shell = ephy_shell_get_default (); windows = g_list_copy (gtk_application_get_windows (GTK_APPLICATION (shell))); for (p = windows; p; p = p->next) gtk_widget_destroy (GTK_WIDGET (p->data)); g_list_free (windows); g_queue_foreach (session->closed_tabs, (GFunc)closed_tab_free, NULL); g_queue_clear (session->closed_tabs); ephy_session_save (session); } gboolean ephy_session_is_closing (EphySession *session) { return session->closing; }