| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/ui/gtk/gtk_chrome_cookie_view.h" |
| |
| #include "base/i18n/time_formatting.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "content/public/browser/indexed_db_context.h" |
| #include "grit/generated_resources.h" |
| #include "net/cookies/canonical_cookie.h" |
| #include "net/cookies/parsed_cookie.h" |
| #include "ui/base/gtk/gtk_hig_constants.h" |
| #include "ui/base/l10n/l10n_util.h" |
| #include "ui/base/text/bytes_formatting.h" |
| |
| namespace { |
| |
| void InitBrowserDetailStyle(GtkWidget* entry, GtkStyle* label_style, |
| GtkStyle* dialog_style) { |
| gtk_widget_modify_fg(entry, GTK_STATE_NORMAL, |
| &label_style->fg[GTK_STATE_NORMAL]); |
| gtk_widget_modify_fg(entry, GTK_STATE_INSENSITIVE, |
| &label_style->fg[GTK_STATE_INSENSITIVE]); |
| // GTK_NO_WINDOW widgets like GtkLabel don't draw their own background, so we |
| // combine the normal or insensitive foreground of the label style with the |
| // normal background of the window style to achieve the "normal label" and |
| // "insensitive label" colors. |
| gtk_widget_modify_base(entry, GTK_STATE_NORMAL, |
| &dialog_style->bg[GTK_STATE_NORMAL]); |
| gtk_widget_modify_base(entry, GTK_STATE_INSENSITIVE, |
| &dialog_style->bg[GTK_STATE_NORMAL]); |
| } |
| |
| GtkWidget* InitRowLabel(int row, int label_id, GtkWidget* details_table) { |
| GtkWidget* name_label = gtk_label_new( |
| l10n_util::GetStringUTF8(label_id).c_str()); |
| gtk_misc_set_alignment(GTK_MISC(name_label), 1, 0.5); |
| gtk_table_attach(GTK_TABLE(details_table), name_label, |
| 0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0); |
| |
| return name_label; |
| } |
| |
| GtkWidget* InitDetailRow(int row, int label_id, |
| GtkWidget* details_table, GtkWidget** entry) { |
| GtkWidget* name_label = InitRowLabel(row, label_id, details_table); |
| |
| *entry = gtk_entry_new(); |
| gtk_editable_set_editable(GTK_EDITABLE(*entry), FALSE); |
| gtk_entry_set_has_frame(GTK_ENTRY(*entry), FALSE); |
| gtk_table_attach_defaults(GTK_TABLE(details_table), *entry, |
| 1, 2, row, row + 1); |
| |
| return name_label; |
| } |
| |
| GtkWidget* InitComboboxRow(int row, int label_id, |
| GtkWidget* details_table, |
| GtkWidget** combobox, |
| GtkListStore** store) { |
| GtkWidget* name_label = InitRowLabel(row, label_id, details_table); |
| |
| *store = gtk_list_store_new(1, G_TYPE_STRING); |
| *combobox = gtk_combo_box_new_with_model(GTK_TREE_MODEL(*store)); |
| g_object_unref(*store); |
| |
| GtkCellRenderer* cell = gtk_cell_renderer_text_new(); |
| gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(*combobox), cell, TRUE); |
| gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(*combobox), cell, |
| "text", 0, NULL); |
| |
| GtkWidget* hbox = gtk_hbox_new(FALSE, 0); |
| gtk_box_pack_start(GTK_BOX(hbox), *combobox, FALSE, FALSE, 0); |
| |
| gtk_table_attach_defaults(GTK_TABLE(details_table), hbox, |
| 1, 2, row, row + 1); |
| |
| return name_label; |
| } |
| |
| void InitStyles(GtkChromeCookieView *self) { |
| GtkStyle* label_style = gtk_widget_get_style(self->first_label_); |
| GtkStyle* dialog_style = gtk_widget_get_style(GTK_WIDGET(self)); |
| |
| // Cookie details. |
| InitBrowserDetailStyle(self->cookie_name_entry_, label_style, dialog_style); |
| InitBrowserDetailStyle(self->cookie_content_entry_, label_style, |
| dialog_style); |
| InitBrowserDetailStyle(self->cookie_domain_entry_, label_style, dialog_style); |
| InitBrowserDetailStyle(self->cookie_path_entry_, label_style, dialog_style); |
| InitBrowserDetailStyle(self->cookie_send_for_entry_, label_style, |
| dialog_style); |
| InitBrowserDetailStyle(self->cookie_created_entry_, label_style, |
| dialog_style); |
| if (self->cookie_expires_entry_) { |
| InitBrowserDetailStyle(self->cookie_expires_entry_, label_style, |
| dialog_style); |
| } |
| |
| // Database details. |
| InitBrowserDetailStyle(self->database_name_entry_, label_style, dialog_style); |
| InitBrowserDetailStyle(self->database_description_entry_, label_style, |
| dialog_style); |
| InitBrowserDetailStyle(self->database_size_entry_, label_style, dialog_style); |
| InitBrowserDetailStyle(self->database_last_modified_entry_, label_style, |
| dialog_style); |
| |
| // Local storage details. |
| InitBrowserDetailStyle(self->local_storage_origin_entry_, label_style, |
| dialog_style); |
| InitBrowserDetailStyle(self->local_storage_size_entry_, label_style, |
| dialog_style); |
| InitBrowserDetailStyle(self->local_storage_last_modified_entry_, label_style, |
| dialog_style); |
| |
| // AppCache details. |
| InitBrowserDetailStyle(self->appcache_manifest_entry_, label_style, |
| dialog_style); |
| InitBrowserDetailStyle(self->appcache_size_entry_, label_style, dialog_style); |
| InitBrowserDetailStyle(self->appcache_created_entry_, label_style, |
| dialog_style); |
| InitBrowserDetailStyle(self->appcache_last_accessed_entry_, label_style, |
| dialog_style); |
| |
| // Local storage item. |
| InitBrowserDetailStyle(self->local_storage_item_origin_entry_, label_style, |
| dialog_style); |
| InitBrowserDetailStyle(self->local_storage_item_key_entry_, label_style, |
| dialog_style); |
| InitBrowserDetailStyle(self->local_storage_item_value_entry_, label_style, |
| dialog_style); |
| |
| // Database accessed item. |
| InitBrowserDetailStyle(self->database_accessed_origin_entry_, label_style, |
| dialog_style); |
| InitBrowserDetailStyle(self->database_accessed_name_entry_, label_style, |
| dialog_style); |
| InitBrowserDetailStyle(self->database_accessed_description_entry_, |
| label_style, dialog_style); |
| InitBrowserDetailStyle(self->database_accessed_size_entry_, label_style, |
| dialog_style); |
| |
| // AppCache created item. |
| InitBrowserDetailStyle(self->appcache_created_manifest_entry_, label_style, |
| dialog_style); |
| } |
| |
| void SetCookieDetailsSensitivity(GtkChromeCookieView *self, |
| gboolean enabled) { |
| gtk_widget_set_sensitive(self->cookie_name_entry_, enabled); |
| gtk_widget_set_sensitive(self->cookie_content_entry_, enabled); |
| gtk_widget_set_sensitive(self->cookie_domain_entry_, enabled); |
| gtk_widget_set_sensitive(self->cookie_path_entry_, enabled); |
| gtk_widget_set_sensitive(self->cookie_send_for_entry_, enabled); |
| gtk_widget_set_sensitive(self->cookie_created_entry_, enabled); |
| if (self->cookie_expires_entry_) |
| gtk_widget_set_sensitive(self->cookie_expires_entry_, enabled); |
| else |
| gtk_widget_set_sensitive(self->cookie_expires_combobox_, enabled); |
| } |
| |
| void SetDatabaseDetailsSensitivity(GtkChromeCookieView *self, |
| gboolean enabled) { |
| gtk_widget_set_sensitive(self->database_name_entry_, enabled); |
| gtk_widget_set_sensitive(self->database_description_entry_, enabled); |
| gtk_widget_set_sensitive(self->database_size_entry_, enabled); |
| gtk_widget_set_sensitive(self->database_last_modified_entry_, enabled); |
| } |
| |
| void SetLocalStorageDetailsSensitivity(GtkChromeCookieView *self, |
| gboolean enabled) { |
| gtk_widget_set_sensitive(self->local_storage_origin_entry_, enabled); |
| gtk_widget_set_sensitive(self->local_storage_size_entry_, enabled); |
| gtk_widget_set_sensitive(self->local_storage_last_modified_entry_, enabled); |
| } |
| |
| void SetAppCacheDetailsSensitivity(GtkChromeCookieView *self, |
| gboolean enabled) { |
| gtk_widget_set_sensitive(self->appcache_manifest_entry_, enabled); |
| gtk_widget_set_sensitive(self->appcache_size_entry_, enabled); |
| gtk_widget_set_sensitive(self->appcache_created_entry_, enabled); |
| gtk_widget_set_sensitive(self->appcache_last_accessed_entry_, enabled); |
| } |
| |
| void SetIndexedDBDetailsSensitivity(GtkChromeCookieView *self, |
| gboolean enabled) { |
| gtk_widget_set_sensitive(self->indexed_db_origin_entry_, enabled); |
| gtk_widget_set_sensitive(self->indexed_db_size_entry_, enabled); |
| gtk_widget_set_sensitive(self->indexed_db_last_modified_entry_, enabled); |
| } |
| |
| void SetLocalStorageItemSensitivity(GtkChromeCookieView* self, |
| gboolean enabled) { |
| gtk_widget_set_sensitive(self->local_storage_item_origin_entry_, enabled); |
| gtk_widget_set_sensitive(self->local_storage_item_key_entry_, enabled); |
| gtk_widget_set_sensitive(self->local_storage_item_value_entry_, enabled); |
| } |
| |
| void SetDatabaseAccessedSensitivity(GtkChromeCookieView* self, |
| gboolean enabled) { |
| gtk_widget_set_sensitive(self->database_accessed_origin_entry_, enabled); |
| gtk_widget_set_sensitive(self->database_accessed_name_entry_, enabled); |
| gtk_widget_set_sensitive(self->database_accessed_description_entry_, enabled); |
| gtk_widget_set_sensitive(self->database_accessed_size_entry_, enabled); |
| } |
| |
| void SetAppCacheCreatedSensitivity(GtkChromeCookieView* self, |
| gboolean enabled) { |
| gtk_widget_set_sensitive(self->appcache_created_manifest_entry_, enabled); |
| } |
| |
| void ClearCookieDetails(GtkChromeCookieView *self) { |
| std::string no_cookie = |
| l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_NONESELECTED); |
| gtk_entry_set_text(GTK_ENTRY(self->cookie_name_entry_), |
| no_cookie.c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->cookie_content_entry_), |
| no_cookie.c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->cookie_domain_entry_), |
| no_cookie.c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->cookie_path_entry_), |
| no_cookie.c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->cookie_created_entry_), |
| no_cookie.c_str()); |
| if (self->cookie_expires_entry_) { |
| gtk_entry_set_text(GTK_ENTRY(self->cookie_expires_entry_), |
| no_cookie.c_str()); |
| } else { |
| GtkListStore* store = self->cookie_expires_combobox_store_; |
| GtkTreeIter iter; |
| gtk_list_store_clear(store); |
| |
| gtk_list_store_append(store, &iter); |
| gtk_list_store_set(store, &iter, 0, no_cookie.c_str(), -1); |
| |
| gtk_combo_box_set_active(GTK_COMBO_BOX(self->cookie_expires_combobox_), |
| 0); |
| } |
| gtk_entry_set_text(GTK_ENTRY(self->cookie_send_for_entry_), |
| no_cookie.c_str()); |
| SetCookieDetailsSensitivity(self, FALSE); |
| } |
| |
| void UpdateVisibleDetailedInfo(GtkChromeCookieView *self, GtkWidget* table) { |
| SetCookieDetailsSensitivity(self, table == self->cookie_details_table_); |
| SetDatabaseDetailsSensitivity(self, table == self->database_details_table_); |
| SetLocalStorageDetailsSensitivity(self, |
| table == self->local_storage_details_table_); |
| SetAppCacheDetailsSensitivity(self, table == self->appcache_details_table_); |
| SetIndexedDBDetailsSensitivity(self, |
| table == self->indexed_db_details_table_); |
| SetLocalStorageItemSensitivity(self, |
| table == self->local_storage_item_table_); |
| SetDatabaseAccessedSensitivity(self, |
| table == self->database_accessed_table_); |
| SetAppCacheCreatedSensitivity(self, |
| table == self->appcache_created_table_); |
| |
| // Display everything |
| gtk_widget_show(self->table_box_); |
| gtk_widget_show_all(table); |
| // Hide everything that isn't us. |
| if (table != self->cookie_details_table_) |
| gtk_widget_hide(self->cookie_details_table_); |
| if (table != self->database_details_table_) |
| gtk_widget_hide(self->database_details_table_); |
| if (table != self->local_storage_details_table_) |
| gtk_widget_hide(self->local_storage_details_table_); |
| if (table != self->appcache_details_table_) |
| gtk_widget_hide(self->appcache_details_table_); |
| if (table != self->indexed_db_details_table_) |
| gtk_widget_hide(self->indexed_db_details_table_); |
| if (table != self->local_storage_item_table_) |
| gtk_widget_hide(self->local_storage_item_table_); |
| if (table != self->database_accessed_table_) |
| gtk_widget_hide(self->database_accessed_table_); |
| if (table != self->appcache_created_table_) |
| gtk_widget_hide(self->appcache_created_table_); |
| } |
| |
| } // namespace |
| |
| G_DEFINE_TYPE(GtkChromeCookieView, gtk_chrome_cookie_view, GTK_TYPE_FRAME) |
| |
| static void gtk_chrome_cookie_view_class_init(GtkChromeCookieViewClass *klass) { |
| } |
| |
| static void gtk_chrome_cookie_view_init(GtkChromeCookieView *self) { |
| } |
| |
| void BuildWidgets(GtkChromeCookieView *self, gboolean editable_expiration) { |
| self->table_box_ = gtk_vbox_new(FALSE, 0); |
| gtk_widget_set_no_show_all(self->table_box_, TRUE); |
| |
| // Cookie details. |
| self->cookie_details_table_ = gtk_table_new(7, 2, FALSE); |
| gtk_container_add(GTK_CONTAINER(self->table_box_), |
| self->cookie_details_table_); |
| gtk_table_set_col_spacing(GTK_TABLE(self->cookie_details_table_), 0, |
| ui::kLabelSpacing); |
| |
| int row = 0; |
| self->first_label_ = InitDetailRow(row++, IDS_COOKIES_COOKIE_NAME_LABEL, |
| self->cookie_details_table_, &self->cookie_name_entry_); |
| InitDetailRow(row++, IDS_COOKIES_COOKIE_CONTENT_LABEL, |
| self->cookie_details_table_, &self->cookie_content_entry_); |
| InitDetailRow(row++, IDS_COOKIES_COOKIE_DOMAIN_LABEL, |
| self->cookie_details_table_, &self->cookie_domain_entry_); |
| InitDetailRow(row++, IDS_COOKIES_COOKIE_PATH_LABEL, |
| self->cookie_details_table_, &self->cookie_path_entry_); |
| InitDetailRow(row++, IDS_COOKIES_COOKIE_SENDFOR_LABEL, |
| self->cookie_details_table_, &self->cookie_send_for_entry_); |
| InitDetailRow(row++, IDS_COOKIES_COOKIE_CREATED_LABEL, |
| self->cookie_details_table_, &self->cookie_created_entry_); |
| if (editable_expiration) { |
| InitComboboxRow(row++, IDS_COOKIES_COOKIE_EXPIRES_LABEL, |
| self->cookie_details_table_, |
| &self->cookie_expires_combobox_, |
| &self->cookie_expires_combobox_store_); |
| } else { |
| InitDetailRow(row++, IDS_COOKIES_COOKIE_EXPIRES_LABEL, |
| self->cookie_details_table_, &self->cookie_expires_entry_); |
| } |
| |
| // Database details. |
| self->database_details_table_ = gtk_table_new(4, 2, FALSE); |
| gtk_container_add(GTK_CONTAINER(self->table_box_), |
| self->database_details_table_); |
| gtk_table_set_col_spacing(GTK_TABLE(self->database_details_table_), 0, |
| ui::kLabelSpacing); |
| |
| InitDetailRow(row++, IDS_COOKIES_COOKIE_NAME_LABEL, |
| self->database_details_table_, &self->database_name_entry_); |
| InitDetailRow(row++, IDS_COOKIES_WEB_DATABASE_DESCRIPTION_LABEL, |
| self->database_details_table_, |
| &self->database_description_entry_); |
| InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_SIZE_ON_DISK_LABEL, |
| self->database_details_table_, &self->database_size_entry_); |
| InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_LAST_MODIFIED_LABEL, |
| self->database_details_table_, |
| &self->database_last_modified_entry_); |
| |
| // Local storage details. |
| self->local_storage_details_table_ = gtk_table_new(3, 2, FALSE); |
| gtk_container_add(GTK_CONTAINER(self->table_box_), |
| self->local_storage_details_table_); |
| gtk_table_set_col_spacing(GTK_TABLE(self->local_storage_details_table_), 0, |
| ui::kLabelSpacing); |
| |
| row = 0; |
| InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_ORIGIN_LABEL, |
| self->local_storage_details_table_, |
| &self->local_storage_origin_entry_); |
| InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_SIZE_ON_DISK_LABEL, |
| self->local_storage_details_table_, |
| &self->local_storage_size_entry_); |
| InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_LAST_MODIFIED_LABEL, |
| self->local_storage_details_table_, |
| &self->local_storage_last_modified_entry_); |
| |
| // AppCache details. |
| self->appcache_details_table_ = gtk_table_new(4, 2, FALSE); |
| gtk_container_add(GTK_CONTAINER(self->table_box_), |
| self->appcache_details_table_); |
| gtk_table_set_col_spacing(GTK_TABLE(self->appcache_details_table_), 0, |
| ui::kLabelSpacing); |
| |
| row = 0; |
| InitDetailRow(row++, IDS_COOKIES_APPLICATION_CACHE_MANIFEST_LABEL, |
| self->appcache_details_table_, |
| &self->appcache_manifest_entry_); |
| InitDetailRow(row++, IDS_COOKIES_SIZE_LABEL, |
| self->appcache_details_table_, &self->appcache_size_entry_); |
| InitDetailRow(row++, IDS_COOKIES_COOKIE_CREATED_LABEL, |
| self->appcache_details_table_, &self->appcache_created_entry_); |
| InitDetailRow(row++, IDS_COOKIES_LAST_ACCESSED_LABEL, |
| self->appcache_details_table_, |
| &self->appcache_last_accessed_entry_); |
| |
| // IndexedDB details. |
| self->indexed_db_details_table_ = gtk_table_new(4, 2, FALSE); |
| gtk_container_add(GTK_CONTAINER(self->table_box_), |
| self->indexed_db_details_table_); |
| gtk_table_set_col_spacing(GTK_TABLE(self->indexed_db_details_table_), 0, |
| ui::kLabelSpacing); |
| |
| row = 0; |
| InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_ORIGIN_LABEL, |
| self->indexed_db_details_table_, |
| &self->indexed_db_origin_entry_); |
| InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_SIZE_ON_DISK_LABEL, |
| self->indexed_db_details_table_, &self->indexed_db_size_entry_); |
| InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_LAST_MODIFIED_LABEL, |
| self->indexed_db_details_table_, |
| &self->indexed_db_last_modified_entry_); |
| |
| // Local storage item. |
| self->local_storage_item_table_ = gtk_table_new(3, 2, FALSE); |
| gtk_container_add(GTK_CONTAINER(self->table_box_), |
| self->local_storage_item_table_); |
| gtk_table_set_col_spacing(GTK_TABLE(self->local_storage_item_table_), 0, |
| ui::kLabelSpacing); |
| |
| row = 0; |
| InitDetailRow(row++, IDS_COOKIES_COOKIE_DOMAIN_LABEL, |
| self->local_storage_item_table_, |
| &self->local_storage_item_origin_entry_); |
| InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_KEY_LABEL, |
| self->local_storage_item_table_, |
| &self->local_storage_item_key_entry_); |
| InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_VALUE_LABEL, |
| self->local_storage_item_table_, |
| &self->local_storage_item_value_entry_); |
| |
| // Database accessed prompt. |
| self->database_accessed_table_ = gtk_table_new(2, 2, FALSE); |
| gtk_container_add(GTK_CONTAINER(self->table_box_), |
| self->database_accessed_table_); |
| gtk_table_set_col_spacing(GTK_TABLE(self->local_storage_item_table_), 0, |
| ui::kLabelSpacing); |
| |
| row = 0; |
| InitDetailRow(row++, IDS_COOKIES_COOKIE_DOMAIN_LABEL, |
| self->database_accessed_table_, |
| &self->database_accessed_origin_entry_); |
| InitDetailRow(row++, IDS_COOKIES_WEB_DATABASE_NAME, |
| self->database_accessed_table_, |
| &self->database_accessed_name_entry_); |
| InitDetailRow(row++, IDS_COOKIES_WEB_DATABASE_DESCRIPTION_LABEL, |
| self->database_accessed_table_, |
| &self->database_accessed_description_entry_); |
| InitDetailRow(row++, IDS_COOKIES_SIZE_LABEL, |
| self->database_accessed_table_, |
| &self->database_accessed_size_entry_); |
| |
| // AppCache created prompt. |
| self->appcache_created_table_ = gtk_table_new(1, 2, FALSE); |
| gtk_container_add(GTK_CONTAINER(self->table_box_), |
| self->appcache_created_table_); |
| gtk_table_set_col_spacing(GTK_TABLE(self->appcache_created_table_), 0, |
| ui::kLabelSpacing); |
| row = 0; |
| InitDetailRow(row++, IDS_COOKIES_APPLICATION_CACHE_MANIFEST_LABEL, |
| self->appcache_created_table_, |
| &self->appcache_created_manifest_entry_); |
| |
| gtk_frame_set_shadow_type(GTK_FRAME(self), GTK_SHADOW_ETCHED_IN); |
| gtk_container_add(GTK_CONTAINER(self), self->table_box_); |
| } |
| |
| GtkWidget* gtk_chrome_cookie_view_new(gboolean editable_expiration) { |
| GtkChromeCookieView* view = GTK_CHROME_COOKIE_VIEW( |
| g_object_new(GTK_TYPE_CHROME_COOKIE_VIEW, NULL)); |
| BuildWidgets(view, editable_expiration); |
| g_signal_connect(view, "realize", G_CALLBACK(InitStyles), NULL); |
| return GTK_WIDGET(view); |
| } |
| |
| void gtk_chrome_cookie_view_clear(GtkChromeCookieView* self) { |
| UpdateVisibleDetailedInfo(self, self->cookie_details_table_); |
| ClearCookieDetails(self); |
| } |
| |
| // Switches the display to showing the passed in cookie. |
| void gtk_chrome_cookie_view_display_cookie( |
| GtkChromeCookieView* self, |
| const std::string& domain, |
| const net::CanonicalCookie& cookie) { |
| UpdateVisibleDetailedInfo(self, self->cookie_details_table_); |
| |
| gtk_entry_set_text(GTK_ENTRY(self->cookie_name_entry_), |
| cookie.Name().c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->cookie_content_entry_), |
| cookie.Value().c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->cookie_domain_entry_), |
| domain.c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->cookie_path_entry_), |
| cookie.Path().c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->cookie_created_entry_), |
| UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime( |
| cookie.CreationDate())).c_str()); |
| |
| std::string expire_text = cookie.IsPersistent() ? |
| UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(cookie.ExpiryDate())) : |
| l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_EXPIRES_SESSION); |
| |
| if (self->cookie_expires_entry_) { |
| gtk_entry_set_text(GTK_ENTRY(self->cookie_expires_entry_), |
| expire_text.c_str()); |
| } else { |
| GtkListStore* store = self->cookie_expires_combobox_store_; |
| GtkTreeIter iter; |
| gtk_list_store_clear(store); |
| |
| if (cookie.IsPersistent()) { |
| gtk_list_store_append(store, &iter); |
| gtk_list_store_set(store, &iter, 0, expire_text.c_str(), -1); |
| } |
| |
| gtk_list_store_append(store, &iter); |
| gtk_list_store_set( |
| store, &iter, 0, |
| l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_EXPIRES_SESSION).c_str(), |
| -1); |
| |
| gtk_combo_box_set_active(GTK_COMBO_BOX(self->cookie_expires_combobox_), |
| 0); |
| } |
| |
| gtk_entry_set_text( |
| GTK_ENTRY(self->cookie_send_for_entry_), |
| l10n_util::GetStringUTF8(cookie.IsSecure() ? |
| IDS_COOKIES_COOKIE_SENDFOR_SECURE : |
| IDS_COOKIES_COOKIE_SENDFOR_ANY).c_str()); |
| SetCookieDetailsSensitivity(self, TRUE); |
| } |
| |
| void gtk_chrome_cookie_view_display_cookie_string( |
| GtkChromeCookieView* self, |
| const GURL& url, |
| const std::string& cookie_line) { |
| net::ParsedCookie pc(cookie_line); |
| net::CanonicalCookie cookie(url, pc); |
| |
| gtk_chrome_cookie_view_display_cookie( |
| self, |
| pc.HasDomain() ? pc.Domain() : url.host(), |
| cookie); |
| } |
| |
| // Switches the display to showing the passed in database. |
| void gtk_chrome_cookie_view_display_database( |
| GtkChromeCookieView* self, |
| const BrowsingDataDatabaseHelper::DatabaseInfo& database_info) { |
| UpdateVisibleDetailedInfo(self, self->database_details_table_); |
| |
| gtk_entry_set_text( |
| GTK_ENTRY(self->database_name_entry_), |
| database_info.database_name.empty() ? |
| l10n_util::GetStringUTF8( |
| IDS_COOKIES_WEB_DATABASE_UNNAMED_NAME).c_str() : |
| database_info.database_name.c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->database_description_entry_), |
| database_info.description.c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->database_size_entry_), |
| UTF16ToUTF8(ui::FormatBytes(database_info.size)).c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->database_last_modified_entry_), |
| UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime( |
| database_info.last_modified)).c_str()); |
| SetDatabaseDetailsSensitivity(self, TRUE); |
| } |
| |
| // Switches the display to showing the passed in local storage data. |
| void gtk_chrome_cookie_view_display_local_storage( |
| GtkChromeCookieView* self, |
| const BrowsingDataLocalStorageHelper::LocalStorageInfo& |
| local_storage_info) { |
| UpdateVisibleDetailedInfo(self, self->local_storage_details_table_); |
| |
| gtk_entry_set_text(GTK_ENTRY(self->local_storage_origin_entry_), |
| local_storage_info.origin_url.spec().c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->local_storage_size_entry_), |
| UTF16ToUTF8(ui::FormatBytes( |
| local_storage_info.size)).c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->local_storage_last_modified_entry_), |
| UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime( |
| local_storage_info.last_modified)).c_str()); |
| SetLocalStorageDetailsSensitivity(self, TRUE); |
| } |
| |
| // Switches the display to showing the passed in app cache. |
| void gtk_chrome_cookie_view_display_app_cache( |
| GtkChromeCookieView* self, |
| const appcache::AppCacheInfo& info) { |
| UpdateVisibleDetailedInfo(self, self->appcache_details_table_); |
| |
| gtk_entry_set_text(GTK_ENTRY(self->appcache_manifest_entry_), |
| info.manifest_url.spec().c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->appcache_size_entry_), |
| UTF16ToUTF8(ui::FormatBytes(info.size)).c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->appcache_created_entry_), |
| UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime( |
| info.creation_time)).c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->appcache_last_accessed_entry_), |
| UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime( |
| info.last_access_time)).c_str()); |
| SetAppCacheDetailsSensitivity(self, TRUE); |
| } |
| |
| // Switches the display to showing the passed in IndexedDB data. |
| void gtk_chrome_cookie_view_display_indexed_db( |
| GtkChromeCookieView* self, |
| const content::IndexedDBInfo& indexed_db_info) { |
| UpdateVisibleDetailedInfo(self, self->indexed_db_details_table_); |
| |
| gtk_entry_set_text(GTK_ENTRY(self->indexed_db_origin_entry_), |
| indexed_db_info.origin_.spec().c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->indexed_db_size_entry_), |
| UTF16ToUTF8(ui::FormatBytes( |
| indexed_db_info.size_)).c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->indexed_db_last_modified_entry_), |
| UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime( |
| indexed_db_info.last_modified_)).c_str()); |
| SetLocalStorageDetailsSensitivity(self, TRUE); |
| } |
| |
| void gtk_chrome_cookie_view_display_local_storage_item( |
| GtkChromeCookieView* self, |
| const std::string& host, |
| const string16& key, |
| const string16& value) { |
| UpdateVisibleDetailedInfo(self, self->local_storage_item_table_); |
| |
| gtk_entry_set_text(GTK_ENTRY(self->local_storage_item_origin_entry_), |
| host.c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->local_storage_item_key_entry_), |
| UTF16ToUTF8(key).c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->local_storage_item_value_entry_), |
| UTF16ToUTF8(value).c_str()); |
| SetLocalStorageItemSensitivity(self, TRUE); |
| } |
| |
| void gtk_chrome_cookie_view_display_database_accessed( |
| GtkChromeCookieView* self, |
| const std::string& host, |
| const string16& database_name, |
| const string16& display_name, |
| unsigned long estimated_size) { |
| UpdateVisibleDetailedInfo(self, self->database_accessed_table_); |
| |
| gtk_entry_set_text(GTK_ENTRY(self->database_accessed_origin_entry_), |
| host.c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->database_accessed_name_entry_), |
| UTF16ToUTF8(database_name).c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->database_accessed_description_entry_), |
| UTF16ToUTF8(display_name).c_str()); |
| gtk_entry_set_text(GTK_ENTRY(self->database_accessed_size_entry_), |
| UTF16ToUTF8(ui::FormatBytes(estimated_size)).c_str()); |
| SetDatabaseAccessedSensitivity(self, TRUE); |
| } |
| |
| void gtk_chrome_cookie_view_display_appcache_created( |
| GtkChromeCookieView* self, |
| const GURL& manifest_url) { |
| UpdateVisibleDetailedInfo(self, self->appcache_created_table_); |
| gtk_entry_set_text(GTK_ENTRY(self->appcache_created_manifest_entry_), |
| manifest_url.spec().c_str()); |
| SetAppCacheCreatedSensitivity(self, TRUE); |
| } |
| |
| bool gtk_chrome_cookie_view_session_expires(GtkChromeCookieView* self) { |
| if (self->cookie_expires_entry_) |
| return false; |
| |
| GtkListStore* store = self->cookie_expires_combobox_store_; |
| int store_size = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store), NULL); |
| if (store_size == 1) |
| return false; |
| |
| DCHECK_EQ(2, store_size); |
| |
| int selected = gtk_combo_box_get_active(GTK_COMBO_BOX( |
| self->cookie_expires_combobox_)); |
| return selected == 1; |
| } |
