Version 0.8.10.1

dart/pkg/shadow_dom/lib/shadow_dom.debug.js

 if (!HTMLElement.prototype.createShadowRoot
     || window.__forceShadowDomPolyfill) {
 
 /*
  * Copyright 2013 The Polymer Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style
  * license that can be found in the LICENSE file.
  */
 (function() {
   // TODO(jmesserly): fix dart:html to use unprefixed name
@@ skipping 14 matching lines @@
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 (function(global) {
   'use strict';
 
+  var PROP_ADD_TYPE = 'add';
+  var PROP_UPDATE_TYPE = 'update';
+  var PROP_RECONFIGURE_TYPE = 'reconfigure';
+  var PROP_DELETE_TYPE = 'delete';
+  var ARRAY_SPLICE_TYPE = 'splice';
+
+  // Detect and do basic sanity checking on Object/Array.observe.
   function detectObjectObserve() {
     if (typeof Object.observe !== 'function' ||
         typeof Array.observe !== 'function') {
       return false;
     }
 
-    var gotSplice = false;
-    function callback(records) {
-      if (records[0].type === 'splice' && records[1].type === 'splice')
-        gotSplice = true;
+    var records = [];
+
+    function callback(recs) {
+      records = recs;
     }
 
-    var test = [0];
+    var test = {};
+    Object.observe(test, callback);
+    test.id = 1;
+    test.id = 2;
+    delete test.id;
+    Object.deliverChangeRecords(callback);
+    if (records.length !== 3)
+      return false;
+
+    // TODO(rafaelw): Remove this when new change record type names make it to
+    // chrome release.
+    if (records[0].type == 'new' &&
+        records[1].type == 'updated' &&
+        records[2].type == 'deleted') {
+      PROP_ADD_TYPE = 'new';
+      PROP_UPDATE_TYPE = 'updated';
+      PROP_RECONFIGURE_TYPE = 'reconfigured';
+      PROP_DELETE_TYPE = 'deleted';
+    } else if (records[0].type != 'add' ||
+               records[1].type != 'update' ||
+               records[2].type != 'delete') {
+      console.error('Unexpected change record names for Object.observe. ' +
+                    'Using dirty-checking instead');
+      return false;
+    }
+    Object.unobserve(test, callback);
+
+    test = [0];
     Array.observe(test, callback);
     test[1] = 1;
     test.length = 0;
     Object.deliverChangeRecords(callback);
-    return gotSplice;
+    if (records.length != 2)
+      return false;
+    if (records[0].type != ARRAY_SPLICE_TYPE ||
+        records[1].type != ARRAY_SPLICE_TYPE) {
+      return false;
+    }
+    Array.unobserve(test, callback);
+
+    return true;
   }
 
   var hasObserve = detectObjectObserve();
 
   function detectEval() {
     // don't test for eval if document has CSP securityPolicy object and we can see that
     // eval is not supported. This avoids an error message in console even when the exception
     // is caught
     if (global.document &&
         'securityPolicy' in global.document &&
@@ skipping 766 matching lines @@
             object.close();
         }
         this.observed = undefined;
         this.values = undefined;
       }
 
       Observer.prototype.close.call(this);
     }
   });
 
-  var knownRecordTypes = {
-    'new': true,
-    'updated': true,
-    'deleted': true
-  };
+  var expectedRecordTypes = {};
+  expectedRecordTypes[PROP_ADD_TYPE] = true;
+  expectedRecordTypes[PROP_UPDATE_TYPE] = true;
+  expectedRecordTypes[PROP_DELETE_TYPE] = true;
 
   function notifyFunction(object, name) {
     if (typeof Object.observe !== 'function')
       return;
 
     var notifier = Object.getNotifier(object);
     return function(type, oldValue) {
       var changeRecord = {
         object: object,
         type: type,
@@ skipping 11 matching lines @@
   // to any dependent value will be observed.
   PathObserver.defineProperty = function(object, name, descriptor) {
     // TODO(rafaelw): Validate errors
     var obj = descriptor.object;
     var path = getPath(descriptor.path);
     var notify = notifyFunction(object, name);
 
     var observer = new PathObserver(obj, descriptor.path,
         function(newValue, oldValue) {
           if (notify)
-            notify('updated', oldValue);
+            notify(PROP_UPDATE_TYPE, oldValue);
         }
     );
 
     Object.defineProperty(object, name, {
       get: function() {
         return path.getValueFrom(obj);
       },
       set: function(newValue) {
         path.setValueFrom(obj, newValue);
       },
@@ skipping 14 matching lines @@
       }
     };
   }
 
   function diffObjectFromChangeRecords(object, changeRecords, oldValues) {
     var added = {};
     var removed = {};
 
     for (var i = 0; i < changeRecords.length; i++) {
       var record = changeRecords[i];
-      if (!knownRecordTypes[record.type]) {
+      if (!expectedRecordTypes[record.type]) {
         console.error('Unknown changeRecord type: ' + record.type);
         console.error(record);
         continue;
       }
 
       if (!(record.name in oldValues))
         oldValues[record.name] = record.oldValue;
 
-      if (record.type == 'updated')
+      if (record.type == PROP_UPDATE_TYPE)
         continue;
 
-      if (record.type == 'new') {
+      if (record.type == PROP_ADD_TYPE) {
         if (record.name in removed)
           delete removed[record.name];
         else
           added[record.name] = true;
 
         continue;
       }
 
-      // type = 'deleted'
+      // type = 'delete'
       if (record.name in added) {
         delete added[record.name];
         delete oldValues[record.name];
       } else {
         removed[record.name] = true;
       }
     }
 
     for (var prop in added)
       added[prop] = object[prop];
@@ skipping 367 matching lines @@
     if (!inserted)
       splices.push(splice);
   }
 
   function createInitialSplices(array, changeRecords) {
     var splices = [];
 
     for (var i = 0; i < changeRecords.length; i++) {
       var record = changeRecords[i];
       switch(record.type) {
-        case 'splice':
+        case ARRAY_SPLICE_TYPE:
           mergeSplice(splices, record.index, record.removed.slice(), record.addedCount);
           break;
-        case 'new':
-        case 'updated':
-        case 'deleted':
+        case PROP_ADD_TYPE:
+        case PROP_UPDATE_TYPE:
+        case PROP_DELETE_TYPE:
           if (!isIndex(record.name))
             continue;
           var index = toNumber(record.name);
           if (index < 0)
             continue;
           mergeSplice(splices, index, [record.oldValue], 1);
           break;
         default:
           console.error('Unexpected record type: ' + JSON.stringify(record));
           break;
@@ skipping 26 matching lines @@
   global.ArrayObserver = ArrayObserver;
   global.ArrayObserver.calculateSplices = function(current, previous) {
     return arraySplice.calculateSplices(current, previous);
   };
 
   global.ArraySplice = ArraySplice;
   global.ObjectObserver = ObjectObserver;
   global.PathObserver = PathObserver;
   global.CompoundPathObserver = CompoundPathObserver;
   global.Path = Path;
+
+  // TODO(rafaelw): Only needed for testing until new change record names
+  // make it to release.
+  global.Observer.changeRecordTypes = {
+    add: PROP_ADD_TYPE,
+    update: PROP_UPDATE_TYPE,
+    reconfigure: PROP_RECONFIGURE_TYPE,
+    'delete': PROP_DELETE_TYPE,
+    splice: ARRAY_SPLICE_TYPE
+  };
 })(typeof global !== 'undefined' && global ? global : this);
 
 /*
  * Copyright 2012 The Polymer Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style
  * license that can be found in the LICENSE file.
  */
 
 if (typeof WeakMap === 'undefined') {
   (function() {
@@ skipping 42 matching lines @@
   // Don't test for eval if document has CSP securityPolicy object and we can
   // see that eval is not supported. This avoids an error message in console
   // even when the exception is caught
   var hasEval = !('securityPolicy' in document) ||
       document.securityPolicy.allowsEval;
   if (hasEval) {
     try {
       var f = new Function('', 'return true;');
       hasEval = f();
     } catch (ex) {
+      hasEval = false;
     }
   }
 
   function assert(b) {
     if (!b)
       throw new Error('Assertion failed');
   };
 
   function mixin(to, from) {
     Object.getOwnPropertyNames(from).forEach(function(name) {
@@ skipping 330 matching lines @@
   scope.registerObject = registerObject;
   scope.registerWrapper = register;
   scope.rewrap = rewrap;
   scope.unwrap = unwrap;
   scope.unwrapIfNeeded = unwrapIfNeeded;
   scope.wrap = wrap;
   scope.wrapIfNeeded = wrapIfNeeded;
   scope.wrappers = wrappers;
 
 })(this.ShadowDOMPolyfill);
+
 // Copyright 2013 The Polymer Authors. All rights reserved.
 // Use of this source code is goverened by a BSD-style
 // license that can be found in the LICENSE file.
 
 (function(scope) {
   'use strict';
 
   var forwardMethodsToWrapper = scope.forwardMethodsToWrapper;
   var mixin = scope.mixin;
   var registerWrapper = scope.registerWrapper;
@@ skipping 3072 matching lines @@
       ].forEach(function(name) {
         var f = prototype[name];
         if (!f)
           return;
         newPrototype[name] = function() {
           f.apply(wrap(this), arguments);
         };
       });
 
       var nativeConstructor = originalRegister.call(unwrap(this), tagName,
+          object.extends ? {prototype: newPrototype, extends: object.extends} :
           {prototype: newPrototype});
 
       function GeneratedWrapper(node) {
         if (!node)
           return document.createElement(tagName);
         this.impl = node;
       }
       GeneratedWrapper.prototype = prototype;
       GeneratedWrapper.prototype.constructor = GeneratedWrapper;
 
@@ skipping 1098 matching lines @@
   var head = document.querySelector('head');
   head.insertBefore(getSheet(), head.childNodes[0]);
 }
 
 // exports
 scope.ShadowCSS = ShadowCSS;
 
 })(window.Platform);
 
 }