Roll third_party/polymer.

third_party/polymer/v1_0/components-chromium/iron-selector/iron-selectable-extracted.js

 /** @polymerBehavior */
   Polymer.IronSelectableBehavior = {
 
       /**
        * Fired when iron-selector is activated (selected or deselected).
        * It is fired before the selected items are changed.
        * Cancel the event to abort selection.
        *
        * @event iron-activate
        */
@@ skipping 14 matching lines @@
        * Fired when the list of selectable items changes (e.g., items are
        * added or removed). The detail of the event is a list of mutation
        * records that describe what changed.
        *
        * @event iron-items-changed
        */
 
     properties: {
 
       /**
-       * If you want to use the attribute value of an element for `selected` instead of the index,
-       * set this to the name of the attribute.
+       * If you want to use an attribute value or property of an element for
+       * `selected` instead of the index, set this to the name of the attribute
+       * or property. Hyphenated values are converted to camel case when used to
+       * look up the property of a selectable element. Camel cased values are
+       * *not* converted to hyphenated values for attribute lookup. It's
+       * recommended that you provide the hyphenated form of the name so that
+       * selection works in both cases. (Use `attr-or-property-name` instead of
+       * `attrOrPropertyName`.)
        */
       attrForSelected: {
         type: String,
         value: null
       },
 
       /**
        * Gets or sets the selected element. The default is to use the index of the item.
        * @type {string|number}
        */
@@ skipping 40 matching lines @@
 
       /**
        * The attribute to set on elements when selected.
        */
       selectedAttribute: {
         type: String,
         value: null
       },
 
       /**
+       * Default fallback if the selection based on selected with `attrForSelected`
+       * is not found.
+       */
+      fallbackSelection: {
+        type: String,
+        value: null
+      },
+
+      /**
        * The list of items from which a selection can be made.
        */
       items: {
         type: Array,
         readOnly: true,
         notify: true,
         value: function() {
           return [];
         }
       },
 
       /**
        * The set of excluded elements where the key is the `localName`
        * of the element that will be ignored from the item list.
        *
        * @default {template: 1}
        */
       _excludedLocalNames: {
         type: Object,
         value: function() {
           return {
             'template': 1
           };
         }
       }
     },
 
     observers: [
       '_updateAttrForSelected(attrForSelected)',
-      '_updateSelected(selected)'
+      '_updateSelected(selected)',
+      '_checkFallback(fallbackSelection)'
     ],
 
     created: function() {
       this._bindFilterItem = this._filterItem.bind(this);
       this._selection = new Polymer.IronSelection(this._applySelection.bind(this));
     },
 
     attached: function() {
       this._observer = this._observeItems(this);
       this._updateItems();
@@ skipping 65 matching lines @@
      * on its own to reflect selectable items in the DOM.
      */
     forceSynchronousItemUpdate: function() {
       this._updateItems();
     },
 
     get _shouldUpdateSelection() {
       return this.selected != null;
     },
 
+    _checkFallback: function() {
+      if (this._shouldUpdateSelection) {
+        this._updateSelected();
+      }
+    },
+
     _addListener: function(eventName) {
       this.listen(this, eventName, '_activateHandler');
     },
 
     _removeListener: function(eventName) {
       this.unlisten(this, eventName, '_activateHandler');
     },
 
     _activateEventChanged: function(eventName, old) {
       this._removeListener(old);
       this._addListener(eventName);
     },
 
     _updateItems: function() {
       var nodes = Polymer.dom(this).queryDistributedElements(this.selectable || '*');
       nodes = Array.prototype.filter.call(nodes, this._bindFilterItem);
       this._setItems(nodes);
     },
 
     _updateAttrForSelected: function() {
       if (this._shouldUpdateSelection) {
-        this.selected = this._indexToValue(this.indexOf(this.selectedItem));        
+        this.selected = this._indexToValue(this.indexOf(this.selectedItem));
       }
     },
 
     _updateSelected: function() {
       this._selectSelected(this.selected);
     },
 
     _selectSelected: function(selected) {
       this._selection.select(this._valueToItem(this.selected));
+      // Check for items, since this array is populated only when attached
+      // Since Number(0) is falsy, explicitly check for undefined
+      if (this.fallbackSelection && this.items.length && (this._selection.get() === undefined)) {
+        this.selected = this.fallbackSelection;
+      }
     },
 
     _filterItem: function(node) {
       return !this._excludedLocalNames[node.localName];
     },
 
     _valueToItem: function(value) {
       return (value == null) ? null : this.items[this._valueToIndex(value)];
     },
 
@@ skipping 14 matching lines @@
         var item = this.items[index];
         if (item) {
           return this._valueForItem(item);
         }
       } else {
         return index;
       }
     },
 
     _valueForItem: function(item) {
-      var propValue = item[this.attrForSelected];
+      var propValue = item[Polymer.CaseMap.dashToCamelCase(this.attrForSelected)];
       return propValue != undefined ? propValue : item.getAttribute(this.attrForSelected);
     },
 
     _applySelection: function(item, isSelected) {
       if (this.selectedClass) {
         this.toggleClass(this.selectedClass, isSelected, item);
       }
       if (this.selectedAttribute) {
         this.toggleAttribute(this.selectedAttribute, isSelected, item);
       }
@@ skipping 38 matching lines @@
     },
 
     _itemActivate: function(value, item) {
       if (!this.fire('iron-activate',
           {selected: value, item: item}, {cancelable: true}).defaultPrevented) {
         this.select(value);
       }
     }
 
   };