build fix for 14530

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 39 matching lines @@
   Isolate* GetIsolate() const { return isolate_; }
 
  private:
   Isolate* isolate_;
 };
 }
 
 TEST(PerIsolateState) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context1;
+  v8::LocalContext context1;
   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;
+    v8::LocalContext context2;
     context2->Global()->Set(String::New("obj"), obj);
     notify_fun2 = CompileRun(
         "(function() { obj.foo = 'baz'; })");
   }
   Handle<Value> notify_fun3;
   {
-    LocalContext context3;
+    v8::LocalContext context3;
     context3->Global()->Set(String::New("obj"), obj);
     notify_fun3 = CompileRun(
         "(function() { obj.foo = 'bat'; })");
   }
   {
-    LocalContext context4;
+    v8::LocalContext context4;
     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;
+  v8::LocalContext context;
   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;
+  v8::LocalContext context;
   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 10 matching lines @@
       "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) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context;
+  v8::LocalContext context;
   CompileRun(
       "var obj = {};"
       "var reentered = false;"
       "var ordering = [];"
       "function observer1() { ordering.push(1); };"
       "function observer2() {"
       "  if (!reentered) {"
       "    obj.foo = 'baz';"
       "    reentered = true;"
       "  }"
@@ skipping 10 matching lines @@
   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) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context;
+  v8::LocalContext context;
   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;
+  v8::LocalContext context;
   Handle<Value> obj = CompileRun("obj = {};");
   Handle<Value> observer = CompileRun(
       "var ran = false;"
       "(function() { ran = true })");
   {
     // As does initializing this context.
-    LocalContext context2;
+    v8::LocalContext context2;
     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;
+  v8::LocalContext context;
   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;
+    v8::LocalContext context2;
     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);
+    v8::LocalContext context3(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 28 matching lines @@
     }
   }
 }
 
 #define EXPECT_RECORDS(records, expectations) \
     ExpectRecords(records, expectations, ARRAY_SIZE(expectations))
 
 TEST(APITestBasicMutation) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
-  LocalContext context;
+  v8::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"));
   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 22 matching lines @@
     { obj, "deleted", "foo", Number::New(3) },
     { 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;
+  v8::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;"
@@ 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;
+  v8::LocalContext context;
   CompileRun(
       "var obj = {};"
       "Object.observe(obj, function(){});"
       "Object.getNotifier(obj);"
       "obj = null;");
   i::Handle<i::JSObject> observation_state = FACTORY->observation_state();
   i::Handle<i::JSWeakMap> observerInfoMap =
       i::Handle<i::JSWeakMap>::cast(
           i::GetProperty(observation_state, "observerInfoMap"));
   i::Handle<i::JSWeakMap> objectInfoMap =
       i::Handle<i::JSWeakMap>::cast(
           i::GetProperty(observation_state, "objectInfoMap"));
   i::Handle<i::JSWeakMap> notifierTargetMap =
       i::Handle<i::JSWeakMap>::cast(
           i::GetProperty(observation_state, "notifierTargetMap"));
   CHECK_EQ(1, NumberOfElements(observerInfoMap));
   CHECK_EQ(1, NumberOfElements(objectInfoMap));
   CHECK_EQ(1, NumberOfElements(notifierTargetMap));
   HEAP->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
   CHECK_EQ(0, NumberOfElements(observerInfoMap));
   CHECK_EQ(0, NumberOfElements(objectInfoMap));
   CHECK_EQ(0, NumberOfElements(notifierTargetMap));
 }