Object.observe: Change semantics of deliverChangeRecords to iterate.

test/mjsunit/harmony/object-observe.js

 // Copyright 2012 the V8 project 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
@@ skipping 47 matching lines @@
     assertCalled: function() {
       assertEquals(1, this.callbackCount);
     },
     assertRecordCount: function(count) {
       this.assertCalled();
       assertEquals(count, this.records.length);
     },
     assertCallbackRecords: function(recs) {
       this.assertRecordCount(recs.length);
       for (var i = 0; i < recs.length; i++) {
-        if ('name' in recs[i])
-          recs[i].name = String(recs[i].name);
+        if ('name' in recs[i]) recs[i].name = String(recs[i].name);
         print(i, stringifyNoThrow(this.records[i]), stringifyNoThrow(recs[i]));
         assertSame(this.records[i].object, recs[i].object);
         assertEquals('string', typeof recs[i].type);
         assertPropertiesEqual(this.records[i], recs[i]);
       }
     }
   };
 
   observer.callback = function(r) {
     assertEquals(undefined, this);
@@ skipping 18 matching lines @@
 var changeRecordWithAccessor = { type: 'foo' };
 var recordCreated = false;
 Object.defineProperty(changeRecordWithAccessor, 'name', {
   get: function() {
     recordCreated = true;
     return "bar";
   },
   enumerable: true
 })
 
+
 // Object.observe
 assertThrows(function() { Object.observe("non-object", observer.callback); }, TypeError);
 assertThrows(function() { Object.observe(obj, nonFunction); }, TypeError);
 assertThrows(function() { Object.observe(obj, frozenFunction); }, TypeError);
 assertEquals(obj, Object.observe(obj, observer.callback));
 
+
 // Object.unobserve
 assertThrows(function() { Object.unobserve(4, observer.callback); }, TypeError);
 assertThrows(function() { Object.unobserve(obj, nonFunction); }, TypeError);
 assertEquals(obj, Object.unobserve(obj, observer.callback));
 
+
 // Object.getNotifier
 var notifier = Object.getNotifier(obj);
 assertSame(notifier, Object.getNotifier(obj));
 assertEquals(null, Object.getNotifier(Object.freeze({})));
 assertFalse(notifier.hasOwnProperty('notify'));
 assertEquals([], Object.keys(notifier));
 var notifyDesc = Object.getOwnPropertyDescriptor(notifier.__proto__, 'notify');
 assertTrue(notifyDesc.configurable);
 assertTrue(notifyDesc.writable);
 assertFalse(notifyDesc.enumerable);
 assertThrows(function() { notifier.notify({}); }, TypeError);
 assertThrows(function() { notifier.notify({ type: 4 }); }, TypeError);
 var notify = notifier.notify;
 assertThrows(function() { notify.call(undefined, { type: 'a' }); }, TypeError);
 assertThrows(function() { notify.call(null, { type: 'a' }); }, TypeError);
 assertThrows(function() { notify.call(5, { type: 'a' }); }, TypeError);
 assertThrows(function() { notify.call('hello', { type: 'a' }); }, TypeError);
 assertThrows(function() { notify.call(false, { type: 'a' }); }, TypeError);
 assertThrows(function() { notify.call({}, { type: 'a' }); }, TypeError);
 assertFalse(recordCreated);
 notifier.notify(changeRecordWithAccessor);
 assertFalse(recordCreated);  // not observed yet
 
+
 // Object.deliverChangeRecords
 assertThrows(function() { Object.deliverChangeRecords(nonFunction); }, TypeError);
 
 Object.observe(obj, observer.callback);
 
+
 // notify uses to [[CreateOwnProperty]] to create changeRecord;
 reset();
 var protoExpandoAccessed = false;
 Object.defineProperty(Object.prototype, 'protoExpando',
   {
     configurable: true,
     set: function() { protoExpandoAccessed = true; }
   }
 );
 notifier.notify({ type: 'foo', protoExpando: 'val'});
 assertFalse(protoExpandoAccessed);
 delete Object.prototype.protoExpando;
 Object.deliverChangeRecords(observer.callback);
 
+
 // Multiple records are delivered.
 reset();
 notifier.notify({
   type: 'updated',
   name: 'foo',
   expando: 1
 });
 
 notifier.notify({
   object: notifier,  // object property is ignored
   type: 'deleted',
   name: 'bar',
   expando2: 'str'
 });
 Object.deliverChangeRecords(observer.callback);
 observer.assertCallbackRecords([
   { object: obj, name: 'foo', type: 'updated', expando: 1 },
   { object: obj, name: 'bar', type: 'deleted', expando2: 'str' }
 ]);
 
+
 // No delivery takes place if no records are pending
 reset();
 Object.deliverChangeRecords(observer.callback);
 observer.assertNotCalled();
 
+
 // Multiple observation has no effect.
 reset();
 Object.observe(obj, observer.callback);
 Object.observe(obj, observer.callback);
 Object.getNotifier(obj).notify({
   type: 'foo',
 });
 Object.deliverChangeRecords(observer.callback);
 observer.assertCalled();
 
+
 // Observation can be stopped.
 reset();
 Object.unobserve(obj, observer.callback);
 Object.getNotifier(obj).notify({
   type: 'foo',
 });
 Object.deliverChangeRecords(observer.callback);
 observer.assertNotCalled();
 
+
 // Multiple unobservation has no effect
 reset();
 Object.unobserve(obj, observer.callback);
 Object.unobserve(obj, observer.callback);
 Object.getNotifier(obj).notify({
   type: 'foo',
 });
 Object.deliverChangeRecords(observer.callback);
 observer.assertNotCalled();
 
+
 // Re-observation works and only includes changeRecords after of call.
 reset();
 Object.getNotifier(obj).notify({
   type: 'foo',
 });
 Object.observe(obj, observer.callback);
 Object.getNotifier(obj).notify({
   type: 'foo',
 });
 records = undefined;
 Object.deliverChangeRecords(observer.callback);
 observer.assertRecordCount(1);
 
+
 // Observing a continuous stream of changes, while itermittantly unobserving.
 reset();
 Object.observe(obj, observer.callback);
 Object.getNotifier(obj).notify({
   type: 'foo',
   val: 1
 });
 
 Object.unobserve(obj, observer.callback);
 Object.getNotifier(obj).notify({
@@ skipping 20 matching lines @@
 });
 
 Object.unobserve(obj, observer.callback);
 Object.deliverChangeRecords(observer.callback);
 observer.assertCallbackRecords([
   { object: obj, type: 'foo', val: 1 },
   { object: obj, type: 'foo', val: 3 },
   { object: obj, type: 'foo', val: 5 }
 ]);
 
+
 // Observing multiple objects; records appear in order.
 reset();
 var obj2 = {};
 var obj3 = {}
 Object.observe(obj, observer.callback);
 Object.observe(obj3, observer.callback);
 Object.observe(obj2, observer.callback);
 Object.getNotifier(obj).notify({
   type: 'foo1',
 });
 Object.getNotifier(obj2).notify({
   type: 'foo2',
 });
 Object.getNotifier(obj3).notify({
   type: 'foo3',
 });
 Object.observe(obj3, observer.callback);
 Object.deliverChangeRecords(observer.callback);
 observer.assertCallbackRecords([
   { object: obj, type: 'foo1' },
   { object: obj2, type: 'foo2' },
   { object: obj3, type: 'foo3' }
 ]);
 
+
+// Recursive observation.
+var obj = {a: 1};
+var callbackCount = 0;
+function recursiveObserver(r) {
+  assertEquals(1, r.length);
+  ++callbackCount;
+  if (r[0].oldValue < 100) ++obj[r[0].name];
+}
+Object.observe(obj, recursiveObserver);
+++obj.a;
+Object.deliverChangeRecords(recursiveObserver);
+assertEquals(100, callbackCount);
+
+var obj1 = {a: 1};
+var obj2 = {a: 1};
+var recordCount = 0;
+function recursiveObserver2(r) {
+  recordCount += r.length;
+  if (r[0].oldValue < 100) {
+    ++obj1.a;
+    ++obj2.a;
+  }
+}
+Object.observe(obj1, recursiveObserver2);
+Object.observe(obj2, recursiveObserver2);
+++obj1.a;
+Object.deliverChangeRecords(recursiveObserver2);
+assertEquals(199, recordCount);
+
+
 // Observing named properties.
 reset();
 var obj = {a: 1}
 Object.observe(obj, observer.callback);
 obj.a = 2;
 obj["a"] = 3;
 delete obj.a;
 obj.a = 4;
 obj.a = 4;  // ignored
 obj.a = 5;
@@ skipping 31 matching lines @@
   { object: obj, name: "a", type: "reconfigured" },
   { object: obj, name: "a", type: "reconfigured" },
   { object: obj, name: "a", type: "deleted" },
   { object: obj, name: "a", type: "new" },
   { object: obj, name: "a", type: "reconfigured" },
   { object: obj, name: "a", type: "updated", oldValue: 9 },
   { object: obj, name: "a", type: "deleted", oldValue: 10 },
   { object: obj, name: "a", type: "new" },
 ]);
 
