[Isolates] Move contents of Top into Isolate....

test/cctest/test-heap.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 
 #include <stdlib.h>
 
 #include "v8.h"
 
 #include "execution.h"
 #include "factory.h"
 #include "macro-assembler.h"
 #include "global-handles.h"
@@ skipping 136 matching lines @@
 
   // nan oddball checks
   CHECK(HEAP->nan_value()->IsNumber());
   CHECK(isnan(HEAP->nan_value()->Number()));
 
   Handle<String> s = Factory::NewStringFromAscii(CStrVector("fisk hest "));
   CHECK(s->IsString());
   CHECK_EQ(10, s->length());
 
   String* object_symbol = String::cast(HEAP->Object_symbol());
-  CHECK(Top::context()->global()->HasLocalProperty(object_symbol));
+  CHECK(
+      Isolate::Current()->context()->global()->HasLocalProperty(object_symbol));
 
   // Check ToString for oddballs
   CheckOddball(HEAP->true_value(), "true");
   CheckOddball(HEAP->false_value(), "false");
   CheckOddball(HEAP->null_value(), "null");
   CheckOddball(HEAP->undefined_value(), "undefined");
 
   // Check ToString for Smis
   CheckSmi(0, "0");
   CheckSmi(42, "42");
@@ skipping 38 matching lines @@
   Handle<String> obj_name = Factory::LookupAsciiSymbol("theObject");
 
   {
     v8::HandleScope inner_scope;
     // Allocate a function and keep it in global object's property.
     Handle<JSFunction> function =
         Factory::NewFunction(name, Factory::undefined_value());
     Handle<Map> initial_map =
         Factory::NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
     function->set_initial_map(*initial_map);
-    Top::context()->global()->SetProperty(*name, *function, NONE);
+    Isolate::Current()->context()->global()->SetProperty(*name, *function,
+                                                         NONE);
     // Allocate an object.  Unrooted after leaving the scope.
     Handle<JSObject> obj = Factory::NewJSObject(function);
     obj->SetProperty(*prop_name, Smi::FromInt(23), NONE);
     obj->SetProperty(*prop_namex, Smi::FromInt(24), NONE);
 
     CHECK_EQ(Smi::FromInt(23), obj->GetProperty(*prop_name));
     CHECK_EQ(Smi::FromInt(24), obj->GetProperty(*prop_namex));
   }
 
   CHECK(HEAP->CollectGarbage(free_bytes, NEW_SPACE));
 
   // Function should be alive.
-  CHECK(Top::context()->global()->HasLocalProperty(*name));
+  CHECK(Isolate::Current()->context()->global()->HasLocalProperty(*name));
   // Check function is retained.
-  Object* func_value = Top::context()->global()->GetProperty(*name);
+  Object* func_value =
+      Isolate::Current()->context()->global()->GetProperty(*name);
   CHECK(func_value->IsJSFunction());
   Handle<JSFunction> function(JSFunction::cast(func_value));
 
   {
     HandleScope inner_scope;
     // Allocate another object, make it reachable from global.
     Handle<JSObject> obj = Factory::NewJSObject(function);
-    Top::context()->global()->SetProperty(*obj_name, *obj, NONE);
+    Isolate::Current()->context()->global()->SetProperty(*obj_name, *obj, NONE);
     obj->SetProperty(*prop_name, Smi::FromInt(23), NONE);
   }
 
   // After gc, it should survive.
   CHECK(HEAP->CollectGarbage(free_bytes, NEW_SPACE));
 
-  CHECK(Top::context()->global()->HasLocalProperty(*obj_name));
-  CHECK(Top::context()->global()->GetProperty(*obj_name)->IsJSObject());
+  CHECK(Isolate::Current()->context()->global()->HasLocalProperty(*obj_name));
+  CHECK(Isolate::Current()->context()->global()->GetProperty(*obj_name)->
+      IsJSObject());
   JSObject* obj =
