Make v8::TryCatch able to consume natively thrown exceptions (again).

src/isolate.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 
 #include "v8.h"
 
 #include "ast.h"
 #include "bootstrapper.h"
@@ skipping 890 matching lines @@
   Object* script = reinterpret_cast<Object*>(handler->message_script_);
   ASSERT(message->IsJSMessageObject() || message->IsTheHole());
   ASSERT(script->IsScript() || script->IsTheHole());
   thread_local_top()->pending_message_obj_ = message;
   thread_local_top()->pending_message_script_ = script;
   thread_local_top()->pending_message_start_pos_ = handler->message_start_pos_;
   thread_local_top()->pending_message_end_pos_ = handler->message_end_pos_;
 }
 
 
+void Isolate::CancelScheduledExceptionFromTryCatch(v8::TryCatch* handler) {
+  ASSERT(has_scheduled_exception());
+  if (scheduled_exception() == handler->exception_) {
+    ASSERT(scheduled_exception() != heap()->termination_exception());
+    clear_scheduled_exception();
+  }
+}
+
+
 Object* Isolate::PromoteScheduledException() {
   Object* thrown = scheduled_exception();
   clear_scheduled_exception();
   // Re-throw the exception to avoid getting repeated error reporting.
   return ReThrow(thrown);
 }
 
 
 void Isolate::PrintCurrentStackTrace(FILE* out) {
   StackTraceFrameIterator it(this);
@@ skipping 267 matching lines @@
 
   return true;
 }
 
 
 void Isolate::ReportPendingMessages() {
   ASSERT(has_pending_exception());
   PropagatePendingExceptionToExternalTryCatch();
 
   HandleScope scope(this);
-  if (thread_local_top_.pending_exception_ ==
-          heap()->termination_exception()) {
+  if (thread_local_top_.pending_exception_ == heap()->termination_exception()) {
     // Do nothing: if needed, the exception has been already propagated to
     // v8::TryCatch.
   } else {
     if (thread_local_top_.has_pending_message_) {
       thread_local_top_.has_pending_message_ = false;
       if (!thread_local_top_.pending_message_obj_->IsTheHole()) {
         HandleScope scope(this);
         Handle<Object> message_obj(thread_local_top_.pending_message_obj_,
                                    this);
         if (!thread_local_top_.pending_message_script_->IsTheHole()) {
@@ skipping 516 matching lines @@
 
 
 void Isolate::PropagatePendingExceptionToExternalTryCatch() {
   ASSERT(has_pending_exception());
 
   bool external_caught = IsExternallyCaught();
   thread_local_top_.external_caught_exception_ = external_caught;
 
   if (!external_caught) return;
 
-  if (thread_local_top_.pending_exception_ ==
-             heap()->termination_exception()) {
+  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 {
     v8::TryCatch* handler = try_catch_handler();
     ASSERT(thread_local_top_.pending_message_obj_->IsJSMessageObject() ||
            thread_local_top_.pending_message_obj_->IsTheHole());
     ASSERT(thread_local_top_.pending_message_script_->IsScript() ||
            thread_local_top_.pending_message_script_->IsTheHole());
     handler->can_continue_ = true;
@@ skipping 540 matching lines @@
       Execution::Call(this, microtask, factory()->undefined_value(),
                       0, NULL).Check();
     }
   }
 
   handle_scope_implementer()->DecrementCallDepth();
 }
 
 
 } }  // namespace v8::internal