Revert "This implements per-isolate locking and unlocking, including tests"

src/isolate.h

 // Copyright 2011 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 206 matching lines @@
   inline void set_try_catch_handler_address(Address address) {
     try_catch_handler_address_ = address;
   }
 
   void Free() {
     ASSERT(!has_pending_message_);
     ASSERT(!external_caught_exception_);
     ASSERT(try_catch_handler_address_ == NULL);
   }
 
-  Isolate* isolate_;
   // The context where the current execution method is created and for variable
   // lookups.
   Context* context_;
   ThreadId thread_id_;
   MaybeObject* pending_exception_;
   bool has_pending_message_;
   Object* pending_message_obj_;
   Script* pending_message_script_;
   int pending_message_start_pos_;
   int pending_message_end_pos_;
@@ skipping 242 matching lines @@
   void TearDown();
 
   bool IsDefaultIsolate() const { return this == default_isolate_; }
 
   // Ensures that process-wide resources and the default isolate have been
   // allocated. It is only necessary to call this method in rare casses, for
   // example if you are using V8 from within the body of a static initializer.
   // Safe to call multiple times.
   static void EnsureDefaultIsolate();
 
-  // Find the PerThread for this particular (isolate, thread) combination
-  // If one does not yet exist, return null.
-  PerIsolateThreadData* FindPerThreadDataForThisThread();
-
 #ifdef ENABLE_DEBUGGER_SUPPORT
   // Get the debugger from the default isolate. Preinitializes the
   // default isolate if needed.
   static Debugger* GetDefaultIsolateDebugger();
 #endif
 
   // Get the stack guard from the default isolate. Preinitializes the
   // default isolate if needed.
   static StackGuard* GetDefaultIsolateStackGuard();
 
@@ skipping 559 matching lines @@
   EntryStackItem* entry_stack_;
 
   // Allocate and insert PerIsolateThreadData into the ThreadDataTable
   // (regardless of whether such data already exists).
   PerIsolateThreadData* AllocatePerIsolateThreadData(ThreadId thread_id);
 
   // Find the PerThread for this particular (isolate, thread) combination.
   // If one does not yet exist, allocate a new one.
   PerIsolateThreadData* FindOrAllocatePerThreadDataForThisThread();
 
-// PreInits and returns a default isolate. Needed when a new thread tries
+  // PreInits and returns a default isolate. Needed when a new thread tries
   // to create a Locker for the first time (the lock itself is in the isolate).
   static Isolate* GetDefaultIsolateForLocking();
 
   // Initializes the current thread to run this Isolate.
   // Not thread-safe. Multiple threads should not Enter/Exit the same isolate
   // at the same time, this should be prevented using external locking.
   void Enter();
 
   // Exits the current thread. The previosuly entered Isolate is restored
   // for the thread.
@@ skipping 111 matching lines @@
   // between compilation units.
 #define ISOLATE_FIELD_OFFSET(type, name, ignored)                              \
   static const intptr_t name##_debug_offset_;
   ISOLATE_INIT_LIST(ISOLATE_FIELD_OFFSET)
   ISOLATE_INIT_ARRAY_LIST(ISOLATE_FIELD_OFFSET)
 #undef ISOLATE_FIELD_OFFSET
 #endif
 
   friend class ExecutionAccess;
   friend class IsolateInitializer;
-  friend class ThreadManager;
-  friend class StackGuard;
   friend class ThreadId;
   friend class v8::Isolate;
   friend class v8::Locker;
-  friend class v8::Unlocker;
 
   DISALLOW_COPY_AND_ASSIGN(Isolate);
 };
 
 
 // If the GCC version is 4.1.x or 4.2.x an additional field is added to the
 // class as a work around for a bug in the generated code found with these
 // versions of GCC. See V8 issue 122 for details.
 class SaveContext BASE_EMBEDDED {
  public:
@@ skipping 160 matching lines @@
 
 } }  // namespace v8::internal
 
 // TODO(isolates): Get rid of these -inl.h includes and place them only where
 //                 they're needed.
 #include "allocation-inl.h"
 #include "zone-inl.h"
 #include "frames-inl.h"
 
 #endif  // V8_ISOLATE_H_