Revert "Enable Object.observe by default"

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 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.
 
 #include "v8.h"
 
 #include "cctest.h"
 
 using namespace v8;
 namespace i = v8::internal;
 
+namespace {
+// Need to create a new isolate when FLAG_harmony_observation is on.
+class HarmonyIsolate {
+ public:
+  HarmonyIsolate() {
+    i::FLAG_harmony_observation = true;
+    isolate_ = Isolate::New();
+    isolate_->Enter();
+  }
+
+  ~HarmonyIsolate() {
+    isolate_->Exit();
+    isolate_->Dispose();
+  }
+
+  Isolate* GetIsolate() const { return isolate_; }
+
+ private:
+  Isolate* isolate_;
+};
+}
+
 
 TEST(PerIsolateState) {
-  HandleScope scope(CcTest::isolate());
-  LocalContext context1(CcTest::isolate());
+  HarmonyIsolate isolate;
+  HandleScope scope(isolate.GetIsolate());
+  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(CcTest::isolate());
-    context2->Global()->Set(String::NewFromUtf8(CcTest::isolate(), "obj"),
+    LocalContext context2(isolate.GetIsolate());
+    context2->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "obj"),
                             obj);
     notify_fun2 = CompileRun(
         "(function() { obj.foo = 'baz'; })");
   }
   Handle<Value> notify_fun3;
   {
-    LocalContext context3(CcTest::isolate());
-    context3->Global()->Set(String::NewFromUtf8(CcTest::isolate(), "obj"),
+    LocalContext context3(isolate.GetIsolate());
+    context3->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "obj"),
                             obj);
     notify_fun3 = CompileRun(
         "(function() { obj.foo = 'bat'; })");
   }
   {
-    LocalContext context4(CcTest::isolate());
+    LocalContext context4(isolate.GetIsolate());
     context4->Global()->Set(
-        String::NewFromUtf8(CcTest::isolate(), "observer"), observer);
-    context4->Global()->Set(String::NewFromUtf8(CcTest::isolate(), "fun1"),
+        String::NewFromUtf8(isolate.GetIsolate(), "observer"), observer);
+    context4->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "fun1"),
                             notify_fun1);
-    context4->Global()->Set(String::NewFromUtf8(CcTest::isolate(), "fun2"),
+    context4->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "fun2"),
                             notify_fun2);
-    context4->Global()->Set(String::NewFromUtf8(CcTest::isolate(), "fun3"),
+    context4->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "fun3"),
                             notify_fun3);
     CompileRun("fun1(); fun2(); fun3(); Object.deliverChangeRecords(observer)");
   }
   CHECK_EQ(1, CompileRun("calls")->Int32Value());
   CHECK_EQ(3, CompileRun("count")->Int32Value());
 }
 
 
 TEST(EndOfMicrotaskDelivery) {
-  HandleScope scope(CcTest::isolate());
-  LocalContext context(CcTest::isolate());
+  HarmonyIsolate isolate;
+  HandleScope scope(isolate.GetIsolate());
+  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) {
-  HandleScope scope(CcTest::isolate());
-  LocalContext context(CcTest::isolate());
+  HarmonyIsolate isolate;
+  HandleScope scope(isolate.GetIsolate());
+  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);"
       "obj1.foo = 'bar';");
   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());
   CompileRun(
       "ordering = [];"
       "Object.observe(obj2, observer3);"
       "Object.observe(obj2, observer2);"
       "Object.observe(obj2, observer1);"
       "obj2.foo = 'baz'");
   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) {
-  HandleScope scope(CcTest::isolate());
-  LocalContext context(CcTest::isolate());
+  HarmonyIsolate isolate;
+  HandleScope scope(isolate.GetIsolate());
+  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;"
       "  }"
       "  ordering.push(2);"
       "};"
       "function observer3() { ordering.push(3); };"
       "Object.observe(obj, observer1);"
       "Object.observe(obj, observer2);"
       "Object.observe(obj, observer3);"
       "obj.foo = 'bar';");
   CHECK_EQ(5, 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());
   // 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) {
