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

chrome/browser/resources/options2/cookies_list.js

 // 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.
 
 cr.define('options', function() {
   /** @const */ var DeletableItemList = options.DeletableItemList;
   /** @const */ var DeletableItem = options.DeletableItem;
   /** @const */ var ArrayDataModel = cr.ui.ArrayDataModel;
   /** @const */ var ListSingleSelectionModel = cr.ui.ListSingleSelectionModel;
 
@@ skipping 59 matching lines @@
     var nodes = data.map(function(x) { return new CookieTreeNode(x); });
     // Insert [start, 0] at the beginning of the array of nodes, making it
     // into the arguments we want to pass to @{code list.splice} below.
     nodes.splice(0, 0, start, 0);
     list.splice.apply(list, nodes);
     // Remove the [start, 0] prefix and return the array of nodes.
     nodes.splice(0, 2);
     return nodes;
   }
 
+  /**
+   * Adds information about an app that protects this data item to the
+   * @{code element}.
+   * @param {Element} element The DOM element the information should be
+         appended to.
+   * @param {{id: string, name: string}} appInfo Information about an app.
+   */
+  function addAppInfo(element, appInfo) {
+    var img = element.ownerDocument.createElement('img');
+    img.src = 'chrome://extension-icon/' + appInfo.id + '/16/1';
+    img.title = loadTimeData.getString('label_protected_by_apps') +
+                ' ' + appInfo.name;
+    img.className = 'protecting-app';
+    element.appendChild(img);
+  }
+
   var parentLookup = {};
   var lookupRequests = {};
 
   /**
    * Creates a new list item for sites data. Note that these are created and
    * destroyed lazily as they scroll into and out of view, so they must be
    * stateless. We cache the expanded item in @{code CookiesList} though, so it
    * can keep state. (Mostly just which item is selected.)
    * @param {Object} origin Data used to create a cookie list item.
    * @param {CookiesList} list The list that will contain this item.
@@ skipping 142 matching lines @@
         cookies: 0,
         database: false,
         localStorage: false,
         appCache: false,
         indexedDb: false,
         fileSystem: false,
         serverBoundCerts: 0,
       };
       if (this.origin)
         this.origin.collectSummaryInfo(info);
+
       var list = [];
       if (info.cookies > 1)
         list.push(loadTimeData.getStringF('cookie_plural', info.cookies));
       else if (info.cookies > 0)
         list.push(loadTimeData.getString('cookie_singular'));
       if (info.database || info.indexedDb)
         list.push(loadTimeData.getString('cookie_database_storage'));
       if (info.localStorage)
         list.push(loadTimeData.getString('cookie_local_storage'));
       if (info.appCache)
         list.push(loadTimeData.getString('cookie_app_cache'));
       if (info.fileSystem)
         list.push(loadTimeData.getString('cookie_file_system'));
       if (info.serverBoundCerts)
         list.push(loadTimeData.getString('cookie_server_bound_cert'));
+
       var text = '';
-      for (var i = 0; i < list.length; ++i)
+      for (var i = 0; i < list.length; ++i) {
         if (text.length > 0)
           text += ', ' + list[i];
         else
           text = list[i];
+      }
       this.dataChild.textContent = text;
-      if (info.quota && info.quota.totalUsage) {
+
+      for (var key in info.appsProtectingThis) {
+        addAppInfo(this.dataChild, apps[key]);
+      }
+
+      if (info.quota && info.quota.totalUsage)
         this.sizeChild.textContent = info.quota.totalUsage;
-      }
 
       if (this.expanded)
         this.updateItems_();
     },
 
     /**
      * Updates the items section to reflect changes, animating to the new state.
      * Removes existing contents and calls @{code CookieTreeNode.createItems}.
      * @private
      */
@@ skipping 178 matching lines @@
           info.appCache = true;
         } else if (this.data.type == 'indexed_db') {
           info.indexedDb = true;
         } else if (this.data.type == 'file_system') {
           info.fileSystem = true;
         } else if (this.data.type == 'quota') {
           info.quota = this.data;
         } else if (this.data.type == 'server_bound_cert') {
           info.serverBoundCerts++;
         }
