Revert "Implement Object.getNotifier(obj).performChange()" (r14696)

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 70 matching lines @@
     observer.records = r;
     observer.callbackCount++;
   };
 
   observer.reset();
   allObservers.push(observer);
   return observer;
 }
 
 var observer = createObserver();
-var observer2 = createObserver();
-
 assertEquals("function", typeof observer.callback);
-assertEquals("function", typeof observer2.callback);
-
 var obj = {};
 
 function frozenFunction() {}
 Object.freeze(frozenFunction);
 var nonFunction = {};
 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);
-assertThrows(function() { Object.observe(obj, function() {}, 1); }, TypeError);
-assertThrows(function() { Object.observe(obj, function() {}, [undefined]); }, TypeError);
-assertThrows(function() { Object.observe(obj, function() {}, [1]); }, TypeError);
-assertThrows(function() { Object.observe(obj, function() {}, ['foo', null]); }, TypeError);
-assertEquals(obj, Object.observe(obj, observer.callback, ['foo', 'bar', 'baz']));
-assertEquals(obj, Object.observe(obj, observer.callback, []));
-assertEquals(obj, Object.observe(obj, observer.callback, undefined));
 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);
-
-assertThrows(function() { notifier.performChange(1, function(){}); }, TypeError);
-assertThrows(function() { notifier.performChange(undefined, function(){}); }, TypeError);
-assertThrows(function() { notifier.performChange('foo', undefined); }, TypeError);
-assertThrows(function() { notifier.performChange('foo', 'bar'); }, TypeError);
-var testSelf = {};
-notifier.performChange('foo', function() {
-  assertTrue(testSelf === this);
-}, testSelf);
-var self = this;
-notifier.performChange('foo', function() {
-  assertTrue(self === this);
-});
-
 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
@@ skipping 45 matching lines @@
 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: 'updated',
