Revert "Revert "Dart2js support for custom element lifecycle events""

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
 // in the documentation and/or other materials provided with the
 // distribution.
 //    * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-(function() {
-
-var scope = window.PolymerLoader = {};
-var flags = {};
-
-// convert url arguments to flags
-
-if (!flags.noOpts) {
-  location.search.slice(1).split('&').forEach(function(o) {
-    o = o.split('=');
-    o[0] && (flags[o[0]] = o[1] || true);
-  });
-}
-
-// process global logFlags
-
-parseLogFlags(flags);
-
-function load(scopeName) {
-  // imports
-
-  var scope = window[scopeName];
-  var entryPointName = scope.entryPointName;
-  var processFlags = scope.processFlags;
-
-  // acquire attributes and base path from entry point
-
-  var entryPoint = findScript(entryPointName);
-  var base = entryPoint.basePath;
-
-  // acquire common flags
-  var flags = scope.flags;
-
-  // convert attributes to flags
-  var flags = PolymerLoader.flags;
-  for (var i=0, a; (a=entryPoint.attributes[i]); i++) {
-    if (a.name !== 'src') {
-      flags[a.name] = a.value || true;
-    }
-  }
-
-  // parse log flags into global
-  parseLogFlags(flags);
-
-  // exports
-
-  scope.basePath = base;
-  scope.flags = flags;
-
-  // process flags for dynamic dependencies
-
-  if (processFlags) {
-    processFlags.call(scope, flags);
-  }
-
-  // post-process imports
-
-  var modules = scope.modules || [];
-  var sheets = scope.sheets || [];
-
-  // write script tags for dependencies
-
-  modules.forEach(function(src) {
-    document.write('<script src="' + base + src + '"></script>');
-  });
-
-  // write link tags for styles
-
-  sheets.forEach(function(src) {
-    document.write('<link rel="stylesheet" href="' + base + src + '">');
-  });
-}
-
-// utility method
-
-function findScript(fileName) {
-  var script = document.querySelector('script[src*="' + fileName + '"]');
-  var src = script.attributes.src.value;
-  script.basePath = src.slice(0, src.indexOf(fileName));
-  return script;
-}
-
-function parseLogFlags(flags) {
-  var logFlags = window.logFlags = window.logFlags || {};
-  if (flags.log) {
-    flags.log.split(',').forEach(function(f) {
-      logFlags[f] = true;
-    });
-  }
-}
-
-scope.flags = flags;
-scope.load = load;
-
-})();
-
 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;
@@ skipping 588 matching lines @@
     if (find(e, data) !== true) {
       findAll(e, find, data);
     }
     e = e.nextElementSibling;
   }
   return null;
 }
 
 // walk all shadowRoots on a given node.
 function forRoots(node, cb) {
-  var root = node.webkitShadowRoot;
+  var root = node.shadowRoot;
   while(root) {
     forSubtree(root, cb);
     root = root.olderShadowRoot;
   }
 }
 
 // walk the subtree rooted at node, including descent into shadow-roots,
 // applying 'cb' to each element
 function forSubtree(node, cb) {
   //logFlags.dom && node.childNodes && node.childNodes.length && console.group('subTree: ', node);
@@ skipping 46 matching lines @@
 
 function insertedNode(node) {
   inserted(node);
   if (inDocument(node)) {
     forSubtree(node, function(e) {
       inserted(e);
     });
   }
 }
 
+
+// TODO(sorvell): on platforms without MutationObserver, mutations may not be
+// reliable and therefore entered/leftView are not reliable.
+// To make these callbacks less likely to fail, we defer all inserts and removes
+// to give a chance for elements to be inserted into dom.
+// This ensures enteredViewCallback fires for elements that are created and
+// immediately added to dom.
+var hasPolyfillMutations = (!window.MutationObserver ||
+    (window.MutationObserver === window.JsMutationObserver));
+scope.hasPolyfillMutations = hasPolyfillMutations;
+
+var isPendingMutations = false;
+var pendingMutations = [];
+function deferMutation(fn) {
+  pendingMutations.push(fn);
+  if (!isPendingMutations) {
+    isPendingMutations = true;
+    var async = (window.Platform && window.Platform.endOfMicrotask) ||
+        setTimeout;
+    async(takeMutations);
+  }
+}
+
+function takeMutations() {
+  isPendingMutations = false;
+  var $p = pendingMutations;
+  for (var i=0, l=$p.length, p; (i<l) && (p=$p[i]); i++) {
+    p();
+  }
+  pendingMutations = [];
+}
+
+function inserted(element) {
+  if (hasPolyfillMutations) {
+    deferMutation(function() {
+      _inserted(element);
+    });
+  } else {
+    _inserted(element);
+  }
+}
+
 // TODO(sjmiles): if there are descents into trees that can never have inDocument(*) true, fix this
-
-function inserted(element) {
+function _inserted(element) {
   // 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);
@@ skipping 18 matching lines @@
   }
 }
 
 function removedNode(node) {
   removed(node);
   forSubtree(node, function(e) {
     removed(e);
   });
 }
 
+
+function removed(element) {
+  if (hasPolyfillMutations) {
+    deferMutation(function() {
+      _removed(element);
+    });
+  } else {
+    _removed(element);
+  }
+}
+
 function removed(element) {
   // TODO(sjmiles): temporary: do work on all custom elements so we can track
   // behavior even when callbacks not defined
   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;
@@ skipping 15 matching lines @@
       window.ShadowDOMPolyfill.wrapIfNeeded(document) || document;
   while (p) {
     if (p == doc) {
       return true;
     }
     p = p.parentNode || p.host;
   }
 }
 
 function watchShadow(node) {
-  if (node.webkitShadowRoot && !node.webkitShadowRoot.__watched) {
+  if (node.shadowRoot && !node.shadowRoot.__watched) {
     logFlags.dom && console.log('watching shadow-root for: ', node.localName);
     // watch all unwatched roots...
-    var root = node.webkitShadowRoot;
+    var root = node.shadowRoot;
     while (root) {
       watchRoot(root);
       root = root.olderShadowRoot;
     }
   }
 }
 
 function watchRoot(root) {
   if (!root.__watched) {
     observe(root);
@@ skipping 51 matching lines @@
     //logFlags.dom && console.groupEnd();
   });
   logFlags.dom && console.groupEnd();
 };
 
 var observer = new MutationObserver(handler);
 
 function takeRecords() {
   // TODO(sjmiles): ask Raf why we have to call handler ourselves
   handler(observer.takeRecords());
+  takeMutations();
 }
 
 var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);
 
 function observe(inRoot) {
   observer.observe(inRoot, {childList: true, subtree: true});
 }
 
 function observeDocument(document) {
   observe(document);
@@ skipping 493 matching lines @@
   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';
+  var loadEvent = window.HTMLImports ? 'HTMLImportsLoaded' :
+      document.readyState == 'loading' ? 'DOMContentLoaded' : 'load';
   window.addEventListener(loadEvent, bootstrap);
 }
 
 })();
+
+(function() {
+// Patch to allow custom element and shadow dom to work together, from:
+// https://github.com/Polymer/platform/blob/master/src/patches-shadowdom-polyfill.js
+// include .host reference
+if (HTMLElement.prototype.createShadowRoot) {
+  var originalCreateShadowRoot = HTMLElement.prototype.createShadowRoot;
+  HTMLElement.prototype.createShadowRoot = function() {
+    var root = originalCreateShadowRoot.call(this);
+    root.host = this;
+    return root;
+  }
+}
+})();