Content settings: allow "session only" type for cookies exceptions

chrome/browser/resources/options/content_settings_exceptions_area.js

 // Copyright (c) 2010 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 List = cr.ui.List;
   const ListItem = cr.ui.ListItem;
   const ArrayDataModel = cr.ui.ArrayDataModel;
 
   /**
    * Creates a new exceptions list item.
+   * @param {string} contentType The type of the list.
    * @param {Array} exception A pair of the form [filter, setting].
    * @constructor
    * @extends {cr.ui.ListItem}
    */
-  function ExceptionsListItem(exception) {
+  function ExceptionsListItem(contentType, exception) {
     var el = cr.doc.createElement('li');
+    el.contentType = contentType;
     el.dataItem = exception;
     el.__proto__ = ExceptionsListItem.prototype;
     el.decorate();
 
     return el;
   }
 
   ExceptionsListItem.prototype = {
     __proto__: ListItem.prototype,
 
@@ skipping 15 matching lines @@
 
       // Elements for edit mode.
       var input = cr.doc.createElement('input');
       input.type = 'text';
       this.appendChild(input);
       input.className = 'exceptionInput hidden';
 
       var select = cr.doc.createElement('select');
       var optionAllow = cr.doc.createElement('option');
       optionAllow.textContent = templateData.allowException;
+      select.appendChild(optionAllow);
       var optionBlock = cr.doc.createElement('option');
       optionBlock.textContent = templateData.blockException;
-      select.appendChild(optionAllow);
       select.appendChild(optionBlock);
+
+      if (this.contentType == 'cookies') {
+        var optionSession = cr.doc.createElement('option');
+        optionSession.textContent = templateData.sessionException;
+        select.appendChild(optionSession);
+        this.optionSession = optionSession;
+      }
+
       this.appendChild(select);
       select.className = 'exceptionSetting hidden';
 
       // Used to track whether the URL pattern in the input is valid.
       // This will be true if the browser process has informed us that the
       // current text in the input is valid. Changing the text resets this to
       // false, and getting a response from the browser sets it back to true.
       // It starts off as false for empty string (new exceptions) or true for
       // already-existing exceptions (which we assume are valid).
       this.inputValidityKnown = this.pattern;
       // This one tracks the actual validity of the pattern in the input. This
       // starts off as true so as not to annoy the user when he adds a new and
       // empty input.
       this.inputIsValid = true;
 
       this.patternLabel = patternLabel;
       this.settingLabel = settingLabel;
       this.input = input;
       this.select = select;
       this.optionAllow = optionAllow;
       this.optionBlock = optionBlock;
 
       this.updateEditables();
 
       var listItem = this;
       // Handle events on the editable nodes.
       input.oninput = function(event) {
         listItem.inputValidityKnown = false;
-        if (listItem.parentNode) {
-          chrome.send('checkExceptionPatternValidity',
-                      [listItem.parentNode.contentType, input.value]);
-        }
+        chrome.send('checkExceptionPatternValidity',
+                    [listItem.contentType, input.value]);
       };
 
       var eventsToStop =
           ['mousedown', 'mouseup', 'contextmenu', 'dblclick', 'paste'];
       eventsToStop.forEach(function(type) {
         input.addEventListener(type, function(e) {
             e.stopPropagation();
           });
         }
       );
@@ skipping 97 matching lines @@
     updateEditables: function() {
       if (!(this.pattern && this.setting))
         return;
 
       this.input.value = this.pattern;
 
       if (this.setting == 'allow')
         this.optionAllow.selected = true;
       else if (this.setting == 'block')
         this.optionBlock.selected = true;
+      else if (this.setting == 'session')
+        this.optionSession.selected = true;
     },
 
     /**
      * Whether the user is currently able to edit the list item.
      * @type {boolean}
      */
     get editing() {
       return this.hasAttribute('editing');
     },
     set editing(editing) {
       var oldEditing = this.editing;
       if (oldEditing == editing)
         return;
 
       var listItem = this;
       var pattern = this.pattern;
       var setting = this.setting;
       var patternLabel = this.patternLabel;
       var settingLabel = this.settingLabel;
       var input = this.input;
       var select = this.select;
       var optionAllow = this.optionAllow;
       var optionBlock = this.optionBlock;
+      var optionSession = this.optionSession;
 
       // Check that we have a valid pattern and if not we do not change the
       // editing mode.
       if (!editing && (!this.inputValidityKnown || !this.inputIsValid)) {
         input.focus();
         input.select();
         return;
       }
 
       patternLabel.classList.toggle('hidden');
       settingLabel.classList.toggle('hidden');
       input.classList.toggle('hidden');
       select.classList.toggle('hidden');
 
       var doc = this.ownerDocument;
       if (editing) {
         this.setAttribute('editing', '');
         cr.ui.limitInputWidth(input, this, 20);
         input.focus();
         input.select();
       } else {
         var newPattern = input.value;
 
         this.pattern = patternLabel.textContent = newPattern;
         if (optionAllow.selected)
           this.setting = 'allow';
         else if (optionBlock.selected)
           this.setting = 'block';
+        else if (optionSession.selected)
+          this.setting = 'session';
         settingLabel.textContent = this.settingForDisplay();
 
         this.removeAttribute('editing');
 
         var contentType = this.parentNode.contentType;
 
         if (pattern != this.pattern)
           chrome.send('removeExceptions', [contentType, pattern]);
 
         chrome.send('setException', [contentType, this.pattern, this.setting]);
@@ skipping 18 matching lines @@
       List.prototype.decorate.call(this);
 
       this.dataModel = new ArrayDataModel([]);
     },
 
     /**
      * Creates an item to go in the list.
      * @param {Object} entry The element from the data model for this row.
      */
     createItem: function(entry) {
-      return new ExceptionsListItem(entry);
+      return new ExceptionsListItem(this.contentType, entry);
     },
 
     /**
      * Adds an exception to the js model.
      * @param {Array} entry A pair of the form [filter, setting].
      */
     addException: function(entry) {
       this.dataModel.push(entry);
 
       // When an empty row is added, put it into editing mode.
@@ skipping 129 matching lines @@
       this.updateButtonSensitivity();
    },
   };
 
   return {
     ExceptionsListItem: ExceptionsListItem,
     ExceptionsList: ExceptionsList,
     ExceptionsArea: ExceptionsArea
   };
 });