+  type: 'foo',
 });
 Object.deliverChangeRecords(observer.callback);
 observer.assertCalled();
 
 
 // Observation can be stopped.
 reset();
 Object.unobserve(obj, observer.callback);
 Object.getNotifier(obj).notify({
-  type: 'updated',
+  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: 'updated',
+  type: 'foo',
 });
 Object.deliverChangeRecords(observer.callback);
 observer.assertNotCalled();
 
 
 // Re-observation works and only includes changeRecords after of call.
 reset();
 Object.getNotifier(obj).notify({
-  type: 'updated',
+  type: 'foo',
 });
 Object.observe(obj, observer.callback);
 Object.getNotifier(obj).notify({
-  type: 'updated',
+  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: 'updated',
+  type: 'foo',
   val: 1
 });
 
 Object.unobserve(obj, observer.callback);
 Object.getNotifier(obj).notify({
-  type: 'updated',
+  type: 'foo',
   val: 2
 });
 
 Object.observe(obj, observer.callback);
 Object.getNotifier(obj).notify({
-  type: 'updated',
+  type: 'foo',
   val: 3
 });
 
 Object.unobserve(obj, observer.callback);
 Object.getNotifier(obj).notify({
-  type: 'updated',
+  type: 'foo',
   val: 4
 });
 
 Object.observe(obj, observer.callback);
 Object.getNotifier(obj).notify({
-  type: 'updated',
+  type: 'foo',
   val: 5
 });
 
 Object.unobserve(obj, observer.callback);
 Object.deliverChangeRecords(observer.callback);
 observer.assertCallbackRecords([
-  { object: obj, type: 'updated', val: 1 },
-  { object: obj, type: 'updated', val: 3 },
-  { object: obj, type: 'updated', val: 5 }
-]);
-
-// Accept
-reset();
-Object.observe(obj, observer.callback, []);
-Object.getNotifier(obj).notify({
-  type: 'new'
-});
-Object.getNotifier(obj).notify({
-  type: 'updated'
-});
-Object.getNotifier(obj).notify({
-  type: 'deleted'
-});
-Object.getNotifier(obj).notify({
-  type: 'reconfigured'
-});
-Object.getNotifier(obj).notify({
-  type: 'prototype'
-});
-Object.deliverChangeRecords(observer.callback);
-observer.assertNotCalled();
-
-reset();
-Object.observe(obj, observer.callback, ['new', 'deleted', 'prototype']);
-Object.getNotifier(obj).notify({
-  type: 'new'
-});
-Object.getNotifier(obj).notify({
-  type: 'updated'
-});
-Object.getNotifier(obj).notify({
-  type: 'deleted'
-});
-Object.getNotifier(obj).notify({
-  type: 'deleted'
-});
-Object.getNotifier(obj).notify({
-  type: 'reconfigured'
-});
-Object.getNotifier(obj).notify({
-  type: 'prototype'
-});
-Object.deliverChangeRecords(observer.callback);
-observer.assertCallbackRecords([
-  { object: obj, type: 'new' },
-  { object: obj, type: 'deleted' },
-  { object: obj, type: 'deleted' },
-  { object: obj, type: 'prototype' }
-]);
-
-reset();
-Object.observe(obj, observer.callback, ['updated', 'foo']);
-Object.getNotifier(obj).notify({
-  type: 'new'
-});
-Object.getNotifier(obj).notify({
-  type: 'updated'
-});
-Object.getNotifier(obj).notify({
-  type: 'deleted'
-});
-Object.getNotifier(obj).notify({
-  type: 'foo'
-});
-Object.getNotifier(obj).notify({
-  type: 'bar'
-});
-Object.getNotifier(obj).notify({
-  type: 'foo'
-});
-Object.deliverChangeRecords(observer.callback);
-observer.assertCallbackRecords([
-  { object: obj, type: 'updated' },
-  { object: obj, type: 'foo' },
-  { object: obj, type: 'foo' }
-]);
-
-reset();
-function Thingy(a, b, c) {
-  this.a = a;
-  this.b = b;
-}
-
-Thingy.MULTIPLY = 'multiply';
-Thingy.INCREMENT = 'increment';
-Thingy.INCREMENT_AND_MULTIPLY = 'incrementAndMultiply';
-
-Thingy.prototype = {
-  increment: function(amount) {
-    var notifier = Object.getNotifier(this);
-
-    notifier.performChange(Thingy.INCREMENT, function() {
-      this.a += amount;
-      this.b += amount;
-    }, this);
-
-    notifier.notify({
-      object: this,
-      type: Thingy.INCREMENT,
-      incremented: amount
-    });
-  },
-
-  multiply: function(amount) {
-    var notifier = Object.getNotifier(this);
-
-    notifier.performChange(Thingy.MULTIPLY, function() {
-      this.a *= amount;
-      this.b *= amount;
-    }, this);
-
-    notifier.notify({
-      object: this,
-      type: Thingy.MULTIPLY,
-      multiplied: amount
-    });
-  },
-
-  incrementAndMultiply: function(incAmount, multAmount) {
-    var notifier = Object.getNotifier(this);
-
-    notifier.performChange(Thingy.INCREMENT_AND_MULTIPLY, function() {
-      this.increment(incAmount);
-      this.multiply(multAmount);
-    }, this);
-
-    notifier.notify({
-      object: this,
-      type: Thingy.INCREMENT_AND_MULTIPLY,
-      incremented: incAmount,
-      multiplied: multAmount
-    });
-  }
-}
-
-Thingy.observe = function(thingy, callback) {
-  Object.observe(thingy, callback, [Thingy.INCREMENT,
-                                    Thingy.MULTIPLY,
-                                    Thingy.INCREMENT_AND_MULTIPLY,
-                                    'updated']);
-}
-
-Thingy.unobserve = function(thingy, callback) {
-  Object.unobserve(thingy);
-}
-
-var thingy = new Thingy(2, 4);
-
-Object.observe(thingy, observer.callback);
-Thingy.observe(thingy, observer2.callback);
-thingy.increment(3);               // { a: 5, b: 7 }
-thingy.b++;                        // { a: 5, b: 8 }
-thingy.multiply(2);                // { a: 10, b: 16 }
-thingy.a++;                        // { a: 11, b: 16 }
-thingy.incrementAndMultiply(2, 2); // { a: 26, b: 36 }
-
-Object.deliverChangeRecords(observer.callback);
-Object.deliverChangeRecords(observer2.callback);
-observer.assertCallbackRecords([
-  { object: thingy, type: 'updated', name: 'a', oldValue: 2 },
-  { object: thingy, type: 'updated', name: 'b', oldValue: 4 },
-  { object: thingy, type: 'updated', name: 'b', oldValue: 7 },
-  { object: thingy, type: 'updated', name: 'a', oldValue: 5 },
-  { object: thingy, type: 'updated', name: 'b', oldValue: 8 },
-  { object: thingy, type: 'updated', name: 'a', oldValue: 10 },
-  { object: thingy, type: 'updated', name: 'a', oldValue: 11 },
-  { object: thingy, type: 'updated', name: 'b', oldValue: 16 },
-  { object: thingy, type: 'updated', name: 'a', oldValue: 13 },
-  { object: thingy, type: 'updated', name: 'b', oldValue: 18 },
-]);
-observer2.assertCallbackRecords([
-  { object: thingy, type: Thingy.INCREMENT, incremented: 3 },
-  { object: thingy, type: 'updated', name: 'b', oldValue: 7 },
-  { object: thingy, type: Thingy.MULTIPLY, multiplied: 2 },
-  { object: thingy, type: 'updated', name: 'a', oldValue: 10 },
-  {
-    object: thingy,
-    type: Thingy.INCREMENT_AND_MULTIPLY,
-    incremented: 2,
-    multiplied: 2
-  }
+  { object: obj, type: 'foo', val: 1 },
+  { object: obj, type: 'foo', val: 3 },
+  { object: obj, type: 'foo', val: 5 }
 ]);
 
 
