Site Settings Desktop: Support adding exceptions for incognito mode.

chrome/browser/resources/settings/site_settings/site_list.js

 // Copyright 2015 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.
 
 /**
  * @fileoverview
  * 'site-list' shows a list of Allowed and Blocked sites for a given
  * category.
  */
 Polymer({
@@ skipping 59 matching lines @@
      */
     showBlockAction_: Boolean,
 
     /**
      * Whether to show the 'Clear on exit' action in the action
      * menu.
      */
     showSessionOnlyAction_: Boolean,
 
     /**
+     * Keeps track of the incognito status of the current profile (whether one
+     * exists).
+     */
+    incognitoProfileActive_: {
+      type: Boolean,
+      value: false,
+    },
+
+    /**
      * All possible actions in the action menu.
      */
     actions_: {
       readOnly: true,
       type: Object,
       values: {
         ALLOW: 'Allow',
         BLOCK: 'Block',
         RESET: 'Reset',
         SESSION_ONLY: 'SessionOnly',
       }
     },
   },
 
   observers: [
     'configureWidget_(category, categorySubtype, categoryEnabled, allSites)'
   ],
 
   ready: function() {
     this.addWebUIListener('contentSettingSitePermissionChanged',
         this.siteWithinCategoryChanged_.bind(this));
+    this.addWebUIListener('onIncognitoStatusChanged',
+        this.onIncognitoStatusChanged_.bind(this));
   },
 
   /**
    * Called when a site changes permission.
    * @param {string} category The category of the site that changed.
    * @param {string} site The site that changed.
    * @private
    */
   siteWithinCategoryChanged_: function(category, site) {
     if (category == this.category)
       this.configureWidget_();
   },
 
+  onIncognitoStatusChanged_: function(incognitoEnabled) {
+    // A change notification is not sent for each site that is deleted during
+    // incognito profile destruction. Therefore, we reconfigure the list when
+    // the incognito profile is destroyed, except for SESSION_ONLY, which won't
+    // have any incognito exceptions.
+    if (this.categorySubtype == settings.PermissionValues.SESSION_ONLY)
+      return;
+
+    if (this.incognitoProfileActive_)
+      this.configureWidget_();  // The incognito profile is being destroyed.
+
+    this.incognitoProfileActive_ = incognitoEnabled;
+  },
+
   /**
    * Configures the action menu, visibility of the widget and shows the list.
    * @private
    */
   configureWidget_: function() {
     // The observer for All Sites fires before the attached/ready event, so
     // initialize this here.
     if (this.browserProxy_ === undefined) {
       this.browserProxy_ =
           settings.SiteSettingsPrefsBrowserProxyImpl.getInstance();
@@ skipping 210 matching lines @@
             var host1 = self.toUrl_(a.embeddingOrigin);
             var host2 = self.toUrl_(b.embeddingOrigin);
             host1 = (host1 == null) ? '' : host1.host;
             host2 = (host2 == null) ? '' : host2.host;
             return host1.localeCompare(host2);
           }
         }
       }
       return comparison;
     });