-  HandleScope scope(CcTest::isolate());
-  LocalContext context(CcTest::isolate());
+  HarmonyIsolate isolate;
+  HandleScope scope(isolate.GetIsolate());
+  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) {
-  HandleScope scope(CcTest::isolate());
+  HarmonyIsolate isolate;
+  HandleScope scope(isolate.GetIsolate());
   // Initializing this context sets up initial hash tables.
-  LocalContext context(CcTest::isolate());
+  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(CcTest::isolate());
-    context2->Global()->Set(String::NewFromUtf8(CcTest::isolate(), "obj"),
+    LocalContext context2(isolate.GetIsolate());
+    context2->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "obj"),
                             obj);
     context2->Global()->Set(
-        String::NewFromUtf8(CcTest::isolate(), "observer"), observer);
+        String::NewFromUtf8(isolate.GetIsolate(), "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) {
-  LocalContext context(CcTest::isolate());
-  HandleScope scope(CcTest::isolate());
+  HarmonyIsolate isolate;
+  LocalContext context(isolate.GetIsolate());
+  HandleScope scope(isolate.GetIsolate());
   Handle<Object> global_proxy = context->Global();
   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")));
 
   // Detached, mutating the proxy has no effect.
   context->DetachGlobal();
   CompileRun("global.bar = 'goodbye';");
   CHECK_EQ(1, CompileRun("records.length")->Int32Value());
   CompileRun("this.baz = 'goodbye';");
   CHECK_EQ(1, CompileRun("records.length")->Int32Value());
 
   // Attached to a different context, should not leak mutations
   // to the old context.
   context->DetachGlobal();
   {
-    LocalContext context2(CcTest::isolate());
+    LocalContext context2(isolate.GetIsolate());
     CompileRun(
         "var records2 = [];"
         "var global = this;"
         "Object.observe(this, function(r) { [].push.apply(records2, r) });"
         "this.v1 = 'context2';");
     context2->DetachGlobal();
     CompileRun(
         "global.v2 = 'context2';"
         "this.v3 = 'context2';");
     CHECK_EQ(1, CompileRun("records2.length")->Int32Value());
   }
   CHECK_EQ(1, CompileRun("records.length")->Int32Value());
 
   // Attaching by passing to Context::New
   {
     // Delegates to Context::New
     LocalContext context3(
-        CcTest::isolate(), NULL, Handle<ObjectTemplate>(), global_proxy);
+        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(1, CompileRun("records.length")->Int32Value());
 }
 
@@ skipping 27 matching lines @@
           recordObj->Get(String::NewFromUtf8(isolate, "name"))));
       if (!expectations[i].old_value.IsEmpty()) {
         CHECK(expectations[i].old_value->Equals(
             recordObj->Get(String::NewFromUtf8(isolate, "oldValue"))));
       }
     }
   }
 }
 
 #define EXPECT_RECORDS(records, expectations)                \
