Adds local storage nodes to cookie tree model and cookies view.

chrome/browser/gtk/options/cookies_view.cc

 // Copyright (c) 2009 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/gtk/options/cookies_view.h"
 
 #include <gdk/gdkkeysyms.h>
 #include <set>
 #include <string>
 
@@ skipping 17 matching lines @@
 
 // Response ids for our custom buttons.
 enum {
   RESPONSE_REMOVE = 1,
   RESPONSE_REMOVE_ALL
 };
 
 // The currently open cookie manager, if any.
 CookiesView* instance_ = NULL;
 
-void InitCookieDetailStyle(GtkWidget* entry, GtkStyle* label_style,
-                           GtkStyle* dialog_style) {
+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]);
 }
 
 }  // namespace
 
 CookiesView::~CookiesView() {
 }
 
 // static
-void CookiesView::Show(Profile* profile) {
+void CookiesView::Show(
+    Profile* profile,
+    BrowsingDataLocalStorageHelper* browsing_data_local_storage_helper) {
   DCHECK(profile);
+  DCHECK(browsing_data_local_storage_helper);
 
   // If there's already an existing editor window, activate it.
   if (instance_) {
     gtk_window_present(GTK_WINDOW(instance_->dialog_));
   } else {
-    instance_ = new CookiesView(profile);
+    instance_ = new CookiesView(profile, browsing_data_local_storage_helper);
     instance_->InitStylesAndShow();
   }
 }
 
-CookiesView::CookiesView(Profile* profile)
+CookiesView::CookiesView(
+    Profile* profile,
+    BrowsingDataLocalStorageHelper* browsing_data_local_storage_helper)
     : profile_(profile),
+      browsing_data_local_storage_helper_(browsing_data_local_storage_helper),
       filter_update_factory_(this) {
   Init();
 }
 
 void CookiesView::Init() {
   dialog_ = gtk_dialog_new_with_buttons(
       l10n_util::GetStringUTF8(
           IDS_COOKIES_WEBSITE_PERMISSIONS_WINDOW_TITLE).c_str(),
       NULL,
       GTK_DIALOG_NO_SEPARATOR,
@@ skipping 69 matching lines @@
                      FALSE, FALSE, 0);
 
   GtkWidget* scroll_window = gtk_scrolled_window_new(NULL, NULL);
   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window),
                                  GTK_POLICY_AUTOMATIC,
                                  GTK_POLICY_AUTOMATIC);
   gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll_window),
                                       GTK_SHADOW_ETCHED_IN);
   gtk_box_pack_start(GTK_BOX(cookie_list_vbox), scroll_window, TRUE, TRUE, 0);
 
-  cookies_tree_model_.reset(new CookiesTreeModel(profile_));
+  cookies_tree_model_.reset(new CookiesTreeModel(
+      profile_, browsing_data_local_storage_helper_));
   cookies_tree_adapter_.reset(
       new gtk_tree::TreeAdapter(this, cookies_tree_model_.get()));
   tree_ = gtk_tree_view_new_with_model(
       GTK_TREE_MODEL(cookies_tree_adapter_->tree_store()));
   gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree_), FALSE);
   gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(tree_), TRUE);
   gtk_container_add(GTK_CONTAINER(scroll_window), tree_);
 
   GtkTreeViewColumn* title_column = gtk_tree_view_column_new();
   GtkCellRenderer* pixbuf_renderer = gtk_cell_renderer_pixbuf_new();
@@ skipping 12 matching lines @@
                    G_CALLBACK(OnTreeViewKeyPress), this);
   g_signal_connect(G_OBJECT(tree_), "row-expanded",
                    G_CALLBACK(OnTreeViewRowExpanded), this);
 
   selection_ = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_));
   gtk_tree_selection_set_mode(selection_, GTK_SELECTION_SINGLE);
   g_signal_connect(G_OBJECT(selection_), "changed",
                    G_CALLBACK(OnSelectionChanged), this);
 
   // Cookie details.
-  GtkWidget* details_frame = gtk_frame_new(NULL);
-  gtk_frame_set_shadow_type(GTK_FRAME(details_frame), GTK_SHADOW_ETCHED_IN);
-  gtk_box_pack_start(GTK_BOX(cookie_list_vbox), details_frame,
+  GtkWidget* cookie_details_frame = gtk_frame_new(NULL);
+  gtk_frame_set_shadow_type(GTK_FRAME(cookie_details_frame),
+                            GTK_SHADOW_ETCHED_IN);
+  gtk_box_pack_start(GTK_BOX(cookie_list_vbox), cookie_details_frame,
                      FALSE, FALSE, 0);
   cookie_details_table_ = gtk_table_new(7, 2, FALSE);
-  gtk_container_add(GTK_CONTAINER(details_frame), cookie_details_table_);
+  gtk_container_add(GTK_CONTAINER(cookie_details_frame), cookie_details_table_);
   gtk_table_set_col_spacing(GTK_TABLE(cookie_details_table_), 0,
                             gtk_util::kLabelSpacing);
 
   int row = 0;
-  InitCookieDetailRow(row++, IDS_COOKIES_COOKIE_NAME_LABEL,
-                      &cookie_name_entry_);
-  InitCookieDetailRow(row++, IDS_COOKIES_COOKIE_CONTENT_LABEL,
-                      &cookie_content_entry_);
-  InitCookieDetailRow(row++, IDS_COOKIES_COOKIE_DOMAIN_LABEL,
-                      &cookie_domain_entry_);
-  InitCookieDetailRow(row++, IDS_COOKIES_COOKIE_PATH_LABEL,
-                      &cookie_path_entry_);
-  InitCookieDetailRow(row++, IDS_COOKIES_COOKIE_SENDFOR_LABEL,
-                      &cookie_send_for_entry_);
-  InitCookieDetailRow(row++, IDS_COOKIES_COOKIE_CREATED_LABEL,
-                      &cookie_created_entry_);
-  InitCookieDetailRow(row++, IDS_COOKIES_COOKIE_EXPIRES_LABEL,
-                      &cookie_expires_entry_);
+  InitDetailRow(row++, IDS_COOKIES_COOKIE_NAME_LABEL,
+                cookie_details_table_, &cookie_name_entry_);
+  InitDetailRow(row++, IDS_COOKIES_COOKIE_CONTENT_LABEL,
+                cookie_details_table_, &cookie_content_entry_);
+  InitDetailRow(row++, IDS_COOKIES_COOKIE_DOMAIN_LABEL,
+                cookie_details_table_, &cookie_domain_entry_);
+  InitDetailRow(row++, IDS_COOKIES_COOKIE_PATH_LABEL,
+                cookie_details_table_, &cookie_path_entry_);
+  InitDetailRow(row++, IDS_COOKIES_COOKIE_SENDFOR_LABEL,
+                cookie_details_table_, &cookie_send_for_entry_);
+  InitDetailRow(row++, IDS_COOKIES_COOKIE_CREATED_LABEL,
+                cookie_details_table_, &cookie_created_entry_);
+  InitDetailRow(row++, IDS_COOKIES_COOKIE_EXPIRES_LABEL,
+                cookie_details_table_, &cookie_expires_entry_);
 
+  // Local storage details.
+  GtkWidget* local_storage_details_frame = gtk_frame_new(NULL);
+  gtk_frame_set_shadow_type(GTK_FRAME(local_storage_details_frame),
+                            GTK_SHADOW_ETCHED_IN);
+  gtk_box_pack_start(GTK_BOX(cookie_list_vbox), local_storage_details_frame,
+                     FALSE, FALSE, 0);
+  local_storage_details_table_ = gtk_table_new(3, 2, FALSE);
+  gtk_container_add(GTK_CONTAINER(local_storage_details_frame),
+                    local_storage_details_table_);
+  gtk_table_set_col_spacing(GTK_TABLE(local_storage_details_table_), 0,
+                            gtk_util::kLabelSpacing);
+
+  row = 0;
+  InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_ORIGIN_LABEL,
+                local_storage_details_table_, &local_storage_origin_entry_);
+  InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_SIZE_ON_DISK_LABEL,
+                local_storage_details_table_, &local_storage_size_entry_);
+  InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_LAST_MODIFIED_LABEL,
+                local_storage_details_table_,
+                &local_storage_last_modified_entry_);
+
+  UpdateVisibleDetailedInfo(cookie_details_table_);
   // Populate the view.
   cookies_tree_adapter_->Init();
   SetInitialTreeState();
   EnableControls();
 }
 
 void CookiesView::InitStylesAndShow() {
   // Realize a label so that its style gets initialized.
   gtk_widget_realize(description_label_);
   gtk_widget_realize(dialog_);
   GtkStyle* label_style = gtk_widget_get_style(description_label_);
   GtkStyle* dialog_style = gtk_widget_get_style(dialog_);
 
-  InitCookieDetailStyle(cookie_name_entry_, label_style, dialog_style);
-  InitCookieDetailStyle(cookie_content_entry_, label_style, dialog_style);
-  InitCookieDetailStyle(cookie_domain_entry_, label_style, dialog_style);
-  InitCookieDetailStyle(cookie_path_entry_, label_style, dialog_style);
-  InitCookieDetailStyle(cookie_send_for_entry_, label_style, dialog_style);
-  InitCookieDetailStyle(cookie_created_entry_, label_style, dialog_style);
-  InitCookieDetailStyle(cookie_expires_entry_, label_style, dialog_style);
+  // Cookie details.
+  InitBrowserDetailStyle(cookie_name_entry_, label_style, dialog_style);
+  InitBrowserDetailStyle(cookie_content_entry_, label_style, dialog_style);
+  InitBrowserDetailStyle(cookie_domain_entry_, label_style, dialog_style);
+  InitBrowserDetailStyle(cookie_path_entry_, label_style, dialog_style);
+  InitBrowserDetailStyle(cookie_send_for_entry_, label_style, dialog_style);
+  InitBrowserDetailStyle(cookie_created_entry_, label_style, dialog_style);
+  InitBrowserDetailStyle(cookie_expires_entry_, label_style, dialog_style);
+
+  // Local storage details.
+  InitBrowserDetailStyle(local_storage_origin_entry_, label_style,
+                         dialog_style);
+  InitBrowserDetailStyle(local_storage_size_entry_, label_style, dialog_style);
+  InitBrowserDetailStyle(local_storage_last_modified_entry_, label_style,
+                         dialog_style);
 
   gtk_widget_show_all(dialog_);
 }
 
