Teach the cookie tree view / model about appcaches. Not hooked up to real dat...

chrome/browser/gtk/options/cookies_view.cc

 // Copyright (c) 2010 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 43 matching lines @@
 }  // namespace
 
 CookiesView::~CookiesView() {
 }
 
 // static
 void CookiesView::Show(
     GtkWindow* parent,
     Profile* profile,
     BrowsingDataDatabaseHelper* browsing_data_database_helper,
-    BrowsingDataLocalStorageHelper* browsing_data_local_storage_helper) {
+    BrowsingDataLocalStorageHelper* browsing_data_local_storage_helper,
+    BrowsingDataAppCacheHelper* browsing_data_appcache_helper) {
   DCHECK(profile);
   DCHECK(browsing_data_database_helper);
   DCHECK(browsing_data_local_storage_helper);
+  DCHECK(browsing_data_appcache_helper);
 
   // If there's already an existing editor window, activate it.
   if (instance_) {
     gtk_window_present(GTK_WINDOW(instance_->dialog_));
   } else {
     instance_ = new CookiesView(parent,
                                 profile,
                                 browsing_data_database_helper,
-                                browsing_data_local_storage_helper);
+                                browsing_data_local_storage_helper,
+                                browsing_data_appcache_helper);
     instance_->InitStylesAndShow();
   }
 }
 
 CookiesView::CookiesView(
     GtkWindow* parent,
     Profile* profile,
     BrowsingDataDatabaseHelper* browsing_data_database_helper,
-    BrowsingDataLocalStorageHelper* browsing_data_local_storage_helper)
+    BrowsingDataLocalStorageHelper* browsing_data_local_storage_helper,
+    BrowsingDataAppCacheHelper* browsing_data_appcache_helper)
     : profile_(profile),
       browsing_data_database_helper_(browsing_data_database_helper),
       browsing_data_local_storage_helper_(browsing_data_local_storage_helper),
+      browsing_data_appcache_helper_(browsing_data_appcache_helper),
       filter_update_factory_(this) {
   Init(parent);
 }
 
 void CookiesView::Init(GtkWindow* parent) {
   dialog_ = gtk_dialog_new_with_buttons(
       l10n_util::GetStringUTF8(
           IDS_COOKIES_WEBSITE_PERMISSIONS_WINDOW_TITLE).c_str(),
       parent,
       static_cast<GtkDialogFlags>(GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR),
@@ skipping 73 matching lines @@
   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_,
       browsing_data_database_helper_,
-      browsing_data_local_storage_helper_));
+      browsing_data_local_storage_helper_,
+      browsing_data_appcache_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 44 matching lines @@
                 cookie_details_table_, &cookie_created_entry_);
   InitDetailRow(row++, IDS_COOKIES_COOKIE_EXPIRES_LABEL,
                 cookie_details_table_, &cookie_expires_entry_);
 
   // Database details.
   GtkWidget* database_details_frame = gtk_frame_new(NULL);
   gtk_frame_set_shadow_type(GTK_FRAME(database_details_frame),
                             GTK_SHADOW_ETCHED_IN);
   gtk_box_pack_start(GTK_BOX(cookie_list_vbox), database_details_frame,
                      FALSE, FALSE, 0);
-  database_details_table_ = gtk_table_new(3, 2, FALSE);
+  database_details_table_ = gtk_table_new(4, 2, FALSE);
   gtk_container_add(GTK_CONTAINER(database_details_frame),
                     database_details_table_);
   gtk_table_set_col_spacing(GTK_TABLE(database_details_table_), 0,
                             gtk_util::kLabelSpacing);
 
   row = 0;
+  InitDetailRow(row++, IDS_COOKIES_COOKIE_NAME_LABEL,
+                database_details_table_, &database_name_entry_);
   InitDetailRow(row++, IDS_COOKIES_WEB_DATABASE_DESCRIPTION_LABEL,
                 database_details_table_, &database_description_entry_);
   InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_SIZE_ON_DISK_LABEL,
                 database_details_table_, &database_size_entry_);
   InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_LAST_MODIFIED_LABEL,
                 database_details_table_,
                 &database_last_modified_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_);
 
+  // AppCache details.
+  GtkWidget* appcache_details_frame = gtk_frame_new(NULL);
+  gtk_frame_set_shadow_type(GTK_FRAME(appcache_details_frame),
+                            GTK_SHADOW_ETCHED_IN);
+  gtk_box_pack_start(GTK_BOX(cookie_list_vbox), appcache_details_frame,
+                     FALSE, FALSE, 0);
+  appcache_details_table_ = gtk_table_new(4, 2, FALSE);
+  gtk_container_add(GTK_CONTAINER(appcache_details_frame),
+                    appcache_details_table_);
+  gtk_table_set_col_spacing(GTK_TABLE(appcache_details_table_), 0,
+                            gtk_util::kLabelSpacing);
+  row = 0;
+  InitDetailRow(row++, IDS_COOKIES_APPLICATION_CACHE_MANIFEST_LABEL,
+                appcache_details_table_, &appcache_manifest_entry_);
+  InitDetailRow(row++, IDS_COOKIES_SIZE_LABEL,
+                appcache_details_table_, &appcache_size_entry_);
+  InitDetailRow(row++, IDS_COOKIES_COOKIE_CREATED_LABEL,
+                appcache_details_table_, &appcache_created_entry_);
+  InitDetailRow(row++, IDS_COOKIES_LAST_ACCESSED_LABEL,
+                appcache_details_table_, &appcache_last_accessed_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_);
 
   // 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);
 
   // Database details.