-      JSObject::cast(Top::context()->global()->GetProperty(*obj_name));
+      JSObject::cast(Isolate::Current()->context()->global()->
+          GetProperty(*obj_name));
   CHECK_EQ(Smi::FromInt(23), obj->GetProperty(*prop_name));
 }
 
 
 static void VerifyStringAllocation(const char* string) {
   v8::HandleScope scope;
   Handle<String> s = Factory::NewStringFromUtf8(CStrVector(string));
   CHECK_EQ(StrLength(string), s->length());
   for (int index = 0; index < s->length(); index++) {
     CHECK_EQ(static_cast<uint16_t>(string[index]), s->Get(index));
@@ skipping 288 matching lines @@
   CHECK_EQ(Smi::FromInt(24), function->GetProperty(*prop_name));
 }
 
 
 TEST(ObjectProperties) {
   InitializeVM();
 
   v8::HandleScope sc;
   String* object_symbol = String::cast(HEAP->Object_symbol());
   JSFunction* object_function =
-      JSFunction::cast(Top::context()->global()->GetProperty(object_symbol));
+      JSFunction::cast(Isolate::Current()->context()->global()->
+          GetProperty(object_symbol));
   Handle<JSFunction> constructor(object_function);
   Handle<JSObject> obj = Factory::NewJSObject(constructor);
   Handle<String> first = Factory::LookupAsciiSymbol("first");
   Handle<String> second = Factory::LookupAsciiSymbol("second");
 
   // check for empty
   CHECK(!obj->HasLocalProperty(*first));
 
   // add first
   obj->SetProperty(*first, Smi::FromInt(1), NONE);
@@ skipping 67 matching lines @@
   CHECK(*initial_map != obj->map());
 }
 
 
 TEST(JSArray) {
   InitializeVM();
 
   v8::HandleScope sc;
   Handle<String> name = Factory::LookupAsciiSymbol("Array");
   Handle<JSFunction> function = Handle<JSFunction>(
-      JSFunction::cast(Top::context()->global()->GetProperty(*name)));
+      JSFunction::cast(Isolate::Current()->context()->global()->
+          GetProperty(*name)));
 
   // Allocate the object.
   Handle<JSObject> object = Factory::NewJSObject(function);
   Handle<JSArray> array = Handle<JSArray>::cast(object);
   array->Initialize(0);
 
   // Set array length to 0.
   array->SetElementsLength(Smi::FromInt(0));
   CHECK_EQ(Smi::FromInt(0), array->length());
   CHECK(array->HasFastElements());  // Must be in fast mode.
@@ skipping 22 matching lines @@
   CHECK_EQ(array->GetElement(0), *name);
 }
 
 
 TEST(JSObjectCopy) {
   InitializeVM();
 
   v8::HandleScope sc;
   String* object_symbol = String::cast(HEAP->Object_symbol());
   JSFunction* object_function =
-      JSFunction::cast(Top::context()->global()->GetProperty(object_symbol));
+      JSFunction::cast(Isolate::Current()->context()->global()->
+          GetProperty(object_symbol));
   Handle<JSFunction> constructor(object_function);
   Handle<JSObject> obj = Factory::NewJSObject(constructor);
   Handle<String> first = Factory::LookupAsciiSymbol("first");
   Handle<String> second = Factory::LookupAsciiSymbol("second");
 
   obj->SetProperty(*first, Smi::FromInt(1), NONE);
   obj->SetProperty(*second, Smi::FromInt(2), NONE);
 
   obj->SetElement(0, *first);
   obj->SetElement(1, *second);
@@ skipping 184 matching lines @@
   bool force_compaction = true;
   HEAP->CollectAllGarbage(force_compaction);
 
   v8::HandleScope scope;
 
   // The plan: create JSObject which references objects in new space.
   // Then clone this object (forcing it to go into old space) and check
   // that region dirty marks are updated correctly.
 
   // Step 1: prepare a map for the object.  We add 1 inobject property to it.
-  Handle<JSFunction> object_ctor(Top::global_context()->object_function());
+  Handle<JSFunction> object_ctor(
+      Isolate::Current()->global_context()->object_function());
   CHECK(object_ctor->has_initial_map());
   Handle<Map> object_map(object_ctor->initial_map());
   // Create a map with single inobject property.
   Handle<Map> my_map = Factory::CopyMap(object_map, 1);
   int n_properties = my_map->inobject_properties();
   CHECK_GT(n_properties, 0);
 
   int object_size = my_map->instance_size();
 
   // Step 2: allocate a lot of objects so to almost fill new space: we need
@@ skipping 64 matching lines @@
                        "  var y = 42;"
                        "  var z = x + y;"
                        "};"
                        "foo()";
   Handle<String> foo_name = Factory::LookupAsciiSymbol("foo");
 
   // This compile will add the code to the compilation cache.
   CompileRun(source);
 
   // Check function is compiled.
-  Object* func_value = Top::context()->global()->GetProperty(*foo_name);
+  Object* func_value =
+      Isolate::Current()->context()->global()->GetProperty(*foo_name);
   CHECK(func_value->IsJSFunction());
   Handle<JSFunction> function(JSFunction::cast(func_value));
   CHECK(function->shared()->is_compiled());
 
   HEAP->CollectAllGarbage(true);
   HEAP->CollectAllGarbage(true);
 
   // foo should still be in the compilation cache and therefore not
   // have been removed.
   CHECK(function->shared()->is_compiled());
   HEAP->CollectAllGarbage(true);
   HEAP->CollectAllGarbage(true);
   HEAP->CollectAllGarbage(true);
   HEAP->CollectAllGarbage(true);
 
   // foo should no longer be in the compilation cache
   CHECK(!function->shared()->is_compiled());
   // Call foo to get it recompiled.
   CompileRun("foo()");
   CHECK(function->shared()->is_compiled());
 }