+
 // Observing indexed properties.
 reset();
 var obj = {'1': 1}
 Object.observe(obj, observer.callback);
 obj[1] = 2;
 obj[1] = 3;
 delete obj[1];
 obj[1] = 4;
 obj[1] = 4;  // ignored
 obj[1] = 5;
@@ skipping 106 matching lines @@
 function TestObserveNonConfigurable(obj, prop, desc) {
   reset();
   obj[prop] = 1;
   Object.observe(obj, observer.callback);
   obj[prop] = 4;
   obj[prop] = 4;  // ignored
   obj[prop] = 5;
   Object.defineProperty(obj, prop, {value: 6});
   Object.defineProperty(obj, prop, {value: 6});  // ignored
   Object.defineProperty(obj, prop, {value: 7});
-  Object.defineProperty(obj, prop,
-                        {enumerable: desc.enumerable});  // ignored
+  Object.defineProperty(obj, prop, {enumerable: desc.enumerable});  // ignored
   Object.defineProperty(obj, prop, {writable: false});
   obj[prop] = 7;  // ignored
   Object.deliverChangeRecords(observer.callback);
   observer.assertCallbackRecords([
     { object: obj, name: prop, type: "updated", oldValue: 1 },
     { object: obj, name: prop, type: "updated", oldValue: 4 },
     { object: obj, name: prop, type: "updated", oldValue: 5 },
     { object: obj, name: prop, type: "updated", oldValue: 6 },
     { object: obj, name: prop, type: "reconfigured", oldValue: 7 },
   ]);
@@ skipping 53 matching lines @@
   new Set, new Map, new WeakMap,
   new ArrayBuffer(10), new Int32Array(5),
   createProxy(Proxy.create, null),
   createProxy(Proxy.createFunction, function(){}),
 ];
 var properties = ["a", "1", 1, "length", "prototype", "name", "caller"];
 
 // Cases that yield non-standard results.
 function blacklisted(obj, prop) {
   return (obj instanceof Int32Array && prop == 1) ||
-    (obj instanceof Int32Array && prop === "length") ||
-    (obj instanceof ArrayBuffer && prop == 1)
+         (obj instanceof Int32Array && prop === "length") ||
+         (obj instanceof ArrayBuffer && prop == 1)
 }
 
 for (var i in objects) for (var j in properties) {
   var obj = objects[i];
   var prop = properties[j];
   if (blacklisted(obj, prop)) continue;
   var desc = Object.getOwnPropertyDescriptor(obj, prop);
   print("***", typeof obj, stringifyNoThrow(obj), prop);
   if (!desc || desc.configurable)
     TestObserveConfigurable(obj, prop);
@@ skipping 41 matching lines @@
   { object: arr2, name: '1', type: 'deleted', oldValue: 'beta' },
   { object: arr2, name: 'length', type: 'updated', oldValue: 2 },
   { object: arr2, name: 'length', type: 'reconfigured', oldValue: 1 },
   { object: arr3, name: '2', type: 'deleted', oldValue: 'goodbye' },
   { object: arr3, name: '0', type: 'deleted', oldValue: 'hello' },
   { object: arr3, name: 'length', type: 'updated', oldValue: 6 },
   { object: arr3, name: 'length', type: 'updated', oldValue: 0 },
   { object: arr3, name: 'length', type: 'reconfigured', oldValue: 5 },
 ]);
 