-  ExpectRecords(CcTest::isolate(), records, expectations, \
+  ExpectRecords(isolate.GetIsolate(), records, expectations, \
                 ARRAY_SIZE(expectations))
 
 TEST(APITestBasicMutation) {
-  v8::Isolate* v8_isolate = CcTest::isolate();
+  HarmonyIsolate isolate;
+  v8::Isolate* v8_isolate = isolate.GetIsolate();
   HandleScope scope(v8_isolate);
   LocalContext context(v8_isolate);
   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::NewFromUtf8(v8_isolate, "foo"),
            Number::New(v8_isolate, 7));
@@ skipping 26 matching lines @@
     { obj, "add", "1.1", Handle<Value>() },
     { obj, "delete", "foo", Number::New(v8_isolate, 3) },
     { obj, "delete", "1", Number::New(v8_isolate, 5) },
     { obj, "delete", "1.1", Number::New(v8_isolate, 6) }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records);
 }
 
 
 TEST(HiddenPrototypeObservation) {
-  v8::Isolate* v8_isolate = CcTest::isolate();
+  HarmonyIsolate isolate;
+  v8::Isolate* v8_isolate = isolate.GetIsolate();
   HandleScope scope(v8_isolate);
   LocalContext context(v8_isolate);
   Handle<FunctionTemplate> tmpl = FunctionTemplate::New(v8_isolate);
   tmpl->SetHiddenPrototype(true);
   tmpl->InstanceTemplate()->Set(
       String::NewFromUtf8(v8_isolate, "foo"), Number::New(v8_isolate, 75));
   Handle<Object> proto = tmpl->GetFunction()->NewInstance();
   Handle<Object> obj = Object::New(v8_isolate);
   obj->SetPrototype(proto);
   context->Global()->Set(String::NewFromUtf8(v8_isolate, "obj"), obj);
@@ skipping 30 matching lines @@
   EXPECT_RECORDS(CompileRun("records"), expected_records3);
 }
 
 
 static int NumberOfElements(i::Handle<i::JSWeakMap> map) {
   return i::ObjectHashTable::cast(map->table())->NumberOfElements();
 }
 
 
 TEST(ObservationWeakMap) {
-  HandleScope scope(CcTest::isolate());
-  LocalContext context(CcTest::isolate());
+  HarmonyIsolate isolate;
+  HandleScope scope(isolate.GetIsolate());
+  LocalContext context(isolate.GetIsolate());
   CompileRun(
       "var obj = {};"
       "Object.observe(obj, function(){});"
       "Object.getNotifier(obj);"
       "obj = null;");
-  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(CcTest::isolate());
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate.GetIsolate());
   i::Handle<i::JSObject> 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(
@@ skipping 68 matching lines @@
   tmpl->SetAccessCheckCallbacks(namedCallback, indexedCallback, data);
   Handle<Object> instance = tmpl->NewInstance();
   Handle<Object> global = instance->CreationContext()->Global();
   global->Set(String::NewFromUtf8(isolate, "obj"), instance);
   global->Set(kBlockedContextIndex, v8::True(isolate));
   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(CcTest::isolate());
-    LocalContext context(CcTest::isolate());
+    HandleScope scope(isolate.GetIsolate());
+    LocalContext context(isolate.GetIsolate());
     g_access_block_type = types[i];
     Handle<Object> instance = CreateAccessCheckedObject(
-        CcTest::isolate(),
+        isolate.GetIsolate(),
         NamedAccessAllowUnlessBlocked,
         IndexedAccessAlwaysAllowed,
-        String::NewFromUtf8(CcTest::isolate(), "foo"));
+        String::NewFromUtf8(isolate.GetIsolate(), "foo"));
     CompileRun("var records = null;"
                "var objNoCheck = {};"
                "var observer = function(r) { records = r };"
                "Object.observe(obj, observer);"
                "Object.observe(objNoCheck, observer);");
     Handle<Value> obj_no_check = CompileRun("objNoCheck");
     {
-      LocalContext context2(CcTest::isolate());
-      context2->Global()->Set(String::NewFromUtf8(CcTest::isolate(), "obj"),
+      LocalContext context2(isolate.GetIsolate());
+      context2->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "obj"),
                               instance);
       context2->Global()->Set(
-          String::NewFromUtf8(CcTest::isolate(), "objNoCheck"),
+          String::NewFromUtf8(isolate.GetIsolate(), "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';"
                  "objNoCheck.baz = 'quux'");
       const RecordExpectation expected_records2[] = {
         { instance, "add", "foo", Handle<Value>() },
         { instance, "update", "foo",
-          String::NewFromUtf8(CcTest::isolate(), "bar") },
+          String::NewFromUtf8(isolate.GetIsolate(), "bar") },
         { instance, "reconfigure", "foo",
-          Number::New(CcTest::isolate(), 5) },
+          Number::New(isolate.GetIsolate(), 5) },
         { instance, "add", "bar", Handle<Value>() },
         { obj_no_check, "add", "baz", Handle<Value>() },
       };
       EXPECT_RECORDS(CompileRun("records2"), expected_records2);
     }
     const RecordExpectation expected_records[] = {
       { instance, "add", "bar", Handle<Value>() },
       { obj_no_check, "add", "baz", Handle<Value>() }
     };
     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(CcTest::isolate());
