A64: Synchronize with r16849.

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 40 matching lines @@
 
  private:
   Isolate* isolate_;
 };
 }
 
 
 TEST(PerIsolateState) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context1;
+  LocalContext context1(isolate.GetIsolate());
   CompileRun(
       "var count = 0;"
       "var calls = 0;"
       "var observer = function(records) { count = records.length; calls++ };"
       "var obj = {};"
       "Object.observe(obj, observer);");
   Handle<Value> observer = CompileRun("observer");
   Handle<Value> obj = CompileRun("obj");
   Handle<Value> notify_fun1 = CompileRun(
       "(function() { obj.foo = 'bar'; })");
   Handle<Value> notify_fun2;
   {
-    LocalContext context2;
+    LocalContext context2(isolate.GetIsolate());
     context2->Global()->Set(String::New("obj"), obj);
     notify_fun2 = CompileRun(
         "(function() { obj.foo = 'baz'; })");
   }
   Handle<Value> notify_fun3;
   {
-    LocalContext context3;
+    LocalContext context3(isolate.GetIsolate());
     context3->Global()->Set(String::New("obj"), obj);
     notify_fun3 = CompileRun(
         "(function() { obj.foo = 'bat'; })");
   }
   {
-    LocalContext context4;
+    LocalContext context4(isolate.GetIsolate());
     context4->Global()->Set(String::New("observer"), observer);
     context4->Global()->Set(String::New("fun1"), notify_fun1);
     context4->Global()->Set(String::New("fun2"), notify_fun2);
     context4->Global()->Set(String::New("fun3"), notify_fun3);
     CompileRun("fun1(); fun2(); fun3(); Object.deliverChangeRecords(observer)");
   }
   CHECK_EQ(1, CompileRun("calls")->Int32Value());
   CHECK_EQ(3, CompileRun("count")->Int32Value());
 }
 
 
 TEST(EndOfMicrotaskDelivery) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context;
+  LocalContext context(isolate.GetIsolate());
   CompileRun(
       "var obj = {};"
       "var count = 0;"
       "var observer = function(records) { count = records.length };"
       "Object.observe(obj, observer);"
       "obj.foo = 'bar';");
   CHECK_EQ(1, CompileRun("count")->Int32Value());
 }
 
 
 TEST(DeliveryOrdering) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context;
+  LocalContext context(isolate.GetIsolate());
   CompileRun(
       "var obj1 = {};"
       "var obj2 = {};"
       "var ordering = [];"
       "function observer2() { ordering.push(2); };"
       "function observer1() { ordering.push(1); };"
       "function observer3() { ordering.push(3); };"
       "Object.observe(obj1, observer1);"
       "Object.observe(obj1, observer2);"
       "Object.observe(obj1, observer3);"
@@ skipping 11 matching lines @@
   CHECK_EQ(3, CompileRun("ordering.length")->Int32Value());
   CHECK_EQ(1, CompileRun("ordering[0]")->Int32Value());
   CHECK_EQ(2, CompileRun("ordering[1]")->Int32Value());
   CHECK_EQ(3, CompileRun("ordering[2]")->Int32Value());
 }
 
 
 TEST(DeliveryOrderingReentrant) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context;
+  LocalContext context(isolate.GetIsolate());
   CompileRun(
       "var obj = {};"
       "var reentered = false;"
       "var ordering = [];"
       "function observer1() { ordering.push(1); };"
       "function observer2() {"
       "  if (!reentered) {"
       "    obj.foo = 'baz';"
       "    reentered = true;"
       "  }"
@@ skipping 11 matching lines @@
   // Note that we re-deliver to observers 1 and 2, while observer3
   // already received the second record during the first round.
   CHECK_EQ(1, CompileRun("ordering[3]")->Int32Value());
   CHECK_EQ(2, CompileRun("ordering[1]")->Int32Value());
 }
 
 
 TEST(DeliveryOrderingDeliverChangeRecords) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context;
+  LocalContext context(isolate.GetIsolate());
   CompileRun(
       "var obj = {};"
       "var ordering = [];"
       "function observer1() { ordering.push(1); if (!obj.b) obj.b = true };"
       "function observer2() { ordering.push(2); };"
       "Object.observe(obj, observer1);"
       "Object.observe(obj, observer2);"
       "obj.a = 1;"
       "Object.deliverChangeRecords(observer2);");
   CHECK_EQ(4, CompileRun("ordering.length")->Int32Value());
   // First, observer2 is called due to deliverChangeRecords
   CHECK_EQ(2, CompileRun("ordering[0]")->Int32Value());
   // Then, observer1 is called when the stack unwinds
   CHECK_EQ(1, CompileRun("ordering[1]")->Int32Value());
   // observer1's mutation causes both 1 and 2 to be reactivated,
   // with 1 having priority.
   CHECK_EQ(1, CompileRun("ordering[2]")->Int32Value());
   CHECK_EQ(2, CompileRun("ordering[3]")->Int32Value());
 }
 
 
 TEST(ObjectHashTableGrowth) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   // Initializing this context sets up initial hash tables.
