Implement Object.getNotifier() and remove Object.notify()

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 83 matching lines @@
 })
 
 // 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);
 
 // Object.unobserve
 assertThrows(function() { Object.unobserve(4, observer.callback); }, TypeError);
 
-// Object.notify
-assertThrows(function() { Object.notify(obj, {}); }, TypeError);
-assertThrows(function() { Object.notify(obj, { type: 4 }); }, TypeError);
+// 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.notify.call(undefined, { type: 'a' });
+}, TypeError);
+assertThrows(function() {
+  notifier.notify.call(null, { type: 'a' });
+}, TypeError);

[rossberg, 2012/11/09 14:41:25]

Also:  notifier.notify.call({}, { type: 'a' })
Does nothing, but perhaps should throw? (see other comment)

[adamk, 2012/11/09 14:48:41]

Added a test for this below

 assertFalse(recordCreated);
-Object.notify(obj, changeRecordWithAccessor);
-assertFalse(recordCreated);
+notifier.notify(changeRecordWithAccessor);
+assertFalse(recordCreated); // not observed yet

[rossberg, 2012/11/09 14:41:25]

Nit: 2 spaces before //

[adamk, 2012/11/09 14:48:41]

Damn, WebKit vs google3 style getting me in trouble...

 
 // Object.deliverChangeRecords
 assertThrows(function() { Object.deliverChangeRecords(nonFunction); }, TypeError);
 
 // Multiple records are delivered.
 Object.observe(obj, observer.callback);
-Object.notify(obj, {
-  object: obj,
+notifier.notify({
   type: 'updated',
   name: 'foo',
   expando: 1
 });
 
-Object.notify(obj, {
-  object: obj,
+notifier.notify({
+  object: notifier, // object property is ignored

[rossberg, 2012/11/09 14:41:25]

dito

[adamk, 2012/11/09 14:48:41]

Done.

   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.notify(obj, {
+Object.getNotifier(obj).notify({
   type: 'foo',
 });
 Object.deliverChangeRecords(observer.callback);
 observer.assertCalled();
 
 // Observation can be stopped.
 reset();
 Object.unobserve(obj, observer.callback);
-Object.notify(obj, {
+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.notify(obj, {
+Object.getNotifier(obj).notify({
   type: 'foo',
 });
 Object.deliverChangeRecords(observer.callback);
 observer.assertNotCalled();
 
 // Re-observation works and only includes changeRecords after of call.
 reset();
-Object.notify(obj, {
+Object.getNotifier(obj).notify({
   type: 'foo',
 });
 Object.observe(obj, observer.callback);
-Object.notify(obj, {
+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.notify(obj, {
+Object.getNotifier(obj).notify({
   type: 'foo',
   val: 1
 });
 
 Object.unobserve(obj, observer.callback);
-Object.notify(obj, {
+Object.getNotifier(obj).notify({
   type: 'foo',
   val: 2
 });
 
 Object.observe(obj, observer.callback);
-Object.notify(obj, {
+Object.getNotifier(obj).notify({
   type: 'foo',
   val: 3
 });
 
 Object.unobserve(obj, observer.callback);
-Object.notify(obj, {
+Object.getNotifier(obj).notify({
   type: 'foo',
   val: 4
 });
 
 Object.observe(obj, observer.callback);
-Object.notify(obj, {
+Object.getNotifier(obj).notify({
   type: 'foo',
   val: 5
 });
 
 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.notify(obj, {
+Object.getNotifier(obj).notify({
   type: 'foo1',
 });
-Object.notify(obj2, {
+Object.getNotifier(obj2).notify({
   type: 'foo2',
 });
-Object.notify(obj3, {
+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' }
 ]);
 
@@ skipping 178 matching lines @@
   { 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' },
 ]);