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.
GetInfobarLabel(ContentSetting setting,bool multiple_domains_added,const base::string16 & domain_name)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.
ShowCollectedCookiesDialog(content::WebContents * web_contents)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
CollectedCookiesGtk(GtkWindow * parent,content::WebContents * web_contents)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
Init()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
CreateAllowedPane()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 // Wrap the vbox inside an hbox so that we can specify padding along the
270 // horizontal axis.
271 GtkWidget* box = gtk_hbox_new(FALSE, 0);
272 gtk_box_pack_start(GTK_BOX(box), cookie_list_vbox, TRUE, TRUE,
273 ui::kControlSpacing);
274 return box;
275 }
276
CreateBlockedPane()277 GtkWidget* CollectedCookiesGtk::CreateBlockedPane() {
278 PrefService* prefs = Profile::FromBrowserContext(
279 web_contents_->GetBrowserContext())->GetPrefs();
280
281 GtkWidget* cookie_list_vbox = gtk_vbox_new(FALSE, ui::kControlSpacing);
282
283 GtkWidget* label = gtk_label_new(
284 l10n_util::GetStringUTF8(
285 prefs->GetBoolean(prefs::kBlockThirdPartyCookies) ?
286 IDS_COLLECTED_COOKIES_BLOCKED_THIRD_PARTY_BLOCKING_ENABLED :
287 IDS_COLLECTED_COOKIES_BLOCKED_COOKIES_LABEL).c_str());
288 gtk_widget_set_size_request(label, kTreeViewWidth, -1);
289 gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
290 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
291 gtk_box_pack_start(GTK_BOX(cookie_list_vbox), label, TRUE, TRUE,
292 ui::kControlSpacing);
293
294 GtkWidget* scroll_window = gtk_scrolled_window_new(NULL, NULL);
295 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window),
296 GTK_POLICY_AUTOMATIC,
297 GTK_POLICY_AUTOMATIC);
298 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll_window),
299 GTK_SHADOW_ETCHED_IN);
300 gtk_box_pack_start(GTK_BOX(cookie_list_vbox), scroll_window, TRUE, TRUE, 0);
301
302 TabSpecificContentSettings* content_settings =
303 TabSpecificContentSettings::FromWebContents(web_contents_);
304
305 const LocalSharedObjectsContainer& blocked_data =
306 content_settings->blocked_local_shared_objects();
307 blocked_cookies_tree_model_ = blocked_data.CreateCookiesTreeModel();
308
309 blocked_cookies_tree_adapter_.reset(
310 new gtk_tree::TreeAdapter(this, blocked_cookies_tree_model_.get()));
311 blocked_tree_ = gtk_tree_view_new_with_model(
312 GTK_TREE_MODEL(blocked_cookies_tree_adapter_->tree_store()));
313 gtk_widget_set_size_request(blocked_tree_, kTreeViewWidth, kTreeViewHeight);
314 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(blocked_tree_), FALSE);
315 gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(blocked_tree_), TRUE);
316 gtk_container_add(GTK_CONTAINER(scroll_window), blocked_tree_);
317
318 GtkTreeViewColumn* title_column = gtk_tree_view_column_new();
319 GtkCellRenderer* pixbuf_renderer = gtk_cell_renderer_pixbuf_new();
320 gtk_tree_view_column_pack_start(title_column, pixbuf_renderer, FALSE);
321 gtk_tree_view_column_add_attribute(title_column, pixbuf_renderer, "pixbuf",
322 gtk_tree::TreeAdapter::COL_ICON);
323 GtkCellRenderer* title_renderer = gtk_cell_renderer_text_new();
324 gtk_tree_view_column_pack_start(title_column, title_renderer, TRUE);
325 gtk_tree_view_column_add_attribute(title_column, title_renderer, "text",
326 gtk_tree::TreeAdapter::COL_TITLE);
327 gtk_tree_view_column_set_title(
328 title_column, l10n_util::GetStringUTF8(
329 IDS_COOKIES_DOMAIN_COLUMN_HEADER).c_str());
330 gtk_tree_view_append_column(GTK_TREE_VIEW(blocked_tree_), title_column);
331 g_signal_connect(blocked_tree_, "row-expanded",
332 G_CALLBACK(OnTreeViewRowExpandedThunk), this);
333 blocked_selection_ =
334 gtk_tree_view_get_selection(GTK_TREE_VIEW(blocked_tree_));
335 gtk_tree_selection_set_mode(blocked_selection_, GTK_SELECTION_MULTIPLE);
336 g_signal_connect(blocked_selection_, "changed",
337 G_CALLBACK(OnTreeViewSelectionChangeThunk), this);
338
339 GtkWidget* button_box = gtk_hbutton_box_new();
340 gtk_button_box_set_layout(GTK_BUTTON_BOX(button_box), GTK_BUTTONBOX_START);
341 gtk_box_set_spacing(GTK_BOX(button_box), ui::kControlSpacing);
342 gtk_box_pack_start(GTK_BOX(cookie_list_vbox), button_box, FALSE, FALSE,
343 ui::kControlSpacing);
344 allow_blocked_cookie_button_ = gtk_button_new_with_label(
345 l10n_util::GetStringUTF8(IDS_COLLECTED_COOKIES_ALLOW_BUTTON).c_str());
346 g_signal_connect(allow_blocked_cookie_button_, "clicked",
347 G_CALLBACK(OnAllowBlockedButtonClickedThunk), this);
348 gtk_container_add(GTK_CONTAINER(button_box), allow_blocked_cookie_button_);
349 for_session_blocked_cookie_button_ = gtk_button_new_with_label(
350 l10n_util::GetStringUTF8(IDS_COLLECTED_COOKIES_SESSION_ONLY_BUTTON).
351 c_str());
352 g_signal_connect(for_session_blocked_cookie_button_, "clicked",
353 G_CALLBACK(OnForSessionBlockedButtonClickedThunk), this);
354 gtk_container_add(GTK_CONTAINER(button_box),
355 for_session_blocked_cookie_button_);
356
357 // Wrap the vbox inside an hbox so that we can specify padding along the
358 // horizontal axis.
359 GtkWidget* box = gtk_hbox_new(FALSE, 0);
360 gtk_box_pack_start(GTK_BOX(box), cookie_list_vbox, TRUE, TRUE,
361 ui::kControlSpacing);
362 return box;
363 }
364
ShowCookieInfo(gint current_page)365 void CollectedCookiesGtk::ShowCookieInfo(gint current_page) {
366 if (current_page == kAllowedPageNumber) {
367 ShowSelectionInfo(allowed_selection_, allowed_cookies_tree_adapter_.get());
368 } else if (current_page == kBlockedPageNumber) {
369 ShowSelectionInfo(blocked_selection_, blocked_cookies_tree_adapter_.get());
370 }
371 }
372
ShowSelectionInfo(GtkTreeSelection * selection,gtk_tree::TreeAdapter * adapter)373 void CollectedCookiesGtk::ShowSelectionInfo(GtkTreeSelection* selection,
374 gtk_tree::TreeAdapter* adapter) {
375 // Check if one "cookie" node is selected. Don't allow more than one.
376 GtkTreeModel* model;
377 GList* paths = gtk_tree_selection_get_selected_rows(selection, &model);
378 if (g_list_length(paths) == 1) {
379 GList* item = g_list_first(paths);
380 GtkTreeIter iter;
381 gtk_tree_model_get_iter(model, &iter,
382 reinterpret_cast<GtkTreePath*>(item->data));
383 CookieTreeNode* node =
384 static_cast<CookieTreeNode*>(adapter->GetNode(&iter));
385 const CookieTreeNode::DetailedInfo detailed_info = node->GetDetailedInfo();
386 if (detailed_info.node_type == CookieTreeNode::DetailedInfo::TYPE_COOKIE) {
387 gtk_chrome_cookie_view_display_cookie(
388 GTK_CHROME_COOKIE_VIEW(cookie_info_view_),
389 detailed_info.cookie->Domain(),
390 *detailed_info.cookie);
391 } else {
392 gtk_chrome_cookie_view_clear(GTK_CHROME_COOKIE_VIEW(cookie_info_view_));
393 }
394 } else {
395 gtk_chrome_cookie_view_clear(GTK_CHROME_COOKIE_VIEW(cookie_info_view_));
396 }
397
398 g_list_foreach(paths, reinterpret_cast<GFunc>(gtk_tree_path_free), NULL);
399 g_list_free(paths);
400 }
401
~CollectedCookiesGtk()402 CollectedCookiesGtk::~CollectedCookiesGtk() {
403 gtk_widget_destroy(dialog_);
404 }
405
SelectionContainsHostNode(GtkTreeSelection * selection,gtk_tree::TreeAdapter * adapter)406 bool CollectedCookiesGtk::SelectionContainsHostNode(
407 GtkTreeSelection* selection, gtk_tree::TreeAdapter* adapter) {
408 // Check whether at least one "origin" node is selected.
409 GtkTreeModel* model;
410 GList* paths =
411 gtk_tree_selection_get_selected_rows(selection, &model);
412 bool contains_host_node = false;
413 for (GList* item = paths; item; item = item->next) {
414 GtkTreeIter iter;
415 gtk_tree_model_get_iter(
416 model, &iter, reinterpret_cast<GtkTreePath*>(item->data));
417 CookieTreeNode* node =
418 static_cast<CookieTreeNode*>(adapter->GetNode(&iter));
419 if (node->GetDetailedInfo().node_type !=
420 CookieTreeNode::DetailedInfo::TYPE_HOST)
421 continue;
422 CookieTreeHostNode* host_node = static_cast<CookieTreeHostNode*>(
423 node);
424 if (!host_node->CanCreateContentException())
425 continue;
426 contains_host_node = true;
427 }
428 g_list_foreach(paths, reinterpret_cast<GFunc>(gtk_tree_path_free), NULL);
429 g_list_free(paths);
430 return contains_host_node;
431 }
432
EnableControls()433 void CollectedCookiesGtk::EnableControls() {
434 // Update button states.
435 bool enable_for_allowed_cookies =
436 SelectionContainsHostNode(allowed_selection_,
437 allowed_cookies_tree_adapter_.get());
438 gtk_widget_set_sensitive(block_allowed_cookie_button_,
439 enable_for_allowed_cookies);
440
441 bool enable_for_blocked_cookies =
442 SelectionContainsHostNode(blocked_selection_,
443 blocked_cookies_tree_adapter_.get());
444 gtk_widget_set_sensitive(allow_blocked_cookie_button_,
445 enable_for_blocked_cookies);
446 gtk_widget_set_sensitive(for_session_blocked_cookie_button_,
447 enable_for_blocked_cookies);
448 }
449
Observe(int type,const content::NotificationSource & source,const content::NotificationDetails & details)450 void CollectedCookiesGtk::Observe(int type,
451 const content::NotificationSource& source,
452 const content::NotificationDetails& details) {
453 DCHECK(type == chrome::NOTIFICATION_COLLECTED_COOKIES_SHOWN);
454 gtk_widget_destroy(window_);
455 }
456
OnClose(GtkWidget * close_button)457 void CollectedCookiesGtk::OnClose(GtkWidget* close_button) {
458 if (status_changed_) {
459 CollectedCookiesInfoBarDelegate::Create(
460 InfoBarService::FromWebContents(web_contents_));
461 }
462 gtk_widget_destroy(window_);
463 }
464
AddExceptions(GtkTreeSelection * selection,gtk_tree::TreeAdapter * adapter,ContentSetting setting)465 void CollectedCookiesGtk::AddExceptions(GtkTreeSelection* selection,
466 gtk_tree::TreeAdapter* adapter,
467 ContentSetting setting) {
468 GtkTreeModel* model;
469 GList* paths =
470 gtk_tree_selection_get_selected_rows(selection, &model);
471 base::string16 last_domain_name;
472 bool multiple_domains_added = false;
473 for (GList* item = paths; item; item = item->next) {
474 GtkTreeIter iter;
475 gtk_tree_model_get_iter(
476 model, &iter, reinterpret_cast<GtkTreePath*>(item->data));
477 CookieTreeNode* node =
478 static_cast<CookieTreeNode*>(adapter->GetNode(&iter));
479 if (node->GetDetailedInfo().node_type !=
480 CookieTreeNode::DetailedInfo::TYPE_HOST)
481 continue;
482 CookieTreeHostNode* host_node = static_cast<CookieTreeHostNode*>(
483 node);
484 if (host_node->CanCreateContentException()) {
485 if (!last_domain_name.empty())
486 multiple_domains_added = true;
487 last_domain_name = host_node->GetTitle();
488 Profile* profile =
489 Profile::FromBrowserContext(web_contents_->GetBrowserContext());
490 host_node->CreateContentException(
491 CookieSettings::Factory::GetForProfile(profile).get(), setting);
492 }
493 }
494 g_list_foreach(paths, reinterpret_cast<GFunc>(gtk_tree_path_free), NULL);
495 g_list_free(paths);
496 if (last_domain_name.empty()) {
497 gtk_widget_hide(infobar_);
498 } else {
499 gtk_label_set_text(
500 GTK_LABEL(infobar_label_), GetInfobarLabel(
501 setting, multiple_domains_added, last_domain_name).c_str());
502 gtk_widget_show(infobar_);
503 }
504 status_changed_ = true;
505 }
506
OnBlockAllowedButtonClicked(GtkWidget * button)507 void CollectedCookiesGtk::OnBlockAllowedButtonClicked(GtkWidget* button) {
508 AddExceptions(allowed_selection_, allowed_cookies_tree_adapter_.get(),
509 CONTENT_SETTING_BLOCK);
510 }
511
OnAllowBlockedButtonClicked(GtkWidget * button)512 void CollectedCookiesGtk::OnAllowBlockedButtonClicked(GtkWidget* button) {
513 AddExceptions(blocked_selection_, blocked_cookies_tree_adapter_.get(),
514 CONTENT_SETTING_ALLOW);
515 }
516
OnForSessionBlockedButtonClicked(GtkWidget * button)517 void CollectedCookiesGtk::OnForSessionBlockedButtonClicked(GtkWidget* button) {
518 AddExceptions(blocked_selection_, blocked_cookies_tree_adapter_.get(),
519 CONTENT_SETTING_SESSION_ONLY);
520 }
521
OnSwitchPage(GtkWidget * notebook,gpointer page,guint page_num)522 void CollectedCookiesGtk::OnSwitchPage(GtkWidget* notebook,
523 gpointer page,
524 guint page_num) {
525 EnableControls();
526 ShowCookieInfo(page_num);
527 }
528
OnTreeViewRowExpanded(GtkWidget * tree_view,GtkTreeIter * iter,GtkTreePath * path)529 void CollectedCookiesGtk::OnTreeViewRowExpanded(GtkWidget* tree_view,
530 GtkTreeIter* iter,
531 GtkTreePath* path) {
532 // When a row in the tree is expanded, expand all the children too.
533 g_signal_handlers_block_by_func(
534 tree_view, reinterpret_cast<gpointer>(OnTreeViewRowExpandedThunk), this);
535 gtk_tree_view_expand_row(GTK_TREE_VIEW(tree_view), path, TRUE);
536 g_signal_handlers_unblock_by_func(
537 tree_view, reinterpret_cast<gpointer>(OnTreeViewRowExpandedThunk), this);
538 }
539
OnTreeViewSelectionChange(GtkWidget * selection)540 void CollectedCookiesGtk::OnTreeViewSelectionChange(GtkWidget* selection) {
541 EnableControls();
542 ShowCookieInfo(gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook_)));
543 }
544
OnDestroy(GtkWidget * widget)545 void CollectedCookiesGtk::OnDestroy(GtkWidget* widget) {
546 delete this;
547 }
548