-  LocalContext context;
+  LocalContext context(isolate.GetIsolate());
   Handle<Value> obj = CompileRun("obj = {};");
   Handle<Value> observer = CompileRun(
       "var ran = false;"
       "(function() { ran = true })");
   {
     // As does initializing this context.
-    LocalContext context2;
+    LocalContext context2(isolate.GetIsolate());
     context2->Global()->Set(String::New("obj"), obj);
     context2->Global()->Set(String::New("observer"), observer);
     CompileRun(
         "var objArr = [];"
         // 100 objects should be enough to make the hash table grow
         // (and thus relocate).
         "for (var i = 0; i < 100; ++i) {"
         "  objArr.push({});"
         "  Object.observe(objArr[objArr.length-1], function(){});"
         "}"
         "Object.observe(obj, observer);");
   }
   // obj is now marked "is_observed", but our map has moved.
   CompileRun("obj.foo = 'bar'");
   CHECK(CompileRun("ran")->BooleanValue());
 }
 
 
 TEST(GlobalObjectObservation) {
   HarmonyIsolate isolate;
-  LocalContext context;
+  LocalContext context(isolate.GetIsolate());
   HandleScope scope(isolate.GetIsolate());
   Handle<Object> global_proxy = context->Global();
   Handle<Object> inner_global = global_proxy->GetPrototype().As<Object>();
   CompileRun(
       "var records = [];"
       "var global = this;"
       "Object.observe(global, function(r) { [].push.apply(records, r) });"
       "global.foo = 'hello';");
   CHECK_EQ(1, CompileRun("records.length")->Int32Value());
   CHECK(global_proxy->StrictEquals(CompileRun("records[0].object")));
@@ skipping 11 matching lines @@
   // Reattached, back to global proxy.
   context->ReattachGlobal(global_proxy);
   CompileRun("global.baz = 'again';");
   CHECK_EQ(3, CompileRun("records.length")->Int32Value());
   CHECK(global_proxy->StrictEquals(CompileRun("records[2].object")));
 
   // Attached to a different context, should not leak mutations
   // to the old context.
   context->DetachGlobal();
   {
-    LocalContext context2;
+    LocalContext context2(isolate.GetIsolate());
     context2->DetachGlobal();
     context2->ReattachGlobal(global_proxy);
     CompileRun(
         "var records2 = [];"
         "Object.observe(this, function(r) { [].push.apply(records2, r) });"
         "this.bat = 'context2';");
     CHECK_EQ(1, CompileRun("records2.length")->Int32Value());
     CHECK(global_proxy->StrictEquals(CompileRun("records2[0].object")));
   }
   CHECK_EQ(3, CompileRun("records.length")->Int32Value());
 
   // Attaching by passing to Context::New
   {
     // Delegates to Context::New
-    LocalContext context3(NULL, Handle<ObjectTemplate>(), global_proxy);
+    LocalContext context3(
+        isolate.GetIsolate(), NULL, Handle<ObjectTemplate>(), global_proxy);
     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());
 }
 
@@ skipping 31 matching lines @@
     }
   }
 }
 
 #define EXPECT_RECORDS(records, expectations) \
     ExpectRecords(records, expectations, ARRAY_SIZE(expectations))
 
 TEST(APITestBasicMutation) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context;
+  LocalContext context(isolate.GetIsolate());
   Handle<Object> obj = Handle<Object>::Cast(CompileRun(
       "var records = [];"
       "var obj = {};"
       "function observer(r) { [].push.apply(records, r); };"
       "Object.observe(obj, observer);"
       "obj"));
   obj->Set(String::New("foo"), Number::New(7));
   obj->Set(1, Number::New(2));
   // ForceSet should work just as well as Set
   obj->ForceSet(String::New("foo"), Number::New(3));
@@ skipping 23 matching lines @@
     { obj, "deleted", "1", Number::New(5) },
     { obj, "deleted", "1.1", Number::New(6) }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records);
 }
 
 
 TEST(HiddenPrototypeObservation) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context;
+  LocalContext context(isolate.GetIsolate());
   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;"
@@ skipping 28 matching lines @@
 
 
 static int NumberOfElements(i::Handle<i::JSWeakMap> map) {
   return i::ObjectHashTable::cast(map->table())->NumberOfElements();
 }
 
 
 TEST(ObservationWeakMap) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context;
