Added base template for config ui.

appengine/config_service/ui/bower_components/polymer/lib/legacy/mutable-data-behavior.html

Index: appengine/config_service/ui/bower_components/polymer/lib/legacy/mutable-data-behavior.html
diff --git a/appengine/config_service/ui/bower_components/polymer/lib/legacy/mutable-data-behavior.html b/appengine/config_service/ui/bower_components/polymer/lib/legacy/mutable-data-behavior.html
new file mode 100644
index 0000000000000000000000000000000000000000..7a1d5294c7d64396326519e079aa463fede0faad
--- /dev/null
+++ b/appengine/config_service/ui/bower_components/polymer/lib/legacy/mutable-data-behavior.html
@@ -0,0 +1,150 @@
+<!--
+@license
+Copyright (c) 2017 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 distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="../mixins/mutable-data.html">
+
+<script>
+(function() {
+  'use strict';
+
+  let mutablePropertyChange = Polymer.MutableData._mutablePropertyChange;
+
+  /**
+   * Legacy element behavior to skip strict dirty-checking for objects and arrays,
+   * (always consider them to be "dirty") for use on legacy API Polymer elements.
+   *
+   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
+   * objects, which means that any deep modifications to an object or array will
+   * not be propagated unless "immutable" data patterns are used (i.e. all object
+   * references from the root to the mutation were changed).
+   *
+   * Polymer also provides a proprietary data mutation and path notification API
+   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
+   * mutation and notification of deep changes in an object graph to all elements
+   * bound to the same object graph.
+   *
+   * In cases where neither immutable patterns nor the data mutation API can be
+   * used, applying this mixin will cause Polymer to skip dirty checking for
+   * objects and arrays (always consider them to be "dirty").  This allows a
+   * user to make a deep modification to a bound object graph, and then either
+   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
+   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
+   * elements that wish to be updated based on deep mutations must apply this
+   * mixin or otherwise skip strict dirty checking for objects/arrays.
+   *
+   * In order to make the dirty check strategy configurable, see
+   * `Polymer.OptionalMutableDataBehavior`.
+   *
+   * Note, the performance characteristics of propagating large object graphs
+   * will be worse as opposed to using strict dirty checking with immutable
+   * patterns or Polymer's path notification API.
+   *
+   * @polymerBehavior
+   * @memberof Polymer
+   * @summary Behavior to skip strict dirty-checking for objects and
+   *   arrays
+   */
+  Polymer.MutableDataBehavior = {
+
+    /**
+     * Overrides `Polymer.PropertyEffects` to provide option for skipping
+     * strict equality checking for Objects and Arrays.
+     *
+     * This method pulls the value to dirty check against from the `__dataTemp`
+     * cache (rather than the normal `__data` cache) for Objects.  Since the temp
+     * cache is cleared at the end of a turn, this implementation allows
+     * side-effects of deep object changes to be processed by re-setting the
+     * same object (using the temp cache as an in-turn backstop to prevent
+     * cycles due to 2-way notification).
+     *
+     * @param {string} property Property name
+     * @param {*} value New property value
+     * @param {*} old Previous property value
+     * @return {boolean} Whether the property should be considered a change
+     * @protected
+     */
+    _shouldPropertyChange(property, value, old) {
+      return mutablePropertyChange(this, property, value, old, true);
+    }
+  };
+
+  /**
+   * Legacy element behavior to add the optional ability to skip strict
+   * dirty-checking for objects and arrays (always consider them to be
+   * "dirty") by setting a `mutable-data` attribute on an element instance.
+   *
+   * By default, `Polymer.PropertyEffects` performs strict dirty checking on
+   * objects, which means that any deep modifications to an object or array will
+   * not be propagated unless "immutable" data patterns are used (i.e. all object
+   * references from the root to the mutation were changed).
+   *
+   * Polymer also provides a proprietary data mutation and path notification API
+   * (e.g. `notifyPath`, `set`, and array mutation API's) that allow efficient
+   * mutation and notification of deep changes in an object graph to all elements
+   * bound to the same object graph.
+   *
+   * In cases where neither immutable patterns nor the data mutation API can be
+   * used, applying this mixin will allow Polymer to skip dirty checking for
+   * objects and arrays (always consider them to be "dirty").  This allows a
+   * user to make a deep modification to a bound object graph, and then either
+   * simply re-set the object (e.g. `this.items = this.items`) or call `notifyPath`
+   * (e.g. `this.notifyPath('items')`) to update the tree.  Note that all
+   * elements that wish to be updated based on deep mutations must apply this
+   * mixin or otherwise skip strict dirty checking for objects/arrays.
+   *
+   * While this behavior adds the ability to forgo Object/Array dirty checking,
+   * the `mutableData` flag defaults to false and must be set on the instance.
+   *
+   * Note, the performance characteristics of propagating large object graphs
+   * will be worse by relying on `mutableData: true` as opposed to using
+   * strict dirty checking with immutable patterns or Polymer's path notification
+   * API.
+   *
+   * @polymerBehavior
+   * @memberof Polymer
+   * @summary Behavior to optionally skip strict dirty-checking for objects and
+   *   arrays
+   */
+  Polymer.OptionalMutableDataBehavior = {
+
+    properties: {
+      /**
+       * Instance-level flag for configuring the dirty-checking strategy
+       * for this element.  When true, Objects and Arrays will skip dirty
+       * checking, otherwise strict equality checking will be used.
+       */
+      mutableData: Boolean
+    },
+
+    /**
+     * Overrides `Polymer.PropertyEffects` to skip strict equality checking
+     * for Objects and Arrays.
+     *
+     * Pulls the value to dirty check against from the `__dataTemp` cache
+     * (rather than the normal `__data` cache) for Objects.  Since the temp
+     * cache is cleared at the end of a turn, this implementation allows
+     * side-effects of deep object changes to be processed by re-setting the
+     * same object (using the temp cache as an in-turn backstop to prevent
+     * cycles due to 2-way notification).
+     *
+     * @param {string} property Property name
+     * @param {*} value New property value
+     * @param {*} old Previous property value
+     * @return {boolean} Whether the property should be considered a change
+     * @protected
+     */
+    _shouldPropertyChange(property, value, old) {
+      return mutablePropertyChange(this, property, value, old, this.mutableData);
+    }
+  };
+
+})();
+
+</script>