update platform.js to get memory leak fixes

pkg/web_components/lib/platform.concat.js

 /**
  * Copyright (c) 2014 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
  */
 
 window.Platform = window.Platform || {};
@@ skipping 2299 matching lines @@
   'use strict';
 
   var setEndOfMicrotask = scope.setEndOfMicrotask
   var wrapIfNeeded = scope.wrapIfNeeded
   var wrappers = scope.wrappers;
 
   var registrationsTable = new WeakMap();
   var globalMutationObservers = [];
   var isScheduled = false;
 
-  function scheduleCallback() {
+  function scheduleCallback(observer) {
+    if (observer.scheduled_)
+      return;
+
+    observer.scheduled_ = true;
+    globalMutationObservers.push(observer);
+
     if (isScheduled)
       return;
     setEndOfMicrotask(notifyObservers);
     isScheduled = true;
   }
 
   // http://dom.spec.whatwg.org/#mutation-observers
   function notifyObservers() {
     isScheduled = false;
 
     while (globalMutationObservers.length) {
       var notifyList = globalMutationObservers;
       globalMutationObservers = [];
 
       // Deliver changes in birth order of the MutationObservers.
       notifyList.sort(function(x, y) { return x.uid_ - y.uid_; });
 
       for (var i = 0; i < notifyList.length; i++) {
         var mo = notifyList[i];
+        mo.scheduled_ = false;
         var queue = mo.takeRecords();
         removeTransientObserversFor(mo);
         if (queue.length) {
           mo.callback_(queue, mo);
         }
       }
     }
   }
 
 
@@ skipping 95 matching lines @@
         // true, or type is "characterData" and options's characterDataOldValue
         // is true, set the paired string of registered observer's observer in
         // interested observers to oldValue.
         if (type === 'attributes' && options.attributeOldValue ||
             type === 'characterData' && options.characterDataOldValue) {
           associatedStrings[observer.uid_] = data.oldValue;
         }
       }
     }
 
-    var anyObserversEnqueued = false;
-
     // 4.
     for (var uid in interestedObservers) {
       var observer = interestedObservers[uid];
       var record = new MutationRecord(type, target);
 
       // 2.
       if ('name' in data && 'namespace' in data) {
         record.attributeName = data.name;
         record.attributeNamespace = data.namespace;
       }
@@ skipping 12 matching lines @@
 
       // 6.
       if (data.nextSibling)
         record.nextSibling = data.nextSibling;
 
       // 7.
       if (associatedStrings[uid] !== undefined)
         record.oldValue = associatedStrings[uid];
 
       // 8.
-      if (!observer.records_.length) {
-        globalMutationObservers.push(observer);
-        anyObserversEnqueued = true;
-      }
+      scheduleCallback(observer);
       observer.records_.push(record);
     }
-
-    if (anyObserversEnqueued)
-      scheduleCallback();
   }
 
   var slice = Array.prototype.slice;
 
   /**
    * @param {!Object} options
    * @constructor
    */
   function MutationObserverOptions(options) {
     this.childList = !!options.childList;
@@ skipping 42 matching lines @@
   /**
    * The class that maps to the DOM MutationObserver interface.
    * @param {Function} callback.
    * @constructor
    */
   function MutationObserver(callback) {
     this.callback_ = callback;
     this.nodes_ = [];
     this.records_ = [];
     this.uid_ = ++uidCounter;
+    this.scheduled_ = false;
   }
 
   MutationObserver.prototype = {
     constructor: MutationObserver,
 
     // http://dom.spec.whatwg.org/#dom-mutationobserver-observe
     observe: function(target, options) {
       target = wrapIfNeeded(target);
 
       var newOptions = new MutationObserverOptions(options);
@@ skipping 65 matching lines @@
      * Adds a transient observer on node. The transient observer gets removed
      * next time we deliver the change records.
      * @param {Node} node
      */
     addTransientObserver: function(node) {
       // Don't add transient observers on the target itself. We already have all
       // the required listeners set up on the target.
       if (node === this.target)
         return;
 
+      // Make sure we remove transient observers at the end of microtask, even
+      // if we didn't get any change records.
+      scheduleCallback(this.observer);
+
       this.transientObservedNodes.push(node);
       var registrations = registrationsTable.get(node);
       if (!registrations)
         registrationsTable.set(node, registrations = []);
 
       // We know that registrations does not contain this because we already
       // checked if node === this.target.
       registrations.push(this);
     },
 
@@ skipping 8711 matching lines @@
     // watch all unwatched roots...
     var root = node.shadowRoot;
     while (root) {
       watchRoot(root);
       root = root.olderShadowRoot;
     }
   }
 }
 
 function watchRoot(root) {
-  if (!root.__watched) {
-    observe(root);
-    root.__watched = true;
-  }
+  observe(root);
 }
 
 function handler(mutations) {
   //
   if (logFlags.dom) {
     var mx = mutations[0];
     if (mx && mx.type === 'childList' && mx.addedNodes) {
         if (mx.addedNodes) {
           var d = mx.addedNodes[0];
           while (d && d !== document && !d.host) {
@@ skipping 24 matching lines @@
           return;
         }
         removedNode(n);
       });
     }
     //logFlags.dom && console.groupEnd();
   });
   logFlags.dom && console.groupEnd();
 };
 
-var observer = new MutationObserver(handler);
+function takeRecords(node) {
+  // If the optional node is not supplied, assume we mean the whole document.
+  if (node === undefined) node = document;
 
-function takeRecords() {
-  // TODO(sjmiles): ask Raf why we have to call handler ourselves
-  handler(observer.takeRecords());
-  takeMutations();
+  // Find the root of the tree, which will be an Document or ShadowRoot.
+  while (node.parentNode) {
+    node = node.parentNode;
+  }
+
+  var observer = node.__observer;
+  if (observer) {
+    handler(observer.takeRecords());
+    takeMutations();
+  }
 }
 
 var forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach);
 
 function observe(inRoot) {
+  if (inRoot.__observer) return;
+
+  // For each ShadowRoot, we create a new MutationObserver, so the root can be
+  // garbage collected once all references to the `inRoot` node are gone.
+  var observer = new MutationObserver(handler);
   observer.observe(inRoot, {childList: true, subtree: true});
+  inRoot.__observer = observer;
 }
 
 function observeDocument(doc) {
   observe(doc);
 }
 
 function upgradeDocument(doc) {
   logFlags.dom && console.group('upgradeDocument: ', (doc.baseURI).split('/').pop());
   addedNode(doc);
   logFlags.dom && console.groupEnd();
@@ skipping 884 matching lines @@
   // exports
 
   scope.marshal = marshal;
   // `module` confuses commonjs detectors
   scope.modularize = module;
   scope.using = using;
 
 })(window);
 
 //# sourceMappingURL=platform.concat.js.map