Basic test for interaction of Object.observe and hidden prototypes

test/cctest/test-object-observe.cc

Index: test/cctest/test-object-observe.cc
diff --git a/test/cctest/test-object-observe.cc b/test/cctest/test-object-observe.cc
index abd10117dd49ea4fa5c8f7191dc66ddb42f6fed9..539db4f68ef13a8a9e07f8deb193c1f8321ca393 100644
--- a/test/cctest/test-object-observe.cc
+++ b/test/cctest/test-object-observe.cc
@@ -279,6 +279,7 @@ TEST(GlobalObjectObservation) {
   CHECK_EQ(3, CompileRun("records.length")->Int32Value());
 }
 
+
 struct RecordExpectation {
   Handle<Value> object;
   const char* type;
@@ -310,6 +311,9 @@ static void ExpectRecords(Handle<Value> records,
   }
 }
 
+#define EXPECT_RECORDS(records, expectations) \
+    ExpectRecords(records, expectations, ARRAY_SIZE(expectations))
+
 TEST(APITestBasicMutation) {
   HarmonyIsolate isolate;
   HandleScope scope;
@@ -348,7 +352,35 @@ TEST(APITestBasicMutation) {
     { obj, "deleted", "1", Number::New(5) },
     { obj, "deleted", "1.1", Number::New(6) }
   };
-  ExpectRecords(CompileRun("records"),
-                expected_records,
-                ARRAY_SIZE(expected_records));
+  EXPECT_RECORDS(CompileRun("records"), expected_records);
+}
+
+TEST(HiddenPrototypeObservation) {
+  HarmonyIsolate isolate;
+  HandleScope scope;
+  LocalContext context;
+  Handle<FunctionTemplate> tmpl = FunctionTemplate::New();
+  tmpl->SetHiddenPrototype(true);
+  tmpl->InstanceTemplate()->Set(String::New("foo"), Number::New(75));
+  Handle<Object> proto = tmpl->GetFunction()->NewInstance();
+  Handle<Object> obj = Object::New();
+  obj->SetPrototype(proto);
+  context->Global()->Set(String::New("obj"), obj);
+  context->Global()->Set(String::New("proto"), proto);
+  CompileRun(
+      "var records;"
+      "Object.observe(obj, function(r) { records = r });"

[rossberg, 2012/12/20 15:18:35]

How about also adding the dual test, where you observe the hidden prototype but
not the object?

[adamk, 2012/12/21 01:53:46]

Added. The result is...unfortunate. But in most uses of hidden prototypes I
wouldn't expect user code to even have access to the hidden proto in order to
call observe()!

[rossberg, 2012/12/21 11:32:11]

I'm not so sure. From V8DOMWindowShell.cpp:

// To implement split-window, see
//   1) https://bugs.webkit.org/show_bug.cgi?id=17249
//   2) https://wiki.mozilla.org/Gecko:SplitWindow
//   3) https://bugzilla.mozilla.org/show_bug.cgi?id=296639
// we need to split the shadow object further into two objects:
// an outer window and an inner window. The inner window is the hidden
// prototype of the outer window. The inner window is the default
// global object of the context. A variable declared in the global
// scope is a property of the inner window.
//
// The outer window sticks to a Frame, it is exposed to JavaScript
// via window.window, window.self, window.parent, etc. The outer window
// has a security token which is the domain. The outer window cannot
// have its own properties. window.foo = 'x' is delegated to the
// inner window.
//
// When a frame navigates to a new page, the inner window is cut off
// the outer window, and the outer window identify is preserved for
// the frame. However, a new inner window is created for the new page.
// If there are JS code holds a closure to the old inner window,
// it won't be able to reach the outer window via its global object.

That seems to imply that you can get a handle on both the outer and the inner
window, and try to observe either. Now, I have always thought that this is an
abomination, and one that fundamentally violates the JS object model. But it
seems to reflect the reality of the web, and the awful requirements of the DOM
spec.

+      "obj.foo = 41;"  // triggers a notification
+      "proto.foo = 42;"  // does not trigger a notification
+      );
+  const RecordExpectation expected_records[] = {
+    { obj, "updated", "foo", Number::New(75) }
+  };
+  EXPECT_RECORDS(CompileRun("records"), expected_records);
+  obj->SetPrototype(Null());
+  CompileRun("obj.foo = 43");
+  const RecordExpectation expected_records2[] = {
+    { obj, "new", "foo", Handle<Value>() }
+  };
+  EXPECT_RECORDS(CompileRun("records"), expected_records2);
 }