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

src/debug.cc

 // Copyright 2006-2008 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 61 matching lines @@
 static Handle<Code> ComputeCallDebugPrepareStepIn(int argc,  Code::Kind kind) {
   CALL_HEAP_FUNCTION(
       Isolate::Current()->stub_cache()->ComputeCallDebugPrepareStepIn(
           argc, kind),
       Code);
 }
 
 
 static v8::Handle<v8::Context> GetDebugEventContext() {
   Handle<Context> context = Debug::debugger_entry()->GetContext();
-  // Top::context() may have been NULL when "script collected" event occured.
+  // Isolate::context() may have been NULL when "script collected" event
+  // occured.
   if (*context == NULL) {
     return v8::Local<v8::Context>();
   }
   Handle<Context> global_context(context->global_context());
   return v8::Utils::ToLocal(global_context);
 }
 
 
 BreakLocationIterator::BreakLocationIterator(Handle<DebugInfo> debug_info,
                                              BreakLocatorType type) {
@@ skipping 638 matching lines @@
   Handle<SharedFunctionInfo> function_info;
   function_info = Compiler::Compile(source_code,
                                     script_name,
                                     0, 0, NULL, NULL,
                                     Handle<String>::null(),
                                     NATIVES_CODE);
   FLAG_allow_natives_syntax = allow_natives_syntax;
 
   // Silently ignore stack overflows during compilation.
   if (function_info.is_null()) {
-    ASSERT(Top::has_pending_exception());
-    Top::clear_pending_exception();
+    ASSERT(Isolate::Current()->has_pending_exception());
+    Isolate::Current()->clear_pending_exception();
     return false;
   }
 
   // Execute the shared function in the debugger context.
-  Handle<Context> context = Top::global_context();
+  Handle<Context> context = Isolate::Current()->global_context();
   bool caught_exception = false;
   Handle<JSFunction> function =
       Factory::NewFunctionFromSharedFunctionInfo(function_info, context);
   Handle<Object> result =
       Execution::TryCall(function, Handle<Object>(context->global()),
                          0, NULL, &caught_exception);
 
   // Check for caught exceptions.
   if (caught_exception) {
     Handle<Object> message = MessageHandler::MakeMessageObject(
@@ skipping 28 matching lines @@
   // Create the debugger context.
   HandleScope scope;
   Handle<Context> context =
       Isolate::Current()->bootstrapper()->CreateEnvironment(
           Handle<Object>::null(),
           v8::Handle<ObjectTemplate>(),
           NULL);
 
   // Use the debugger context.
   SaveContext save;
-  Top::set_context(*context);
+  Isolate::Current()->set_context(*context);
 
   // Expose the builtins object in the debugger context.
   Handle<String> key = Factory::LookupAsciiSymbol("builtins");
   Handle<GlobalObject> global = Handle<GlobalObject>(context->global());
   SetProperty(global, key, Handle<Object>(global->builtins()), NONE);
 
   // Compile the JavaScript for the debugger in the debugger context.
   Debugger::set_compiling_natives(true);
   bool caught_exception =
       !CompileDebuggerScript(Natives::GetIndex("mirror")) ||
@@ skipping 191 matching lines @@
   Handle<Object> break_id = Factory::NewNumberFromInt(Debug::break_id());
 
   // Call HandleBreakPointx.
   bool caught_exception = false;
   const int argc = 2;
   Object** argv[argc] = {
     break_id.location(),
     reinterpret_cast<Object**>(break_point_object.location())
   };
   Handle<Object> result = Execution::TryCall(check_break_point,
-                                             Top::builtins(), argc, argv,
-                                             &caught_exception);
+                                             Isolate::Current()->builtins(),
+                                             argc, argv, &caught_exception);
 
   // If exception or non boolean result handle as not triggered
   if (caught_exception || !result->IsBoolean()) {
     return false;
   }
 
   // Return whether the break point is triggered.
   return *result == HEAP->true_value();
 }
 
@@ skipping 740 matching lines @@
 }
 
 
 bool Debug::IsDebugGlobal(GlobalObject* global) {
   return IsLoaded() && global == Debug::debug_context()->global();
 }
 
 
 void Debug::ClearMirrorCache() {
   HandleScope scope;
-  ASSERT(Top::context() == *Debug::debug_context());
+  ASSERT(Isolate::Current()->context() == *Debug::debug_context());
 
   // Clear the mirror cache.
   Handle<String> function_name =
       Factory::LookupSymbol(CStrVector("ClearMirrorCache"));
-  Handle<Object> fun(Top::global()->GetProperty(*function_name));
+  Handle<Object> fun(Isolate::Current()->global()->GetProperty(*function_name));
   ASSERT(fun->IsJSFunction());
   bool caught_exception;
   Handle<Object> js_object = Execution::TryCall(
       Handle<JSFunction>::cast(fun),
       Handle<JSObject>(Debug::debug_context()->global()),
       0, NULL, &caught_exception);
 }
 
 
 void Debug::CreateScriptCache() {
@@ skipping 81 matching lines @@
 MessageDispatchHelperThread* Debugger::message_dispatch_helper_thread_ = NULL;
 int Debugger::host_dispatch_micros_ = 100 * 1000;
 DebuggerAgent* Debugger::agent_ = NULL;
 LockingCommandMessageQueue Debugger::command_queue_(kQueueInitialSize);
 Semaphore* Debugger::command_received_ = OS::CreateSemaphore(0);
 
 
 Handle<Object> Debugger::MakeJSObject(Vector<const char> constructor_name,
                                       int argc, Object*** argv,
                                       bool* caught_exception) {
-  ASSERT(Top::context() == *Debug::debug_context());
+  ASSERT(Isolate::Current()->context() == *Debug::debug_context());
 
   // Create the execution state object.
   Handle<String> constructor_str = Factory::LookupSymbol(constructor_name);
-  Handle<Object> constructor(Top::global()->GetProperty(*constructor_str));
+  Handle<Object> constructor(
+      Isolate::Current()->global()->GetProperty(*constructor_str));
   ASSERT(constructor->IsJSFunction());
   if (!constructor->IsJSFunction()) {
     *caught_exception = true;
     return Factory::undefined_value();
   }
   Handle<Object> js_object = Execution::TryCall(
       Handle<JSFunction>::cast(constructor),
       Handle<JSObject>(Debug::debug_context()->global()), argc, argv,
       caught_exception);
   return js_object;
@@ skipping 123 matching lines @@
   ProcessDebugEvent(v8::Exception, Handle<JSObject>::cast(event_data), false);
   // Return to continue execution from where the exception was thrown.
 }
 
 
 void Debugger::OnDebugBreak(Handle<Object> break_points_hit,
                             bool auto_continue) {
   HandleScope scope;
 
   // Debugger has already been entered by caller.
-  ASSERT(Top::context() == *Debug::debug_context());
+  ASSERT(Isolate::Current()->context() == *Debug::debug_context());
 
   // Bail out if there is no listener for this event
   if (!Debugger::EventActive(v8::Break)) return;
 
   // Debugger must be entered in advance.
-  ASSERT(Top::context() == *Debug::debug_context());
+  ASSERT(Isolate::Current()->context() == *Debug::debug_context());
 
   // Create the event data object.
   bool caught_exception = false;
   Handle<Object> exec_state = MakeExecutionState(&caught_exception);
   Handle<Object> event_data;
   if (!caught_exception) {
     event_data = MakeBreakEvent(exec_state, break_points_hit,
                                 &caught_exception);
   }
   // Bail out and don't call debugger if exception.
@@ skipping 71 matching lines @@
   // Wrap the script object in a proper JS object before passing it
   // to JavaScript.
   Handle<JSValue> wrapper = GetScriptWrapper(script);
 
   // Call UpdateScriptBreakPoints expect no exceptions.
   bool caught_exception = false;
   const int argc = 1;
   Object** argv[argc] = { reinterpret_cast<Object**>(wrapper.location()) };
   Handle<Object> result = Execution::TryCall(
       Handle<JSFunction>::cast(update_script_break_points),
-      Top::builtins(), argc, argv,
+      Isolate::Current()->builtins(), argc, argv,
       &caught_exception);
   if (caught_exception) {
     return;
   }
   // Bail out based on state or if there is no listener for this event
   if (in_debugger && (after_compile_flags & SEND_WHEN_DEBUGGING) == 0) return;
   if (!Debugger::EventActive(v8::AfterCompile)) return;
 
   // Create the compile state object.
   Handle<Object> event_data = MakeCompileEvent(script,
@@ skipping 78 matching lines @@
       // JavaScript debug event listener.
       ASSERT(event_listener_->IsJSFunction());
       Handle<JSFunction> fun(Handle<JSFunction>::cast(event_listener_));
 
       // Invoke the JavaScript debug event listener.
       const int argc = 4;
       Object** argv[argc] = { Handle<Object>(Smi::FromInt(event)).location(),
                               exec_state.location(),
                               Handle<Object>::cast(event_data).location(),
                               event_listener_data_.location() };
-      Handle<Object> result = Execution::TryCall(fun, Top::global(),
+      Handle<Object> result = Execution::TryCall(fun,
+                                                 Isolate::Current()->global(),
                                                  argc, argv, &caught_exception);
       // Silently ignore exceptions from debug event listeners.
     }
   }
 }
 
 
 Handle<Context> Debugger::GetDebugContext() {
     never_unload_debugger_ = true;
     EnterDebugger debugger;
@@ skipping 495 matching lines @@
     }
     return scope.Close(v8::Utils::ToLocal(Handle<String>::cast(json)));
   } else {
     return v8::Utils::ToLocal(response_json_);
   }
 }
 
 
 v8::Handle<v8::Context> MessageImpl::GetEventContext() const {
   v8::Handle<v8::Context> context = GetDebugEventContext();
-  // Top::context() may be NULL when "script collected" event occures.
+  // Isolate::context() may be NULL when "script collected" event occures.
   ASSERT(!context.IsEmpty() || event_ == v8::ScriptCollected);
   return GetDebugEventContext();
 }
 
 
 v8::Debug::ClientData* MessageImpl::GetClientData() const {
   return client_data_;
 }
 
 
@@ skipping 179 matching lines @@
     {
       Locker locker;
       Debugger::CallMessageDispatchHandler();
     }
   }
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal