Remove usage of deprecated APIs from cctests

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 54 matching lines @@
       "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(isolate.GetIsolate());
-    context2->Global()->Set(String::New("obj"), obj);
+    context2->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "obj"),
+                            obj);
     notify_fun2 = CompileRun(
         "(function() { obj.foo = 'baz'; })");
   }
   Handle<Value> notify_fun3;
   {
     LocalContext context3(isolate.GetIsolate());
-    context3->Global()->Set(String::New("obj"), obj);
+    context3->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "obj"),
+                            obj);
     notify_fun3 = CompileRun(
         "(function() { obj.foo = 'bat'; })");
   }
   {
     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);
+    context4->Global()->Set(
+        String::NewFromUtf8(isolate.GetIsolate(), "observer"), observer);
+    context4->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "fun1"),
+                            notify_fun1);
+    context4->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "fun2"),
+                            notify_fun2);
+    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) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
@@ skipping 102 matching lines @@
   HandleScope scope(isolate.GetIsolate());
   // Initializing this context sets up initial hash tables.
   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(isolate.GetIsolate());
-    context2->Global()->Set(String::New("obj"), obj);
-    context2->Global()->Set(String::New("observer"), observer);
+    context2->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "obj"),
+                            obj);
+    context2->Global()->Set(
+        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);");
   }
@@ skipping 67 matching lines @@
 
 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,
+static void ExpectRecords(v8::Isolate* isolate,
+                          Handle<Value> records,
                           const RecordExpectation expectations[],
                           int num) {
   CHECK(records->IsArray());
   Handle<Array> recordArray = records.As<Array>();
   CHECK_EQ(num, static_cast<int>(recordArray->Length()));
   for (int i = 0; i < num; ++i) {
     Handle<Value> record = recordArray->Get(i);
     CHECK(record->IsObject());
     Handle<Object> recordObj = record.As<Object>();
     CHECK(expectations[i].object->StrictEquals(
-        recordObj->Get(String::New("object"))));
-    CHECK(String::New(expectations[i].type)->Equals(
-        recordObj->Get(String::New("type"))));
+        recordObj->Get(String::NewFromUtf8(isolate, "object"))));
+    CHECK(String::NewFromUtf8(isolate, expectations[i].type)->Equals(
+        recordObj->Get(String::NewFromUtf8(isolate, "type"))));
     if (strcmp("splice", expectations[i].type) != 0) {
-      CHECK(String::New(expectations[i].name)->Equals(
-          recordObj->Get(String::New("name"))));
+      CHECK(String::NewFromUtf8(isolate, expectations[i].name)->Equals(
+          recordObj->Get(String::NewFromUtf8(isolate, "name"))));
       if (!expectations[i].old_value.IsEmpty()) {
         CHECK(expectations[i].old_value->Equals(
-            recordObj->Get(String::New("oldValue"))));
+            recordObj->Get(String::NewFromUtf8(isolate, "oldValue"))));
       }
     }
   }
 }
 
