Patch for allowing several V8 instances in process:...

include/v8.h

 // Copyright 2007-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 114 matching lines @@
 template <class T> class Persistent;
 class FunctionTemplate;
 class ObjectTemplate;
 class Data;
 
 namespace internal {
 
 class Arguments;
 class Object;
 class Top;
+class V8Context;
 
 }
 
 
 // --- W e a k  H a n d l e s
 
 
 /**
  * A weak reference callback function.
  *
@@ skipping 2609 matching lines @@
   static void StopPreemption();
 
   /**
    * Returns whether or not the locker is locked by the current thread.
    */
   static bool IsLocked();
 
   /**
    * Returns whether v8::Locker is being used by this V8 instance.
    */
-  static bool IsActive() { return active_; }
+  static bool IsActive();
 
  private:
   bool has_lock_;
   bool top_level_;
 
-  static bool active_;
-
   // Disallow copying and assigning.
   Locker(const Locker&);
   void operator=(const Locker&);
 };
 
 
 
 // --- I m p l e m e n t a t i o n ---
 
 
@@ skipping 418 matching lines @@
   return Local<Object>(reinterpret_cast<Object*>(&args_[0]));
 }
 
 
 Local<Object> AccessorInfo::Holder() const {
   return Local<Object>(reinterpret_cast<Object*>(&args_[-1]));
 }
 
 
 /**
+ * Encapsulates V8 instance
+ */
+class V8EXPORT V8ContextProvider {
+ public:
+  V8ContextProvider();
+  ~V8ContextProvider();
+
+  operator internal::V8Context*() const {
+    return v8context_;
+  }
+ private:
+  V8ContextProvider(const V8ContextProvider&);
+  void operator=(const V8ContextProvider&);
+  void* operator new(size_t size);
+  void operator delete(void*, size_t);
+
+  internal::V8Context* const v8context_;
+  friend class V8ContextBinder;
+};
+
+/**
+ * Manages binding of V8 instance (from V8ContextProvider) to current thread
+ *
+ * V8ContextProvider context_provider;
+ * ...
+ * V8ContextBinder context_binder(context_provider);
+ */
+class V8EXPORT V8ContextBinder {
+ public:
+  V8ContextBinder(internal::V8Context*, bool bind_default = false);
+  ~V8ContextBinder();
+ private:
+  V8ContextBinder(const V8ContextBinder&);
+  void operator=(const V8ContextBinder&);
+  void* operator new(size_t size);
+  void operator delete(void*, size_t);
+
+  internal::V8Context* const v8context_;
+  bool bound_default_;
+};
+
+/**
+ * Allocated statically, implies intent of V8 host to have several instances
+ * of V8 in process
+ */
+class V8EXPORT AllowSeveralV8InstancesInProcess {
+ public:
+  AllowSeveralV8InstancesInProcess();
+  ~AllowSeveralV8InstancesInProcess();
+};
+
+/**
  * \example shell.cc
  * A simple shell that takes a list of expressions on the
  * command-line and executes them.
  */
 
 
 /**
  * \example process.cc
  */
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef V8EXPORT_INLINE
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_