More API cleanup.

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 314 matching lines @@
     }
   }
 }
 
 #define EXPECT_RECORDS(records, expectations)                \
   ExpectRecords(isolate.GetIsolate(), records, expectations, \
                 ARRAY_SIZE(expectations))
 
 TEST(APITestBasicMutation) {
   HarmonyIsolate isolate;
-  HandleScope scope(isolate.GetIsolate());
-  LocalContext context(isolate.GetIsolate());
+  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(isolate.GetIsolate(), "foo"), Number::New(7));
-  obj->Set(1, Number::New(2));
+  obj->Set(String::NewFromUtf8(v8_isolate, "foo"),
+           Number::New(v8_isolate, 7));
+  obj->Set(1, Number::New(v8_isolate, 2));
   // ForceSet should work just as well as Set
-  obj->ForceSet(String::NewFromUtf8(isolate.GetIsolate(), "foo"),
-                Number::New(3));
-  obj->ForceSet(Number::New(1), Number::New(4));
+  obj->ForceSet(String::NewFromUtf8(v8_isolate, "foo"),
+                Number::New(v8_isolate, 3));
+  obj->ForceSet(Number::New(v8_isolate, 1), Number::New(v8_isolate, 4));
   // Setting an indexed element via the property setting method
-  obj->Set(Number::New(1), Number::New(5));
+  obj->Set(Number::New(v8_isolate, 1), Number::New(v8_isolate, 5));
   // Setting with a non-String, non-uint32 key
-  obj->Set(Number::New(1.1), Number::New(6), DontDelete);
-  obj->Delete(String::NewFromUtf8(isolate.GetIsolate(), "foo"));
+  obj->Set(Number::New(v8_isolate, 1.1),
+           Number::New(v8_isolate, 6), DontDelete);
+  obj->Delete(String::NewFromUtf8(v8_isolate, "foo"));
   obj->Delete(1);
-  obj->ForceDelete(Number::New(1.1));
+  obj->ForceDelete(Number::New(v8_isolate, 1.1));
 
   // Force delivery
   // TODO(adamk): Should the above set methods trigger delivery themselves?
   CompileRun("void 0");
   CHECK_EQ(9, CompileRun("records.length")->Int32Value());
   const RecordExpectation expected_records[] = {
     { obj, "add", "foo", Handle<Value>() },
     { obj, "add", "1", Handle<Value>() },
     // Note: use 7 not 1 below, as the latter triggers a nifty VS10 compiler bug
     // where instead of 1.0, a garbage value would be passed into Number::New.
-    { obj, "update", "foo", Number::New(7) },
-    { obj, "update", "1", Number::New(2) },
-    { obj, "update", "1", Number::New(4) },
+    { obj, "update", "foo", Number::New(v8_isolate, 7) },
+    { obj, "update", "1", Number::New(v8_isolate, 2) },
+    { obj, "update", "1", Number::New(v8_isolate, 4) },
     { obj, "add", "1.1", Handle<Value>() },
-    { obj, "delete", "foo", Number::New(3) },
-    { obj, "delete", "1", Number::New(5) },
-    { obj, "delete", "1.1", Number::New(6) }
+    { 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) {
   HarmonyIsolate isolate;
-  HandleScope scope(isolate.GetIsolate());
-  LocalContext context(isolate.GetIsolate());
-  Handle<FunctionTemplate> tmpl = FunctionTemplate::New(isolate.GetIsolate());
+  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(isolate.GetIsolate(), "foo"), Number::New(75));
+      String::NewFromUtf8(v8_isolate, "foo"), Number::New(v8_isolate, 75));
   Handle<Object> proto = tmpl->GetFunction()->NewInstance();
-  Handle<Object> obj = Object::New();
+  Handle<Object> obj = Object::New(v8_isolate);
   obj->SetPrototype(proto);
-  context->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "obj"), obj);
-  context->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "proto"),
+  context->Global()->Set(String::NewFromUtf8(v8_isolate, "obj"), obj);
+  context->Global()->Set(String::NewFromUtf8(v8_isolate, "proto"),
                          proto);
   CompileRun(
       "var records;"
       "function observer(r) { records = r; };"
       "Object.observe(obj, observer);"
       "obj.foo = 41;"  // triggers a notification
       "proto.foo = 42;");  // does not trigger a notification
   const RecordExpectation expected_records[] = {
-    { obj, "update", "foo", Number::New(75) }
+    { obj, "update", "foo", Number::New(v8_isolate, 75) }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records);
-  obj->SetPrototype(Null(isolate.GetIsolate()));
+  obj->SetPrototype(Null(v8_isolate));
   CompileRun("obj.foo = 43");
   const RecordExpectation expected_records2[] = {
     { obj, "add", "foo", Handle<Value>() }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records2);
   obj->SetPrototype(proto);
   CompileRun(
       "Object.observe(proto, observer);"
       "proto.bar = 1;"
       "Object.unobserve(obj, observer);"
@@ skipping 141 matching lines @@
                  "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(isolate.GetIsolate(), "bar") },
-        { instance, "reconfigure", "foo", Number::New(5) },
+        { instance, "reconfigure", "foo",
+          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(isolate.GetIsolate());
     LocalContext context(isolate.GetIsolate());
     g_access_block_type = types[i];
     Handle<Object> instance = CreateAccessCheckedObject(
         isolate.GetIsolate(), NamedAccessAlwaysAllowed,
-        IndexedAccessAllowUnlessBlocked, Number::New(7));
+        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(isolate.GetIsolate());
       context2->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "obj"),
                               instance);
       context2->Global()->Set(
           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(isolate.GetIsolate(), "foo") },
-        { instance, "reconfigure", "7", Number::New(5) },
+        { 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) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   LocalContext context(isolate.GetIsolate());
   g_access_block_type = ACCESS_GET;
   Handle<Object> instance = CreateAccessCheckedObject(
       isolate.GetIsolate(), NamedAccessAlwaysAllowed,
-      IndexedAccessAllowUnlessBlocked, Number::New(1));
+      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(isolate.GetIsolate());
@@ skipping 104 matching lines @@
              "var observer = function(r) { records = r };"
              "Object.observe(obj, observer);");
   Handle<Value> obj =
       context->Global()->Get(String::NewFromUtf8(isolate.GetIsolate(), "obj"));
   Handle<Object>::Cast(obj)
       ->SetHiddenValue(String::NewFromUtf8(isolate.GetIsolate(), "foo"),
                        Null(isolate.GetIsolate()));
   CompileRun("");  // trigger delivery
   CHECK(CompileRun("records")->IsNull());
 }