-void CookiesView::InitCookieDetailRow(int row, int label_id,
-                                      GtkWidget** entry) {
+void CookiesView::InitDetailRow(int row, int label_id,
+                                GtkWidget* details_table, GtkWidget** entry) {
   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(cookie_details_table_), name_label,
+  gtk_table_attach(GTK_TABLE(details_table), name_label,
                    0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
 
   *entry = gtk_entry_new();
 
   gtk_entry_set_editable(GTK_ENTRY(*entry), FALSE);
   gtk_entry_set_has_frame(GTK_ENTRY(*entry), FALSE);
-  gtk_table_attach_defaults(GTK_TABLE(cookie_details_table_), *entry,
+  gtk_table_attach_defaults(GTK_TABLE(details_table), *entry,
                             1, 2, row, row + 1);
 }
 
 void CookiesView::SetInitialTreeState() {
   if (cookies_tree_model_->GetChildCount(cookies_tree_model_->GetRoot()))
     gtk_tree::SelectAndFocusRowNum(0, GTK_TREE_VIEW(tree_));
 }
 
 void CookiesView::EnableControls() {
   GtkTreeIter iter;
   bool selected = gtk_tree_selection_get_selected(selection_, NULL, &iter);
   gtk_widget_set_sensitive(remove_button_, selected);
   gtk_widget_set_sensitive(
       remove_all_button_,
       cookies_tree_model_->GetChildCount(cookies_tree_model_->GetRoot()));
 
   const gchar* filter_text = gtk_entry_get_text(GTK_ENTRY(filter_entry_));
   gtk_widget_set_sensitive(filter_clear_button_, filter_text && *filter_text);
 
   if (selected) {
     CookieTreeNode::DetailedInfo detailed_info =
         static_cast<CookieTreeNode*>(
             cookies_tree_adapter_->GetNode(&iter))->GetDetailedInfo();
     if (detailed_info.node_type == CookieTreeNode::DetailedInfo::TYPE_COOKIE) {
+      UpdateVisibleDetailedInfo(cookie_details_table_);
       PopulateCookieDetails(detailed_info.cookie->first,
                             detailed_info.cookie->second);
+    } else if (detailed_info.node_type ==
+               CookieTreeNode::DetailedInfo::TYPE_LOCAL_STORAGE) {
+      UpdateVisibleDetailedInfo(local_storage_details_table_);
+      PopulateLocalStorageDetails(*detailed_info.local_storage_info);
     } else {
+      UpdateVisibleDetailedInfo(cookie_details_table_);
       ClearCookieDetails();
     }
   } else {
     ClearCookieDetails();
   }
 }
 
 void CookiesView::SetCookieDetailsSensitivity(gboolean enabled) {
   gtk_widget_set_sensitive(cookie_name_entry_, enabled);
   gtk_widget_set_sensitive(cookie_content_entry_, enabled);
   gtk_widget_set_sensitive(cookie_domain_entry_, enabled);
   gtk_widget_set_sensitive(cookie_path_entry_, enabled);
   gtk_widget_set_sensitive(cookie_send_for_entry_, enabled);
   gtk_widget_set_sensitive(cookie_created_entry_, enabled);
   gtk_widget_set_sensitive(cookie_expires_entry_, enabled);
 }
 
+void CookiesView::SetLocalStorageDetailsSensitivity(gboolean enabled) {
+  gtk_widget_set_sensitive(local_storage_origin_entry_, enabled);
+  gtk_widget_set_sensitive(local_storage_size_entry_, enabled);
+  gtk_widget_set_sensitive(local_storage_last_modified_entry_, enabled);
+}
+
 void CookiesView::PopulateCookieDetails(
     const std::string& domain,
     const net::CookieMonster::CanonicalCookie& cookie) {
   gtk_entry_set_text(GTK_ENTRY(cookie_name_entry_), cookie.Name().c_str());
   gtk_entry_set_text(GTK_ENTRY(cookie_content_entry_), cookie.Value().c_str());
   gtk_entry_set_text(GTK_ENTRY(cookie_domain_entry_), domain.c_str());
   gtk_entry_set_text(GTK_ENTRY(cookie_path_entry_), cookie.Path().c_str());
   gtk_entry_set_text(GTK_ENTRY(cookie_created_entry_),
                      WideToUTF8(base::TimeFormatFriendlyDateAndTime(
                          cookie.CreationDate())).c_str());
   if (cookie.DoesExpire()) {
     gtk_entry_set_text(GTK_ENTRY(cookie_expires_entry_),
                        WideToUTF8(base::TimeFormatFriendlyDateAndTime(
                            cookie.ExpiryDate())).c_str());
   } else {
     gtk_entry_set_text(GTK_ENTRY(cookie_expires_entry_),
                        l10n_util::GetStringUTF8(
                            IDS_COOKIES_COOKIE_EXPIRES_SESSION).c_str());
   }
   gtk_entry_set_text(
       GTK_ENTRY(cookie_send_for_entry_),
       l10n_util::GetStringUTF8(cookie.IsSecure() ?
                                IDS_COOKIES_COOKIE_SENDFOR_SECURE :
                                IDS_COOKIES_COOKIE_SENDFOR_ANY).c_str());
   SetCookieDetailsSensitivity(TRUE);
 }
 
+void CookiesView::PopulateLocalStorageDetails(
+    const BrowsingDataLocalStorageHelper::LocalStorageInfo&
+    local_storage_info) {
+  gtk_entry_set_text(GTK_ENTRY(local_storage_origin_entry_),
+                     local_storage_info.origin.c_str());
+  gtk_entry_set_text(GTK_ENTRY(local_storage_size_entry_),
+                     WideToUTF8(FormatBytes(
+                         local_storage_info.size,
+                         GetByteDisplayUnits(local_storage_info.size),
+                         true)).c_str());
+  gtk_entry_set_text(GTK_ENTRY(local_storage_last_modified_entry_),
+                     WideToUTF8(base::TimeFormatFriendlyDateAndTime(
+                         local_storage_info.last_modified)).c_str());
+  SetLocalStorageDetailsSensitivity(TRUE);
+}
+
 void CookiesView::ClearCookieDetails() {
   std::string no_cookie =
       l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_NONESELECTED);
   gtk_entry_set_text(GTK_ENTRY(cookie_name_entry_), no_cookie.c_str());
   gtk_entry_set_text(GTK_ENTRY(cookie_content_entry_), no_cookie.c_str());
   gtk_entry_set_text(GTK_ENTRY(cookie_domain_entry_), no_cookie.c_str());
   gtk_entry_set_text(GTK_ENTRY(cookie_path_entry_), no_cookie.c_str());
   gtk_entry_set_text(GTK_ENTRY(cookie_created_entry_), no_cookie.c_str());
   gtk_entry_set_text(GTK_ENTRY(cookie_expires_entry_), no_cookie.c_str());
   gtk_entry_set_text(GTK_ENTRY(cookie_send_for_entry_), no_cookie.c_str());
@@ skipping 41 matching lines @@
   EnableControls();
 }
 
 // static
 void CookiesView::OnResponse(GtkDialog* dialog, int response_id,
                              CookiesView* window) {
   if (response_id == RESPONSE_REMOVE) {
     window->RemoveSelectedItems();
   } else if (response_id == RESPONSE_REMOVE_ALL) {
     window->cookies_tree_model_->DeleteAllCookies();
+    window->browsing_data_local_storage_helper_->DeleteAllLocalStorageFiles();
   } else {
     gtk_widget_destroy(window->dialog_);
   }
 }
 
 // static
 void CookiesView::OnWindowDestroy(GtkWidget* widget, CookiesView* window) {
   instance_ = NULL;
   MessageLoop::current()->DeleteSoon(FROM_HERE, window);
 }
@@ skipping 30 matching lines @@
 }
 
 void CookiesView::UpdateFilterResults() {
   const gchar* text = gtk_entry_get_text(GTK_ENTRY(filter_entry_));
   if (text) {
     cookies_tree_model_->UpdateSearchResults(UTF8ToWide(text));
     SetInitialTreeState();
   }
 }
 
+void CookiesView::UpdateVisibleDetailedInfo(GtkWidget* table) {
+  // Toggle the parent (the table frame) visibility and sensitivity.
+  gtk_widget_show(gtk_widget_get_parent(table));
+  // Toggle the other tables.
+  if (table == cookie_details_table_) {
+    SetCookieDetailsSensitivity(true);
+    SetLocalStorageDetailsSensitivity(false);
+    gtk_widget_hide(gtk_widget_get_parent(local_storage_details_table_));
+  } else if (table == local_storage_details_table_) {
+    SetCookieDetailsSensitivity(false);
+    SetLocalStorageDetailsSensitivity(true);
+    gtk_widget_hide(gtk_widget_get_parent(cookie_details_table_));
+  }
+}
+
 // static
 void CookiesView::OnFilterEntryActivated(GtkEntry* entry, CookiesView* window) {
   window->filter_update_factory_.RevokeAll();
   window->UpdateFilterResults();
 }
 
 // static
 void CookiesView::OnFilterEntryChanged(GtkEditable* editable,
                                        CookiesView* window) {
   window->filter_update_factory_.RevokeAll();
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       window->filter_update_factory_.NewRunnableMethod(
           &CookiesView::UpdateFilterResults), kSearchFilterDelayMs);
   window->EnableControls();
 }
 
 // static
 void CookiesView::OnFilterClearButtonClicked(GtkButton* button,
                                              CookiesView* window) {
   gtk_entry_set_text(GTK_ENTRY(window->filter_entry_), "");
   window->filter_update_factory_.RevokeAll();
   window->UpdateFilterResults();
 }