+  LocalContext context(isolate.GetIsolate());
   CompileRun(
       "var obj = {};"
       "Object.observe(obj, function(){});"
       "Object.getNotifier(obj);"
       "obj = null;");
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate.GetIsolate());
   i::Handle<i::JSObject> observation_state =
-      i::Isolate::Current()->factory()->observation_state();
+      i_isolate->factory()->observation_state();
   i::Handle<i::JSWeakMap> callbackInfoMap =
       i::Handle<i::JSWeakMap>::cast(
           i::GetProperty(observation_state, "callbackInfoMap"));
   i::Handle<i::JSWeakMap> objectInfoMap =
       i::Handle<i::JSWeakMap>::cast(
           i::GetProperty(observation_state, "objectInfoMap"));
   i::Handle<i::JSWeakMap> notifierObjectInfoMap =
       i::Handle<i::JSWeakMap>::cast(
           i::GetProperty(observation_state, "notifierObjectInfoMap"));
   CHECK_EQ(1, NumberOfElements(callbackInfoMap));
   CHECK_EQ(1, NumberOfElements(objectInfoMap));
   CHECK_EQ(1, NumberOfElements(notifierObjectInfoMap));
-  HEAP->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
+  i_isolate->heap()->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
   CHECK_EQ(0, NumberOfElements(callbackInfoMap));
   CHECK_EQ(0, NumberOfElements(objectInfoMap));
   CHECK_EQ(0, NumberOfElements(notifierObjectInfoMap));
 }
 
 
 static bool NamedAccessAlwaysAllowed(Local<Object>, Local<Value>, AccessType,
                                      Local<Value>) {
   return true;
 }
