| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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/collected_cookies_gtk.h" | |
| 6 | |
| 7 #include <string> | |
| 8 #include "base/prefs/pref_service.h" | |
| 9 #include "chrome/browser/browsing_data/browsing_data_appcache_helper.h" | |
| 10 #include "chrome/browser/browsing_data/browsing_data_cookie_helper.h" | |
| 11 #include "chrome/browser/browsing_data/browsing_data_database_helper.h" | |
| 12 #include "chrome/browser/browsing_data/browsing_data_file_system_helper.h" | |
| 13 #include "chrome/browser/browsing_data/browsing_data_indexed_db_helper.h" | |
| 14 #include "chrome/browser/browsing_data/browsing_data_local_storage_helper.h" | |
| 15 #include "chrome/browser/browsing_data/browsing_data_server_bound_cert_helper.h" | |
| 16 #include "chrome/browser/browsing_data/cookies_tree_model.h" | |
| 17 #include "chrome/browser/browsing_data/local_data_container.h" | |
| 18 #include "chrome/browser/chrome_notification_types.h" | |
| 19 #include "chrome/browser/content_settings/cookie_settings.h" | |
| 20 #include "chrome/browser/content_settings/local_shared_objects_container.h" | |
| 21 #include "chrome/browser/content_settings/tab_specific_content_settings.h" | |
| 22 #include "chrome/browser/infobars/infobar_service.h" | |
| 23 #include "chrome/browser/profiles/profile.h" | |
| 24 #include "chrome/browser/ui/browser_dialogs.h" | |
| 25 #include "chrome/browser/ui/collected_cookies_infobar_delegate.h" | |
| 26 #include "chrome/browser/ui/gtk/constrained_window_gtk.h" | |
| 27 #include "chrome/browser/ui/gtk/gtk_chrome_cookie_view.h" | |
| 28 #include "chrome/browser/ui/gtk/gtk_util.h" | |
| 29 #include "chrome/common/pref_names.h" | |
| 30 #include "components/web_modal/web_contents_modal_dialog_manager.h" | |
| 31 #include "content/public/browser/notification_source.h" | |
| 32 #include "content/public/browser/web_contents.h" | |
| 33 #include "content/public/browser/web_contents_view.h" | |
| 34 #include "grit/generated_resources.h" | |
| 35 #include "net/cookies/canonical_cookie.h" | |
| 36 #include "ui/base/gtk/gtk_hig_constants.h" | |
| 37 #include "ui/base/l10n/l10n_util.h" | |
| 38 | |
| 39 using web_modal::WebContentsModalDialogManager; | |
| 40 | |
| 41 namespace { | |
| 42 // Width and height of the cookie tree view. | |
| 43 const int kTreeViewWidth = 450; | |
| 44 const int kTreeViewHeight = 150; | |
| 45 | |
| 46 // The page numbers of the pages in the notebook. | |
| 47 const gint kAllowedPageNumber = 0; | |
| 48 const gint kBlockedPageNumber = 1; | |
| 49 | |
| 50 // Padding within the banner box. | |
| 51 const int kBannerPadding = 3; | |
| 52 | |
| 53 // Returns the text to display in the info bar when content settings were | |
| 54 // created. | |
| 55 const std::string GetInfobarLabel(ContentSetting setting, | |
| 56 bool multiple_domains_added, | |
| 57 const base::string16& domain_name) { | |
| 58 if (multiple_domains_added) { | |
| 59 switch (setting) { | |
| 60 case CONTENT_SETTING_BLOCK: | |
| 61 return l10n_util::GetStringUTF8( | |
| 62 IDS_COLLECTED_COOKIES_MULTIPLE_BLOCK_RULES_CREATED); | |
| 63 | |
| 64 case CONTENT_SETTING_ALLOW: | |
| 65 return l10n_util::GetStringUTF8( | |
| 66 IDS_COLLECTED_COOKIES_MULTIPLE_ALLOW_RULES_CREATED); | |
| 67 | |
| 68 case CONTENT_SETTING_SESSION_ONLY: | |
| 69 return l10n_util::GetStringUTF8( | |
| 70 IDS_COLLECTED_COOKIES_MULTIPLE_SESSION_RULES_CREATED); | |
| 71 | |
| 72 default: | |
| 73 NOTREACHED(); | |
| 74 return std::string(); | |
| 75 } | |
| 76 } | |
| 77 | |
| 78 switch (setting) { | |
| 79 case CONTENT_SETTING_BLOCK: | |
| 80 return l10n_util::GetStringFUTF8( | |
| 81 IDS_COLLECTED_COOKIES_BLOCK_RULE_CREATED, domain_name); | |
| 82 | |
| 83 case CONTENT_SETTING_ALLOW: | |
| 84 return l10n_util::GetStringFUTF8( | |
| 85 IDS_COLLECTED_COOKIES_ALLOW_RULE_CREATED, domain_name); | |
| 86 | |
| 87 case CONTENT_SETTING_SESSION_ONLY: | |
| 88 return l10n_util::GetStringFUTF8( | |
| 89 IDS_COLLECTED_COOKIES_SESSION_RULE_CREATED, domain_name); | |
| 90 | |
| 91 default: | |
| 92 NOTREACHED(); | |
| 93 return std::string(); | |
| 94 } | |
| 95 } | |
| 96 | |
| 97 } // namespace | |
| 98 | |
| 99 namespace chrome { | |
| 100 | |
| 101 // Declared in browser_dialogs.h so others don't have to depend on our header. | |
| 102 void ShowCollectedCookiesDialog(content::WebContents* web_contents) { | |
| 103 // Deletes itself on close. | |
| 104 new CollectedCookiesGtk( | |
| 105 web_contents->GetView()->GetTopLevelNativeWindow(), | |
| 106 web_contents); | |
| 107 } | |
| 108 | |
| 109 } // namespace chrome | |
| 110 | |
| 111 CollectedCookiesGtk::CollectedCookiesGtk(GtkWindow* parent, | |
| 112 content::WebContents* web_contents) | |
| 113 : web_contents_(web_contents), | |
| 114 status_changed_(false) { | |
| 115 TabSpecificContentSettings* content_settings = | |
| 116 TabSpecificContentSettings::FromWebContents(web_contents); | |
| 117 registrar_.Add(this, chrome::NOTIFICATION_COLLECTED_COOKIES_SHOWN, | |
| 118 content::Source<TabSpecificContentSettings>(content_settings)); | |
| 119 | |
| 120 Init(); | |
| 121 } | |
| 122 | |
| 123 void CollectedCookiesGtk::Init() { | |
| 124 dialog_ = gtk_vbox_new(FALSE, ui::kContentAreaSpacing); | |
| 125 gtk_box_set_spacing(GTK_BOX(dialog_), ui::kContentAreaSpacing); | |
| 126 g_signal_connect(dialog_, "destroy", G_CALLBACK(OnDestroyThunk), this); | |
| 127 | |
| 128 GtkWidget* label = gtk_label_new( | |
| 129 l10n_util::GetStringUTF8(IDS_COLLECTED_COOKIES_DIALOG_TITLE).c_str()); | |
| 130 gtk_box_pack_start(GTK_BOX(dialog_), label, TRUE, TRUE, 0); | |
| 131 | |
| 132 notebook_ = gtk_notebook_new(); | |
| 133 gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook_), GTK_POS_TOP); | |
| 134 gtk_box_pack_start(GTK_BOX(dialog_), notebook_, TRUE, TRUE, 0); | |
| 135 | |
| 136 GtkWidget* allowed_pane = CreateAllowedPane(); | |
| 137 label = gtk_label_new( | |
| 138 l10n_util::GetStringUTF8(IDS_COLLECTED_COOKIES_ALLOWED_COOKIES_TAB_LABEL) | |
| 139 .c_str()); | |
| 140 gtk_widget_show(label); | |
| 141 gtk_notebook_insert_page(GTK_NOTEBOOK(notebook_), allowed_pane, label, | |
| 142 kAllowedPageNumber); | |
| 143 | |
| 144 GtkWidget* blocked_pane = CreateBlockedPane(); | |
| 145 label = gtk_label_new( | |
| 146 l10n_util::GetStringUTF8(IDS_COLLECTED_COOKIES_BLOCKED_COOKIES_TAB_LABEL) | |
| 147 .c_str()); | |
| 148 gtk_widget_show(label); | |
| 149 gtk_notebook_insert_page(GTK_NOTEBOOK(notebook_), blocked_pane, label, | |
| 150 kBlockedPageNumber); | |
| 151 // Hook up the signal only after all pages are inserted, otherwise not | |
| 152 // all member variables used in OnSwitchPage() will be properly initialized. | |
| 153 g_signal_connect(notebook_, "switch-page", G_CALLBACK(OnSwitchPageThunk), | |
| 154 this); | |
| 155 | |
| 156 // Cookie info view. | |
| 157 cookie_info_view_ = gtk_chrome_cookie_view_new(false); | |
| 158 gtk_box_pack_start(GTK_BOX(dialog_), cookie_info_view_, TRUE, TRUE, 0); | |
| 159 gtk_chrome_cookie_view_clear(GTK_CHROME_COOKIE_VIEW(cookie_info_view_)); | |
| 160 gtk_widget_show_all(cookie_info_view_); | |
| 161 | |
| 162 // Infobar. | |
| 163 infobar_ = gtk_frame_new(NULL); | |
| 164 GtkWidget* infobar_contents = gtk_hbox_new(FALSE, kBannerPadding); | |
| 165 gtk_container_set_border_width(GTK_CONTAINER(infobar_contents), | |
| 166 kBannerPadding); | |
| 167 gtk_container_add(GTK_CONTAINER(infobar_), infobar_contents); | |
| 168 GtkWidget* info_image = | |
| 169 gtk_image_new_from_stock(GTK_STOCK_DIALOG_INFO, | |
| 170 GTK_ICON_SIZE_SMALL_TOOLBAR); | |
| 171 gtk_box_pack_start(GTK_BOX(infobar_contents), info_image, FALSE, FALSE, 0); | |
| 172 infobar_label_ = gtk_label_new(NULL); | |
| 173 gtk_box_pack_start( | |
| 174 GTK_BOX(infobar_contents), infobar_label_, FALSE, FALSE, 0); | |
| 175 gtk_widget_show_all(infobar_); | |
| 176 gtk_widget_set_no_show_all(infobar_, TRUE); | |
| 177 gtk_widget_hide(infobar_); | |
| 178 gtk_box_pack_start(GTK_BOX(dialog_), infobar_, TRUE, TRUE, 0); | |
| 179 | |
| 180 // Close button. | |
| 181 GtkWidget* button_box = gtk_hbutton_box_new(); | |
| 182 gtk_button_box_set_layout(GTK_BUTTON_BOX(button_box), GTK_BUTTONBOX_END); | |
| 183 gtk_box_set_spacing(GTK_BOX(button_box), ui::kControlSpacing); | |
| 184 gtk_box_pack_end(GTK_BOX(dialog_), button_box, FALSE, TRUE, 0); | |
| 185 close_button_ = gtk_button_new_from_stock(GTK_STOCK_CLOSE); | |
| 186 gtk_button_set_label(GTK_BUTTON(close_button_), | |
| 187 l10n_util::GetStringUTF8(IDS_CLOSE).c_str()); | |
| 188 g_signal_connect(close_button_, "clicked", G_CALLBACK(OnCloseThunk), this); | |
| 189 gtk_box_pack_end(GTK_BOX(button_box), close_button_, FALSE, TRUE, 0); | |
| 190 | |
| 191 // Show the dialog. | |
| 192 allowed_cookies_tree_adapter_->Init(); | |
| 193 blocked_cookies_tree_adapter_->Init(); | |
| 194 EnableControls(); | |
| 195 ShowCookieInfo(gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook_))); | |
| 196 window_ = CreateWebContentsModalDialogGtk(dialog_, close_button_); | |
| 197 | |
| 198 WebContentsModalDialogManager* web_contents_modal_dialog_manager = | |
| 199 WebContentsModalDialogManager::FromWebContents(web_contents_); | |
| 200 web_contents_modal_dialog_manager->ShowDialog(window_); | |
| 201 } | |
| 202 | |
| 203 GtkWidget* CollectedCookiesGtk::CreateAllowedPane() { | |
| 204 GtkWidget* cookie_list_vbox = gtk_vbox_new(FALSE, ui::kControlSpacing); | |
| 205 | |
| 206 GtkWidget* label = gtk_label_new( | |
| 207 l10n_util::GetStringUTF8(IDS_COLLECTED_COOKIES_ALLOWED_COOKIES_LABEL). | |
| 208 c_str()); | |
| 209 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); | |
| 210 gtk_box_pack_start(GTK_BOX(cookie_list_vbox), label, FALSE, FALSE, | |
| 211 ui::kControlSpacing); | |
| 212 | |
| 213 GtkWidget* scroll_window = gtk_scrolled_window_new(NULL, NULL); | |
| 214 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window), | |
| 215 GTK_POLICY_AUTOMATIC, | |
| 216 GTK_POLICY_AUTOMATIC); | |
| 217 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll_window), | |
| 218 GTK_SHADOW_ETCHED_IN); | |
| 219 gtk_box_pack_start(GTK_BOX(cookie_list_vbox), scroll_window, TRUE, TRUE, 0); | |
| 220 | |
| 221 TabSpecificContentSettings* content_settings = | |
| 222 TabSpecificContentSettings::FromWebContents(web_contents_); | |
| 223 | |
| 224 const LocalSharedObjectsContainer& allowed_data = | |
| 225 content_settings->allowed_local_shared_objects(); | |
| 226 allowed_cookies_tree_model_ = allowed_data.CreateCookiesTreeModel(); | |
| 227 | |
| 228 allowed_cookies_tree_adapter_.reset( | |
| 229 new gtk_tree::TreeAdapter(this, allowed_cookies_tree_model_.get())); | |
| 230 allowed_tree_ = gtk_tree_view_new_with_model( | |
| 231 GTK_TREE_MODEL(allowed_cookies_tree_adapter_->tree_store())); | |
| 232 gtk_widget_set_size_request(allowed_tree_, kTreeViewWidth, kTreeViewHeight); | |
| 233 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(allowed_tree_), FALSE); | |
| 234 gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(allowed_tree_), TRUE); | |
| 235 gtk_container_add(GTK_CONTAINER(scroll_window), allowed_tree_); | |
| 236 | |
| 237 GtkTreeViewColumn* title_column = gtk_tree_view_column_new(); | |
| 238 GtkCellRenderer* pixbuf_renderer = gtk_cell_renderer_pixbuf_new(); | |
| 239 gtk_tree_view_column_pack_start(title_column, pixbuf_renderer, FALSE); | |
| 240 gtk_tree_view_column_add_attribute(title_column, pixbuf_renderer, "pixbuf", | |
| 241 gtk_tree::TreeAdapter::COL_ICON); | |
| 242 GtkCellRenderer* title_renderer = gtk_cell_renderer_text_new(); | |
| 243 gtk_tree_view_column_pack_start(title_column, title_renderer, TRUE); | |
| 244 gtk_tree_view_column_add_attribute(title_column, title_renderer, "text", | |
| 245 gtk_tree::TreeAdapter::COL_TITLE); | |
| 246 gtk_tree_view_column_set_title( | |
| 247 title_column, l10n_util::GetStringUTF8( | |
| 248 IDS_COOKIES_DOMAIN_COLUMN_HEADER).c_str()); | |
| 249 gtk_tree_view_append_column(GTK_TREE_VIEW(allowed_tree_), title_column); | |
| 250 g_signal_connect(allowed_tree_, "row-expanded", | |
| 251 G_CALLBACK(OnTreeViewRowExpandedThunk), this); | |
| 252 allowed_selection_ = | |
| 253 gtk_tree_view_get_selection(GTK_TREE_VIEW(allowed_tree_)); | |
| 254 gtk_tree_selection_set_mode(allowed_selection_, GTK_SELECTION_MULTIPLE); | |
| 255 g_signal_connect(allowed_selection_, "changed", | |
| 256 G_CALLBACK(OnTreeViewSelectionChangeThunk), this); | |
| 257 | |
| 258 GtkWidget* button_box = gtk_hbutton_box_new(); | |
| 259 gtk_button_box_set_layout(GTK_BUTTON_BOX(button_box), GTK_BUTTONBOX_START); | |
| 260 gtk_box_set_spacing(GTK_BOX(button_box), ui::kControlSpacing); | |
| 261 gtk_box_pack_start(GTK_BOX(cookie_list_vbox), button_box, FALSE, FALSE, | |
| 262 ui::kControlSpacing); | |
| 263 block_allowed_cookie_button_ = gtk_button_new_with_label( | |
| 264 l10n_util::GetStringUTF8(IDS_COLLECTED_COOKIES_BLOCK_BUTTON).c_str()); | |
| 265 g_signal_connect(block_allowed_cookie_button_, "clicked", | |
| 266 G_CALLBACK(OnBlockAllowedButtonClickedThunk), this); | |
| 267 gtk_container_add(GTK_CONTAINER(button_box), block_allowed_cookie_button_); | |
| 268 | |
| 269 delete_allowed_cookie_button_ = gtk_button_new_with_label( | |
| 270 l10n_util::GetStringUTF8(IDS_COOKIES_REMOVE_LABEL).c_str()); | |
| 271 g_signal_connect(delete_allowed_cookie_button_, "clicked", | |
| 272 G_CALLBACK(OnDeleteAllowedButtonClickedThunk), this); | |
| 273 gtk_container_add(GTK_CONTAINER(button_box), delete_allowed_cookie_button_); | |
| 274 | |
| 275 // Wrap the vbox inside an hbox so that we can specify padding along the | |
| 276 // horizontal axis. | |
| 277 GtkWidget* box = gtk_hbox_new(FALSE, 0); | |
| 278 gtk_box_pack_start(GTK_BOX(box), cookie_list_vbox, TRUE, TRUE, | |
| 279 ui::kControlSpacing); | |
| 280 return box; | |
| 281 } | |
| 282 | |
| 283 GtkWidget* CollectedCookiesGtk::CreateBlockedPane() { | |
| 284 PrefService* prefs = Profile::FromBrowserContext( | |
| 285 web_contents_->GetBrowserContext())->GetPrefs(); | |
| 286 | |
| 287 GtkWidget* cookie_list_vbox = gtk_vbox_new(FALSE, ui::kControlSpacing); | |
| 288 | |
| 289 GtkWidget* label = gtk_label_new( | |
| 290 l10n_util::GetStringUTF8( | |
| 291 prefs->GetBoolean(prefs::kBlockThirdPartyCookies) ? | |
| 292 IDS_COLLECTED_COOKIES_BLOCKED_THIRD_PARTY_BLOCKING_ENABLED : | |
| 293 IDS_COLLECTED_COOKIES_BLOCKED_COOKIES_LABEL).c_str()); | |
| 294 gtk_widget_set_size_request(label, kTreeViewWidth, -1); | |
| 295 gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); | |
| 296 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); | |
| 297 gtk_box_pack_start(GTK_BOX(cookie_list_vbox), label, TRUE, TRUE, | |
| 298 ui::kControlSpacing); | |
| 299 | |
| 300 GtkWidget* scroll_window = gtk_scrolled_window_new(NULL, NULL); | |
| 301 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window), | |
| 302 GTK_POLICY_AUTOMATIC, | |
| 303 GTK_POLICY_AUTOMATIC); | |
| 304 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll_window), | |
| 305 GTK_SHADOW_ETCHED_IN); | |
| 306 gtk_box_pack_start(GTK_BOX(cookie_list_vbox), scroll_window, TRUE, TRUE, 0); | |
| 307 | |
| 308 TabSpecificContentSettings* content_settings = | |
| 309 TabSpecificContentSettings::FromWebContents(web_contents_); | |
| 310 | |
| 311 const LocalSharedObjectsContainer& blocked_data = | |
| 312 content_settings->blocked_local_shared_objects(); | |
| 313 blocked_cookies_tree_model_ = blocked_data.CreateCookiesTreeModel(); | |
| 314 | |
| 315 blocked_cookies_tree_adapter_.reset( | |
| 316 new gtk_tree::TreeAdapter(this, blocked_cookies_tree_model_.get())); | |
| 317 blocked_tree_ = gtk_tree_view_new_with_model( | |
| 318 GTK_TREE_MODEL(blocked_cookies_tree_adapter_->tree_store())); | |
| 319 gtk_widget_set_size_request(blocked_tree_, kTreeViewWidth, kTreeViewHeight); | |
| 320 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(blocked_tree_), FALSE); | |
| 321 gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(blocked_tree_), TRUE); | |
| 322 gtk_container_add(GTK_CONTAINER(scroll_window), blocked_tree_); | |
| 323 | |
| 324 GtkTreeViewColumn* title_column = gtk_tree_view_column_new(); | |
| 325 GtkCellRenderer* pixbuf_renderer = gtk_cell_renderer_pixbuf_new(); | |
| 326 gtk_tree_view_column_pack_start(title_column, pixbuf_renderer, FALSE); | |
| 327 gtk_tree_view_column_add_attribute(title_column, pixbuf_renderer, "pixbuf", | |
| 328 gtk_tree::TreeAdapter::COL_ICON); | |
| 329 GtkCellRenderer* title_renderer = gtk_cell_renderer_text_new(); | |
| 330 gtk_tree_view_column_pack_start(title_column, title_renderer, TRUE); | |
| 331 gtk_tree_view_column_add_attribute(title_column, title_renderer, "text", | |
| 332 gtk_tree::TreeAdapter::COL_TITLE); | |
| 333 gtk_tree_view_column_set_title( | |
| 334 title_column, l10n_util::GetStringUTF8( | |
| 335 IDS_COOKIES_DOMAIN_COLUMN_HEADER).c_str()); | |
| 336 gtk_tree_view_append_column(GTK_TREE_VIEW(blocked_tree_), title_column); | |
| 337 g_signal_connect(blocked_tree_, "row-expanded", | |
| 338 G_CALLBACK(OnTreeViewRowExpandedThunk), this); | |
| 339 blocked_selection_ = | |
| 340 gtk_tree_view_get_selection(GTK_TREE_VIEW(blocked_tree_)); | |
| 341 gtk_tree_selection_set_mode(blocked_selection_, GTK_SELECTION_MULTIPLE); | |
| 342 g_signal_connect(blocked_selection_, "changed", | |
| 343 G_CALLBACK(OnTreeViewSelectionChangeThunk), this); | |
| 344 | |
| 345 GtkWidget* button_box = gtk_hbutton_box_new(); | |
| 346 gtk_button_box_set_layout(GTK_BUTTON_BOX(button_box), GTK_BUTTONBOX_START); | |
| 347 gtk_box_set_spacing(GTK_BOX(button_box), ui::kControlSpacing); | |
| 348 gtk_box_pack_start(GTK_BOX(cookie_list_vbox), button_box, FALSE, FALSE, | |
| 349 ui::kControlSpacing); | |
| 350 allow_blocked_cookie_button_ = gtk_button_new_with_label( | |
| 351 l10n_util::GetStringUTF8(IDS_COLLECTED_COOKIES_ALLOW_BUTTON).c_str()); | |
| 352 g_signal_connect(allow_blocked_cookie_button_, "clicked", | |
| 353 G_CALLBACK(OnAllowBlockedButtonClickedThunk), this); | |
| 354 gtk_container_add(GTK_CONTAINER(button_box), allow_blocked_cookie_button_); | |
| 355 for_session_blocked_cookie_button_ = gtk_button_new_with_label( | |
| 356 l10n_util::GetStringUTF8(IDS_COLLECTED_COOKIES_SESSION_ONLY_BUTTON). | |
| 357 c_str()); | |
| 358 g_signal_connect(for_session_blocked_cookie_button_, "clicked", | |
| 359 G_CALLBACK(OnForSessionBlockedButtonClickedThunk), this); | |
| 360 gtk_container_add(GTK_CONTAINER(button_box), | |
| 361 for_session_blocked_cookie_button_); | |
| 362 | |
| 363 // Wrap the vbox inside an hbox so that we can specify padding along the | |
| 364 // horizontal axis. | |
| 365 GtkWidget* box = gtk_hbox_new(FALSE, 0); | |
| 366 gtk_box_pack_start(GTK_BOX(box), cookie_list_vbox, TRUE, TRUE, | |
| 367 ui::kControlSpacing); | |
| 368 return box; | |
| 369 } | |
| 370 | |
| 371 void CollectedCookiesGtk::ShowCookieInfo(gint current_page) { | |
| 372 if (current_page == kAllowedPageNumber) { | |
| 373 ShowSelectionInfo(allowed_selection_, allowed_cookies_tree_adapter_.get()); | |
| 374 } else if (current_page == kBlockedPageNumber) { | |
| 375 ShowSelectionInfo(blocked_selection_, blocked_cookies_tree_adapter_.get()); | |
| 376 } | |
| 377 } | |
| 378 | |
| 379 void CollectedCookiesGtk::ShowSelectionInfo(GtkTreeSelection* selection, | |
| 380 gtk_tree::TreeAdapter* adapter) { | |
| 381 // Check if one "cookie" node is selected. Don't allow more than one. | |
| 382 GtkTreeModel* model; | |
| 383 GList* paths = gtk_tree_selection_get_selected_rows(selection, &model); | |
| 384 if (g_list_length(paths) == 1) { | |
| 385 GList* item = g_list_first(paths); | |
| 386 GtkTreeIter iter; | |
| 387 gtk_tree_model_get_iter(model, &iter, | |
| 388 reinterpret_cast<GtkTreePath*>(item->data)); | |
| 389 CookieTreeNode* node = | |
| 390 static_cast<CookieTreeNode*>(adapter->GetNode(&iter)); | |
| 391 const CookieTreeNode::DetailedInfo detailed_info = node->GetDetailedInfo(); | |
| 392 if (detailed_info.node_type == CookieTreeNode::DetailedInfo::TYPE_COOKIE) { | |
| 393 gtk_chrome_cookie_view_display_cookie( | |
| 394 GTK_CHROME_COOKIE_VIEW(cookie_info_view_), | |
| 395 detailed_info.cookie->Domain(), | |
| 396 *detailed_info.cookie); | |
| 397 } else { | |
| 398 gtk_chrome_cookie_view_clear(GTK_CHROME_COOKIE_VIEW(cookie_info_view_)); | |
| 399 } | |
| 400 } else { | |
| 401 gtk_chrome_cookie_view_clear(GTK_CHROME_COOKIE_VIEW(cookie_info_view_)); | |
| 402 } | |
| 403 | |
| 404 g_list_foreach(paths, reinterpret_cast<GFunc>(gtk_tree_path_free), NULL); | |
| 405 g_list_free(paths); | |
| 406 } | |
| 407 | |
| 408 CollectedCookiesGtk::~CollectedCookiesGtk() { | |
| 409 gtk_widget_destroy(dialog_); | |
| 410 } | |
| 411 | |
| 412 bool CollectedCookiesGtk::SelectionContainsHostNode( | |
| 413 GtkTreeSelection* selection, gtk_tree::TreeAdapter* adapter) { | |
| 414 // Check whether at least one "origin" node is selected. | |
| 415 GtkTreeModel* model; | |
| 416 GList* paths = | |
| 417 gtk_tree_selection_get_selected_rows(selection, &model); | |
| 418 bool contains_host_node = false; | |
| 419 for (GList* item = paths; item; item = item->next) { | |
| 420 GtkTreeIter iter; | |
| 421 gtk_tree_model_get_iter( | |
| 422 model, &iter, reinterpret_cast<GtkTreePath*>(item->data)); | |
| 423 CookieTreeNode* node = | |
| 424 static_cast<CookieTreeNode*>(adapter->GetNode(&iter)); | |
| 425 if (node->GetDetailedInfo().node_type != | |
| 426 CookieTreeNode::DetailedInfo::TYPE_HOST) | |
| 427 continue; | |
| 428 CookieTreeHostNode* host_node = static_cast<CookieTreeHostNode*>( | |
| 429 node); | |
| 430 if (!host_node->CanCreateContentException()) | |
| 431 continue; | |
| 432 contains_host_node = true; | |
| 433 } | |
| 434 g_list_foreach(paths, reinterpret_cast<GFunc>(gtk_tree_path_free), NULL); | |
| 435 g_list_free(paths); | |
| 436 return contains_host_node; | |
| 437 } | |
| 438 | |
| 439 void CollectedCookiesGtk::EnableControls() { | |
| 440 // Update button states. | |
| 441 bool enable_for_allowed_cookies = | |
| 442 SelectionContainsHostNode(allowed_selection_, | |
| 443 allowed_cookies_tree_adapter_.get()); | |
| 444 gtk_widget_set_sensitive(block_allowed_cookie_button_, | |
| 445 enable_for_allowed_cookies); | |
| 446 gtk_widget_set_sensitive( | |
| 447 delete_allowed_cookie_button_, | |
| 448 gtk_tree_selection_count_selected_rows(allowed_selection_) > 0); | |
| 449 | |
| 450 bool enable_for_blocked_cookies = | |
| 451 SelectionContainsHostNode(blocked_selection_, | |
| 452 blocked_cookies_tree_adapter_.get()); | |
| 453 gtk_widget_set_sensitive(allow_blocked_cookie_button_, | |
| 454 enable_for_blocked_cookies); | |
| 455 gtk_widget_set_sensitive(for_session_blocked_cookie_button_, | |
| 456 enable_for_blocked_cookies); | |
| 457 } | |
| 458 | |
| 459 void CollectedCookiesGtk::Observe(int type, | |
| 460 const content::NotificationSource& source, | |
| 461 const content::NotificationDetails& details) { | |
| 462 DCHECK(type == chrome::NOTIFICATION_COLLECTED_COOKIES_SHOWN); | |
| 463 gtk_widget_destroy(window_); | |
| 464 } | |
| 465 | |
| 466 void CollectedCookiesGtk::OnClose(GtkWidget* close_button) { | |
| 467 if (status_changed_) { | |
| 468 CollectedCookiesInfoBarDelegate::Create( | |
| 469 InfoBarService::FromWebContents(web_contents_)); | |
| 470 } | |
| 471 gtk_widget_destroy(window_); | |
| 472 } | |
| 473 | |
| 474 void CollectedCookiesGtk::AddExceptions(GtkTreeSelection* selection, | |
| 475 gtk_tree::TreeAdapter* adapter, | |
| 476 ContentSetting setting) { | |
| 477 GtkTreeModel* model; | |
| 478 GList* paths = | |
| 479 gtk_tree_selection_get_selected_rows(selection, &model); | |
| 480 base::string16 last_domain_name; | |
| 481 bool multiple_domains_added = false; | |
| 482 for (GList* item = paths; item; item = item->next) { | |
| 483 GtkTreeIter iter; | |
| 484 gtk_tree_model_get_iter( | |
| 485 model, &iter, reinterpret_cast<GtkTreePath*>(item->data)); | |
| 486 CookieTreeNode* node = | |
| 487 static_cast<CookieTreeNode*>(adapter->GetNode(&iter)); | |
| 488 if (node->GetDetailedInfo().node_type != | |
| 489 CookieTreeNode::DetailedInfo::TYPE_HOST) | |
| 490 continue; | |
| 491 CookieTreeHostNode* host_node = static_cast<CookieTreeHostNode*>( | |
| 492 node); | |
| 493 if (host_node->CanCreateContentException()) { | |
| 494 if (!last_domain_name.empty()) | |
| 495 multiple_domains_added = true; | |
| 496 last_domain_name = host_node->GetTitle(); | |
| 497 Profile* profile = | |
| 498 Profile::FromBrowserContext(web_contents_->GetBrowserContext()); | |
| 499 host_node->CreateContentException( | |
| 500 CookieSettings::Factory::GetForProfile(profile).get(), setting); | |
| 501 } | |
| 502 } | |
| 503 g_list_foreach(paths, reinterpret_cast<GFunc>(gtk_tree_path_free), NULL); | |
| 504 g_list_free(paths); | |
| 505 if (last_domain_name.empty()) { | |
| 506 gtk_widget_hide(infobar_); | |
| 507 } else { | |
| 508 gtk_label_set_text( | |
| 509 GTK_LABEL(infobar_label_), GetInfobarLabel( | |
| 510 setting, multiple_domains_added, last_domain_name).c_str()); | |
| 511 gtk_widget_show(infobar_); | |
| 512 } | |
| 513 status_changed_ = true; | |
| 514 } | |
| 515 | |
| 516 void CollectedCookiesGtk::OnBlockAllowedButtonClicked(GtkWidget* button) { | |
| 517 AddExceptions(allowed_selection_, allowed_cookies_tree_adapter_.get(), | |
| 518 CONTENT_SETTING_BLOCK); | |
| 519 } | |
| 520 | |
| 521 void CollectedCookiesGtk::OnDeleteAllowedButtonClicked(GtkWidget* button) { | |
| 522 GtkTreeModel* model; | |
| 523 GList* paths = gtk_tree_selection_get_selected_rows( | |
| 524 allowed_selection_, &model); | |
| 525 for (GList* item = paths; item; item = item->next) { | |
| 526 GtkTreeIter iter; | |
| 527 gtk_tree_model_get_iter( | |
| 528 model, &iter, reinterpret_cast<GtkTreePath*>(item->data)); | |
| 529 CookieTreeNode* node = static_cast<CookieTreeNode*>( | |
| 530 allowed_cookies_tree_adapter_->GetNode(&iter)); | |
| 531 allowed_cookies_tree_model_->DeleteCookieNode(node); | |
| 532 } | |
| 533 } | |
| 534 | |
| 535 void CollectedCookiesGtk::OnAllowBlockedButtonClicked(GtkWidget* button) { | |
| 536 AddExceptions(blocked_selection_, blocked_cookies_tree_adapter_.get(), | |
| 537 CONTENT_SETTING_ALLOW); | |
| 538 } | |
| 539 | |
| 540 void CollectedCookiesGtk::OnForSessionBlockedButtonClicked(GtkWidget* button) { | |
| 541 AddExceptions(blocked_selection_, blocked_cookies_tree_adapter_.get(), | |
| 542 CONTENT_SETTING_SESSION_ONLY); | |
| 543 } | |
| 544 | |
| 545 void CollectedCookiesGtk::OnSwitchPage(GtkWidget* notebook, | |
| 546 gpointer page, | |
| 547 guint page_num) { | |
| 548 EnableControls(); | |
| 549 ShowCookieInfo(page_num); | |
| 550 } | |
| 551 | |
| 552 void CollectedCookiesGtk::OnTreeViewRowExpanded(GtkWidget* tree_view, | |
| 553 GtkTreeIter* iter, | |
| 554 GtkTreePath* path) { | |
| 555 // When a row in the tree is expanded, expand all the children too. | |
| 556 g_signal_handlers_block_by_func( | |
| 557 tree_view, reinterpret_cast<gpointer>(OnTreeViewRowExpandedThunk), this); | |
| 558 gtk_tree_view_expand_row(GTK_TREE_VIEW(tree_view), path, TRUE); | |
| 559 g_signal_handlers_unblock_by_func( | |
| 560 tree_view, reinterpret_cast<gpointer>(OnTreeViewRowExpandedThunk), this); | |
| 561 } | |
| 562 | |
| 563 void CollectedCookiesGtk::OnTreeViewSelectionChange(GtkWidget* selection) { | |
| 564 EnableControls(); | |
| 565 ShowCookieInfo(gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook_))); | |
| 566 } | |
| 567 | |
| 568 void CollectedCookiesGtk::OnDestroy(GtkWidget* widget) { | |
| 569 delete this; | |
| 570 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 231733005:
Delete the GTK+ port of Chrome. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src