1// Copyright (c) 2011 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/ui/gtk/gtk_chrome_cookie_view.h"
6
7#include "base/i18n/time_formatting.h"
8#include "base/utf_string_conversions.h"
9#include "chrome/browser/ui/gtk/gtk_util.h"
10#include "grit/generated_resources.h"
11#include "ui/base/l10n/l10n_util.h"
12
13namespace {
14
15void InitBrowserDetailStyle(GtkWidget* entry, GtkStyle* label_style,
16                            GtkStyle* dialog_style) {
17  gtk_widget_modify_fg(entry, GTK_STATE_NORMAL,
18                       &label_style->fg[GTK_STATE_NORMAL]);
19  gtk_widget_modify_fg(entry, GTK_STATE_INSENSITIVE,
20                       &label_style->fg[GTK_STATE_INSENSITIVE]);
21  // GTK_NO_WINDOW widgets like GtkLabel don't draw their own background, so we
22  // combine the normal or insensitive foreground of the label style with the
23  // normal background of the window style to achieve the "normal label" and
24  // "insensitive label" colors.
25  gtk_widget_modify_base(entry, GTK_STATE_NORMAL,
26                         &dialog_style->bg[GTK_STATE_NORMAL]);
27  gtk_widget_modify_base(entry, GTK_STATE_INSENSITIVE,
28                         &dialog_style->bg[GTK_STATE_NORMAL]);
29}
30
31GtkWidget* InitRowLabel(int row, int label_id, GtkWidget* details_table) {
32  GtkWidget* name_label = gtk_label_new(
33      l10n_util::GetStringUTF8(label_id).c_str());
34  gtk_misc_set_alignment(GTK_MISC(name_label), 1, 0.5);
35  gtk_table_attach(GTK_TABLE(details_table), name_label,
36                   0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
37
38  return name_label;
39}
40
41GtkWidget* InitDetailRow(int row, int label_id,
42                         GtkWidget* details_table, GtkWidget** entry) {
43  GtkWidget* name_label = InitRowLabel(row, label_id, details_table);
44
45  *entry = gtk_entry_new();
46  gtk_entry_set_editable(GTK_ENTRY(*entry), FALSE);
47  gtk_entry_set_has_frame(GTK_ENTRY(*entry), FALSE);
48  gtk_table_attach_defaults(GTK_TABLE(details_table), *entry,
49                            1, 2, row, row + 1);
50
51  return name_label;
52}
53
54GtkWidget* InitComboboxRow(int row, int label_id,
55                           GtkWidget* details_table,
56                           GtkWidget** combobox,
57                           GtkListStore** store) {
58  GtkWidget* name_label = InitRowLabel(row, label_id, details_table);
59
60  *store = gtk_list_store_new(1, G_TYPE_STRING);
61  *combobox = gtk_combo_box_new_with_model(GTK_TREE_MODEL(*store));
62  g_object_unref(*store);
63
64  GtkCellRenderer* cell = gtk_cell_renderer_text_new();
65  gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(*combobox), cell, TRUE);
66  gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(*combobox), cell,
67                                  "text", 0, NULL);
68
69  GtkWidget* hbox = gtk_hbox_new(FALSE, 0);
70  gtk_box_pack_start(GTK_BOX(hbox), *combobox, FALSE, FALSE, 0);
71
72  gtk_table_attach_defaults(GTK_TABLE(details_table), hbox,
73                            1, 2, row, row + 1);
74
75  return name_label;
76}
77
78void InitStyles(GtkChromeCookieView *self) {
79  GtkStyle* label_style = gtk_widget_get_style(self->first_label_);
80  GtkStyle* dialog_style = gtk_widget_get_style(GTK_WIDGET(self));
81
82  // Cookie details.
83  InitBrowserDetailStyle(self->cookie_name_entry_, label_style, dialog_style);
84  InitBrowserDetailStyle(self->cookie_content_entry_, label_style,
85                         dialog_style);
86  InitBrowserDetailStyle(self->cookie_domain_entry_, label_style, dialog_style);
87  InitBrowserDetailStyle(self->cookie_path_entry_, label_style, dialog_style);
88  InitBrowserDetailStyle(self->cookie_send_for_entry_, label_style,
89                         dialog_style);
90  InitBrowserDetailStyle(self->cookie_created_entry_, label_style,
91                         dialog_style);
92  if (self->cookie_expires_entry_) {
93    InitBrowserDetailStyle(self->cookie_expires_entry_, label_style,
94                           dialog_style);
95  }
96
97  // Database details.
98  InitBrowserDetailStyle(self->database_name_entry_, label_style, dialog_style);
99  InitBrowserDetailStyle(self->database_description_entry_, label_style,
100                         dialog_style);
101  InitBrowserDetailStyle(self->database_size_entry_, label_style, dialog_style);
102  InitBrowserDetailStyle(self->database_last_modified_entry_, label_style,
103                         dialog_style);
104
105  // Local storage details.
106  InitBrowserDetailStyle(self->local_storage_origin_entry_, label_style,
107                         dialog_style);
108  InitBrowserDetailStyle(self->local_storage_size_entry_, label_style,
109                         dialog_style);
110  InitBrowserDetailStyle(self->local_storage_last_modified_entry_, label_style,
111                         dialog_style);
112
113  // AppCache details.
114  InitBrowserDetailStyle(self->appcache_manifest_entry_, label_style,
115                         dialog_style);
116  InitBrowserDetailStyle(self->appcache_size_entry_, label_style, dialog_style);
117  InitBrowserDetailStyle(self->appcache_created_entry_, label_style,
118                         dialog_style);
119  InitBrowserDetailStyle(self->appcache_last_accessed_entry_, label_style,
120                         dialog_style);
121
122  // Local storage item.
123  InitBrowserDetailStyle(self->local_storage_item_origin_entry_, label_style,
124                         dialog_style);
125  InitBrowserDetailStyle(self->local_storage_item_key_entry_, label_style,
126                         dialog_style);
127  InitBrowserDetailStyle(self->local_storage_item_value_entry_, label_style,
128                         dialog_style);
129
130  // Database accessed item.
131  InitBrowserDetailStyle(self->database_accessed_origin_entry_, label_style,
132                         dialog_style);
133  InitBrowserDetailStyle(self->database_accessed_name_entry_, label_style,
134                         dialog_style);
135  InitBrowserDetailStyle(self->database_accessed_description_entry_,
136                         label_style, dialog_style);
137  InitBrowserDetailStyle(self->database_accessed_size_entry_, label_style,
138                         dialog_style);
139
140  // AppCache created item.
141  InitBrowserDetailStyle(self->appcache_created_manifest_entry_, label_style,
142                         dialog_style);
143}
144
145void SetCookieDetailsSensitivity(GtkChromeCookieView *self,
146                                 gboolean enabled) {
147  gtk_widget_set_sensitive(self->cookie_name_entry_, enabled);
148  gtk_widget_set_sensitive(self->cookie_content_entry_, enabled);
149  gtk_widget_set_sensitive(self->cookie_domain_entry_, enabled);
150  gtk_widget_set_sensitive(self->cookie_path_entry_, enabled);
151  gtk_widget_set_sensitive(self->cookie_send_for_entry_, enabled);
152  gtk_widget_set_sensitive(self->cookie_created_entry_, enabled);
153  if (self->cookie_expires_entry_)
154    gtk_widget_set_sensitive(self->cookie_expires_entry_, enabled);
155  else
156    gtk_widget_set_sensitive(self->cookie_expires_combobox_, enabled);
157}
158
159void SetDatabaseDetailsSensitivity(GtkChromeCookieView *self,
160                                   gboolean enabled) {
161  gtk_widget_set_sensitive(self->database_name_entry_, enabled);
162  gtk_widget_set_sensitive(self->database_description_entry_, enabled);
163  gtk_widget_set_sensitive(self->database_size_entry_, enabled);
164  gtk_widget_set_sensitive(self->database_last_modified_entry_, enabled);
165}
166
167void SetLocalStorageDetailsSensitivity(GtkChromeCookieView *self,
168                                       gboolean enabled) {
169  gtk_widget_set_sensitive(self->local_storage_origin_entry_, enabled);
170  gtk_widget_set_sensitive(self->local_storage_size_entry_, enabled);
171  gtk_widget_set_sensitive(self->local_storage_last_modified_entry_, enabled);
172}
173
174void SetAppCacheDetailsSensitivity(GtkChromeCookieView *self,
175                                   gboolean enabled) {
176  gtk_widget_set_sensitive(self->appcache_manifest_entry_, enabled);
177  gtk_widget_set_sensitive(self->appcache_size_entry_, enabled);
178  gtk_widget_set_sensitive(self->appcache_created_entry_, enabled);
179  gtk_widget_set_sensitive(self->appcache_last_accessed_entry_, enabled);
180}
181
182void SetIndexedDBDetailsSensitivity(GtkChromeCookieView *self,
183                                    gboolean enabled) {
184  gtk_widget_set_sensitive(self->indexed_db_origin_entry_, enabled);
185  gtk_widget_set_sensitive(self->indexed_db_size_entry_, enabled);
186  gtk_widget_set_sensitive(self->indexed_db_last_modified_entry_, enabled);
187}
188
189void SetLocalStorageItemSensitivity(GtkChromeCookieView* self,
190                                    gboolean enabled) {
191  gtk_widget_set_sensitive(self->local_storage_item_origin_entry_, enabled);
192  gtk_widget_set_sensitive(self->local_storage_item_key_entry_, enabled);
193  gtk_widget_set_sensitive(self->local_storage_item_value_entry_, enabled);
194}
195
196void SetDatabaseAccessedSensitivity(GtkChromeCookieView* self,
197                                    gboolean enabled) {
198  gtk_widget_set_sensitive(self->database_accessed_origin_entry_, enabled);
199  gtk_widget_set_sensitive(self->database_accessed_name_entry_, enabled);
200  gtk_widget_set_sensitive(self->database_accessed_description_entry_, enabled);
201  gtk_widget_set_sensitive(self->database_accessed_size_entry_, enabled);
202}
203
204void SetAppCacheCreatedSensitivity(GtkChromeCookieView* self,
205                                   gboolean enabled) {
206  gtk_widget_set_sensitive(self->appcache_created_manifest_entry_, enabled);
207}
208
209void ClearCookieDetails(GtkChromeCookieView *self) {
210  std::string no_cookie =
211      l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_NONESELECTED);
212  gtk_entry_set_text(GTK_ENTRY(self->cookie_name_entry_),
213                     no_cookie.c_str());
214  gtk_entry_set_text(GTK_ENTRY(self->cookie_content_entry_),
215                     no_cookie.c_str());
216  gtk_entry_set_text(GTK_ENTRY(self->cookie_domain_entry_),
217                     no_cookie.c_str());
218  gtk_entry_set_text(GTK_ENTRY(self->cookie_path_entry_),
219                     no_cookie.c_str());
220  gtk_entry_set_text(GTK_ENTRY(self->cookie_created_entry_),
221                     no_cookie.c_str());
222  if (self->cookie_expires_entry_) {
223    gtk_entry_set_text(GTK_ENTRY(self->cookie_expires_entry_),
224                       no_cookie.c_str());
225  } else {
226    GtkListStore* store = self->cookie_expires_combobox_store_;
227    GtkTreeIter iter;
228    gtk_list_store_clear(store);
229
230    gtk_list_store_append(store, &iter);
231    gtk_list_store_set(store, &iter, 0, no_cookie.c_str(), -1);
232
233    gtk_combo_box_set_active(GTK_COMBO_BOX(self->cookie_expires_combobox_),
234                             0);
235  }
236  gtk_entry_set_text(GTK_ENTRY(self->cookie_send_for_entry_),
237                     no_cookie.c_str());
238  SetCookieDetailsSensitivity(self, FALSE);
239}
240
241void UpdateVisibleDetailedInfo(GtkChromeCookieView *self, GtkWidget* table) {
242  SetCookieDetailsSensitivity(self, table == self->cookie_details_table_);
243  SetDatabaseDetailsSensitivity(self, table == self->database_details_table_);
244  SetLocalStorageDetailsSensitivity(self,
245      table == self->local_storage_details_table_);
246  SetAppCacheDetailsSensitivity(self, table == self->appcache_details_table_);
247  SetIndexedDBDetailsSensitivity(self,
248      table == self->indexed_db_details_table_);
249  SetLocalStorageItemSensitivity(self,
250      table == self->local_storage_item_table_);
251  SetDatabaseAccessedSensitivity(self,
252      table == self->database_accessed_table_);
253  SetAppCacheCreatedSensitivity(self,
254      table == self->appcache_created_table_);
255
256  // Display everything
257  gtk_widget_show(self->table_box_);
258  gtk_widget_show_all(table);
259  // Hide everything that isn't us.
260  if (table != self->cookie_details_table_)
261    gtk_widget_hide(self->cookie_details_table_);
262  if (table != self->database_details_table_)
263    gtk_widget_hide(self->database_details_table_);
264  if (table != self->local_storage_details_table_)
265    gtk_widget_hide(self->local_storage_details_table_);
266  if (table != self->appcache_details_table_)
267    gtk_widget_hide(self->appcache_details_table_);
268  if (table != self->indexed_db_details_table_)
269    gtk_widget_hide(self->indexed_db_details_table_);
270  if (table != self->local_storage_item_table_)
271    gtk_widget_hide(self->local_storage_item_table_);
272  if (table != self->database_accessed_table_)
273    gtk_widget_hide(self->database_accessed_table_);
274  if (table != self->appcache_created_table_)
275    gtk_widget_hide(self->appcache_created_table_);
276}
277
278}  // namespace
279
280G_DEFINE_TYPE(GtkChromeCookieView, gtk_chrome_cookie_view, GTK_TYPE_FRAME)
281
282static void gtk_chrome_cookie_view_class_init(GtkChromeCookieViewClass *klass) {
283}
284
285static void gtk_chrome_cookie_view_init(GtkChromeCookieView *self) {
286}
287
288void BuildWidgets(GtkChromeCookieView *self, gboolean editable_expiration) {
289  self->table_box_ = gtk_vbox_new(FALSE, 0);
290  gtk_widget_set_no_show_all(self->table_box_, TRUE);
291
292  // Cookie details.
293  self->cookie_details_table_ = gtk_table_new(7, 2, FALSE);
294  gtk_container_add(GTK_CONTAINER(self->table_box_),
295                    self->cookie_details_table_);
296  gtk_table_set_col_spacing(GTK_TABLE(self->cookie_details_table_), 0,
297                            gtk_util::kLabelSpacing);
298
299  int row = 0;
300  self->first_label_ = InitDetailRow(row++, IDS_COOKIES_COOKIE_NAME_LABEL,
301                self->cookie_details_table_, &self->cookie_name_entry_);
302  InitDetailRow(row++, IDS_COOKIES_COOKIE_CONTENT_LABEL,
303                self->cookie_details_table_, &self->cookie_content_entry_);
304  InitDetailRow(row++, IDS_COOKIES_COOKIE_DOMAIN_LABEL,
305                self->cookie_details_table_, &self->cookie_domain_entry_);
306  InitDetailRow(row++, IDS_COOKIES_COOKIE_PATH_LABEL,
307                self->cookie_details_table_, &self->cookie_path_entry_);
308  InitDetailRow(row++, IDS_COOKIES_COOKIE_SENDFOR_LABEL,
309                self->cookie_details_table_, &self->cookie_send_for_entry_);
310  InitDetailRow(row++, IDS_COOKIES_COOKIE_CREATED_LABEL,
311                self->cookie_details_table_, &self->cookie_created_entry_);
312  if (editable_expiration) {
313    InitComboboxRow(row++, IDS_COOKIES_COOKIE_EXPIRES_LABEL,
314                    self->cookie_details_table_,
315                    &self->cookie_expires_combobox_,
316                    &self->cookie_expires_combobox_store_);
317  } else {
318    InitDetailRow(row++, IDS_COOKIES_COOKIE_EXPIRES_LABEL,
319                  self->cookie_details_table_, &self->cookie_expires_entry_);
320  }
321
322  // Database details.
323  self->database_details_table_ = gtk_table_new(4, 2, FALSE);
324  gtk_container_add(GTK_CONTAINER(self->table_box_),
325                    self->database_details_table_);
326  gtk_table_set_col_spacing(GTK_TABLE(self->database_details_table_), 0,
327                            gtk_util::kLabelSpacing);
328
329  InitDetailRow(row++, IDS_COOKIES_COOKIE_NAME_LABEL,
330                self->database_details_table_, &self->database_name_entry_);
331  InitDetailRow(row++, IDS_COOKIES_WEB_DATABASE_DESCRIPTION_LABEL,
332                self->database_details_table_,
333                &self->database_description_entry_);
334  InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_SIZE_ON_DISK_LABEL,
335                self->database_details_table_, &self->database_size_entry_);
336  InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_LAST_MODIFIED_LABEL,
337                self->database_details_table_,
338                &self->database_last_modified_entry_);
339
340  // Local storage details.
341  self->local_storage_details_table_ = gtk_table_new(3, 2, FALSE);
342  gtk_container_add(GTK_CONTAINER(self->table_box_),
343                    self->local_storage_details_table_);
344  gtk_table_set_col_spacing(GTK_TABLE(self->local_storage_details_table_), 0,
345                            gtk_util::kLabelSpacing);
346
347  row = 0;
348  InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_ORIGIN_LABEL,
349                self->local_storage_details_table_,
350                &self->local_storage_origin_entry_);
351  InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_SIZE_ON_DISK_LABEL,
352                self->local_storage_details_table_,
353                &self->local_storage_size_entry_);
354  InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_LAST_MODIFIED_LABEL,
355                self->local_storage_details_table_,
356                &self->local_storage_last_modified_entry_);
357
358  // AppCache details.
359  self->appcache_details_table_ = gtk_table_new(4, 2, FALSE);
360  gtk_container_add(GTK_CONTAINER(self->table_box_),
361                    self->appcache_details_table_);
362  gtk_table_set_col_spacing(GTK_TABLE(self->appcache_details_table_), 0,
363                            gtk_util::kLabelSpacing);
364
365  row = 0;
366  InitDetailRow(row++, IDS_COOKIES_APPLICATION_CACHE_MANIFEST_LABEL,
367                self->appcache_details_table_,
368                &self->appcache_manifest_entry_);
369  InitDetailRow(row++, IDS_COOKIES_SIZE_LABEL,
370                self->appcache_details_table_, &self->appcache_size_entry_);
371  InitDetailRow(row++, IDS_COOKIES_COOKIE_CREATED_LABEL,
372                self->appcache_details_table_, &self->appcache_created_entry_);
373  InitDetailRow(row++, IDS_COOKIES_LAST_ACCESSED_LABEL,
374                self->appcache_details_table_,
375                &self->appcache_last_accessed_entry_);
376
377  // IndexedDB details.
378  self->indexed_db_details_table_ = gtk_table_new(4, 2, FALSE);
379  gtk_container_add(GTK_CONTAINER(self->table_box_),
380                    self->indexed_db_details_table_);
381  gtk_table_set_col_spacing(GTK_TABLE(self->indexed_db_details_table_), 0,
382                            gtk_util::kLabelSpacing);
383
384  row = 0;
385  InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_ORIGIN_LABEL,
386                self->indexed_db_details_table_,
387                &self->indexed_db_origin_entry_);
388  InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_SIZE_ON_DISK_LABEL,
389                self->indexed_db_details_table_, &self->indexed_db_size_entry_);
390  InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_LAST_MODIFIED_LABEL,
391                self->indexed_db_details_table_,
392                &self->indexed_db_last_modified_entry_);
393
394  // Local storage item.
395  self->local_storage_item_table_ = gtk_table_new(3, 2, FALSE);
396  gtk_container_add(GTK_CONTAINER(self->table_box_),
397                    self->local_storage_item_table_);
398  gtk_table_set_col_spacing(GTK_TABLE(self->local_storage_item_table_), 0,
399                            gtk_util::kLabelSpacing);
400
401  row = 0;
402  InitDetailRow(row++, IDS_COOKIES_COOKIE_DOMAIN_LABEL,
403                self->local_storage_item_table_,
404                &self->local_storage_item_origin_entry_);
405  InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_KEY_LABEL,
406                self->local_storage_item_table_,
407                &self->local_storage_item_key_entry_);
408  InitDetailRow(row++, IDS_COOKIES_LOCAL_STORAGE_VALUE_LABEL,
409                self->local_storage_item_table_,
410                &self->local_storage_item_value_entry_);
411
412  // Database accessed prompt.
413  self->database_accessed_table_ = gtk_table_new(2, 2, FALSE);
414  gtk_container_add(GTK_CONTAINER(self->table_box_),
415                    self->database_accessed_table_);
416  gtk_table_set_col_spacing(GTK_TABLE(self->local_storage_item_table_), 0,
417                            gtk_util::kLabelSpacing);
418
419  row = 0;
420  InitDetailRow(row++, IDS_COOKIES_COOKIE_DOMAIN_LABEL,
421                self->database_accessed_table_,
422                &self->database_accessed_origin_entry_);
423  InitDetailRow(row++, IDS_COOKIES_WEB_DATABASE_NAME,
424                self->database_accessed_table_,
425                &self->database_accessed_name_entry_);
426  InitDetailRow(row++, IDS_COOKIES_WEB_DATABASE_DESCRIPTION_LABEL,
427                self->database_accessed_table_,
428                &self->database_accessed_description_entry_);
429  InitDetailRow(row++, IDS_COOKIES_SIZE_LABEL,
430                self->database_accessed_table_,
431                &self->database_accessed_size_entry_);
432
433  // AppCache created prompt.
434  self->appcache_created_table_ = gtk_table_new(1, 2, FALSE);
435  gtk_container_add(GTK_CONTAINER(self->table_box_),
436                    self->appcache_created_table_);
437  gtk_table_set_col_spacing(GTK_TABLE(self->appcache_created_table_), 0,
438                            gtk_util::kLabelSpacing);
439  row = 0;
440  InitDetailRow(row++, IDS_COOKIES_APPLICATION_CACHE_MANIFEST_LABEL,
441                self->appcache_created_table_,
442                &self->appcache_created_manifest_entry_);
443
444  gtk_frame_set_shadow_type(GTK_FRAME(self), GTK_SHADOW_ETCHED_IN);
445  gtk_container_add(GTK_CONTAINER(self), self->table_box_);
446}
447
448GtkWidget* gtk_chrome_cookie_view_new(gboolean editable_expiration) {
449  GtkChromeCookieView* view = GTK_CHROME_COOKIE_VIEW(
450      g_object_new(GTK_TYPE_CHROME_COOKIE_VIEW, NULL));
451  BuildWidgets(view, editable_expiration);
452  g_signal_connect(view, "realize", G_CALLBACK(InitStyles), NULL);
453  return GTK_WIDGET(view);
454}
455
456void gtk_chrome_cookie_view_clear(GtkChromeCookieView* self) {
457  UpdateVisibleDetailedInfo(self, self->cookie_details_table_);
458  ClearCookieDetails(self);
459}
460
461// Switches the display to showing the passed in cookie.
462void gtk_chrome_cookie_view_display_cookie(
463    GtkChromeCookieView* self,
464    const std::string& domain,
465    const net::CookieMonster::CanonicalCookie& cookie) {
466  UpdateVisibleDetailedInfo(self, self->cookie_details_table_);
467
468  gtk_entry_set_text(GTK_ENTRY(self->cookie_name_entry_),
469                     cookie.Name().c_str());
470  gtk_entry_set_text(GTK_ENTRY(self->cookie_content_entry_),
471                     cookie.Value().c_str());
472  gtk_entry_set_text(GTK_ENTRY(self->cookie_domain_entry_),
473                     domain.c_str());
474  gtk_entry_set_text(GTK_ENTRY(self->cookie_path_entry_),
475                     cookie.Path().c_str());
476  gtk_entry_set_text(GTK_ENTRY(self->cookie_created_entry_),
477                     UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(
478                         cookie.CreationDate())).c_str());
479
480  std::string expire_text = cookie.DoesExpire() ?
481      UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(cookie.ExpiryDate())) :
482      l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_EXPIRES_SESSION);
483
484  if (self->cookie_expires_entry_) {
485    gtk_entry_set_text(GTK_ENTRY(self->cookie_expires_entry_),
486                       expire_text.c_str());
487  } else {
488    GtkListStore* store = self->cookie_expires_combobox_store_;
489    GtkTreeIter iter;
490    gtk_list_store_clear(store);
491
492    if (cookie.DoesExpire()) {
493      gtk_list_store_append(store, &iter);
494      gtk_list_store_set(store, &iter, 0, expire_text.c_str(), -1);
495    }
496
497    gtk_list_store_append(store, &iter);
498    gtk_list_store_set(
499        store, &iter, 0,
500        l10n_util::GetStringUTF8(IDS_COOKIES_COOKIE_EXPIRES_SESSION).c_str(),
501        -1);
502
503    gtk_combo_box_set_active(GTK_COMBO_BOX(self->cookie_expires_combobox_),
504                             0);
505  }
506
507  gtk_entry_set_text(
508      GTK_ENTRY(self->cookie_send_for_entry_),
509      l10n_util::GetStringUTF8(cookie.IsSecure() ?
510                               IDS_COOKIES_COOKIE_SENDFOR_SECURE :
511                               IDS_COOKIES_COOKIE_SENDFOR_ANY).c_str());
512  SetCookieDetailsSensitivity(self, TRUE);
513}
514
515void gtk_chrome_cookie_view_display_cookie_string(
516    GtkChromeCookieView* self,
517    const GURL& url,
518    const std::string& cookie_line) {
519  net::CookieMonster::ParsedCookie pc(cookie_line);
520  net::CookieMonster::CanonicalCookie cookie(url, pc);
521
522  gtk_chrome_cookie_view_display_cookie(
523      self,
524      pc.HasDomain() ? pc.Domain() : url.host(),
525      cookie);
526}
527
528// Switches the display to showing the passed in database.
529void gtk_chrome_cookie_view_display_database(
530    GtkChromeCookieView* self,
531    const BrowsingDataDatabaseHelper::DatabaseInfo& database_info) {
532  UpdateVisibleDetailedInfo(self, self->database_details_table_);
533
534  gtk_entry_set_text(
535      GTK_ENTRY(self->database_name_entry_),
536      database_info.database_name.empty() ?
537          l10n_util::GetStringUTF8(
538              IDS_COOKIES_WEB_DATABASE_UNNAMED_NAME).c_str() :
539          database_info.database_name.c_str());
540  gtk_entry_set_text(GTK_ENTRY(self->database_description_entry_),
541                     database_info.description.c_str());
542  gtk_entry_set_text(GTK_ENTRY(self->database_size_entry_),
543                     UTF16ToUTF8(FormatBytes(
544                         database_info.size,
545                         GetByteDisplayUnits(database_info.size),
546                         true)).c_str());
547  gtk_entry_set_text(GTK_ENTRY(self->database_last_modified_entry_),
548                     UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(
549                         database_info.last_modified)).c_str());
550  SetDatabaseDetailsSensitivity(self, TRUE);
551}
552
553// Switches the display to showing the passed in local storage data.
554void gtk_chrome_cookie_view_display_local_storage(
555    GtkChromeCookieView* self,
556    const BrowsingDataLocalStorageHelper::LocalStorageInfo&
557    local_storage_info) {
558  UpdateVisibleDetailedInfo(self, self->local_storage_details_table_);
559
560  gtk_entry_set_text(GTK_ENTRY(self->local_storage_origin_entry_),
561                     local_storage_info.origin.c_str());
562  gtk_entry_set_text(GTK_ENTRY(self->local_storage_size_entry_),
563                     UTF16ToUTF8(FormatBytes(
564                         local_storage_info.size,
565                         GetByteDisplayUnits(local_storage_info.size),
566                         true)).c_str());
567  gtk_entry_set_text(GTK_ENTRY(self->local_storage_last_modified_entry_),
568                     UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(
569                         local_storage_info.last_modified)).c_str());
570  SetLocalStorageDetailsSensitivity(self, TRUE);
571}
572
573// Switches the display to showing the passed in app cache.
574void gtk_chrome_cookie_view_display_app_cache(
575    GtkChromeCookieView* self,
576    const appcache::AppCacheInfo& info) {
577  UpdateVisibleDetailedInfo(self, self->appcache_details_table_);
578
579  gtk_entry_set_text(GTK_ENTRY(self->appcache_manifest_entry_),
580                     info.manifest_url.spec().c_str());
581  gtk_entry_set_text(GTK_ENTRY(self->appcache_size_entry_),
582                     UTF16ToUTF8(FormatBytes(
583                         info.size,
584                         GetByteDisplayUnits(info.size),
585                         true)).c_str());
586  gtk_entry_set_text(GTK_ENTRY(self->appcache_created_entry_),
587                     UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(
588                         info.creation_time)).c_str());
589  gtk_entry_set_text(GTK_ENTRY(self->appcache_last_accessed_entry_),
590                     UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(
591                         info.last_access_time)).c_str());
592  SetAppCacheDetailsSensitivity(self, TRUE);
593}
594
595// Switches the display to showing the passed in IndexedDB data.
596void gtk_chrome_cookie_view_display_indexed_db(
597    GtkChromeCookieView* self,
598    const BrowsingDataIndexedDBHelper::IndexedDBInfo& indexed_db_info) {
599  UpdateVisibleDetailedInfo(self, self->indexed_db_details_table_);
600
601  gtk_entry_set_text(GTK_ENTRY(self->indexed_db_origin_entry_),
602                     indexed_db_info.origin.c_str());
603  gtk_entry_set_text(GTK_ENTRY(self->indexed_db_size_entry_),
604                     UTF16ToUTF8(FormatBytes(
605                         indexed_db_info.size,
606                         GetByteDisplayUnits(indexed_db_info.size),
607                         true)).c_str());
608  gtk_entry_set_text(GTK_ENTRY(self->indexed_db_last_modified_entry_),
609                     UTF16ToUTF8(base::TimeFormatFriendlyDateAndTime(
610                         indexed_db_info.last_modified)).c_str());
611  SetLocalStorageDetailsSensitivity(self, TRUE);
612}
613
614void gtk_chrome_cookie_view_display_local_storage_item(
615    GtkChromeCookieView* self,
616    const std::string& host,
617    const string16& key,
618    const string16& value) {
619  UpdateVisibleDetailedInfo(self, self->local_storage_item_table_);
620
621  gtk_entry_set_text(GTK_ENTRY(self->local_storage_item_origin_entry_),
622                     host.c_str());
623  gtk_entry_set_text(GTK_ENTRY(self->local_storage_item_key_entry_),
624                     UTF16ToUTF8(key).c_str());
625  gtk_entry_set_text(GTK_ENTRY(self->local_storage_item_value_entry_),
626                     UTF16ToUTF8(value).c_str());
627  SetLocalStorageItemSensitivity(self, TRUE);
628}
629
630void gtk_chrome_cookie_view_display_database_accessed(
631    GtkChromeCookieView* self,
632    const std::string& host,
633    const string16& database_name,
634    const string16& display_name,
635    unsigned long estimated_size) {
636  UpdateVisibleDetailedInfo(self, self->database_accessed_table_);
637
638  gtk_entry_set_text(GTK_ENTRY(self->database_accessed_origin_entry_),
639                     host.c_str());
640  gtk_entry_set_text(GTK_ENTRY(self->database_accessed_name_entry_),
641                     UTF16ToUTF8(database_name).c_str());
642  gtk_entry_set_text(GTK_ENTRY(self->database_accessed_description_entry_),
643                     UTF16ToUTF8(display_name).c_str());
644  gtk_entry_set_text(GTK_ENTRY(self->database_accessed_size_entry_),
645                     UTF16ToUTF8(FormatBytes(
646                         estimated_size,
647                         GetByteDisplayUnits(estimated_size),
648                         true)).c_str());
649  SetDatabaseAccessedSensitivity(self, TRUE);
650}
651
652void gtk_chrome_cookie_view_display_appcache_created(
653    GtkChromeCookieView* self,
654    const GURL& manifest_url) {
655  UpdateVisibleDetailedInfo(self, self->appcache_created_table_);
656  gtk_entry_set_text(GTK_ENTRY(self->appcache_created_manifest_entry_),
657                     manifest_url.spec().c_str());
658  SetAppCacheCreatedSensitivity(self, TRUE);
659}
660
661bool gtk_chrome_cookie_view_session_expires(GtkChromeCookieView* self) {
662  if (self->cookie_expires_entry_)
663    return false;
664
665  GtkListStore* store = self->cookie_expires_combobox_store_;
666  int store_size = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store), NULL);
667  if (store_size == 1)
668    return false;
669
670  DCHECK_EQ(2, store_size);
671
672  int selected = gtk_combo_box_get_active(GTK_COMBO_BOX(
673      self->cookie_expires_combobox_));
674  return selected == 1;
675}
676