@@ skipping 52 matching lines @@
   instance->CreationContext()->Global()->Set(String::New("obj"), instance);
   return instance;
 }
 
 
 TEST(NamedAccessCheck) {
   HarmonyIsolate isolate;
   const AccessType types[] = { ACCESS_GET, ACCESS_HAS };
   for (size_t i = 0; i < ARRAY_SIZE(types); ++i) {
     HandleScope scope(isolate.GetIsolate());
-    LocalContext context;
+    LocalContext context(isolate.GetIsolate());
     g_access_block_type = types[i];
     Handle<Object> instance = CreateAccessCheckedObject(
         NamedAccessAllowUnlessBlocked, IndexedAccessAlwaysAllowed);
     CompileRun("var records = null;"
                "var objNoCheck = {};"
                "var blacklist = {foo: true};"
                "var observer = function(r) { records = r };"
                "Object.observe(obj, observer);"
                "Object.observe(objNoCheck, observer);");
     Handle<Value> obj_no_check = CompileRun("objNoCheck");
     {
-      LocalContext context2;
+      LocalContext context2(isolate.GetIsolate());
       context2->Global()->Set(String::New("obj"), instance);
       context2->Global()->Set(String::New("objNoCheck"), obj_no_check);
       CompileRun("var records2 = null;"
                  "var observer2 = function(r) { records2 = r };"
                  "Object.observe(obj, observer2);"
                  "Object.observe(objNoCheck, observer2);"
                  "obj.foo = 'bar';"
                  "Object.defineProperty(obj, 'foo', {value: 5});"
                  "Object.defineProperty(obj, 'foo', {get: function(){}});"
                  "obj.bar = 'baz';"
@@ skipping 14 matching lines @@
     EXPECT_RECORDS(CompileRun("records"), expected_records);
   }
 }
 
 
 TEST(IndexedAccessCheck) {
   HarmonyIsolate isolate;
   const AccessType types[] = { ACCESS_GET, ACCESS_HAS };
   for (size_t i = 0; i < ARRAY_SIZE(types); ++i) {
     HandleScope scope(isolate.GetIsolate());
-    LocalContext context;
+    LocalContext context(isolate.GetIsolate());
     g_access_block_type = types[i];
     Handle<Object> instance = CreateAccessCheckedObject(
         NamedAccessAlwaysAllowed, IndexedAccessAllowUnlessBlocked);
     CompileRun("var records = null;"
                "var objNoCheck = {};"
                "var blacklist = {7: true};"
                "var observer = function(r) { records = r };"
                "Object.observe(obj, observer);"
                "Object.observe(objNoCheck, observer);");
     Handle<Value> obj_no_check = CompileRun("objNoCheck");
     {
-      LocalContext context2;
+      LocalContext context2(isolate.GetIsolate());
       context2->Global()->Set(String::New("obj"), instance);
       context2->Global()->Set(String::New("objNoCheck"), obj_no_check);
       CompileRun("var records2 = null;"
                  "var observer2 = function(r) { records2 = r };"
                  "Object.observe(obj, observer2);"
                  "Object.observe(objNoCheck, observer2);"
                  "obj[7] = 'foo';"
                  "Object.defineProperty(obj, '7', {value: 5});"
                  "Object.defineProperty(obj, '7', {get: function(){}});"
                  "obj[8] = 'bar';"
@@ skipping 12 matching lines @@
       { obj_no_check, "new", "42", Handle<Value>() }
     };
     EXPECT_RECORDS(CompileRun("records"), expected_records);
   }
 }
 
 
 TEST(SpliceAccessCheck) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context;
+  LocalContext context(isolate.GetIsolate());
   g_access_block_type = ACCESS_GET;
   Handle<Object> instance = CreateAccessCheckedObject(
       NamedAccessAlwaysAllowed, IndexedAccessAllowUnlessBlocked);
   CompileRun("var records = null;"
              "obj[1] = 'foo';"
              "obj.length = 2;"
              "var objNoCheck = {1: 'bar', length: 2};"
              "var blacklist = {1: true};"
              "observer = function(r) { records = r };"
              "Array.observe(obj, observer);"
              "Array.observe(objNoCheck, observer);");
   Handle<Value> obj_no_check = CompileRun("objNoCheck");
   {
-    LocalContext context2;
+    LocalContext context2(isolate.GetIsolate());
     context2->Global()->Set(String::New("obj"), instance);
     context2->Global()->Set(String::New("objNoCheck"), obj_no_check);
     CompileRun("var records2 = null;"
                "var observer2 = function(r) { records2 = r };"
                "Array.observe(obj, observer2);"
                "Array.observe(objNoCheck, observer2);"
                // No one should hear about this: no splice records are emitted
                // for access-checked objects
                "[].push.call(obj, 5);"
                "[].splice.call(obj, 1, 1);"
@@ skipping 10 matching lines @@
   const RecordExpectation expected_records[] = {
     { obj_no_check, "splice", "", Handle<Value>() }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records);
 }
 
 
 TEST(DisallowAllForAccessKeys) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context;
+  LocalContext context(isolate.GetIsolate());
   Handle<Object> instance = CreateAccessCheckedObject(
       BlockAccessKeys, IndexedAccessAlwaysAllowed);
   CompileRun("var records = null;"
              "var objNoCheck = {};"
              "var observer = function(r) { records = r };"
              "var blacklist = {__block_access_keys: true};"
              "Object.observe(obj, observer);"
              "Object.observe(objNoCheck, observer);");
   Handle<Value> obj_no_check = CompileRun("objNoCheck");
   {
-    LocalContext context2;
+    LocalContext context2(isolate.GetIsolate());
     context2->Global()->Set(String::New("obj"), instance);
     context2->Global()->Set(String::New("objNoCheck"), obj_no_check);
     CompileRun("var records2 = null;"
                "var observer2 = function(r) { records2 = r };"
                "Object.observe(obj, observer2);"
                "Object.observe(objNoCheck, observer2);"
                "obj.foo = 'bar';"
                "obj[5] = 'baz';"
                "objNoCheck.baz = 'quux'");
     const RecordExpectation expected_records2[] = {
       { instance, "new", "foo", Handle<Value>() },
       { instance, "new", "5", Handle<Value>() },
       { obj_no_check, "new", "baz", Handle<Value>() },
     };
     EXPECT_RECORDS(CompileRun("records2"), expected_records2);
   }
   const RecordExpectation expected_records[] = {
     { obj_no_check, "new", "baz", Handle<Value>() }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records);
 }
 
 
 TEST(AccessCheckDisallowApiModifications) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context;
+  LocalContext context(isolate.GetIsolate());
   Handle<Object> instance = CreateAccessCheckedObject(
       BlockAccessKeys, IndexedAccessAlwaysAllowed);
   CompileRun("var records = null;"
              "var observer = function(r) { records = r };"
              "var blacklist = {__block_access_keys: true};"
              "Object.observe(obj, observer);");
   {
-    LocalContext context2;
+    LocalContext context2(isolate.GetIsolate());
     context2->Global()->Set(String::New("obj"), instance);
     CompileRun("var records2 = null;"
                "var observer2 = function(r) { records2 = r };"
                "Object.observe(obj, observer2);");
     instance->Set(5, String::New("bar"));
     instance->Set(String::New("foo"), String::New("bar"));
     CompileRun("");  // trigger delivery
     const RecordExpectation expected_records2[] = {
       { instance, "new", "5", Handle<Value>() },
       { instance, "new", "foo", Handle<Value>() }
     };
     EXPECT_RECORDS(CompileRun("records2"), expected_records2);
   }
   CHECK(CompileRun("records")->IsNull());
 }