Show apps protecting local data in chrome://settings/cookies.

chrome/browser/ui/gtk/collected_cookies_gtk.cc

 // 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/collected_cookies_gtk.h"
 
 #include <string>
 #include "chrome/browser/browsing_data_appcache_helper.h"
 #include "chrome/browser/browsing_data_cookie_helper.h"
 #include "chrome/browser/browsing_data_database_helper.h"
@@ skipping 205 matching lines @@
   allowed_cookies_tree_model_.reset(
       new CookiesTreeModel(allowed_lsos.cookies()->Clone(),
                            allowed_lsos.databases()->Clone(),
                            allowed_lsos.local_storages()->Clone(),
                            allowed_lsos.session_storages()->Clone(),
                            allowed_lsos.appcaches()->Clone(),
                            allowed_lsos.indexed_dbs()->Clone(),
                            allowed_lsos.file_systems()->Clone(),
                            NULL,
                            allowed_lsos.server_bound_certs()->Clone(),
+                           NULL,
                            true));
   allowed_cookies_tree_adapter_.reset(
       new gtk_tree::TreeAdapter(this, allowed_cookies_tree_model_.get()));
   allowed_tree_ = gtk_tree_view_new_with_model(
       GTK_TREE_MODEL(allowed_cookies_tree_adapter_->tree_store()));
   gtk_widget_set_size_request(allowed_tree_, kTreeViewWidth, kTreeViewHeight);
   gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(allowed_tree_), FALSE);
   gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(allowed_tree_), TRUE);
   gtk_container_add(GTK_CONTAINER(scroll_window), allowed_tree_);
 
@@ skipping 69 matching lines @@
   blocked_cookies_tree_model_.reset(
       new CookiesTreeModel(blocked_lsos.cookies()->Clone(),
                            blocked_lsos.databases()->Clone(),
                            blocked_lsos.local_storages()->Clone(),
                            blocked_lsos.session_storages()->Clone(),
                            blocked_lsos.appcaches()->Clone(),
                            blocked_lsos.indexed_dbs()->Clone(),
                            blocked_lsos.file_systems()->Clone(),
                            NULL,
                            blocked_lsos.server_bound_certs()->Clone(),
+                           NULL,
                            true));
   blocked_cookies_tree_adapter_.reset(
       new gtk_tree::TreeAdapter(this, blocked_cookies_tree_model_.get()));
   blocked_tree_ = gtk_tree_view_new_with_model(
       GTK_TREE_MODEL(blocked_cookies_tree_adapter_->tree_store()));
   gtk_widget_set_size_request(blocked_tree_, kTreeViewWidth, kTreeViewHeight);
   gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(blocked_tree_), FALSE);
   gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(blocked_tree_), TRUE);
   gtk_container_add(GTK_CONTAINER(scroll_window), blocked_tree_);
 
@@ skipping 90 matching lines @@
 }
 
 GtkWidget* CollectedCookiesGtk::GetFocusWidget() {
   return close_button_;
 }
 
 void CollectedCookiesGtk::DeleteDelegate() {
   delete this;
 }
 
