[Polymer] update third_party polymer

third_party/polymer/v1_0/components-chromium/polymer-externs/polymer.externs.js

 /**
  * @fileoverview Closure compiler externs for the Polymer library.
  *
  * @externs
  * @license
  * Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
  * This code may only be used under the BSD style license found at
  * http://polymer.github.io/LICENSE.txt. The complete set of authors may be
  * found at http://polymer.github.io/AUTHORS.txt. The complete set of
  * contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt. Code
@@ skipping 122 matching lines @@
  * @param  {string} path  The path to set.
  * @param  {*}      value The value to send in the update notification.
  * @param {boolean=} fromAbove When true, specifies that the change came from
  *     above this element and thus upward notification is not necessary.
  * @return {boolean} True if notification actually took place, based on a dirty
  *     check of whether the new value was already known.
  */
 PolymerElement.prototype.notifyPath = function(path, value, fromAbove) {};
 
 /**
+ * @param {string} path Path that should be notified.
+ * @param {!Array<!PolymerSplice>} splices Array of splice records indicating
+ *     ordered changes that occurred to the array.
+ */
+PolymerElement.prototype.notifySplices = function(path, splices) {};
+
+/**
  * Convienence method for setting a value to a path and notifying any
  * elements bound to the same path.
  *
  * Note, if any part in the path except for the last is undefined,
  * this method does nothing (this method does not throw when
  * dereferencing undefined paths).
  *
  * @param {(string|Array<(string|number)>)} path Path to the value
  *   to read.  The path may be specified as a string (e.g. `foo.bar.baz`)
  *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
@@ skipping 112 matching lines @@
  * elements are returned.
  *
  * @param {string=} slctr CSS selector to choose the desired
  *   `<content>`.  Defaults to `content`.
  * @return {!Array<!HTMLElement>} List of distributed nodes for the
  *   `<content>`.
  */
 PolymerElement.prototype.getContentChildren = function(slctr) {};
 
 /**
+ * Returns a list of nodes that are the effective childNodes. The effective
+ * childNodes list is the same as the element's childNodes except that
+ * any `<content>` elements are replaced with the list of nodes distributed
+ * to the `<content>`, the result of its `getDistributedNodes` method.
+ *
+ * @return {!Array<!Node>} List of effective child nodes.
+ */
+PolymerElement.prototype.getEffectiveChildNodes = function() {};
+
+/**
+ * Returns a list of elements that are the effective children. The effective
+ * children list is the same as the element's children except that
+ * any `<content>` elements are replaced with the list of elements
+ * distributed to the `<content>`.
+ *
+ * @return {!Array<!Node>} List of effective children.
+ */
+PolymerElement.prototype.getEffectiveChildren = function() {};
+
+/**
+ * Returns a string of text content that is the concatenation of the
+ * text content's of the element's effective childNodes (the elements
+ * returned by <a href="#getEffectiveChildNodes>getEffectiveChildNodes</a>.
+ *
+ * @return {string} A concatenated string of all effective childNode text
+ *   content.
+ */
+PolymerElement.prototype.getEffectiveTextContent = function() {};
+
+/**
+ * @param {string} selector
+ * @return {?HTMLElement}
+ */
+PolymerElement.prototype.queryEffectiveChildren = function(selector) {};
+
+/**
  * Fire an event.
  *
  * @param {string} type An event name.
  * @param {*=} detail
  * @param {{
  *   bubbles: (boolean|undefined),
  *   cancelable: (boolean|undefined),
  *   node: (!EventTarget|undefined)}=} options
  * @return {Object} event
  */
 PolymerElement.prototype.fire = function(type, detail, options) {};
 
 /**
  * Toggles the named boolean class on the host element, adding the class if
  * bool is truthy and removing it if bool is falsey. If node is specified, sets
  * the class on node instead of the host element.
  * @param {string} name
- * @param {boolean} bool
+ * @param {boolean=} bool
  * @param {HTMLElement=} node
  */
 PolymerElement.prototype.toggleClass = function(name, bool, node) {};
 
 /**
  * Toggles the named boolean attribute on the host element, adding the attribute
  * if bool is truthy and removing it if bool is falsey. If node is specified,
  * sets the attribute on node instead of the host element.
  * @param {string} name
  * @param {boolean} bool
@@ skipping 14 matching lines @@
  * Convenience method to add an event listener on a given element, late bound to
  * a named method on this element.
  * @param {!EventTarget} node Element to add event listener to.
  * @param {string} eventName Name of event to listen for.
  * @param {string} methodName Name of handler method on this to call.
  */
 PolymerElement.prototype.listen = function(node, eventName, methodName) {};
 
 /**
  * Convenience method to remove an event listener from a given element.
- * @param {!EventTarget} node Element to remove event listener from.
+ * @param {?EventTarget} node Element to remove event listener from.
  * @param {string} eventName Name of event to stop listening for.
  * @param {string} methodName Name of handler method on this to remove.
  */
 PolymerElement.prototype.unlisten = function(node, eventName, methodName) {};
 
 /**
  * Override scrolling behavior to all direction, one direction, or none.
  *
  * Valid scroll directions:
  * 'all': scroll in any direction
@@ skipping 20 matching lines @@
 PolymerElement.prototype.factoryImpl = function(var_args) {};
 
 /**
  * Apply style scoping to the specified container and all its descendants.
  * @param {!Element} container Element to scope.
  * @param {boolean} shouldObserve When true, monitors the container for changes
  *   and re-applies scoping for any future changes.
  */
 PolymerElement.prototype.scopeSubtree = function(container, shouldObserve) {};
 
