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 13 namespace { 14 15 void 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 31 GtkWidget* 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 41 GtkWidget* 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 54 GtkWidget* 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 78 void 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 145 void 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 159 void 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 167 void 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 174 void 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 182 void 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 189 void 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 196 void 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 204 void SetAppCacheCreatedSensitivity(GtkChromeCookieView* self, 205 gboolean enabled) { 206 gtk_widget_set_sensitive(self->appcache_created_manifest_entry_, enabled); 207 } 208 209 void 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 241 void 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 280 G_DEFINE_TYPE(GtkChromeCookieView, gtk_chrome_cookie_view, GTK_TYPE_FRAME) 281 282 static void gtk_chrome_cookie_view_class_init(GtkChromeCookieViewClass *klass) { 283 } 284 285 static void gtk_chrome_cookie_view_init(GtkChromeCookieView *self) { 286 } 287 288 void 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 448 GtkWidget* 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 456 void 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. 462 void 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 515 void 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. 529 void 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. 554 void 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. 574 void 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. 596 void 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 614 void 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 630 void 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 652 void 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 661 bool 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