-    var results = [];
+    var results = /** @type {!Array<SiteException>} */ [];
     var lastOrigin = '';
     var lastEmbeddingOrigin = '';
     for (var i = 0; i < sites.length; ++i) {
       var origin = sites[i].origin;
       var originForDisplay = this.sanitizePort(origin.replace('[*.]', ''));
 
       var embeddingOrigin = sites[i].embeddingOrigin;
       var embeddingOriginForDisplay = '';
       if (origin != embeddingOrigin) {
         embeddingOriginForDisplay =
             this.getEmbedderString(embeddingOrigin, this.category);
       }
 
       // The All Sites category can contain duplicates (from other categories).
       if (originForDisplay == lastOrigin &&
           embeddingOriginForDisplay == lastEmbeddingOrigin) {
         continue;
       }
 
       results.push({
          origin: origin,
          originForDisplay: originForDisplay,
          embeddingOrigin: embeddingOrigin,
          embeddingOriginForDisplay: embeddingOriginForDisplay,
+         incognito: sites[i].incognito,
          source: sites[i].source,
       });
 
       lastOrigin = originForDisplay;
       lastEmbeddingOrigin = embeddingOriginForDisplay;
     }
     return results;
   },
 
   /**
    * Setup the values to use for the action menu.
    * @private
    */
   setUpActionMenu_: function() {
     this.showAllowAction_ =
         this.categorySubtype != settings.PermissionValues.ALLOW;
     this.showBlockAction_ =
         this.categorySubtype != settings.PermissionValues.BLOCK;
     this.showSessionOnlyAction_ =
         this.categorySubtype != settings.PermissionValues.SESSION_ONLY &&
         this.category == settings.ContentSettingsTypes.COOKIES;
   },
 
   /**
+   * Whether to show the Session Only menu item for a given site.
+   * @param {SiteException} site The site in question.
+   * @return {boolean} Whether to show the menu item.
+   */
+  showSessionOnlyActionForSite_: function(site) {
+    // It makes no sense to show "clear on exit" for exceptions that only apply
+    // to incognito. It gives the impression that they might under some
+    // circumstances not be cleared on exit, which isn't true.
+    if (site.incognito)
+      return false;
+
+    return this.showSessionOnlyAction_;
+  },
+
+  /**
    * A handler for selecting a site (by clicking on the origin).
    * @private
    */
   onOriginTap_: function(event) {
     this.selectedSite = event.model.item;
     if (this.isPolicyControlled_(this.selectedSite.source))
       return;
 
     settings.navigateTo(settings.Route.SITE_SETTINGS_SITE_DETAILS);
   },
 
   /**
    * A handler for activating one of the menu action items.
    * @param {!{model: !{item: !{origin: string}},
    *           detail: !{selected: string}}} event
    * @private
    */
   onActionMenuIronActivate_: function(event) {
     var origin = event.model.item.origin;
+    var incognito = event.model.item.incognito;
     var embeddingOrigin = event.model.item.embeddingOrigin;
     var action = event.detail.selected;
     if (action == settings.PermissionValues.DEFAULT) {
-      this.resetCategoryPermissionForOrigin(
-          origin, embeddingOrigin, this.category);
+      this.browserProxy.resetCategoryPermissionForOrigin(
+          origin, embeddingOrigin, this.category, incognito);
     } else {
-      this.setCategoryPermissionForOrigin(
-          origin, embeddingOrigin, this.category, action);
+      this.browserProxy.setCategoryPermissionForOrigin(
+          origin, embeddingOrigin, this.category, action, incognito);
     }
   },
 
   /**
    * Returns the appropriate header value for display.
    * @param {Array<string>} siteList The list of all sites to display for this
    *     category subtype.
    * @param {boolean} toggleState The state of the global toggle for this
    *     category.
    * @private
    */
   computeSiteListHeader_: function(siteList, toggleState) {
     var title = '';
     if (this.categorySubtype == settings.PermissionValues.ALLOW) {
       title = loadTimeData.getString(
           toggleState ? 'siteSettingsAllow' : 'siteSettingsExceptions');
     } else if (this.categorySubtype == settings.PermissionValues.BLOCK) {
       title = loadTimeData.getString('siteSettingsBlock');
     } else if (this.categorySubtype == settings.PermissionValues.SESSION_ONLY) {
       title = loadTimeData.getString('siteSettingsSessionOnly');
     } else {
       return title;
     }
     return loadTimeData.getStringF('titleAndCount', title, siteList.length);
   },
 
   /**
+   * Returns the appropriate site description to display. This can, for example,
+   * be blank, an 'embedded on <site>' or 'Current incognito session' (or a
+   * mix of the last two).
+   * @param {SiteException} item The site exception entry.
+   * @return {string} The site description.
+   */
+  computeSiteDescription_: function(item) {
+    if (item.incognito && item.embeddingOriginForDisplay.length > 0) {
+      return loadTimeData.getStringF('embeddedIncognitoSite',
+          item.embeddingOriginForDisplay);
+    }
+
+    if (item.incognito)
+      return loadTimeData.getString('incognitoSite');
+    return item.embeddingOriginForDisplay;
+  },
+
+  /**
    * Returns true if this widget is showing the Allow list.
    * @private
    */
   isAllowList_: function() {
     return this.categorySubtype == settings.PermissionValues.ALLOW;
   },
 
   /**
    * Returns true if this widget is showing the Session Only list.
    * @private
@@ skipping 15 matching lines @@
     // is redundant to also list all the sites that are blocked.
     if (this.isAllowList_())
       return true;
 
     if (this.isSessionOnlyList_())
       return siteList.length > 0;
 
     return toggleState;
   },
 });