Add methods to allow resuming execution after calling TerminateExecution().

include/v8.h

Index: include/v8.h
===================================================================
--- include/v8.h	(revision 12718)
+++ include/v8.h	(working copy)
@@ -3405,6 +3405,25 @@
   static bool IsExecutionTerminating(Isolate* isolate = NULL);
 
   /**
+   * Resume execution capability in the given isolate, whose execution
+   * was previously forcefully terminated using TerminateExecution().
+   * If no isolate is provided, the default isolate is used.
+   *
+   * When execution is forcefully terminated using TerminateExecution(),
+   * the isolate can not resume execution until all JavaScript frames
+   * have propagated the uncatchable exception which is generated.  This
+   * method allows the program embedding the engine to handle the
+   * termination event and resume execution capability, even if
+   * JavaScript frames remain on the stack.
+   *
+   * This method can be used by any thread even if that thread has not
+   * acquired the V8 lock with a Locker object.
+   *
+   * \param isolate The isolate in which to resume execution capability.
+   */
+  static void ResumeExecution(Isolate* isolate = NULL);

[Sven Panne, 2012/12/06 15:07:34]

In general, we are moving into the direction of requiring Isolate parameters
when the implementation of the API function needs an Isolate. So I would very
much prefer making the parameter non-optional and avoid introducing yet another
old-style API entry.

[Yang, 2012/12/07 15:03:48]

Agreed.

+
+  /**
    * Releases any resources used by v8 and stops any utility threads
    * that may be running.  Note that disposing v8 is permanent, it
    * cannot be reinitialized.
@@ -3501,18 +3520,28 @@
    * For certain types of exceptions, it makes no sense to continue
    * execution.
    *
-   * Currently, the only type of exception that can be caught by a
-   * TryCatch handler and for which it does not make sense to continue
-   * is termination exception.  Such exceptions are thrown when the
-   * TerminateExecution methods are called to terminate a long-running
-   * script.
-   *
    * If CanContinue returns false, the correct action is to perform
-   * any C++ cleanup needed and then return.
+   * any C++ cleanup needed and then return.  If CanContinue returns
+   * false and HasTerminated returns true, it is possible to call
+   * ResumeExecution in order to continue calling into the engine.
    */
   bool CanContinue() const;
 
   /**
+   * Returns true if an exception has been caught due to script execution
+   * being terminated.
+   *
+   * There is no JavaScript representation of an execution termination
+   * exception.  Such exceptions are thrown when the TerminateExecution
+   * methods are called to terminate a long-running script.
+   *
+   * If such an exception has been thrown, HasTerminated will return
+   * true, indicating that it is possible to call ResumeExecution in
+   * order to continue calling into the engine.
+   */
+  bool HasTerminated() const;
+
+  /**
    * Throws the exception caught by this TryCatch in a way that avoids
    * it being caught again by this same TryCatch.  As with ThrowException
    * it is illegal to execute any JavaScript operations after calling
@@ -3581,6 +3610,7 @@
   bool can_continue_ : 1;
   bool capture_message_ : 1;
   bool rethrow_ : 1;
+  bool has_terminated_ : 1;
 
   friend class v8::internal::Isolate;
 };