Updating custom elements polyfill to the latest github.com/dart-lang version

pkg/custom_element/lib/custom-elements.debug.js

 // Copyright (c) 2012 The Polymer Authors. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //    * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //    * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
@@ skipping 113 matching lines @@
 window.CustomElements = {flags:{}};
 // SideTable is a weak map where possible. If WeakMap is not available the
 // association is stored as an expando property.
 var SideTable;
 // TODO(arv): WeakMap does not allow for Node etc to be keys in Firefox
 if (typeof WeakMap !== 'undefined' && navigator.userAgent.indexOf('Firefox/') < 0) {
   SideTable = WeakMap;
 } else {
   (function() {
     var defineProperty = Object.defineProperty;
-    var hasOwnProperty = Object.hasOwnProperty;
-    var counter = new Date().getTime() % 1e9;
+    var counter = Date.now() % 1e9;
 
     SideTable = function() {
       this.name = '__st' + (Math.random() * 1e9 >>> 0) + (counter++ + '__');
     };
 
     SideTable.prototype = {
       set: function(key, value) {
-        defineProperty(key, this.name, {value: value, writable: true});
+        var entry = key[this.name];
+        if (entry && entry[0] === key)
+          entry[1] = value;
+        else
+          defineProperty(key, this.name, {value: [key, value], writable: true});
       },
       get: function(key) {
-        return hasOwnProperty.call(key, this.name) ? key[this.name] : undefined;
+        var entry;
+        return (entry = key[this.name]) && entry[0] === key ?
+            entry[1] : undefined;
       },
       delete: function(key) {
         this.set(key, undefined);
       }
     }
   })();
 }
 
 (function(global) {
 
@@ skipping 536 matching lines @@
   window.MutationObserver =
       window.WebKitMutationObserver ||
       window.JsMutationObserver;
   if (!MutationObserver) {
     throw new Error("no mutation observer support");
   }
 }
 
 (function(scope){
 
-/*
-if (HTMLElement.prototype.webkitShadowRoot) {
-  Object.defineProperty(HTMLElement.prototype, 'shadowRoot', {
-    get: function() {
-      return this.webkitShadowRoot;
-    }
-  };
-}
-*/
+var logFlags = window.logFlags || {};
 
 // walk the subtree rooted at node, applying 'find(element, data)' function
 // to each element
 // if 'find' returns true for 'element', do not search element's subtree
 function findAll(node, find, data) {
   var e = node.firstElementChild;
   if (!e) {
     e = node.firstChild;
     while (e && e.nodeType !== Node.ELEMENT_NODE) {
       e = e.nextSibling;
@@ skipping 83 matching lines @@
   // TODO(sjmiles): it's possible we were inserted and removed in the space
   // of one microtask, in which case we won't be 'inDocument' here
   // But there are other cases where we are testing for inserted without
   // specific knowledge of mutations, and must test 'inDocument' to determine
   // whether to call inserted
   // If we can factor these cases into separate code paths we can have
   // better diagnostics.
   // TODO(sjmiles): when logging, do work on all custom elements so we can
   // track behavior even when callbacks not defined
   //console.log('inserted: ', element.localName);
-  if (element.enteredDocumentCallback || (element.__upgraded__ && logFlags.dom)) {
+  if (element.enteredViewCallback || (element.__upgraded__ && logFlags.dom)) {
     logFlags.dom && console.group('inserted:', element.localName);
     if (inDocument(element)) {
       element.__inserted = (element.__inserted || 0) + 1;
       // if we are in a 'removed' state, bluntly adjust to an 'inserted' state
       if (element.__inserted < 1) {
         element.__inserted = 1;
       }
       // if we are 'over inserted', squelch the callback
       if (element.__inserted > 1) {
         logFlags.dom && console.warn('inserted:', element.localName,
           'insert/remove count:', element.__inserted)
-      } else if (element.enteredDocumentCallback) {
+      } else if (element.enteredViewCallback) {
         logFlags.dom && console.log('inserted:', element.localName);
-        element.enteredDocumentCallback();
+        element.enteredViewCallback();
       }
     }
     logFlags.dom && console.groupEnd();
   }
 }
 
 function removedNode(node) {
   removed(node);
   forSubtree(node, function(e) {
     removed(e);
   });
 }
 
 function removed(element) {
   // TODO(sjmiles): temporary: do work on all custom elements so we can track
   // behavior even when callbacks not defined
-  if (element.leftDocumentCallback || (element.__upgraded__ && logFlags.dom)) {
+  if (element.leftViewCallback || (element.__upgraded__ && logFlags.dom)) {
     logFlags.dom && console.log('removed:', element.localName);
     if (!inDocument(element)) {
       element.__inserted = (element.__inserted || 0) - 1;
       // if we are in a 'inserted' state, bluntly adjust to an 'removed' state
       if (element.__inserted > 0) {
         element.__inserted = 0;
       }
       // if we are 'over removed', squelch the callback
       if (element.__inserted < 0) {
         logFlags.dom && console.warn('removed:', element.localName,
             'insert/remove count:', element.__inserted)
-      } else if (element.leftDocumentCallback) {
-        element.leftDocumentCallback();
+      } else if (element.leftViewCallback) {
+        element.leftViewCallback();
       }
     }
   }
 }
 
 function inDocument(element) {
   var p = element;
+  var doc = window.ShadowDOMPolyfill &&
+      window.ShadowDOMPolyfill.wrapIfNeeded(document) || document;
   while (p) {
-    if (p == element.ownerDocument) {
+    if (p == doc) {
       return true;
     }
     p = p.parentNode || p.host;
   }
 }
 
 function watchShadow(node) {
   if (node.webkitShadowRoot && !node.webkitShadowRoot.__watched) {
     logFlags.dom && console.log('watching shadow-root for: ', node.localName);
     // watch all unwatched roots...
     var root = node.webkitShadowRoot;
     while (root) {
       watchRoot(root);
       root = root.olderShadowRoot;
     }
   }
 }
 
 function watchRoot(root) {
   if (!root.__watched) {
     observe(root);
     root.__watched = true;
   }
 }
 
-function watchAllShadows(node) {
-  watchShadow(node);
-  forSubtree(node, function(e) {
-    watchShadow(node);
-  });
-}
-
 function filter(inNode) {
   switch (inNode.localName) {
     case 'style':
     case 'script':
     case 'template':
     case undefined:
       return true;
   }
 }
 
@@ skipping 15 matching lines @@
   }
   //
   mutations.forEach(function(mx) {
     //logFlags.dom && console.group('mutation');
     if (mx.type === 'childList') {
       forEach(mx.addedNodes, function(n) {
         //logFlags.dom && console.log(n.localName);
         if (filter(n)) {
           return;
         }
-        // watch shadow-roots on nodes that have had them attached manually
-        // TODO(sjmiles): remove if createShadowRoot is overridden
-        // TODO(sjmiles): removed as an optimization, manual shadow roots
-        // must be watched explicitly
-        //watchAllShadows(n);
         // nodes added may need lifecycle management
         addedNode(n);
       });
       // removed nodes may need lifecycle management
       forEach(mx.removedNodes, function(n) {
         //logFlags.dom && console.log(n.localName);
         if (filter(n)) {
           return;
         }
         removedNode(n);
@@ skipping 23 matching lines @@
 
 function upgradeDocument(document) {
   logFlags.dom && console.group('upgradeDocument: ', (document.URL || document._URL || '').split('/').pop());
   addedNode(document);
   logFlags.dom && console.groupEnd();
 }
 
 // exports
 
 scope.watchShadow = watchShadow;
-scope.watchAllShadows = watchAllShadows;
-
 scope.upgradeAll = addedNode;
 scope.upgradeSubtree = addedSubtree;
 
 scope.observeDocument = observeDocument;
 scope.upgradeDocument = upgradeDocument;
 
 scope.takeRecords = takeRecords;
 
 })(window.CustomElements);
 
@@ skipping 11 matching lines @@
 
 // imports
 
 if (!scope) {
   scope = window.CustomElements = {flags:{}};
 }
 var flags = scope.flags;
 
 // native document.register?
 
-var hasNative = Boolean(document.webkitRegister || document.register);
+var hasNative = Boolean(document.register);
 var useNative = !flags.register && hasNative;
 
 if (useNative) {
 
-  // normalize
-  document.register = document.register || document.webkitRegister;
-
   // stub
   var nop = function() {};
 
   // exports
   scope.registry = {};
   scope.upgradeElement = nop;
 
   scope.watchShadow = nop;
-  scope.watchAllShadows = nop;
   scope.upgrade = nop;
   scope.upgradeAll = nop;
   scope.upgradeSubtree = nop;
   scope.observeDocument = nop;
   scope.upgradeDocument = nop;
   scope.takeRecords = nop;
 
 } else {
 
   /**
@@ skipping 40 matching lines @@
     // TODO(sjmiles): probably should clone options instead of mutating it
     var definition = options || {};
     if (!name) {
       // TODO(sjmiles): replace with more appropriate error (EricB can probably
       // offer guidance)
       throw new Error('document.register: first argument `name` must not be empty');
     }
     if (name.indexOf('-') < 0) {
       // TODO(sjmiles): replace with more appropriate error (EricB can probably
       // offer guidance)
-      throw new Error('document.register: first argument `name` must contain a dash (\'-\'). Argument was \'' + String(name) + '\'.');
+      throw new Error('document.register: first argument (\'name\') must contain a dash (\'-\'). Argument provided was \'' + String(name) + '\'.');
     }
     // record name
     definition.name = name;
     // must have a prototype, default to an extension of HTMLElement
     // TODO(sjmiles): probably should throw if no prototype, check spec
     if (!definition.prototype) {
       // TODO(sjmiles): replace with more appropriate error (EricB can probably
       // offer guidance)
       throw new Error('Options missing required prototype property');
     }
@@ skipping 50 matching lines @@
       // if there is a base tag, use secondary 'is' specifier
       definition.is = definition.name;
     }
   }
 
   function resolvePrototypeChain(definition) {
     // if we don't support __proto__ we need to locate the native level
     // prototype for precise mixing in
     if (!Object.__proto__) {
       // default prototype
-      var native = HTMLElement.prototype;
+      var nativePrototype = HTMLElement.prototype;
       // work out prototype when using type-extension
       if (definition.is) {
         var inst = document.createElement(definition.tag);
-        native = Object.getPrototypeOf(inst);
+        nativePrototype = Object.getPrototypeOf(inst);
       }
       // ensure __proto__ reference is installed at each point on the prototype
       // chain.
       // NOTE: On platforms without __proto__, a mixin strategy is used instead
       // of prototype swizzling. In this case, this generated __proto__ provides
       // limited support for prototype traversal.
       var proto = definition.prototype, ancestor;
-      while (proto && (proto !== native)) {
+      while (proto && (proto !== nativePrototype)) {
         var ancestor = Object.getPrototypeOf(proto);
         proto.__proto__ = ancestor;
         proto = ancestor;
       }
     }
     // cache this in case of mixin
-    definition.native = native;
+    definition.native = nativePrototype;
   }
 
   // SECTION 4
 
   function instantiate(definition) {
     // 4.a.1. Create a new object that implements PROTOTYPE
     // 4.a.2. Let ELEMENT by this new object
     //
     // the custom element instantiation algorithm must also ensure that the
     // output is a valid DOM element with the proper wrapper in place.
@@ skipping 87 matching lines @@
       this.attributeChangedCallback(name, oldValue);
     }
   }
 
   // element registry (maps tag names to definitions)
 
   var registry = {};
 
   function registerDefinition(name, definition) {
     if (registry[name]) {
-      throw new Error('a type with that name is already registered.');
+      throw new Error('Cannot register a tag more than once');
     }
     registry[name] = definition;
   }
 
   function generateConstructor(definition) {
     return function() {
       return instantiate(definition);
     };
   }
 
@@ skipping 132 matching lines @@
 var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);
 
 // exports
 
 CustomElements.parser = parser;
 
 })();
 (function(){
 
 // bootstrap parsing
-
 function bootstrap() {
-  // go async so call stack can unwind
-  setTimeout(function() {
-    // parse document
-    CustomElements.parser.parse(document);
-    // one more pass before register is 'live'
-    CustomElements.upgradeDocument(document);
+  // parse document
+  CustomElements.parser.parse(document);
+  // one more pass before register is 'live'
+  CustomElements.upgradeDocument(document);
+  // choose async
+  var async = window.Platform && Platform.endOfMicrotask ?
+    Platform.endOfMicrotask :
+    setTimeout;
+  async(function() {
     // set internal 'ready' flag, now document.register will trigger
     // synchronous upgrades
     CustomElements.ready = true;
     // capture blunt profiling data
     CustomElements.readyTime = Date.now();
     if (window.HTMLImports) {
       CustomElements.elapsed = CustomElements.readyTime - HTMLImports.readyTime;
     }
     // notify the system that we are bootstrapped
     document.body.dispatchEvent(
       new CustomEvent('WebComponentsReady', {bubbles: true})
     );
-  }, 0);
+  });
 }
 
 // CustomEvent shim for IE
 if (typeof window.CustomEvent !== 'function') {
   window.CustomEvent = function(inType) {
      var e = document.createEvent('HTMLEvents');
      e.initEvent(inType, true, true);
      return e;
   };
 }
 
 if (document.readyState === 'complete') {
   bootstrap();
 } else {
   var loadEvent = window.HTMLImports ? 'HTMLImportsLoaded' : 'DOMContentLoaded';
   window.addEventListener(loadEvent, bootstrap);
 }
 
 })();