performChange no longer takes a |receiver| argument

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 127 matching lines @@
 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);
+  assertEquals(undefined, 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);
@@ skipping 228 matching lines @@
 }
 
 Thingy.MULTIPLY = 'multiply';
 Thingy.INCREMENT = 'increment';
 Thingy.INCREMENT_AND_MULTIPLY = 'incrementAndMultiply';
 
 Thingy.prototype = {
   increment: function(amount) {
     var notifier = Object.getNotifier(this);
 
+    var self = this;
     notifier.performChange(Thingy.INCREMENT, function() {
-      this.a += amount;
-      this.b += amount;
-    }, this);
+      self.a += amount;
+      self.b += amount;
+    });
 
     notifier.notify({
       object: this,
       type: Thingy.INCREMENT,
       incremented: amount
     });
   },
 
   multiply: function(amount) {
     var notifier = Object.getNotifier(this);
 
+    var self = this;
     notifier.performChange(Thingy.MULTIPLY, function() {
-      this.a *= amount;
-      this.b *= amount;
-    }, this);
+      self.a *= amount;
+      self.b *= amount;
+    });
 
     notifier.notify({
       object: this,
       type: Thingy.MULTIPLY,
       multiplied: amount
     });
   },
 
   incrementAndMultiply: function(incAmount, multAmount) {
     var notifier = Object.getNotifier(this);
 
+    var self = this;
     notifier.performChange(Thingy.INCREMENT_AND_MULTIPLY, function() {
-      this.increment(incAmount);
-      this.multiply(multAmount);
-    }, this);
+      self.increment(incAmount);
+      self.multiply(multAmount);
+    });
 
     notifier.notify({
       object: this,
       type: Thingy.INCREMENT_AND_MULTIPLY,
       incremented: incAmount,
       multiplied: multAmount
     });
   }
 }
 
@@ skipping 51 matching lines @@
 
 RecursiveThingy.MULTIPLY_FIRST_N = 'multiplyFirstN';
 
 RecursiveThingy.prototype = {
   __proto__: Array.prototype,
 
   multiplyFirstN: function(amount, n) {
     if (!n)
       return;
     var notifier = Object.getNotifier(this);
+    var self = this;
     notifier.performChange(RecursiveThingy.MULTIPLY_FIRST_N, function() {
-      this[n-1] = this[n-1]*amount;
-      this.multiplyFirstN(amount, n-1);
-    }, this);
+      self[n-1] = self[n-1]*amount;
+      self.multiplyFirstN(amount, n-1);
+    });
 
     notifier.notify({
       object: this,
       type: RecursiveThingy.MULTIPLY_FIRST_N,
       multiplied: amount,
       n: n
     });
   },
 }
 
@@ skipping 28 matching lines @@
   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);
+    var self = 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);
+      self.reverse();
+      self.sort(function() { return Math.random()* 2 - 1; });
+      var cut = self.splice(0, 6);
+      Array.prototype.push.apply(self, cut);
+      self.reverse();
+      self.sort(function() { return Math.random()* 2 - 1; });
+      var cut = self.splice(0, 6);
+      Array.prototype.push.apply(self, cut);
+      self.reverse();
+      self.sort(function() { return Math.random()* 2 - 1; });
+    });
 
     notifier.notify({
       object: this,
       type: DeckSuit.SHUFFLE
     });
   },
 }
 
 DeckSuit.observe = function(thingy, callback) {
   Object.observe(thingy, callback, [DeckSuit.SHUFFLE]);
@@ skipping 943 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);