-#define EXPECT_RECORDS(records, expectations) \
-    ExpectRecords(records, expectations, ARRAY_SIZE(expectations))
+#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());
   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(String::NewFromUtf8(isolate.GetIsolate(), "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));
+  obj->ForceSet(String::NewFromUtf8(isolate.GetIsolate(), "foo"),
+                Number::New(3));
   obj->ForceSet(Number::New(1), Number::New(4));
   // Setting an indexed element via the property setting method
   obj->Set(Number::New(1), Number::New(5));
   // Setting with a non-String, non-uint32 key
   obj->Set(Number::New(1.1), Number::New(6), DontDelete);
-  obj->Delete(String::New("foo"));
+  obj->Delete(String::NewFromUtf8(isolate.GetIsolate(), "foo"));
   obj->Delete(1);
   obj->ForceDelete(Number::New(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>() },
@@ skipping 10 matching lines @@
   EXPECT_RECORDS(CompileRun("records"), expected_records);
 }
 
 
 TEST(HiddenPrototypeObservation) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   LocalContext context(isolate.GetIsolate());
   Handle<FunctionTemplate> tmpl = FunctionTemplate::New();
   tmpl->SetHiddenPrototype(true);
-  tmpl->InstanceTemplate()->Set(String::New("foo"), Number::New(75));
+  tmpl->InstanceTemplate()->Set(
+      String::NewFromUtf8(isolate.GetIsolate(), "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);
+  context->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "obj"), obj);
+  context->Global()->Set(String::NewFromUtf8(isolate.GetIsolate(), "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) }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records);
@@ skipping 100 matching lines @@
 static bool BlockAccessKeys(Local<Object> host, Local<Value> key,
                             AccessType type, Local<Value>) {
   v8::Isolate* isolate = reinterpret_cast<v8::Isolate*>(
       Utils::OpenHandle(*host)->GetIsolate());
   Handle<Object> global = isolate->GetCurrentContext()->Global();
   return type != ACCESS_KEYS || !global->Has(kBlockedContextIndex);
 }
 
 
 static Handle<Object> CreateAccessCheckedObject(
+    v8::Isolate* isolate,
     NamedSecurityCallback namedCallback,
     IndexedSecurityCallback indexedCallback,
     Handle<Value> data = Handle<Value>()) {
   Handle<ObjectTemplate> tmpl = ObjectTemplate::New();
   tmpl->SetAccessCheckCallbacks(namedCallback, indexedCallback, data);
   Handle<Object> instance = tmpl->NewInstance();
   Handle<Object> global = instance->CreationContext()->Global();
-  global->Set(String::New("obj"), instance);
+  global->Set(String::NewFromUtf8(isolate, "obj"), instance);
   global->Set(kBlockedContextIndex, v8::True());
   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(isolate.GetIsolate());
     g_access_block_type = types[i];
     Handle<Object> instance = CreateAccessCheckedObject(
+        isolate.GetIsolate(),
         NamedAccessAllowUnlessBlocked,
         IndexedAccessAlwaysAllowed,
-        String::New("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(isolate.GetIsolate());
-      context2->Global()->Set(String::New("obj"), instance);
-      context2->Global()->Set(String::New("objNoCheck"), obj_no_check);
+      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.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::New("bar") },
+        { instance, "update", "foo",
+          String::NewFromUtf8(isolate.GetIsolate(), "bar") },
         { instance, "reconfigure", "foo", Number::New(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(
-        NamedAccessAlwaysAllowed, IndexedAccessAllowUnlessBlocked,
-        Number::New(7));
+        isolate.GetIsolate(), NamedAccessAlwaysAllowed,
+        IndexedAccessAllowUnlessBlocked, Number::New(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::New("obj"), instance);
-      context2->Global()->Set(String::New("objNoCheck"), obj_no_check);
+      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::New("foo") },
+        { instance, "update", "7",
+          String::NewFromUtf8(isolate.GetIsolate(), "foo") },
         { instance, "reconfigure", "7", Number::New(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(
-      NamedAccessAlwaysAllowed, IndexedAccessAllowUnlessBlocked,
-      Number::New(1));
+      isolate.GetIsolate(), NamedAccessAlwaysAllowed,
+      IndexedAccessAllowUnlessBlocked, Number::New(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());
-    context2->Global()->Set(String::New("obj"), instance);
-    context2->Global()->Set(String::New("objNoCheck"), obj_no_check);
+    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 };"
                "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);");
@@ skipping 10 matching lines @@
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records);
 }
 
 
 TEST(DisallowAllForAccessKeys) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   LocalContext context(isolate.GetIsolate());
   Handle<Object> instance = CreateAccessCheckedObject(
-      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(isolate.GetIsolate());
-    context2->Global()->Set(String::New("obj"), instance);
-    context2->Global()->Set(String::New("objNoCheck"), obj_no_check);
+    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.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) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   LocalContext context(isolate.GetIsolate());
   Handle<Object> instance = CreateAccessCheckedObject(
-      BlockAccessKeys, IndexedAccessAlwaysAllowed);
+      isolate.GetIsolate(), BlockAccessKeys, IndexedAccessAlwaysAllowed);
   CompileRun("var records = null;"
              "var observer = function(r) { records = r };"
              "Object.observe(obj, observer);");
   {
     LocalContext context2(isolate.GetIsolate());
-    context2->Global()->Set(String::New("obj"), instance);
+    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::New("bar"));
-    instance->Set(String::New("foo"), String::New("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) {
   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::New("obj"));
-  Handle<Object>::Cast(obj)->SetHiddenValue(String::New("foo"), Null());
+  Handle<Value> obj =
+      context->Global()->Get(String::NewFromUtf8(isolate.GetIsolate(), "obj"));
+  Handle<Object>::Cast(obj)->SetHiddenValue(
+      String::NewFromUtf8(isolate.GetIsolate(), "foo"), Null());
   CompileRun("");  // trigger delivery
   CHECK(CompileRun("records")->IsNull());
 }