GTK: The cookie prompt should allow the user to set expire date for HTML cookies

BUG=42403
TEST=none

Review URL: http://codereview.chromium.org/1774005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@45818 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 175 insertions, 78 deletions

diff --git a/chrome/browser/cookie_modal_dialog.h b/chrome/browser/cookie_modal_dialog.h
index 8e1d5e4..b8891ea4 100644
--- a/chrome/browser/cookie_modal_dialog.h
+++ b/chrome/browser/cookie_modal_dialog.h
@@ -133,6 +133,9 @@ class CookiePromptModalDialog : public AppModalDialog {
 #if defined(OS_LINUX)
   // The "remember this choice" radio button in the dialog.
   GtkWidget* remember_radio_;
+
+  // The cookie view; we keep this to querry the result combobox.
+  GtkWidget* cookie_view_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(CookiePromptModalDialog);
diff --git a/chrome/browser/cookie_modal_dialog_gtk.cc b/chrome/browser/cookie_modal_dialog_gtk.cc
index 5fca166..fed41de 100644
--- a/chrome/browser/cookie_modal_dialog_gtk.cc
+++ b/chrome/browser/cookie_modal_dialog_gtk.cc
@@ -110,32 +110,33 @@ NativeDialog CookiePromptModalDialog::CreateNativeDialog() {
   g_signal_connect(expander, "notify::expanded",
                    G_CALLBACK(OnExpanderActivate), NULL);
 
-  GtkChromeCookieView* cookie_view = gtk_chrome_cookie_view_new();
-  gtk_chrome_cookie_view_clear(cookie_view);
+  cookie_view_ = gtk_chrome_cookie_view_new(TRUE);
+  gtk_chrome_cookie_view_clear(GTK_CHROME_COOKIE_VIEW(cookie_view_));
   if (type == CookiePromptModalDialog::DIALOG_TYPE_COOKIE) {
-    gtk_chrome_cookie_view_display_cookie_string(cookie_view,
-                                                 origin(), cookie_line());
+    gtk_chrome_cookie_view_display_cookie_string(
+        GTK_CHROME_COOKIE_VIEW(cookie_view_),
+        origin(), cookie_line());
   } else if (type == CookiePromptModalDialog::DIALOG_TYPE_LOCAL_STORAGE) {
     gtk_chrome_cookie_view_display_local_storage_item(
-        cookie_view,
+        GTK_CHROME_COOKIE_VIEW(cookie_view_),
         origin().host(),
         local_storage_key(),
         local_storage_value());
   } else if (type == CookiePromptModalDialog::DIALOG_TYPE_DATABASE) {
     gtk_chrome_cookie_view_display_database_accessed(
-        cookie_view,
+        GTK_CHROME_COOKIE_VIEW(cookie_view_),
         origin().host(),
         database_name(),
         display_name(),
         estimated_size());
   } else if (type == CookiePromptModalDialog::DIALOG_TYPE_APPCACHE) {
     gtk_chrome_cookie_view_display_appcache_created(
-        cookie_view,
+        GTK_CHROME_COOKIE_VIEW(cookie_view_),
         appcache_manifest_url());
   } else {
     NOTIMPLEMENTED();
   }
-  gtk_container_add(GTK_CONTAINER(expander), GTK_WIDGET(cookie_view));
+  gtk_container_add(GTK_CONTAINER(expander), cookie_view_);
 
   gtk_box_pack_end(GTK_BOX(content_area), GTK_WIDGET(expander),
                    FALSE, FALSE, 0);
@@ -155,8 +156,9 @@ void CookiePromptModalDialog::HandleDialogResponse(GtkDialog* dialog,
   if (response_id == GTK_RESPONSE_REJECT) {
     BlockSiteData(remember_radio);
   } else if (response_id == GTK_RESPONSE_ACCEPT) {
-    // TODO(erg): Needs to use |session_expire_| instead of true.
-    AllowSiteData(remember_radio, true);
+    bool expires = gtk_chrome_cookie_view_session_expires(
+        GTK_CHROME_COOKIE_VIEW(cookie_view_));
+    AllowSiteData(remember_radio, expires);
   } else {
     BlockSiteData(false);
   }
diff --git a/chrome/browser/gtk/gtk_chrome_cookie_view.cc b/chrome/browser/gtk/gtk_chrome_cookie_view.cc
index 57f7737..359cdca 100644
--- a/chrome/browser/gtk/gtk_chrome_cookie_view.cc
+++ b/chrome/browser/gtk/gtk_chrome_cookie_view.cc
@@ -28,16 +28,21 @@ void InitBrowserDetailStyle(GtkWidget* entry, GtkStyle* label_style,
                          &dialog_style->bg[GTK_STATE_NORMAL]);
 }
 
-GtkWidget* InitDetailRow(int row, int label_id,
-                         GtkWidget* details_table, GtkWidget** entry) {
+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);
 
-  *entry = gtk_entry_new();
+  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_entry_set_editable(GTK_ENTRY(*entry), FALSE);
   gtk_entry_set_has_frame(GTK_ENTRY(*entry), FALSE);
   gtk_table_attach_defaults(GTK_TABLE(details_table), *entry,
@@ -46,6 +51,30 @@ GtkWidget* InitDetailRow(int row, int label_id,
   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));
@@ -60,8 +89,10 @@ void InitStyles(GtkChromeCookieView *self) {
                          dialog_style);
   InitBrowserDetailStyle(self->cookie_created_entry_, label_style,
                          dialog_style);
-  InitBrowserDetailStyle(self->cookie_expires_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);
@@ -119,7 +150,10 @@ void SetCookieDetailsSensitivity(GtkChromeCookieView *self,
   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);
-  gtk_widget_set_sensitive(self->cookie_expires_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,
@@ -178,8 +212,20 @@ void ClearCookieDetails(GtkChromeCookieView *self) {
                      no_cookie.c_str());
   gtk_entry_set_text(GTK_ENTRY(self->cookie_created_entry_),
                      no_cookie.c_str());
-  gtk_entry_set_text(GTK_ENTRY(self->cookie_expires_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);
@@ -226,6 +272,9 @@ 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);
 
@@ -249,8 +298,15 @@ static void gtk_chrome_cookie_view_init(GtkChromeCookieView *self) {
                 self->cookie_details_table_, &self->cookie_send_for_entry_);
   InitDetailRow(row++, IDS_COOKIES_COOKIE_CREATED_LABEL,
                 self->cookie_details_table_, &self->cookie_created_entry_);
-  InitDetailRow(row++, IDS_COOKIES_COOKIE_EXPIRES_LABEL,
-                self->cookie_details_table_, &self->cookie_expires_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);
@@ -361,11 +417,12 @@ static void gtk_chrome_cookie_view_init(GtkChromeCookieView *self) {
   gtk_container_add(GTK_CONTAINER(self), self->table_box_);
 }
 
-GtkChromeCookieView* gtk_chrome_cookie_view_new() {
+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 view;
+  return GTK_WIDGET(view);
 }
 
 void gtk_chrome_cookie_view_clear(GtkChromeCookieView* self) {
@@ -391,15 +448,34 @@ void gtk_chrome_cookie_view_display_cookie(
   gtk_entry_set_text(GTK_ENTRY(self->cookie_created_entry_),
                      WideToUTF8(base::TimeFormatFriendlyDateAndTime(
                          cookie.CreationDate())).c_str());
-  if (cookie.DoesExpire()) {
+
+  std::string expire_text = cookie.DoesExpire() ?
+      WideToUTF8(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_),
-                       WideToUTF8(base::TimeFormatFriendlyDateAndTime(
-                           cookie.ExpiryDate())).c_str());
+                       expire_text.c_str());
   } else {
-    gtk_entry_set_text(GTK_ENTRY(self->cookie_expires_entry_),
-                       l10n_util::GetStringUTF8(
-                           IDS_COOKIES_COOKIE_EXPIRES_SESSION).c_str());
+    GtkListStore* store = self->cookie_expires_combobox_store_;
+    GtkTreeIter iter;
+    gtk_list_store_clear(store);
+
+    if (cookie.DoesExpire()) {
+      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() ?
@@ -534,3 +610,19 @@ void gtk_chrome_cookie_view_display_appcache_created(
                      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;
+}
diff --git a/chrome/browser/gtk/gtk_chrome_cookie_view.h b/chrome/browser/gtk/gtk_chrome_cookie_view.h
index e729b04..aa663a9 100644
--- a/chrome/browser/gtk/gtk_chrome_cookie_view.h
+++ b/chrome/browser/gtk/gtk_chrome_cookie_view.h
@@ -63,7 +63,14 @@ typedef struct {
   GtkWidget* cookie_path_entry_;
   GtkWidget* cookie_send_for_entry_;
   GtkWidget* cookie_created_entry_;
+
+  // Note: These two widgets are mutually exclusive based on what
+  // |editable_expiration| was when the cookie view was created. One of these
+  // variables will be NULL.
   GtkWidget* cookie_expires_entry_;
+  GtkWidget* cookie_expires_combobox_;
+
+  GtkListStore* cookie_expires_combobox_store_;
 
   // The database details widgets.
   GtkWidget* database_details_table_;
@@ -110,7 +117,7 @@ typedef struct {
 GType gtk_chrome_cookie_view_get_type();
 
 // Builds a new cookie view.
-GtkChromeCookieView* gtk_chrome_cookie_view_new();
+GtkWidget* gtk_chrome_cookie_view_new(gboolean editable_expiration);
 
 // Clears the cookie view.
 void gtk_chrome_cookie_view_clear(GtkChromeCookieView* widget);
@@ -167,4 +174,8 @@ void gtk_chrome_cookie_view_display_appcache_created(
     GtkChromeCookieView* self,
     const GURL& manifest_url);
 
+// If |editable_expiration| was true at construction time, returns the value of
+// the combo box. Otherwise, returns false.
+bool gtk_chrome_cookie_view_session_expires(GtkChromeCookieView* self);
+
 #endif  // CHROME_BROWSER_GTK_GTK_CHROME_COOKIE_VIEW_H_
diff --git a/chrome/browser/gtk/options/cookies_view.cc b/chrome/browser/gtk/options/cookies_view.cc
index 3434b6b..1d67b5a 100644
--- a/chrome/browser/gtk/options/cookies_view.cc
+++ b/chrome/browser/gtk/options/cookies_view.cc
@@ -79,7 +79,7 @@ CookiesView::CookiesView(
       destroy_dialog_in_destructor_(false) {
   Init(parent);
   gtk_widget_show_all(dialog_);
-  gtk_chrome_cookie_view_clear(cookie_display_);
+  gtk_chrome_cookie_view_clear(GTK_CHROME_COOKIE_VIEW(cookie_display_));
 }
 
 void CookiesView::TestDestroySyncrhonously() {
@@ -210,9 +210,9 @@ void CookiesView::Init(GtkWindow* parent) {
   g_signal_connect(selection_, "changed",
                    G_CALLBACK(OnTreeViewSelectionChangeThunk), this);
 
-  cookie_display_ = gtk_chrome_cookie_view_new();
+  cookie_display_ = gtk_chrome_cookie_view_new(FALSE);
   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_)->vbox),
-                     GTK_WIDGET(cookie_display_), FALSE, FALSE, 0);
+                     cookie_display_, FALSE, FALSE, 0);
 
   // Populate the view.
   cookies_tree_adapter_->Init();
@@ -241,27 +241,30 @@ void CookiesView::EnableControls() {
         static_cast<CookieTreeNode*>(
             cookies_tree_adapter_->GetNode(&iter))->GetDetailedInfo();
     if (detailed_info.node_type == CookieTreeNode::DetailedInfo::TYPE_COOKIE) {
-      gtk_chrome_cookie_view_display_cookie(cookie_display_,
-                                            detailed_info.cookie->first,
-                                            detailed_info.cookie->second);
+      gtk_chrome_cookie_view_display_cookie(
+          GTK_CHROME_COOKIE_VIEW(cookie_display_),
+          detailed_info.cookie->first,
+          detailed_info.cookie->second);
     } else if (detailed_info.node_type ==
                CookieTreeNode::DetailedInfo::TYPE_DATABASE) {
-      gtk_chrome_cookie_view_display_database(cookie_display_,
-                                              *detailed_info.database_info);
+      gtk_chrome_cookie_view_display_database(
+          GTK_CHROME_COOKIE_VIEW(cookie_display_),
+          *detailed_info.database_info);
     } else if (detailed_info.node_type ==
                CookieTreeNode::DetailedInfo::TYPE_LOCAL_STORAGE) {
       gtk_chrome_cookie_view_display_local_storage(
-          cookie_display_,
+          GTK_CHROME_COOKIE_VIEW(cookie_display_),
           *detailed_info.local_storage_info);
     } else if (detailed_info.node_type ==
                CookieTreeNode::DetailedInfo::TYPE_APPCACHE) {
-      gtk_chrome_cookie_view_display_app_cache(cookie_display_,
-                                               *detailed_info.appcache_info);
+      gtk_chrome_cookie_view_display_app_cache(
+          GTK_CHROME_COOKIE_VIEW(cookie_display_),
+          *detailed_info.appcache_info);
     } else {
-      gtk_chrome_cookie_view_clear(cookie_display_);
+      gtk_chrome_cookie_view_clear(GTK_CHROME_COOKIE_VIEW(cookie_display_));
     }
   } else {
-    gtk_chrome_cookie_view_clear(cookie_display_);
+    gtk_chrome_cookie_view_clear(GTK_CHROME_COOKIE_VIEW(cookie_display_));
   }
 }
 
diff --git a/chrome/browser/gtk/options/cookies_view.h b/chrome/browser/gtk/options/cookies_view.h
index 84465c4..3249306 100644
--- a/chrome/browser/gtk/options/cookies_view.h
+++ b/chrome/browser/gtk/options/cookies_view.h
@@ -103,7 +103,7 @@ class CookiesView : public gtk_tree::TreeAdapter::Delegate {
   GtkWidget* tree_;
   GtkTreeSelection* selection_;
 
-  GtkChromeCookieView* cookie_display_;
+  GtkWidget* cookie_display_;
 
   // The profile and related helpers.
   Profile* profile_;
diff --git a/chrome/browser/gtk/options/cookies_view_unittest.cc b/chrome/browser/gtk/options/cookies_view_unittest.cc
index 9857092..0aeef90 100644
--- a/chrome/browser/gtk/options/cookies_view_unittest.cc
+++ b/chrome/browser/gtk/options/cookies_view_unittest.cc
@@ -43,61 +43,47 @@ class CookiesViewTest : public testing::Test {
                                gboolean expected_local_storage,
                                gboolean expected_appcache,
                                const CookiesView& cookies_view) {
+    GtkChromeCookieView* display = GTK_CHROME_COOKIE_VIEW(
+        cookies_view.cookie_display_);
+
     // Cookies
     EXPECT_EQ(expected_cookies,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   cookie_name_entry_));
+              GTK_WIDGET_SENSITIVE(display->cookie_name_entry_));
     EXPECT_EQ(expected_cookies,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   cookie_content_entry_));
+              GTK_WIDGET_SENSITIVE(display->cookie_content_entry_));
     EXPECT_EQ(expected_cookies,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   cookie_domain_entry_));
+              GTK_WIDGET_SENSITIVE(display->cookie_domain_entry_));
     EXPECT_EQ(expected_cookies,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   cookie_path_entry_));
