Cleanup and unify Isolate::ReportPendingMessages.

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 <fstream>  // NOLINT(readability/streams)
 #include <sstream>
 
 #include "src/v8.h"
@@ skipping 1125 matching lines @@
 Object* Isolate::ThrowIllegalOperation() {
   if (FLAG_stack_trace_on_illegal) PrintStack(stdout);
   return Throw(heap()->illegal_access_string());
 }
 
 
 void Isolate::ScheduleThrow(Object* exception) {
   // When scheduling a throw we first throw the exception to get the
   // error reporting if it is uncaught before rescheduling it.
   Throw(exception);
-  PropagatePendingExceptionToExternalTryCatch();
+  ReportPendingMessages();
   if (has_pending_exception()) {
     thread_local_top()->scheduled_exception_ = pending_exception();
     thread_local_top()->external_caught_exception_ = false;
     clear_pending_exception();
   }
 }
 
 
 void Isolate::RestorePendingMessageFromTryCatch(v8::TryCatch* handler) {
   DCHECK(handler == try_catch_handler());
@@ skipping 246 matching lines @@
   // Note, that finally clauses would re-throw an exception unless it's aborted
   // by jumps in control flow (like return, break, etc.) and we'll have another
   // chance to set proper v8::TryCatch later.
   return (entry_handler > external_handler);
 }
 
 
 void Isolate::ReportPendingMessages() {
   Object* exception = pending_exception();
 
-  // Try to propagate the exception to an external v8::TryCatch handler. If
-  // propagation was unsuccessful, then we will get another chance at reporting
-  // the pending message if the exception is re-thrown.
-  bool has_been_propagated = PropagatePendingExceptionToExternalTryCatch();
-  if (!has_been_propagated) return;
+  // Propagation is unsuccessful because there still is a JavaScript handler on
+  // top that might catch the exception and hence prevent message reporting.
+  if (IsJavaScriptHandlerOnTop(exception)) {
+    thread_local_top_.external_caught_exception_ = false;
+    return;
+  }
+
+  // Determine whether the message needs to be reported to all message handlers
+  // depending on whether an external v8::TryCatch handler is on top.
+  bool should_report_exception;
+  Object* message_obj = thread_local_top_.pending_message_obj_;
+  DCHECK(message_obj->IsJSMessageObject() || message_obj->IsTheHole());
+  if (IsExternalHandlerOnTop(exception)) {
+    // Propagate the exception to an external v8::TryCatch handler.
+    if (!is_catchable_by_javascript(exception)) {
+      try_catch_handler()->can_continue_ = false;
+      try_catch_handler()->has_terminated_ = true;
+      try_catch_handler()->exception_ = heap()->null_value();
+    } else {
+      try_catch_handler()->can_continue_ = true;
+      try_catch_handler()->has_terminated_ = false;
+      try_catch_handler()->exception_ = exception;
+      // Propagate to the external try-catch only if we got an actual message.
+      if (!message_obj->IsTheHole()) {
+        try_catch_handler()->message_obj_ = message_obj;
+      }
+    }
+
+    // Only report the exception if the external handler is verbose.
+    thread_local_top_.external_caught_exception_ = true;
+    should_report_exception = try_catch_handler()->is_verbose_;
+  } else {
+    // Report the exception because it cannot be caught by JavaScript code.
+    thread_local_top_.external_caught_exception_ = false;
+    should_report_exception = true;
+  }
 
   // Clear the pending message object early to avoid endless recursion.
-  Object* message_obj = thread_local_top_.pending_message_obj_;
   clear_pending_message();
 
   // For uncatchable exceptions we do nothing. If needed, the exception and the
   // message have already been propagated to v8::TryCatch.
   if (!is_catchable_by_javascript(exception)) return;
 
-  // Determine whether the message needs to be reported to all message handlers
-  // depending on whether and external v8::TryCatch or an internal JavaScript
-  // handler is on top.
-  bool should_report_exception;
-  if (IsExternalHandlerOnTop(exception)) {
-    // Only report the exception if the external handler is verbose.
-    should_report_exception = try_catch_handler()->is_verbose_;
-  } else {
-    // Report the exception if it isn't caught by JavaScript code.
-    should_report_exception = !IsJavaScriptHandlerOnTop(exception);
-  }
-
   // Actually report the pending message to all message handlers.
   if (!message_obj->IsTheHole() && should_report_exception) {
     HandleScope scope(this);
     Handle<JSMessageObject> message(JSMessageObject::cast(message_obj));
     Handle<JSValue> script_wrapper(JSValue::cast(message->script()));
     Handle<Script> script(Script::cast(script_wrapper->value()));
     int start_pos = message->start_position();
     int end_pos = message->end_position();
     MessageLocation location(script, start_pos, end_pos);
     MessageHandler::ReportMessage(this, &location, message);
@@ skipping 14 matching lines @@
     int end_pos = message_obj->end_position();
     return MessageLocation(script, start_pos, end_pos);
   }
 
   return MessageLocation();
 }
 
 
 bool Isolate::OptionalRescheduleException(bool is_bottom_call) {
   DCHECK(has_pending_exception());
-  PropagatePendingExceptionToExternalTryCatch();
+  ReportPendingMessages();
 
   bool is_termination_exception =
       pending_exception() == heap_.termination_exception();
 
   // Do not reschedule the exception if this is the bottom call.
   bool clear_exception = is_bottom_call;
 
   if (is_termination_exception) {
     if (is_bottom_call) {
       thread_local_top()->external_caught_exception_ = false;
@@ skipping 459 matching lines @@
   debug_ = NULL;
 }
 
 
 void Isolate::InitializeThreadLocal() {
   thread_local_top_.isolate_ = this;
   thread_local_top_.Initialize();
 }
 
 
-bool Isolate::PropagatePendingExceptionToExternalTryCatch() {
-  Object* exception = pending_exception();
-
-  if (IsJavaScriptHandlerOnTop(exception)) {
-    thread_local_top_.external_caught_exception_ = false;
-    return false;
-  }
-
-  if (!IsExternalHandlerOnTop(exception)) {
-    thread_local_top_.external_caught_exception_ = false;
-    return true;
-  }
-
-  thread_local_top_.external_caught_exception_ = true;
-  if (!is_catchable_by_javascript(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();
-    DCHECK(thread_local_top_.pending_message_obj_->IsJSMessageObject() ||
-           thread_local_top_.pending_message_obj_->IsTheHole());
-    handler->can_continue_ = true;
-    handler->has_terminated_ = false;
-    handler->exception_ = pending_exception();
-    // Propagate to the external try-catch only if we got an actual message.
-    if (thread_local_top_.pending_message_obj_->IsTheHole()) return true;
-
-    handler->message_obj_ = thread_local_top_.pending_message_obj_;
-  }
-  return true;
-}
-
-
 void Isolate::InitializeLoggingAndCounters() {
   if (logger_ == NULL) {
     logger_ = new Logger(this);
   }
   if (counters_ == NULL) {
     counters_ = new Counters(this);
   }
 }
 
 
@@ skipping 634 matching lines @@
   if (prev_ && prev_->Intercept(flag)) return true;
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 } }  // namespace v8::internal