-bool CollectedCookiesGtk::SelectionContainsOriginNode(
+bool CollectedCookiesGtk::SelectionContainsHostNode(
     GtkTreeSelection* selection, gtk_tree::TreeAdapter* adapter) {
   // Check whether at least one "origin" node is selected.
   GtkTreeModel* model;
   GList* paths =
       gtk_tree_selection_get_selected_rows(selection, &model);
-  bool contains_origin_node = false;
+  bool contains_host_node = false;
   for (GList* item = paths; item; item = item->next) {
     GtkTreeIter iter;
     gtk_tree_model_get_iter(
         model, &iter, reinterpret_cast<GtkTreePath*>(item->data));
     CookieTreeNode* node =
         static_cast<CookieTreeNode*>(adapter->GetNode(&iter));
     if (node->GetDetailedInfo().node_type !=
-        CookieTreeNode::DetailedInfo::TYPE_ORIGIN)
+        CookieTreeNode::DetailedInfo::TYPE_HOST)
       continue;
-    CookieTreeOriginNode* origin_node = static_cast<CookieTreeOriginNode*>(
+    CookieTreeHostNode* host_node = static_cast<CookieTreeHostNode*>(
         node);
-    if (!origin_node->CanCreateContentException())
+    if (!host_node->CanCreateContentException())
       continue;
-    contains_origin_node = true;
+    contains_host_node = true;
   }
   g_list_foreach(paths, reinterpret_cast<GFunc>(gtk_tree_path_free), NULL);
   g_list_free(paths);
-  return contains_origin_node;
+  return contains_host_node;
 }
 
 void CollectedCookiesGtk::EnableControls() {
   // Update button states.
   bool enable_for_allowed_cookies =
-      SelectionContainsOriginNode(allowed_selection_,
+      SelectionContainsHostNode(allowed_selection_,
                                   allowed_cookies_tree_adapter_.get());
   gtk_widget_set_sensitive(block_allowed_cookie_button_,
                            enable_for_allowed_cookies);
 
   bool enable_for_blocked_cookies =
-      SelectionContainsOriginNode(blocked_selection_,
+      SelectionContainsHostNode(blocked_selection_,
                                   blocked_cookies_tree_adapter_.get());
   gtk_widget_set_sensitive(allow_blocked_cookie_button_,
                            enable_for_blocked_cookies);
   gtk_widget_set_sensitive(for_session_blocked_cookie_button_,
                            enable_for_blocked_cookies);
 }
 
 void CollectedCookiesGtk::Observe(int type,
                                   const content::NotificationSource& source,
                                   const content::NotificationDetails& details) {
@@ skipping 18 matching lines @@
       gtk_tree_selection_get_selected_rows(selection, &model);
   string16 last_domain_name;
   bool multiple_domains_added = false;
   for (GList* item = paths; item; item = item->next) {
     GtkTreeIter iter;
     gtk_tree_model_get_iter(
         model, &iter, reinterpret_cast<GtkTreePath*>(item->data));
     CookieTreeNode* node =
         static_cast<CookieTreeNode*>(adapter->GetNode(&iter));
     if (node->GetDetailedInfo().node_type !=
-        CookieTreeNode::DetailedInfo::TYPE_ORIGIN)
+        CookieTreeNode::DetailedInfo::TYPE_HOST)
       continue;
-    CookieTreeOriginNode* origin_node = static_cast<CookieTreeOriginNode*>(
+    CookieTreeHostNode* host_node = static_cast<CookieTreeHostNode*>(
         node);
-    if (origin_node->CanCreateContentException()) {
+    if (host_node->CanCreateContentException()) {
       if (!last_domain_name.empty())
         multiple_domains_added = true;
-      last_domain_name = origin_node->GetTitle();
+      last_domain_name = host_node->GetTitle();
       Profile* profile = tab_contents_->profile();
-      origin_node->CreateContentException(
+      host_node->CreateContentException(
           CookieSettings::Factory::GetForProfile(profile), setting);
     }
   }
   g_list_foreach(paths, reinterpret_cast<GFunc>(gtk_tree_path_free), NULL);
   g_list_free(paths);
   if (last_domain_name.empty()) {
     gtk_widget_hide(infobar_);
   } else {
     gtk_label_set_text(
         GTK_LABEL(infobar_label_), GetInfobarLabel(
@@ skipping 33 matching lines @@
       tree_view, reinterpret_cast<gpointer>(OnTreeViewRowExpandedThunk), this);
   gtk_tree_view_expand_row(GTK_TREE_VIEW(tree_view), path, TRUE);
   g_signal_handlers_unblock_by_func(
       tree_view, reinterpret_cast<gpointer>(OnTreeViewRowExpandedThunk), this);
 }
 
 void CollectedCookiesGtk::OnTreeViewSelectionChange(GtkWidget* selection) {
   EnableControls();
   ShowCookieInfo(gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook_)));
 }