[Isolates] Allow running multiple isolates in shell and use this in tests.

src/isolate.cc

 // Copyright 2006-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 229 matching lines @@
   }
 
   ScopedLock lock(process_wide_mutex_);
   if (default_isolate_ == NULL) {
     isolate_key_ = Thread::CreateThreadLocalKey();
     thread_id_key_ = Thread::CreateThreadLocalKey();
     per_isolate_thread_data_key_ = Thread::CreateThreadLocalKey();
     thread_data_table_ = new Isolate::ThreadDataTable();
     default_isolate_ = new Isolate();
   }
+  // Can't use SetIsolateThreadLocals(default_isolate_, NULL) here
+  // becase a non-null thread data may be already set.
   Thread::SetThreadLocal(isolate_key_, default_isolate_);
   CHECK(default_isolate_->PreInit());
 }
 
 
 void Isolate::EnterDefaultIsolate() {
   EnsureDefaultIsolate();
   ASSERT(default_isolate_ != NULL);
 
   PerIsolateThreadData* data = CurrentPerIsolateThreadData();
@@ skipping 122 matching lines @@
   ISOLATE_INIT_LIST(ISOLATE_INIT_EXECUTE)
 #undef ISOLATE_INIT_EXECUTE
 
 #define ISOLATE_INIT_ARRAY_EXECUTE(type, name, length)                         \
   memset(name##_, 0, sizeof(type) * length);
   ISOLATE_INIT_ARRAY_LIST(ISOLATE_INIT_ARRAY_EXECUTE)
 #undef ISOLATE_INIT_ARRAY_EXECUTE
 }
 
 void Isolate::TearDown() {
+  // Temporarily set this isolate as current so that various parts of
+  // the isolate can access it in their destructors without having a
+  // direct pointer. We don't use Enter/Exit here to avoid
+  // initializing the thread data.
+  PerIsolateThreadData* saved_data = CurrentPerIsolateThreadData();
+  Isolate* saved_isolate = UncheckedCurrent();
+  SetIsolateThreadLocals(this, NULL);
+
   Deinit();
 
   if (!IsDefaultIsolate()) {
     delete this;
   }
+
+  // Restore the previous current isolate.
+  SetIsolateThreadLocals(saved_isolate, saved_data);
 }
 
 
 void Isolate::Deinit() {
   if (state_ == INITIALIZED) {
     OProfileAgent::TearDown();
     if (FLAG_preemption) {
       v8::Locker locker;
       v8::Locker::StopPreemption();
     }
     builtins_.TearDown();
     bootstrapper_->TearDown();
 
     // Remove the external reference to the preallocated stack memory.
     delete preallocated_message_space_;
     preallocated_message_space_ = NULL;
     PreallocatedMemoryThreadStop();
 
     HeapProfiler::TearDown();
     CpuProfiler::TearDown();
     heap_.TearDown();
     logger_->TearDown();
 
     // The default isolate is re-initializable due to legacy API.
     state_ = PREINITIALIZED;
   }
 }
 
+
+void Isolate::SetIsolateThreadLocals(Isolate* isolate,
+                                     PerIsolateThreadData* data) {
+  Thread::SetThreadLocal(isolate_key_, isolate);
+  Thread::SetThreadLocal(per_isolate_thread_data_key_, data);
+}
+
+
 Isolate::~Isolate() {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   delete producer_heap_profile_;
   producer_heap_profile_ = NULL;
 #endif
 
   delete scanner_character_classes_;
   scanner_character_classes_ = NULL;
 
   delete regexp_stack_;
@@ skipping 259 matching lines @@
 
   PerIsolateThreadData* data = FindOrAllocatePerThreadDataForThisThread();
   ASSERT(data != NULL);
   ASSERT(data->isolate_ == this);
 
   EntryStackItem* item = new EntryStackItem(current_data,
                                             current_isolate,
                                             entry_stack_);
   entry_stack_ = item;
 
-  Thread::SetThreadLocal(per_isolate_thread_data_key_, data);
-  Thread::SetThreadLocal(isolate_key_, this);
+  SetIsolateThreadLocals(this, data);
 
   CHECK(PreInit());
 
   // In case it's the first time some thread enters the isolate.
   set_thread_id(data->thread_id());
 }
 
 
 void Isolate::Exit() {
   ASSERT(entry_stack_ != NULL);
   ASSERT(entry_stack_->previous_thread_data == NULL ||
          entry_stack_->previous_thread_data->thread_id() ==
              Thread::GetThreadLocalInt(thread_id_key_));
 
   if (--entry_stack_->entry_count > 0) return;
 
   ASSERT(CurrentPerIsolateThreadData() != NULL);
   ASSERT(CurrentPerIsolateThreadData()->isolate_ == this);
 
   // Pop the stack.
   EntryStackItem* item = entry_stack_;
   entry_stack_ = item->previous_item;
 
   PerIsolateThreadData* previous_thread_data = item->previous_thread_data;
   Isolate* previous_isolate = item->previous_isolate;
 
   delete item;
 
   // Reinit the current thread for the isolate it was running before this one.
-  Thread::SetThreadLocal(per_isolate_thread_data_key_, previous_thread_data);
-  Thread::SetThreadLocal(isolate_key_, previous_isolate);
+  SetIsolateThreadLocals(previous_isolate, previous_thread_data);
 }
 
 } }  // namespace v8::internal