Make Object.observe on the global object functional

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 14 matching lines @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Flags: --harmony-observation --harmony-proxies --harmony-collections
 
 var allObservers = [];
 function reset() {
   allObservers.forEach(function(observer) { observer.reset(); });
 }
 
+function stringifyNoThrow(arg) {
+  try {
+    return JSON.stringify(arg);
+  } catch (e) {
+    return '{<circular reference>}';
+  }
+}
+
 function createObserver() {
   "use strict";  // So that |this| in callback can be undefined.
 
   var observer = {
     records: undefined,
     callbackCount: 0,
     reset: function() {
       this.records = undefined;
       this.callbackCount = 0;
     },
     assertNotCalled: function() {
       assertEquals(undefined, this.records);
       assertEquals(0, this.callbackCount);
     },
     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);
-        print(i, JSON.stringify(this.records[i]), JSON.stringify(recs[i]));
+        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);
     assertEquals('object', typeof r);
@@ skipping 385 matching lines @@
     delete: function(k) {
       var x = delete this.target[k];
       Object.deliverChangeRecords(this.callback);
       return x;
     },
     getPropertyNames: function() {
       return Object.getOwnPropertyNames(this.target);
     },
     target: {isProxy: true},
     callback: function(changeRecords) {
-      print("callback", JSON.stringify(handler.proxy), JSON.stringify(got));
+      print("callback", stringifyNoThrow(handler.proxy), stringifyNoThrow(got));
       for (var i in changeRecords) {
         var got = changeRecords[i];
         var change = {object: handler.proxy, name: got.name, type: got.type};
         if ("oldValue" in got) change.oldValue = got.oldValue;
         Object.getNotifier(handler.proxy).notify(change);
       }
     },
   };
   Object.observe(handler.target, handler.callback);
   return handler.proxy = create(handler, x);
@@ skipping 18 matching lines @@
 
 // Cases that yield non-standard results.
 // TODO(observe): ...or don't work yet.
 function blacklisted(obj, prop) {
   return (obj instanceof Int32Array && prop == 1) ||
     (obj instanceof Int32Array && prop === "length") ||
     (obj instanceof ArrayBuffer && prop == 1) ||
     // TODO(observe): oldValue when reconfiguring array length
     (obj instanceof Array && prop === "length") ||
     // TODO(observe): prototype property on functions
-    (obj instanceof Function && prop === "prototype") ||
-    // TODO(observe): global object
-    obj === this;
+    (obj instanceof Function && prop === "prototype")
 }
 
 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, JSON.stringify(obj), prop);
+  print("***", typeof obj, stringifyNoThrow(obj), prop);
   if (!desc || desc.configurable)
     TestObserveConfigurable(obj, prop);
   else if (desc.writable)
     TestObserveNonConfigurable(obj, prop);
 }
 
 
 // Observing array length (including truncation)
 reset();
 var arr = ['a', 'b', 'c', 'd'];
@@ skipping 242 matching lines @@
 Object.observe(dummy, observer.callback);
 Object.unobserve(dummy, observer.callback);
 var array = [0];
 Object.observe(array, observer.callback);
 array.splice(0, 1);
 Object.deliverChangeRecords(observer.callback);
 observer.assertCallbackRecords([
   { object: array, name: '0', type: 'deleted', oldValue: 0 },
   { object: array, name: 'length', type: 'updated', oldValue: 1},
 ]);