[Chrome Settings UI] Show overruled User Exceptions as strike-through.

chrome/browser/resources/options/content_settings_exceptions_area.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.contentSettings', function() {
   /** @const */ var ControlledSettingIndicator =
                     options.ControlledSettingIndicator;
   /** @const */ var InlineEditableItemList = options.InlineEditableItemList;
   /** @const */ var InlineEditableItem = options.InlineEditableItem;
   /** @const */ var ArrayDataModel = cr.ui.ArrayDataModel;
@@ skipping 73 matching lines @@
       this.contentElement.appendChild(patternCell);
       if (this.pattern)
         this.patternLabel = patternCell.querySelector('.static-text');
       var input = patternCell.querySelector('input');
 
       // Setting label for display mode. |pattern| will be null for the 'add new
       // exception' row.
       if (this.pattern) {
         var settingLabel = cr.doc.createElement('span');
         settingLabel.textContent = this.settingForDisplay();
-        settingLabel.className = 'exception-setting';
+        settingLabel.className = 'exception-setting overruleable';
         settingLabel.setAttribute('displaymode', 'static');
         this.contentElement.appendChild(settingLabel);
         this.settingLabel = settingLabel;
       }
 
       // Setting select element for edit mode.
       var select = cr.doc.createElement('select');
       var optionAllow = cr.doc.createElement('option');
       optionAllow.textContent = loadTimeData.getString('allowException');
       optionAllow.value = 'allow';
@@ skipping 93 matching lines @@
               this.dataItem.source : null;
 
       if (controlledBy) {
         this.setAttribute('controlled-by', controlledBy);
         this.deletable = false;
         this.editable = false;
       }
 
       if (controlledBy == 'policy' || controlledBy == 'extension') {
         this.querySelector('.row-delete-button').hidden = true;
-        var indicator = new ControlledSettingIndicator();
-        indicator.setAttribute('content-exception', this.contentType);
-        // Create a synthetic pref change event decorated as
-        // CoreOptionsHandler::CreateValueForPref() does.
-        var event = new Event(this.contentType);
-        event.value = { controlledBy: controlledBy };
-        indicator.handlePrefChange(event);
-        this.appendChild(indicator);
+        this.appendIndicatorElement(controlledBy);
       }
 
       // If the exception comes from a hosted app, display the name and the
       // icon of the app.
       if (controlledBy == 'HostedApp') {
         this.title =
             loadTimeData.getString('setBy') + ' ' + this.dataItem.appName;
         var button = this.querySelector('.row-delete-button');
         // Use the host app's favicon (16px, match bigger size).
         // See c/b/ui/webui/extensions/extension_icon_source.h
         // for a description of the chrome://extension-icon URL.
         button.style.backgroundImage =
             'url(\'chrome://extension-icon/' + this.dataItem.appId + '/16/1\')';
       }
 
       var listItem = this;
       // Handle events on the editable nodes.
       input.oninput = function(event) {
         listItem.inputValidityKnown = false;
         chrome.send('checkExceptionPatternValidity',
                     [listItem.contentType, listItem.mode, input.value]);
       };
 
       // Listen for edit events.
       this.addEventListener('canceledit', this.onEditCancelled_);
       this.addEventListener('commitedit', this.onEditCommitted_);
     },
 
+    /**
+     * Appends an indicator element to the item. Should be called at most once.
+     *
+     * @param {string} controlledBy The source that controls the item.
+     */
+    appendIndicatorElement: function(controlledBy) {
+      var indicator = new ControlledSettingIndicator();
+      indicator.setAttribute('content-exception', this.contentType);
+      // Create a synthetic pref change event decorated as
+      // CoreOptionsHandler::CreateValueForPref() does.
+      var event = new Event(this.contentType);
+      event.value = {controlledBy: controlledBy};
+      indicator.handlePrefChange(event);
+      this.appendChild(indicator);
+    },
+
     isEmbeddingRule: function() {
       return this.dataItem.embeddingOrigin &&
           this.dataItem.embeddingOrigin !== this.dataItem.origin;
     },
 
     /**
      * The pattern (e.g., a URL) for the exception.
      *
      * @type {string}
      */
@@ skipping 84 matching lines @@
      */
     updateEditables: function() {
       this.resetInput();
 
       var settingOption =
           this.select.querySelector('[value=\'' + this.setting + '\']');
       if (settingOption)
         settingOption.selected = true;
     },
 
+    /**
+     * Updates UI to indicate that the exception was overruled by a source.
+     *
+     * @param {string} overruledBy The source that overrules the exception.
+     */
+    setOverruledBy: function(overruledBy) {
+      this.classList.toggle('overruled', !!overruledBy);
+      this.appendIndicatorElement(overruledBy);
+    },
+
     /** @override */
     get currentInputIsValid() {
       return this.inputValidityKnown && this.inputIsValid;
     },
 
     /** @override */
     get hasBeenEdited() {
       var livePattern = this.input.value;
       var liveSetting = this.select.value;
       return livePattern != this.pattern || liveSetting != this.setting;
@@ skipping 155 matching lines @@
                                       entry);
       } else {
         var addRowItem = new ExceptionsAddRowListItem(this.contentType,
                                                       this.mode);
         addRowItem.deletable = false;
         return addRowItem;
       }
     },
 
     /**
+     * Updates UI to indicate that user exceptions were overruled by a source.
+     *
+     * @param {string} overruledBy The source that overrules user exceptions.
+     */
+    setOverruledBy: function(overruledBy) {
+      for (var index = 0; index < this.dataModel.length; ++index) {
+        var item = this.getListItemByIndex(index);
+        if (item.dataItem.source == 'preference')
+          item.setOverruledBy(overruledBy);
+      }
+    },
+
+    /**
      * Sets the exceptions in the js model.
      *
      * @param {Array<options.Exception>} entries A list of dictionaries of
      *     values, each dictionary represents an exception.
      */
     setExceptions: function(entries) {
       var deleteCount = this.dataModel.length;
 
       if (this.isEditable()) {
         // We don't want to remove the Add New Exception row.
@@ skipping 163 matching lines @@
     }
   };
 
   return {
     ExceptionsListItem: ExceptionsListItem,
     ExceptionsAddRowListItem: ExceptionsAddRowListItem,
     ExceptionsList: ExceptionsList,
     ContentSettingsExceptionsArea: ContentSettingsExceptionsArea,
   };
 });