+
+        var apps = this.data.appsProtectingThis;
+        if (apps) {
+          if (!info.appsProtectingThis)
+            info.appsProtectingThis = {};
+          apps.forEach(function(appInfo) {
+            info.appsProtectingThis[appInfo.id] = appInfo;
+          });
+        }
       }
     },
 
     /**
      * Create the cookie "bubbles" for this node, recursing into children
      * if there are any. Append the cookie bubbles to @{code item}.
      * @param {CookieListItem} item The cookie list item to create items in.
      */
     createItems: function(item) {
       if (this.children.length > 0) {
         for (var i = 0; i < this.children.length; ++i)
           this.children[i].createItems(item);
-      } else if (this.data && !this.data.hasChildren) {
-        var text = '';
-        switch (this.data.type) {
-          case 'cookie':
-          case 'database':
-            text = this.data.name;
-            break;
-          case 'local_storage':
-            text = loadTimeData.getString('cookie_local_storage');
-            break;
-          case 'app_cache':
-            text = loadTimeData.getString('cookie_app_cache');
-            break;
-          case 'indexed_db':
-            text = loadTimeData.getString('cookie_indexed_db');
-            break;
-          case 'file_system':
-            text = loadTimeData.getString('cookie_file_system');
-            break;
-          case 'server_bound_cert':
-            text = loadTimeData.getString('cookie_server_bound_cert');
-            break;
-        }
-        if (!text)
-          return;
-        var div = item.ownerDocument.createElement('div');
-        div.className = 'cookie-item';
-        // Help out screen readers and such: this is a clickable thing.
-        div.setAttribute('role', 'button');
-        div.textContent = text;
-        var index = item.appendItem(this, div);
-        div.onclick = function() {
-          if (item.selectedIndex == index)
-            item.selectedIndex = -1;
-          else
-            item.selectedIndex = index;
-        };
+        return;
       }
+
+      if (!this.data || this.data.hasChildren)
+        return;
+
+      var text = '';
+      switch (this.data.type) {
+        case 'cookie':
+        case 'database':
+          text = this.data.name;
+          break;
+        default:
+          text = loadTimeData.getString('cookie_' + this.data.type);
+      }
+      if (!text)
+        return;
+
+      var div = item.ownerDocument.createElement('div');
+      div.className = 'cookie-item';
+      // Help out screen readers and such: this is a clickable thing.
+      div.setAttribute('role', 'button');
+      div.tabIndex = 0;
+      div.textContent = text;
+      var apps = this.data.appsProtectingThis;
+      if (apps)
+        apps.forEach(addAppInfo.bind(null, div));
+
+      var index = item.appendItem(this, div);
+      div.onclick = function() {
+        item.selectedIndex = (item.selectedIndex == index) ? -1 : index;
+      };
     },
 
     /**
      * Set the detail text to be displayed to that of this cookie tree node.
      * Uses preallocated DOM elements for each cookie node type from @{code
      * infoNodes}, and inserts the appropriate elements to @{code element}.
      * @param {Element} element The DOM element to insert elements to.
      * @param {Object.<string, {table: Element, info: Object.<string,
      *     Element>}>} infoNodes The map from cookie node types to maps from
      *     cookie attribute names to DOM elements to display cookie attribute
      *     values, created by @{code CookiesList.decorate}.
      */
     setDetailText: function(element, infoNodes) {
       var table;
-      if (this.data && !this.data.hasChildren) {
-        if (cookieInfo[this.data.type]) {
-          var info = cookieInfo[this.data.type];
-          var nodes = infoNodes[this.data.type].info;
-          for (var i = 0; i < info.length; ++i) {
-            var name = info[i][0];
-            if (name != 'id' && this.data[name])
-              nodes[name].textContent = this.data[name];
-            else
-              nodes[name].textContent = '';
-          }
-          table = infoNodes[this.data.type].table;
+      if (this.data && !this.data.hasChildren && cookieInfo[this.data.type]) {
+        var info = cookieInfo[this.data.type];
+        var nodes = infoNodes[this.data.type].info;
+        for (var i = 0; i < info.length; ++i) {
+          var name = info[i][0];
+          if (name != 'id' && this.data[name])
+            nodes[name].textContent = this.data[name];
+          else
+            nodes[name].textContent = '';
         }
+        table = infoNodes[this.data.type].table;
       }
+
       while (element.childNodes.length > 1)
         element.removeChild(element.firstChild);
+
       if (table)
         element.insertBefore(table, element.firstChild);
     },
 
     /**
      * The parent of this cookie tree node.
      * @type {?CookieTreeNode|CookieListItem}
      */
     get parent() {
       // See below for an explanation of this special case.
       if (typeof this.parent_ == 'number')
         return this.list_.getListItemByIndex(this.parent_);
       return this.parent_;
     },
     set parent(parent) {
       if (parent == this.parent)
         return;
+
       if (parent instanceof CookieListItem) {
         // If the parent is to be a CookieListItem, then we keep the reference
         // to it by its containing list and list index, rather than directly.
         // This allows the list items to be garbage collected when they scroll
         // out of view (except the expanded item, which we cache). This is
         // transparent except in the setter and getter, where we handle it.
         this.parent_ = parent.listIndex;
         this.list_ = parent.list;
         parent.addEventListener('listIndexChange',
                                 this.parentIndexChanged_.bind(this));
       } else {
         this.parent_ = parent;
       }
+
       if (this.data && this.data.id) {
         if (parent)
           parentLookup[this.data.id] = this;
         else
           delete parentLookup[this.data.id];
       }
+
       if (this.data && this.data.hasChildren &&
           !this.children.length && !lookupRequests[this.data.id]) {
         lookupRequests[this.data.id] = true;
         chrome.send('loadCookie', [this.pathId]);
       }
     },
 
     /**
      * Called when the parent is a CookieListItem whose index has changed.
      * See the code above that avoids keeping a direct reference to
@@ skipping 269 matching lines @@
       parent.clear();
       this.addByParent_(parent, 0, children);
       parent.endBatchUpdates();
     },
   };
 
   return {
     CookiesList: CookiesList
   };
 });