AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Revert r13218 due to windows test failures.

Browse Source 
R=verwaest@chromium.org
BUG=

Review URL: https://chromiumcodereview.appspot.com/11568014

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@13219 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
yangguo@chromium.org 2012-12-13 17:21:15 +00:00
parent 4cd41edcd9
commit e24b98312b
8 changed files with 8 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
AUTHORS
View File

@ -9,7 +9,6 @@ ARM Ltd.
Hewlett-Packard Development Company, LP
Igalia, S.L.
Joyent, Inc.
Bloomberg Finance L.P.
Akinori MUSHA <knu@FreeBSD.org>
Alexander Botero-Lowry <alexbl@FreeBSD.org>

43
include/v8.h
View File

@ -3478,24 +3478,6 @@ class V8EXPORT V8 {
*/
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
@ -3618,27 +3600,17 @@ class V8EXPORT TryCatch {
* 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
@ -3714,7 +3686,6 @@ class V8EXPORT TryCatch {
bool can_continue_ : 1;
bool capture_message_ : 1;
bool rethrow_ : 1;
bool has_terminated_ : 1;
friend class v8::internal::Isolate;
};

13
src/api.cc
View File

@ -1788,8 +1788,7 @@ v8::TryCatch::TryCatch()
is_verbose_(false),
can_continue_(true),
capture_message_(true),
rethrow_(false),
has_terminated_(false) {
rethrow_(false) {
isolate_->RegisterTryCatchHandler(this);
}
@ -1817,11 +1816,6 @@ bool v8::TryCatch::CanContinue() const {
}
bool v8::TryCatch::HasTerminated() const {
return has_terminated_;
}
v8::Handle<v8::Value> v8::TryCatch::ReThrow() {
if (!HasCaught()) return v8::Local<v8::Value>();
rethrow_ = true;
@ -5589,11 +5583,6 @@ bool V8::IsExecutionTerminating(Isolate* isolate) {
}
void V8::ResumeExecution(Isolate* isolate) {
reinterpret_cast<i::Isolate*>(isolate)->stack_guard()->ResumeExecution();
}
Isolate* Isolate::GetCurrent() {
i::Isolate* isolate = i::Isolate::UncheckedCurrent();
return reinterpret_cast<Isolate*>(isolate);

8
src/execution.cc
View File

@ -423,14 +423,6 @@ bool StackGuard::IsTerminateExecution() {
}
void StackGuard::ResumeExecution() {
ASSERT(thread_local_.interrupt_flags_ & TERMINATE);
ExecutionAccess access(isolate_);
Continue(TERMINATE);
isolate_->ResumeExecution();
}
void StackGuard::TerminateExecution() {
ExecutionAccess access(isolate_);
thread_local_.interrupt_flags_ |= TERMINATE;

1
src/execution.h
View File

@ -193,7 +193,6 @@ class StackGuard {
void Interrupt();
bool IsTerminateExecution();
void TerminateExecution();
void ResumeExecution();
bool IsCodeReadyEvent();
void RequestCodeReadyEvent();
#ifdef ENABLE_DEBUGGER_SUPPORT

15
src/isolate.cc
View File

@ -1028,19 +1028,6 @@ Failure* Isolate::TerminateExecution() {
}
void Isolate::ResumeExecution() {
if (has_pending_exception() &&
pending_exception() == heap_.termination_exception()) {
thread_local_top()->external_caught_exception_ = false;
clear_pending_exception();
}
if (has_scheduled_exception() &&
scheduled_exception() == heap_.termination_exception()) {
clear_scheduled_exception();
}
}
Failure* Isolate::Throw(Object* exception, MessageLocation* location) {
DoThrow(exception, location);
return Failure::Exception();
@ -1896,14 +1883,12 @@ void Isolate::PropagatePendingExceptionToExternalTryCatch() {
} else if (thread_local_top_.pending_exception_ ==
heap()->termination_exception()) {
try_catch_handler()->can_continue_ = false;
try_catch_handler()->has_terminated_ = true;
try_catch_handler()->exception_ = heap()->null_value();
} else {
// At this point all non-object (failure) exceptions have
// been dealt with so this shouldn't fail.
ASSERT(!pending_exception()->IsFailure());
try_catch_handler()->can_continue_ = true;
try_catch_handler()->has_terminated_ = false;
try_catch_handler()->exception_ = pending_exception();
if (!thread_local_top_.pending_message_obj_->IsTheHole()) {
try_catch_handler()->message_ = thread_local_top_.pending_message_obj_;

1
src/isolate.h
View File

@ -765,7 +765,6 @@ class Isolate {
// Out of resource exception helpers.
Failure* StackOverflow();
Failure* TerminateExecution();
void ResumeExecution();
// Administration
void Iterate(ObjectVisitor* v);

38
test/cctest/test-thread-termination.cc
View File

@ -373,41 +373,3 @@ TEST(TerminateAndReenterFromThreadItself) {
context.Dispose();
}
v8::Handle<v8::Value> DoLoopResume(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::ResumeExecution(v8::Isolate::GetCurrent());
CHECK(!v8::V8::IsExecutionTerminating());
return v8::Undefined();
}
// Test that a single thread of JavaScript execution can terminate+
// itself and then resume execution.
TEST(TerminateResumeFromThreadItself) {
v8::HandleScope scope;
v8::Handle<v8::ObjectTemplate> global =
CreateGlobalTemplate(TerminateCurrentThread, DoLoopResume);
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();
context.Dispose();
}