root/chrome/browser/ui/gtk/gtk_chrome_cookie_view.cc

DEFINITIONS

1. InitBrowserDetailStyle
2. InitRowLabel
3. InitDetailRow
4. InitComboboxRow
5. InitStyles
6. SetCookieDetailsSensitivity
7. SetDatabaseDetailsSensitivity
8. SetLocalStorageDetailsSensitivity
9. SetAppCacheDetailsSensitivity
10. SetIndexedDBDetailsSensitivity
11. SetLocalStorageItemSensitivity
12. SetDatabaseAccessedSensitivity
13. SetAppCacheCreatedSensitivity
14. ClearCookieDetails
15. UpdateVisibleDetailedInfo
16. G_DEFINE_TYPE
17. gtk_chrome_cookie_view_init
18. BuildWidgets
19. gtk_chrome_cookie_view_new
20. gtk_chrome_cookie_view_clear
21. gtk_chrome_cookie_view_display_cookie
22. gtk_chrome_cookie_view_display_cookie_string
23. gtk_chrome_cookie_view_display_database
24. gtk_chrome_cookie_view_display_local_storage
25. gtk_chrome_cookie_view_display_app_cache
26. gtk_chrome_cookie_view_display_indexed_db
27. gtk_chrome_cookie_view_display_local_storage_item
28. gtk_chrome_cookie_view_display_database_accessed
29. gtk_chrome_cookie_view_display_appcache_created
30. gtk_chrome_cookie_view_session_expires

// 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"

using base::UTF16ToUTF8;

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 base::string16& key,
    const base::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 base::string16& database_name,
    const base::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;
}