+/**
+ * Aliases one data path as another, such that path notifications from one
+ * are routed to the other.
+ *
+ * @param {string} to Target path to link.
+ * @param {string} from Source path to link.
+ */
+PolymerElement.prototype.linkPaths = function(to, from) {}
+
+/**
+ * Removes a data path alias previously established with `linkPaths`.
+ *
+ * Note, the path to unlink should be the target (`to`) used when
+ * linking the paths.
+ *
+ * @param {string} path Target path to unlink.
+ */
+PolymerElement.prototype.unlinkPaths = function(path) {}
+
 Polymer.Base;
 
 /**
  * Used by the promise-polyfill on its own.
  *
  * @param {!Function} method
  * @param {number=} wait
  * @return {number} A handle which can be used to cancel the job.
  */
 Polymer.Base.async = function(method, wait) {};
@@ skipping 121 matching lines @@
  *     shortcut for setting `customStyle` and then calling `updateStyles`.
  */
 PolymerElement.prototype.updateStyles = function(properties) {};
 
 /**
  * @type {!Object<string, string|undefined>}
  */
 PolymerElement.prototype.customStyle;
 
 /**
+ * Returns the computed style value for the given property.
+ * @param {string} property
+ * @return {string} the computed value
+ */
+PolymerElement.prototype.getComputedStyleValue = function(property) {};
+
+/**
  * Logs a message to the console.
  *
  * @param {!Array} var_args
  * @protected
  */
 PolymerElement.prototype._log = function(var_args) {};
 
 /**
  * Logs a message to the console with a 'warn' level.
  *
@@ skipping 78 matching lines @@
 
 /** @type {?Node} */
 PolymerDomApi.prototype.nextSibling;
 
 /** @type {string} */
 PolymerDomApi.prototype.textContent;
 
 /** @type {string} */
 PolymerDomApi.prototype.innerHTML;
 
+/** @type {?HTMLElement} */
+PolymerDomApi.prototype.activeElement;
+
 /**
  * @param {string} selector
  * @return {?HTMLElement}
  */
 PolymerDomApi.prototype.querySelector = function(selector) {};
 
 /**
  * @param {string} selector
  * @return {!Array<!HTMLElement>}
  */
@@ skipping 264 matching lines @@
    *   var model = modelForElement(el);
    *   if (model.index < 10) {
    *     model.set('item.checked', true);
    *   }
    *
    * @param {?HTMLElement} el Element for which to return a template model.
    * @return {(!PolymerElement)|undefined} Model representing the binding scope for
    *   the element.
    */
   modelForElement: function(el) {},