+              GTK_WIDGET_SENSITIVE(display->cookie_path_entry_));
     EXPECT_EQ(expected_cookies,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   cookie_send_for_entry_));
+              GTK_WIDGET_SENSITIVE(display->cookie_send_for_entry_));
     EXPECT_EQ(expected_cookies,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   cookie_created_entry_));
+              GTK_WIDGET_SENSITIVE(display->cookie_created_entry_));
     EXPECT_EQ(expected_cookies,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   cookie_expires_entry_));
+              GTK_WIDGET_SENSITIVE(display->cookie_expires_entry_));
     // Database
     EXPECT_EQ(expected_database,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   database_description_entry_));
+              GTK_WIDGET_SENSITIVE(display->database_description_entry_));
     EXPECT_EQ(expected_database,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   database_size_entry_));
+              GTK_WIDGET_SENSITIVE(display->database_size_entry_));
     EXPECT_EQ(expected_database,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   database_last_modified_entry_));
+              GTK_WIDGET_SENSITIVE(display->database_last_modified_entry_));
     // Local Storage
     EXPECT_EQ(expected_local_storage,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   local_storage_origin_entry_));
-    EXPECT_EQ(expected_local_storage,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   local_storage_size_entry_));
+              GTK_WIDGET_SENSITIVE(display->local_storage_origin_entry_));
     EXPECT_EQ(expected_local_storage,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   local_storage_last_modified_entry_));
+              GTK_WIDGET_SENSITIVE(display->local_storage_size_entry_));
+    EXPECT_EQ(expected_local_storage, GTK_WIDGET_SENSITIVE(
+        display->local_storage_last_modified_entry_));
     // AppCache
     EXPECT_EQ(expected_appcache,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   appcache_manifest_entry_));
+              GTK_WIDGET_SENSITIVE(display->appcache_manifest_entry_));
     EXPECT_EQ(expected_appcache,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   appcache_size_entry_));
+              GTK_WIDGET_SENSITIVE(display->appcache_size_entry_));
     EXPECT_EQ(expected_appcache,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   appcache_created_entry_));
+              GTK_WIDGET_SENSITIVE(display->appcache_created_entry_));
     EXPECT_EQ(expected_appcache,
-              GTK_WIDGET_SENSITIVE(cookies_view.cookie_display_->
-                                   appcache_last_accessed_entry_));
+              GTK_WIDGET_SENSITIVE(display->appcache_last_accessed_entry_));
   }
 
   // Get the cookie names in the cookie list, as a comma seperated string.