Basic test for interaction of Object.observe and hidden prototypes

test/cctest/test-object-observe.cc

 // 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 261 matching lines @@
     CompileRun(
         "var records3 = [];"
         "Object.observe(this, function(r) { [].push.apply(records3, r) });"
         "this.qux = 'context3';");
     CHECK_EQ(1, CompileRun("records3.length")->Int32Value());
     CHECK(global_proxy->StrictEquals(CompileRun("records3[0].object")));
   }
   CHECK_EQ(3, CompileRun("records.length")->Int32Value());
 }
 
+
 struct RecordExpectation {
   Handle<Value> object;
   const char* type;
   const char* name;
   Handle<Value> old_value;
 };
 
 // TODO(adamk): Use this helper elsewhere in this file.
 static void ExpectRecords(Handle<Value> records,
                           const RecordExpectation expectations[],
@@ skipping 11 matching lines @@
         recordObj->Get(String::New("type"))));
     CHECK(String::New(expectations[i].name)->Equals(
         recordObj->Get(String::New("name"))));
     if (!expectations[i].old_value.IsEmpty()) {
       CHECK(expectations[i].old_value->Equals(
           recordObj->Get(String::New("oldValue"))));
     }
   }
 }
 
+#define EXPECT_RECORDS(records, expectations) \
+    ExpectRecords(records, expectations, ARRAY_SIZE(expectations))
+
 TEST(APITestBasicMutation) {
   HarmonyIsolate isolate;
   HandleScope scope;
   LocalContext context;
   Handle<Object> obj = Handle<Object>::Cast(CompileRun(
       "var records = [];"
       "var obj = {};"
       "function observer(r) { [].push.apply(records, r); };"
       "Object.observe(obj, observer);"
       "obj"));
@@ skipping 18 matching lines @@
     { obj, "new", "foo", Handle<Value>() },
     { obj, "new", "1", Handle<Value>() },
     { obj, "updated", "foo", Number::New(1) },
     { obj, "updated", "1", Number::New(2) },
     { obj, "updated", "1", Number::New(4) },
     { obj, "new", "1.1", Handle<Value>() },
     { obj, "deleted", "foo", Number::New(3) },
     { 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);
+}