[Isolates]...

src/api.cc

 // Copyright 2009 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 363 matching lines @@
 }
 
 
 ResourceConstraints::ResourceConstraints()
   : max_young_space_size_(0),
     max_old_space_size_(0),
     stack_limit_(NULL) { }
 
 
 bool SetResourceConstraints(ResourceConstraints* constraints) {
+  i::Isolate* isolate = i::Isolate::Current();
+
   int young_space_size = constraints->max_young_space_size();
   int old_gen_size = constraints->max_old_space_size();
   if (young_space_size != 0 || old_gen_size != 0) {
-    bool result = i::Heap::ConfigureHeap(young_space_size / 2, old_gen_size);
+    bool result = isolate->heap()->ConfigureHeap(young_space_size / 2,
+                                                 old_gen_size);
     if (!result) return false;
   }
   if (constraints->stack_limit() != NULL) {
     uintptr_t limit = reinterpret_cast<uintptr_t>(constraints->stack_limit());
-    i::StackGuard::SetStackLimit(limit);
+    isolate->stack_guard()->SetStackLimit(limit);
   }
   return true;
 }
 
 
 i::Object** V8::GlobalizeReference(i::Object** obj) {
   if (IsDeadCheck("V8::Persistent::New")) return NULL;
   LOG_API("Persistent::New");
   i::Handle<i::Object> result =
       i::GlobalHandles::Create(*obj);
@@ skipping 3444 matching lines @@
 int V8::GetCurrentThreadId() {
   API_ENTRY_CHECK("V8::GetCurrentThreadId()");
   EnsureInitialized("V8::GetCurrentThreadId()");
   return i::Top::thread_id();
 }
 
 
 void V8::TerminateExecution(int thread_id) {
   if (!i::V8::IsRunning()) return;
   API_ENTRY_CHECK("V8::GetCurrentThreadId()");
+  i::Isolate* isolate = i::Isolate::Current();
   // If the thread_id identifies the current thread just terminate
   // execution right away.  Otherwise, ask the thread manager to
   // terminate the thread with the given id if any.
   if (thread_id == i::Top::thread_id()) {
-    i::StackGuard::TerminateExecution();
+    isolate->stack_guard()->TerminateExecution();
   } else {
     i::ThreadManager::TerminateExecution(thread_id);
   }
 }
 
 
 void V8::TerminateExecution() {
   if (!i::V8::IsRunning()) return;
-  i::StackGuard::TerminateExecution();
+  i::Isolate::Current()->stack_guard()->TerminateExecution();
 }
 
 
 bool V8::IsExecutionTerminating() {
   if (!i::V8::IsRunning()) return false;
   if (i::Top::has_scheduled_exception()) {
     return i::Top::scheduled_exception() == HEAP->termination_exception();
   }
   return false;
 }
@@ skipping 207 matching lines @@
   ON_BAILOUT("v8::Debug::SetDebugEventListener()", return false);
   ENTER_V8;
   i::Debugger::SetEventListener(Utils::OpenHandle(*that),
                                 Utils::OpenHandle(*data));
   return true;
 }
 
 
 void Debug::DebugBreak() {
   if (!i::V8::IsRunning()) return;
-  i::StackGuard::DebugBreak();
+  i::Isolate::Current()->stack_guard()->DebugBreak();
 }
 
 
 static v8::Debug::MessageHandler message_handler = NULL;
 
 static void MessageHandlerWrapper(const v8::Debug::Message& message) {
   if (message_handler) {
     v8::String::Value json(message.GetJSON());
     message_handler(*json, json.length(), message.GetClientData());
   }
@@ skipping 317 matching lines @@
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* thread_local =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   thread_local->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal