Merge isolates to bleeding_edge.

src/v8threads.h

 // Copyright 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 16 matching lines @@
 
 #ifndef V8_V8THREADS_H_
 #define V8_V8THREADS_H_
 
 namespace v8 {
 namespace internal {
 
 
 class ThreadState {
  public:
-  // Iterate over in-use states.
-  static ThreadState* FirstInUse();
   // Returns NULL after the last one.
   ThreadState* Next();
 
   enum List {FREE_LIST, IN_USE_LIST};
 
   void LinkInto(List list);
   void Unlink();
 
-  static ThreadState* GetFree();
-
   // Id of thread.
   void set_id(int id) { id_ = id; }
   int id() { return id_; }
 
   // Should the thread be terminated when it is restored?
   bool terminate_on_restore() { return terminate_on_restore_; }
   void set_terminate_on_restore(bool terminate_on_restore) {
     terminate_on_restore_ = terminate_on_restore;
   }
 
   // Get data area for archiving a thread.
   char* data() { return data_; }
  private:
-  ThreadState();
+  explicit ThreadState(ThreadManager* thread_manager);
 
   void AllocateSpace();
 
   int id_;
   bool terminate_on_restore_;
   char* data_;
   ThreadState* next_;
   ThreadState* previous_;
 
-  // In the following two lists there is always at least one object on the list.
-  // The first object is a flying anchor that is only there to simplify linking
-  // and unlinking.
-  // Head of linked list of free states.
-  static ThreadState* free_anchor_;
-  // Head of linked list of states in use.
-  static ThreadState* in_use_anchor_;
+  ThreadManager* thread_manager_;
+
+  friend class ThreadManager;
 };
 
 
 // Defined in top.h
 class ThreadLocalTop;
 
 
 class ThreadVisitor {
  public:
   // ThreadLocalTop may be only available during this call.
   virtual void VisitThread(ThreadLocalTop* top) = 0;
 
  protected:
   virtual ~ThreadVisitor() {}
 };
 
 
-class ThreadManager : public AllStatic {
+class ThreadManager {
  public:
-  static void Lock();
-  static void Unlock();
+  void Lock();
+  void Unlock();
 
-  static void ArchiveThread();
-  static bool RestoreThread();
-  static void FreeThreadResources();
-  static bool IsArchived();
+  void ArchiveThread();
+  bool RestoreThread();
+  void FreeThreadResources();
+  bool IsArchived();
 
-  static void Iterate(ObjectVisitor* v);
-  static void IterateArchivedThreads(ThreadVisitor* v);
-  static bool IsLockedByCurrentThread() { return mutex_owner_.IsSelf(); }
+  void Iterate(ObjectVisitor* v);
+  void IterateArchivedThreads(ThreadVisitor* v);
+  bool IsLockedByCurrentThread() { return mutex_owner_.IsSelf(); }
 
-  static int CurrentId();
-  static void AssignId();
-  static bool HasId();
+  int CurrentId();
 
-  static void TerminateExecution(int thread_id);
+  void TerminateExecution(int thread_id);
+
+  // Iterate over in-use states.
+  ThreadState* FirstThreadStateInUse();
+  ThreadState* GetFreeThreadState();
 
   static const int kInvalidId = -1;
  private:
-  static void EagerlyArchiveThread();
+  ThreadManager();
+  ~ThreadManager();
 
-  static int last_id_;  // V8 threads are identified through an integer.
-  static Mutex* mutex_;
-  static ThreadHandle mutex_owner_;
-  static ThreadHandle lazily_archived_thread_;
-  static ThreadState* lazily_archived_thread_state_;
+  void EagerlyArchiveThread();
+
+  Mutex* mutex_;
+  ThreadHandle mutex_owner_;
+  ThreadHandle lazily_archived_thread_;
+  ThreadState* lazily_archived_thread_state_;
+
+  // In the following two lists there is always at least one object on the list.
+  // The first object is a flying anchor that is only there to simplify linking
+  // and unlinking.
+  // Head of linked list of free states.
+  ThreadState* free_anchor_;
+  // Head of linked list of states in use.
+  ThreadState* in_use_anchor_;
+
+  Isolate* isolate_;
+
+  friend class Isolate;
+  friend class ThreadState;
 };
 
 
 // The ContextSwitcher thread is used to schedule regular preemptions to
 // multiple running V8 threads. Generally it is necessary to call
 // StartPreemption if there is more than one thread running. If not, a single
 // JavaScript can take full control of V8 and not allow other threads to run.
 class ContextSwitcher: public Thread {
  public:
   // Set the preemption interval for the ContextSwitcher thread.
   static void StartPreemption(int every_n_ms);
 
   // Stop sending preemption requests to threads.
   static void StopPreemption();
 
   // Preempted thread needs to call back to the ContextSwitcher to acknowledge
   // the handling of a preemption request.
   static void PreemptionReceived();
 
  private:
-  explicit ContextSwitcher(int every_n_ms);
+  explicit ContextSwitcher(Isolate* isolate, int every_n_ms);
 
   void Run();
 
   bool keep_going_;
   int sleep_ms_;
-
-  static ContextSwitcher* singleton_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_V8THREADS_H_