-  
+
   /**
    * @param {function()} fn
    * @protected
    */
    _debounceTemplate: function(fn) {}
 };
 
 
 
 /**
@@ skipping 141 matching lines @@
  *   y: number,
  *   sourceEvent: Event
  * }}
  */
 var PolymerTouchEvent;
 
 /**
  * @typedef {{
  *   index: number,
  *   removed: !Array,
- *   addedCount: number
+ *   addedCount: number,
+ *   object: !Array,
+ *   type: string,
  * }}
  */
 var PolymerSplice;
 
 /**
  * @typedef {{
  *   added: !Array<string|number>,
  *   removed: !Array<string|number>
  * }}
  */
@@ skipping 23 matching lines @@
  * method does not size the element, and it's usually necessary to set
  * the element's height and width so that the background image is visible.
  *
  * @param {Element} element The element to which the icon is applied.
  * @param {string} icon The name of the icon to apply.
  * @param {string=} theme (optional) The name or index of the icon to apply.
  * @param {number=} scale (optional, defaults to 1) Icon scaling factor.
  */
 Polymer.Iconset.prototype.applyIcon = function(
       element, icon, theme, scale) {};
+
+Polymer.ResolveUrl = {};
+
+/**
+ * @param {string} cssText Some CSS text taken from ownerDocument.
+ * @param {!Document} ownerDocument The source of the css.
+ * @return {string} The given CSS text with its URLs rewritten to be based on
+ *     the primary document of this window rather than the given ownerDocument.
+ */
+Polymer.ResolveUrl.resolveCss = function(cssText, ownerDocument) {}
+/**
+ * @param {!Element} element An element whose URL attributes need to be renormed.
+ * @param {!Document} ownerDocument The document whose URL is the base of the
+ *     element's current attributes.
+ */
+Polymer.ResolveUrl.resolveAttrs = function(element, ownerDocument) {}
+/**
+ * @param {string} url A url that needs to be renormed.
+ * @param {?string} baseURI The current base of URL for the URL.
+ * @return {string} The given url rewritten to be based on
+ *     the primary document of this window rather than the given url.
+ */
+Polymer.ResolveUrl.resolveUrl = function(url, baseURI) {}
+
+Polymer.RenderStatus;
+
+/**
+ * Makes callback when first render occurs or immediately if render has occured.
+ * @param {!function()} cb Callback function to be invoked.
+ */
+Polymer.RenderStatus.whenReady = function(cb) {}
+
+/**
+ * Queue up function call on next render.
+ * @param {!Element} element The element on which the function call is made.
+ * @param {!function()} fn The function called on next render.
+ * @param {...*} args The function arguments.
+ */
+Polymer.RenderStatus.afterNextRender = function(element, fn, args) {}
+
+Polymer.AppLayout;
+
+/** @constructor */
+Polymer.AppLayout.LocalDomWithBackground = function(){};
+/** @type {!HTMLElement} */
+Polymer.AppLayout.LocalDomWithBackground.prototype.backgroundFrontLayer;
+/** @type {!HTMLElement} */
+Polymer.AppLayout.LocalDomWithBackground.prototype.backgroundRearLayer;
+/** @type {!HTMLElement} */
+Polymer.AppLayout.LocalDomWithBackground.prototype.background;
+
+/**
+ * @constructor
+ * @extends {PolymerElement}
+ */
+Polymer.AppLayout.ElementWithBackground = function(){};
+
+// TODO(garlicnation): Follow up with app-layout team and remove private api from this prototype
+Polymer.AppLayout.ElementWithBackground.prototype = {
+  /** @type {!Polymer.AppLayout.LocalDomWithBackground} */
+  $: null,
+  /** @return {boolean} True if there's content below the current element */
+  isContentBelow: function(){},
+  /** Updates the elements scroll state */
+  _updateScrollState: function(){},
+  /** @return {boolean} true if the element is on screen */
+  isOnScreen: function(){},
+  /** @type {number} Internal bookkeeping to track screen position */
+  _deltaHeight: 0,
+}