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 38 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++) {
-        print(i, JSON.stringify(this.records[i]), JSON.stringify(recs[i]));
+        try {
+          print(i, JSON.stringify(this.records[i]), JSON.stringify(recs[i]));
+        } catch (e) { }

[rossberg, 2012/11/21 12:43:17]

Can you factor this out into a helper function that you use here and below?

[adamk, 2012/11/21 17:02:57]

Done.

         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));
+      try {
+        print("callback", JSON.stringify(handler.proxy), JSON.stringify(got));
+      } catch (e) { }
       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 20 matching lines @@
 // TODO(observe): ...or don't work yet.
 function blacklisted(obj, prop) {
   return (obj instanceof Array && prop == 1) ||
     (obj instanceof Int32Array && prop == 1) ||
     (obj instanceof Int32Array && prop === "length") ||
     // TODO(observe): oldValue when deleting/reconfiguring indexed accessor
     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);
+  try { print("***", typeof obj, JSON.stringify(obj), prop) } catch (e) { };
   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},
 ]);