Revert r13218 due to windows test failures.

include/v8.h

 // Copyright 2012 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 3461 matching lines @@
    * Returns true if JavaScript execution is currently terminating
    * because of a call to TerminateExecution.  In that case there are
    * still JavaScript frames on the stack and the termination
    * exception is still active.
    *
    * \param isolate The isolate in which to check.
    */
   static bool IsExecutionTerminating(Isolate* isolate = NULL);
 
   /**
-   * Resume execution capability in the given isolate, whose execution
-   * was previously forcefully terminated using TerminateExecution().
-   *
-   * 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);
-
-  /**
    * 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.
    *
    * It should generally not be necessary to dispose v8 before exiting
    * a process, this should happen automatically.  It is only necessary
    * to use if the process needs the resources taken up by v8.
    */
   static bool Dispose();
 
@@ skipping 101 matching lines @@
 
   /**
    * Returns true if an exception has been caught by this try/catch block.
    */
   bool HasCaught() const;
 
   /**
    * 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.  If CanContinue returns
-   * false and HasTerminated returns true, it is possible to call
-   * ResumeExecution in order to continue calling into the engine.
+   * any C++ cleanup needed and then return.
    */
   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
    * ReThrow; the caller must return immediately to where the exception
    * is caught.
    */
   Handle<Value> ReThrow();
 
   /**
    * Returns the exception caught by this try/catch block.  If no exception has
@@ skipping 54 matching lines @@
   void operator delete(void*, size_t);
 
   v8::internal::Isolate* isolate_;
   void* next_;
   void* exception_;
   void* message_;
   bool is_verbose_ : 1;
   bool can_continue_ : 1;
   bool capture_message_ : 1;
   bool rethrow_ : 1;
-  bool has_terminated_ : 1;
 
   friend class v8::internal::Isolate;
 };
 
 
 // --- Context ---
 
 
 /**
  * Ignore
@@ skipping 1164 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_