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

src/liveedit.cc

 // Copyright 2010 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 393 matching lines @@
 
   // Only allow non-global compiles for eval.
   ASSERT(is_eval || is_global);
 
   // Build AST.
   ScriptDataImpl* pre_data = NULL;
   FunctionLiteral* lit = MakeAST(is_global, script, extension, pre_data);
 
   // Check for parse errors.
   if (lit == NULL) {
-    ASSERT(Top::has_pending_exception());
+    ASSERT(Isolate::Current()->has_pending_exception());
     return;
   }
 
   // Compile the code.
   CompilationInfo info(lit, script, is_eval);
 
   LiveEditFunctionTracker tracker(lit);
   Handle<Code> code = MakeCodeForLiveEdit(&info);
 
   // Check for stack-overflow exceptions.
   if (code.is_null()) {
-    Top::StackOverflow();
+    Isolate::Current()->StackOverflow();
     return;
   }
   tracker.RecordRootFunctionInfo(code);
 }
 
 // Unwraps JSValue object, returning its field "value"
 static Handle<Object> UnwrapJSValue(Handle<JSValue> jsValue) {
   return Handle<Object>(jsValue->value());
 }
 
 // Wraps any object into a OpaqueReference, that will hide the object
 // from JavaScript.
 static Handle<JSValue> WrapInJSValue(Object* object) {
-  Handle<JSFunction> constructor = Top::opaque_reference_function();
+  Handle<JSFunction> constructor =
+      Isolate::Current()->opaque_reference_function();
   Handle<JSValue> result =
       Handle<JSValue>::cast(Factory::NewJSObject(constructor));
   result->set_value(object);
   return result;
 }
 
 // Simple helper class that creates more or less typed structures over
 // JSArray object. This is an adhoc method of passing structures from C++
 // to JavaScript.
 template<typename S>
@@ skipping 335 matching lines @@
 };
 
 class FrameUncookingThreadVisitor : public ThreadVisitor {
  public:
   void VisitThread(ThreadLocalTop* top) {
     StackFrame::UncookFramesForThread(top);
   }
 };
 
 static void IterateAllThreads(ThreadVisitor* visitor) {
-  Top::IterateThread(visitor);
+  Isolate::Current()->IterateThread(visitor);
   ThreadManager::IterateArchivedThreads(visitor);
 }
 
 // Finds all references to original and replaces them with substitution.
 static void ReplaceCodeObject(Code* original, Code* substitution) {
   ASSERT(!HEAP->InNewSpace(substitution));
 
   AssertNoAllocation no_allocations_please;
 
   // A zone scope for ReferenceCollectorVisitor.
@@ skipping 30 matching lines @@
 static bool IsJSFunctionCode(Code* code) {
   return code->kind() == Code::FUNCTION;
 }
 
 
 Object* LiveEdit::ReplaceFunctionCode(Handle<JSArray> new_compile_info_array,
                                       Handle<JSArray> shared_info_array) {
   HandleScope scope;
 
   if (!SharedInfoWrapper::IsInstance(shared_info_array)) {
-    return Top::ThrowIllegalOperation();
+    return Isolate::Current()->ThrowIllegalOperation();
   }
 
   FunctionInfoWrapper compile_info_wrapper(new_compile_info_array);
   SharedInfoWrapper shared_info_wrapper(shared_info_array);
 
   Handle<SharedFunctionInfo> shared_info = shared_info_wrapper.GetInfo();
 
   if (IsJSFunctionCode(shared_info->code())) {
     ReplaceCodeObject(shared_info->code(),
                       *(compile_info_wrapper.GetFunctionCode()));
@@ skipping 173 matching lines @@
     Handle<Code> result(Factory::CopyCode(code, buffer));
     return result;
   }
 }
 
 
 Object* LiveEdit::PatchFunctionPositions(
     Handle<JSArray> shared_info_array, Handle<JSArray> position_change_array) {
 
   if (!SharedInfoWrapper::IsInstance(shared_info_array)) {
-    return Top::ThrowIllegalOperation();
+    return Isolate::Current()->ThrowIllegalOperation();
   }
 
   SharedInfoWrapper shared_info_wrapper(shared_info_array);
   Handle<SharedFunctionInfo> info = shared_info_wrapper.GetInfo();
 
   int old_function_start = info->start_position();
   int new_function_start = TranslatePosition(old_function_start,
                                              position_change_array);
   info->set_start_position(new_function_start);
   info->set_end_position(TranslatePosition(info->end_position(),
@@ skipping 107 matching lines @@
   }
   return false;
 }
 
 
 // Iterates over handler chain and removes all elements that are inside
 // frames being dropped.
 static bool FixTryCatchHandler(StackFrame* top_frame,
                                StackFrame* bottom_frame) {
   Address* pointer_address =
-      &Memory::Address_at(Top::get_address_from_id(Top::k_handler_address));
+      &Memory::Address_at(Isolate::Current()->get_address_from_id(
+          Isolate::k_handler_address));
 
   while (*pointer_address < top_frame->sp()) {
     pointer_address = &Memory::Address_at(*pointer_address);
   }
   Address* above_frame_address = pointer_address;
   while (*pointer_address < bottom_frame->fp()) {
     pointer_address = &Memory::Address_at(*pointer_address);
   }
   bool change = *above_frame_address != *pointer_address;
   *above_frame_address = *pointer_address;
@@ skipping 279 matching lines @@
 
 bool LiveEditFunctionTracker::IsActive() {
   return false;
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 
 
 } }  // namespace v8::internal