+
 // Assignments in loops (checking different IC states).
 reset();
 var obj = {};
 Object.observe(obj, observer.callback);
 for (var i = 0; i < 5; i++) {
   obj["a" + i] = i;
 }
 Object.deliverChangeRecords(observer.callback);
 observer.assertCallbackRecords([
   { object: obj, name: "a0", type: "new" },
@@ skipping 11 matching lines @@
 }
 Object.deliverChangeRecords(observer.callback);
 observer.assertCallbackRecords([
   { object: obj, name: "0", type: "new" },
   { object: obj, name: "1", type: "new" },
   { object: obj, name: "2", type: "new" },
   { object: obj, name: "3", type: "new" },
   { object: obj, name: "4", type: "new" },
 ]);
 
+
 // Adding elements past the end of an array should notify on length
 reset();
 var arr = [1, 2, 3];
 Object.observe(arr, observer.callback);
 arr[3] = 10;
 arr[100] = 20;
 Object.defineProperty(arr, '200', {value: 7});
 Object.defineProperty(arr, '400', {get: function(){}});
 arr[50] = 30; // no length change expected
 Object.deliverChangeRecords(observer.callback);
 observer.assertCallbackRecords([
   { object: arr, name: '3', type: 'new' },
   { object: arr, name: 'length', type: 'updated', oldValue: 3 },
   { object: arr, name: '100', type: 'new' },
   { object: arr, name: 'length', type: 'updated', oldValue: 4 },
   { object: arr, name: '200', type: 'new' },
   { object: arr, name: 'length', type: 'updated', oldValue: 101 },
   { object: arr, name: '400', type: 'new' },
   { object: arr, name: 'length', type: 'updated', oldValue: 201 },
   { object: arr, name: '50', type: 'new' },
 ]);
 
+
 // Tests for array methods, first on arrays and then on plain objects
 //
 // === ARRAYS ===
 //
 // Push
 reset();
 var array = [1, 2];
 Object.observe(array, observer.callback);
 array.push(3, 4);
 Object.deliverChangeRecords(observer.callback);
@@ skipping 53 matching lines @@
 Object.observe(array, observer.callback);
 array.splice(1, 1, 4, 5);
 Object.deliverChangeRecords(observer.callback);
 observer.assertCallbackRecords([
   { object: array, name: '3', type: 'new' },
   { object: array, name: 'length', type: 'updated', oldValue: 3 },
   { object: array, name: '1', type: 'updated', oldValue: 2 },
   { object: array, name: '2', type: 'updated', oldValue: 3 },
 ]);
 
+
 //
 // === PLAIN OBJECTS ===
 //
 // Push
 reset()
 var array = {0: 1, 1: 2, length: 2}
 Object.observe(array, observer.callback);
 Array.prototype.push.call(array, 3, 4);
 Object.deliverChangeRecords(observer.callback);
 observer.assertCallbackRecords([
@@ skipping 86 matching lines @@
 // TODO(adamk): Add tests for objects with hidden prototypes
 // once we support observing the global object.
 Object.deliverChangeRecords(observer.callback);
 observer.assertCallbackRecords([
   { object: obj, name: '__proto__', type: 'prototype',
     oldValue: Object.prototype },
   { object: obj, name: '__proto__', type: 'prototype', oldValue: p },
   { object: obj, name: '__proto__', type: 'prototype', oldValue: null },
 ]);
 
+
 // Function.prototype
 reset();
 var fun = function(){};
 Object.observe(fun, observer.callback);
 var myproto = {foo: 'bar'};
 fun.prototype = myproto;
 fun.prototype = 7;
 fun.prototype = 7;  // ignored
 Object.defineProperty(fun, 'prototype', {value: 8});
 Object.deliverChangeRecords(observer.callback);
@@ skipping 48 matching lines @@
   observer.assertCallbackRecords([
     { object: arr, name: '1', type: 'updated', oldValue: 212 }
   ]);
 }
 
 for (var b1 = 0; b1 < 2; ++b1)
   for (var b2 = 0; b2 < 2; ++b2)
     for (var b3 = 0; b3 < 2; ++b3)
       TestFastElements(b1 != 0, b2 != 0, b3 != 0);
 
-
 function TestFastElementsLength(polymorphic, optimize, oldSize, newSize) {
   var setLength = eval(
     "(function setLength(a, n) { a.length = n " +
     "/* " + polymorphic + " " + optimize + " " + oldSize + " " + newSize + " */"
     + "})"
   );
   print("TestFastElementsLength:", setLength);
 
   function array(n) {
     var arr = new Array(n);
@@ skipping 23 matching lines @@
     assertEquals('updated', lengthRecord.type);
     assertSame(oldSize, lengthRecord.oldValue);
   }
 }
 
 for (var b1 = 0; b1 < 2; ++b1)
   for (var b2 = 0; b2 < 2; ++b2)
     for (var n1 = 0; n1 < 3; ++n1)
       for (var n2 = 0; n2 < 3; ++n2)
         TestFastElementsLength(b1 != 0, b2 != 0, 20*n1, 20*n2);