-    LocalContext context(CcTest::isolate());
+    HandleScope scope(isolate.GetIsolate());
+    LocalContext context(isolate.GetIsolate());
     g_access_block_type = types[i];
     Handle<Object> instance = CreateAccessCheckedObject(
-        CcTest::isolate(), NamedAccessAlwaysAllowed,
-        IndexedAccessAllowUnlessBlocked, Number::New(CcTest::isolate(), 7));
+        isolate.GetIsolate(), NamedAccessAlwaysAllowed,
+        IndexedAccessAllowUnlessBlocked, Number::New(isolate.GetIsolate(), 7));
     CompileRun("var records = null;"
                "var objNoCheck = {};"
                "var observer = function(r) { records = r };"
                "Object.observe(obj, observer);"
                "Object.observe(objNoCheck, observer);");
     Handle<Value> obj_no_check = CompileRun("objNoCheck");
     {
-      LocalContext context2(CcTest::isolate());
-      context2->Global()->Set(String::NewFromUtf8(CcTest::isolate(), "obj"),
+      LocalContext context2(isolate.GetIsolate());
+      context2->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "obj"),
                               instance);
       context2->Global()->Set(
-          String::NewFromUtf8(CcTest::isolate(), "objNoCheck"),
+          String::NewFromUtf8(isolate.GetIsolate(), "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';"
                  "objNoCheck[42] = 'quux'");
       const RecordExpectation expected_records2[] = {
         { instance, "add", "7", Handle<Value>() },
         { instance, "update", "7",
-          String::NewFromUtf8(CcTest::isolate(), "foo") },
-        { instance, "reconfigure", "7", Number::New(CcTest::isolate(), 5) },
+          String::NewFromUtf8(isolate.GetIsolate(), "foo") },
+        { instance, "reconfigure", "7", Number::New(isolate.GetIsolate(), 5) },
         { instance, "add", "8", Handle<Value>() },
         { obj_no_check, "add", "42", Handle<Value>() }
       };
       EXPECT_RECORDS(CompileRun("records2"), expected_records2);
     }
     const RecordExpectation expected_records[] = {
       { instance, "add", "8", Handle<Value>() },
       { obj_no_check, "add", "42", Handle<Value>() }
     };
     EXPECT_RECORDS(CompileRun("records"), expected_records);
   }
 }
 
 
 TEST(SpliceAccessCheck) {
-  HandleScope scope(CcTest::isolate());
-  LocalContext context(CcTest::isolate());
+  HarmonyIsolate isolate;
+  HandleScope scope(isolate.GetIsolate());
+  LocalContext context(isolate.GetIsolate());
   g_access_block_type = ACCESS_GET;
   Handle<Object> instance = CreateAccessCheckedObject(
-      CcTest::isolate(), NamedAccessAlwaysAllowed,
-      IndexedAccessAllowUnlessBlocked, Number::New(CcTest::isolate(), 1));
+      isolate.GetIsolate(), NamedAccessAlwaysAllowed,
+      IndexedAccessAllowUnlessBlocked, Number::New(isolate.GetIsolate(), 1));
   CompileRun("var records = null;"
              "obj[1] = 'foo';"
              "obj.length = 2;"
              "var objNoCheck = {1: 'bar', length: 2};"
              "observer = function(r) { records = r };"
              "Array.observe(obj, observer);"
              "Array.observe(objNoCheck, observer);");
   Handle<Value> obj_no_check = CompileRun("objNoCheck");
   {
-    LocalContext context2(CcTest::isolate());
-    context2->Global()->Set(String::NewFromUtf8(CcTest::isolate(), "obj"),
+    LocalContext context2(isolate.GetIsolate());
+    context2->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "obj"),
                             instance);
     context2->Global()->Set(
-        String::NewFromUtf8(CcTest::isolate(), "objNoCheck"), obj_no_check);
+        String::NewFromUtf8(isolate.GetIsolate(), "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);"
                "[].pop.call(obj);"
                "[].pop.call(objNoCheck);");
     // TODO(adamk): Extend EXPECT_RECORDS to be able to assert more things
     // about splice records. For this test it's not so important since
     // we just want to guarantee the machinery is in operation at all.
     const RecordExpectation expected_records2[] = {
       { obj_no_check, "splice", "", Handle<Value>() }
     };
     EXPECT_RECORDS(CompileRun("records2"), expected_records2);
   }
   const RecordExpectation expected_records[] = {
     { obj_no_check, "splice", "", Handle<Value>() }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records);
 }
 
 
 TEST(DisallowAllForAccessKeys) {
-  HandleScope scope(CcTest::isolate());
-  LocalContext context(CcTest::isolate());
+  HarmonyIsolate isolate;
+  HandleScope scope(isolate.GetIsolate());
+  LocalContext context(isolate.GetIsolate());
   Handle<Object> instance = CreateAccessCheckedObject(
-      CcTest::isolate(), BlockAccessKeys, IndexedAccessAlwaysAllowed);
+      isolate.GetIsolate(), BlockAccessKeys, IndexedAccessAlwaysAllowed);
   CompileRun("var records = null;"
              "var objNoCheck = {};"
              "var observer = function(r) { records = r };"
              "Object.observe(obj, observer);"
              "Object.observe(objNoCheck, observer);");
   Handle<Value> obj_no_check = CompileRun("objNoCheck");
   {
-    LocalContext context2(CcTest::isolate());
-    context2->Global()->Set(String::NewFromUtf8(CcTest::isolate(), "obj"),
+    LocalContext context2(isolate.GetIsolate());
+    context2->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "obj"),
                             instance);
     context2->Global()->Set(
-        String::NewFromUtf8(CcTest::isolate(), "objNoCheck"), obj_no_check);
+        String::NewFromUtf8(isolate.GetIsolate(), "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, "add", "foo", Handle<Value>() },
       { instance, "add", "5", Handle<Value>() },
       { obj_no_check, "add", "baz", Handle<Value>() },
     };
     EXPECT_RECORDS(CompileRun("records2"), expected_records2);
   }
   const RecordExpectation expected_records[] = {
     { obj_no_check, "add", "baz", Handle<Value>() }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records);
 }
 
 
 TEST(AccessCheckDisallowApiModifications) {
-  HandleScope scope(CcTest::isolate());
-  LocalContext context(CcTest::isolate());
+  HarmonyIsolate isolate;
+  HandleScope scope(isolate.GetIsolate());
+  LocalContext context(isolate.GetIsolate());
   Handle<Object> instance = CreateAccessCheckedObject(
-      CcTest::isolate(), BlockAccessKeys, IndexedAccessAlwaysAllowed);
+      isolate.GetIsolate(), BlockAccessKeys, IndexedAccessAlwaysAllowed);
   CompileRun("var records = null;"
              "var observer = function(r) { records = r };"
              "Object.observe(obj, observer);");
   {
-    LocalContext context2(CcTest::isolate());
-    context2->Global()->Set(String::NewFromUtf8(CcTest::isolate(), "obj"),
+    LocalContext context2(isolate.GetIsolate());
+    context2->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "obj"),
                             instance);
     CompileRun("var records2 = null;"
                "var observer2 = function(r) { records2 = r };"
                "Object.observe(obj, observer2);");