+  InitBrowserDetailStyle(database_name_entry_, label_style, dialog_style);
   InitBrowserDetailStyle(database_description_entry_, label_style,
                          dialog_style);
   InitBrowserDetailStyle(database_size_entry_, label_style, dialog_style);
   InitBrowserDetailStyle(database_last_modified_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);
 
+  // AppCache details.
+  InitBrowserDetailStyle(appcache_manifest_entry_, label_style, dialog_style);
+  InitBrowserDetailStyle(appcache_size_entry_, label_style, dialog_style);
+  InitBrowserDetailStyle(appcache_created_entry_, label_style, dialog_style);
+  InitBrowserDetailStyle(appcache_last_accessed_entry_, label_style,
+                         dialog_style);
+
   gtk_widget_show_all(dialog_);
 }
 
 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(details_table), name_label,
                    0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
@@ skipping 31 matching lines @@
       PopulateCookieDetails(detailed_info.cookie->first,
                             detailed_info.cookie->second);
     } else if (detailed_info.node_type ==
                CookieTreeNode::DetailedInfo::TYPE_DATABASE) {
       UpdateVisibleDetailedInfo(database_details_table_);
       PopulateDatabaseDetails(*detailed_info.database_info);
     } else if (detailed_info.node_type ==
                CookieTreeNode::DetailedInfo::TYPE_LOCAL_STORAGE) {
       UpdateVisibleDetailedInfo(local_storage_details_table_);
       PopulateLocalStorageDetails(*detailed_info.local_storage_info);
+    } else if (detailed_info.node_type ==
+               CookieTreeNode::DetailedInfo::TYPE_APPCACHE) {
+      UpdateVisibleDetailedInfo(appcache_details_table_);
+      PopulateAppCacheDetails(*detailed_info.appcache_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::SetDatabaseDetailsSensitivity(gboolean enabled) {
+  gtk_widget_set_sensitive(database_name_entry_, enabled);
   gtk_widget_set_sensitive(database_description_entry_, enabled);
   gtk_widget_set_sensitive(database_size_entry_, enabled);
   gtk_widget_set_sensitive(database_last_modified_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::SetAppCacheDetailsSensitivity(gboolean enabled) {
+  gtk_widget_set_sensitive(appcache_manifest_entry_, enabled);
+  gtk_widget_set_sensitive(appcache_size_entry_, enabled);
+  gtk_widget_set_sensitive(appcache_created_entry_, enabled);
+  gtk_widget_set_sensitive(appcache_last_accessed_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::PopulateDatabaseDetails(
     const BrowsingDataDatabaseHelper::DatabaseInfo& database_info) {
+  gtk_entry_set_text(
+      GTK_ENTRY(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(database_description_entry_),
                      database_info.description.c_str());
   gtk_entry_set_text(GTK_ENTRY(database_size_entry_),
                      WideToUTF8(FormatBytes(
                          database_info.size,
                          GetByteDisplayUnits(database_info.size),
                          true)).c_str());
   gtk_entry_set_text(GTK_ENTRY(database_last_modified_entry_),
                      WideToUTF8(base::TimeFormatFriendlyDateAndTime(
                          database_info.last_modified)).c_str());
   SetDatabaseDetailsSensitivity(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::PopulateAppCacheDetails(
+    const BrowsingDataAppCacheHelper::AppCacheInfo& info) {
+  gtk_entry_set_text(GTK_ENTRY(appcache_manifest_entry_),
+                     info.manifest_url.spec().c_str());
+  gtk_entry_set_text(GTK_ENTRY(appcache_size_entry_),
+                     WideToUTF8(FormatBytes(
+                         info.size,
+                         GetByteDisplayUnits(info.size),
+                         true)).c_str());
+  gtk_entry_set_text(GTK_ENTRY(appcache_created_entry_),
+                     WideToUTF8(base::TimeFormatFriendlyDateAndTime(
+                         info.creation_time)).c_str());
+  gtk_entry_set_text(GTK_ENTRY(appcache_last_accessed_entry_),
+                     WideToUTF8(base::TimeFormatFriendlyDateAndTime(
+                         info.last_access_time)).c_str());
+  SetAppCacheDetailsSensitivity(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 95 matching lines @@
   if (text) {
     cookies_tree_model_->UpdateSearchResults(UTF8ToWide(text));
     SetInitialTreeState();
   }
 }
 
 void CookiesView::UpdateVisibleDetailedInfo(GtkWidget* table) {
   SetCookieDetailsSensitivity(table == cookie_details_table_);
   SetDatabaseDetailsSensitivity(table == database_details_table_);
   SetLocalStorageDetailsSensitivity(table == local_storage_details_table_);
+  SetAppCacheDetailsSensitivity(table == appcache_details_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_)
     gtk_widget_hide(gtk_widget_get_parent(cookie_details_table_));
   if (table != database_details_table_)
     gtk_widget_hide(gtk_widget_get_parent(database_details_table_));
   if (table != local_storage_details_table_)
     gtk_widget_hide(gtk_widget_get_parent(local_storage_details_table_));
+  if (table != appcache_details_table_)
+    gtk_widget_hide(gtk_widget_get_parent(appcache_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();
 }