-reset();
-function RecursiveThingy() {}
-
-RecursiveThingy.MULTIPLY_FIRST_N = 'multiplyFirstN';
-
-RecursiveThingy.prototype = {
-  __proto__: Array.prototype,
-
-  multiplyFirstN: function(amount, n) {
-    if (!n)
-      return;
-    var notifier = Object.getNotifier(this);
-    notifier.performChange(RecursiveThingy.MULTIPLY_FIRST_N, function() {
-      this[n-1] = this[n-1]*amount;
-      this.multiplyFirstN(amount, n-1);
-    }, this);
-
-    notifier.notify({
-      object: this,
-      type: RecursiveThingy.MULTIPLY_FIRST_N,
-      multiplied: amount,
-      n: n
-    });
-  },
-}
-
-RecursiveThingy.observe = function(thingy, callback) {
-  Object.observe(thingy, callback, [RecursiveThingy.MULTIPLY_FIRST_N]);
-}
-
-RecursiveThingy.unobserve = function(thingy, callback) {
-  Object.unobserve(thingy);
-}
-
-var thingy = new RecursiveThingy;
-thingy.push(1, 2, 3, 4);
-
-Object.observe(thingy, observer.callback);
-RecursiveThingy.observe(thingy, observer2.callback);
-thingy.multiplyFirstN(2, 3);                // [2, 4, 6, 4]
-
-Object.deliverChangeRecords(observer.callback);
-Object.deliverChangeRecords(observer2.callback);
-observer.assertCallbackRecords([
-  { object: thingy, type: 'updated', name: '2', oldValue: 3 },
-  { object: thingy, type: 'updated', name: '1', oldValue: 2 },
-  { object: thingy, type: 'updated', name: '0', oldValue: 1 }
-]);
-observer2.assertCallbackRecords([
-  { object: thingy, type: RecursiveThingy.MULTIPLY_FIRST_N, multiplied: 2, n: 3 }
-]);
-
-reset();
-function DeckSuit() {
-  this.push('1', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'A', 'Q', 'K');
-}
-
-DeckSuit.SHUFFLE = 'shuffle';
-
-DeckSuit.prototype = {
-  __proto__: Array.prototype,
-
-  shuffle: function() {
-    var notifier = Object.getNotifier(this);
-    notifier.performChange(DeckSuit.SHUFFLE, function() {
-      this.reverse();
-      this.sort(function() { return Math.random()* 2 - 1; });
-      var cut = this.splice(0, 6);
-      Array.prototype.push.apply(this, cut);
-      this.reverse();
-      this.sort(function() { return Math.random()* 2 - 1; });
-      var cut = this.splice(0, 6);
-      Array.prototype.push.apply(this, cut);
-      this.reverse();
-      this.sort(function() { return Math.random()* 2 - 1; });
-    }, this);
-
-    notifier.notify({
-      object: this,
-      type: DeckSuit.SHUFFLE
-    });
-  },
-}
-
-DeckSuit.observe = function(thingy, callback) {
-  Object.observe(thingy, callback, [DeckSuit.SHUFFLE]);
-}
-
-DeckSuit.unobserve = function(thingy, callback) {
-  Object.unobserve(thingy);
-}
-
-var deck = new DeckSuit;
-
-DeckSuit.observe(deck, observer2.callback);
-deck.shuffle();
-
-Object.deliverChangeRecords(observer2.callback);
-observer2.assertCallbackRecords([
-  { object: deck, type: DeckSuit.SHUFFLE }
-]);
-
 // 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: 'new',
+  type: 'foo1',
 });
 Object.getNotifier(obj2).notify({
-  type: 'updated',
+  type: 'foo2',
 });
 Object.getNotifier(obj3).notify({
-  type: 'deleted',
+  type: 'foo3',
 });
 Object.observe(obj3, observer.callback);
 Object.deliverChangeRecords(observer.callback);
 observer.assertCallbackRecords([
-  { object: obj, type: 'new' },
-  { object: obj2, type: 'updated' },
-  { object: obj3, type: 'deleted' }
+  { 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];
@@ skipping 758 matching lines @@
     for (var n1 = 0; n1 < 3; ++n1)
       for (var n2 = 0; n2 < 3; ++n2)
         for (var i in mutation)
           TestFastElementsLength(mutation[i], b1 != 0, b2 != 0, 20*n1, 20*n2);
 
 for (var b1 = 0; b1 < 2; ++b1)
   for (var b2 = 0; b2 < 2; ++b2)
     for (var n = 0; n < 3; ++n)
       for (var i in mutationByIncr)
         TestFastElementsLength(mutationByIncr[i], b1 != 0, b2 != 0, 7*n, 7*n+1);