-    instance->Set(5, String::NewFromUtf8(CcTest::isolate(), "bar"));
-    instance->Set(String::NewFromUtf8(CcTest::isolate(), "foo"),
-                  String::NewFromUtf8(CcTest::isolate(), "bar"));
+    instance->Set(5, String::NewFromUtf8(isolate.GetIsolate(), "bar"));
+    instance->Set(String::NewFromUtf8(isolate.GetIsolate(), "foo"),
+                  String::NewFromUtf8(isolate.GetIsolate(), "bar"));
     CompileRun("");  // trigger delivery
     const RecordExpectation expected_records2[] = {
       { instance, "add", "5", Handle<Value>() },
       { instance, "add", "foo", Handle<Value>() }
     };
     EXPECT_RECORDS(CompileRun("records2"), expected_records2);
   }
   CHECK(CompileRun("records")->IsNull());
 }
 
 
 TEST(HiddenPropertiesLeakage) {
-  HandleScope scope(CcTest::isolate());
-  LocalContext context(CcTest::isolate());
+  HarmonyIsolate isolate;
+  HandleScope scope(isolate.GetIsolate());
+  LocalContext context(isolate.GetIsolate());
   CompileRun("var obj = {};"
              "var records = null;"
              "var observer = function(r) { records = r };"
              "Object.observe(obj, observer);");
   Handle<Value> obj =
-      context->Global()->Get(String::NewFromUtf8(CcTest::isolate(), "obj"));
+      context->Global()->Get(String::NewFromUtf8(isolate.GetIsolate(), "obj"));
   Handle<Object>::Cast(obj)
-      ->SetHiddenValue(String::NewFromUtf8(CcTest::isolate(), "foo"),
-                       Null(CcTest::isolate()));
+      ->SetHiddenValue(String::NewFromUtf8(isolate.GetIsolate(), "foo"),
+                       Null(isolate.GetIsolate()));
   CompileRun("");  // trigger delivery
   CHECK(CompileRun("records")->IsNull());
 }