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

test/cctest/test-thread-termination.cc

 // Copyright 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 354 matching lines @@
   CHECK(!v8::V8::IsExecutionTerminating());
   v8::Handle<v8::String> source =
       v8::String::New("try { loop(); fail(); } catch(e) { fail(); }");
   v8::Script::Compile(source)->Run();
   CHECK(!v8::V8::IsExecutionTerminating());
   // Check we can run JS again after termination.
   CHECK(v8::Script::Compile(v8::String::New("function f() { return true; }"
                                             "f()"))->Run()->IsTrue());
   context.Dispose(context->GetIsolate());
 }
+
+v8::Handle<v8::Value> DoLoopCancelTerminate(const v8::Arguments& args) {
+  v8::TryCatch try_catch;
+  CHECK(!v8::V8::IsExecutionTerminating());
+  v8::Script::Compile(v8::String::New("var term = true;"
+                                      "while(true) {"
+                                      "  if (term) terminate();"
+                                      "  term = false;"
+                                      "}"))->Run();
+  CHECK(try_catch.HasCaught());
+  CHECK(try_catch.Exception()->IsNull());
+  CHECK(try_catch.Message().IsEmpty());
+  CHECK(!try_catch.CanContinue());
+  CHECK(v8::V8::IsExecutionTerminating());
+  CHECK(try_catch.HasTerminated());
+  v8::V8::CancelTerminateExecution(v8::Isolate::GetCurrent());
+  CHECK(!v8::V8::IsExecutionTerminating());

[Yang, 2013/03/21 10:47:42]

If you remove the two lines above, the test would still pass, since it would
essentially be the same as the test TerminateAndReenterFromThreadItself. What
you want to test is that the script continues from where it left off when it was
terminated.

+  return v8::Undefined();
+}
+
+// Test that a single thread of JavaScript execution can terminate
+// itself and then resume execution.
+TEST(TerminateCancelTerminateFromThreadItself) {
+  v8::HandleScope scope;
+  v8::Handle<v8::ObjectTemplate> global =
+      CreateGlobalTemplate(TerminateCurrentThread, DoLoopCancelTerminate);
+  v8::Persistent<v8::Context> context = v8::Context::New(NULL, global);
+  v8::Context::Scope context_scope(context);
+  CHECK(!v8::V8::IsExecutionTerminating());
+  // Run a loop that will be infinite if thread termination does not work.
+  v8::Handle<v8::String> source =
+      v8::String::New("try { doloop(); } catch(e) { fail(); }");
+  v8::Script::Compile(source)->Run();
+  // Test that we can run the code again after thread termination.
+  CHECK(!v8::V8::IsExecutionTerminating());
+  v8::Script::Compile(source)->Run();

[Yang, 2013/03/21 10:47:42]

See above. What you want to test is that the script continues from where it left
off when it was terminated, not that it can restart with another script.

I took the liberty to change these last few lines to

  v8::Handle<v8::String> source =
      v8::String::New("try { doloop(); } catch(e) { fail(); } 'completed';");
  // Check that execution completed with correct return value.
  CHECK(v8::Script::Compile(source)->Run()->Equals(v8_str("completed")));

+  context.Dispose(context->GetIsolate());
+}
+