Simplify pending message object handling.

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 69 matching lines @@
   context_ = NULL;
   thread_id_ = ThreadId::Invalid();
   external_caught_exception_ = false;
   failed_access_check_callback_ = NULL;
   save_context_ = NULL;
   promise_on_stack_ = NULL;
 
   // These members are re-initialized later after deserialization
   // is complete.
   pending_exception_ = NULL;
-  has_pending_message_ = false;
   rethrowing_message_ = false;
   pending_message_obj_ = NULL;
   scheduled_exception_ = NULL;
 }
 
 
 void ThreadLocalTop::Initialize() {
   InitializeInternal();
 #ifdef USE_SIMULATOR
   simulator_ = Simulator::current(isolate_);
@@ skipping 892 matching lines @@
           (report_exception || can_be_caught_externally)) {
         fatal_exception_depth++;
         PrintF(stderr, "%s\n\nFROM\n",
                MessageHandler::GetLocalizedMessage(this, message_obj).get());
         PrintCurrentStackTrace(stderr);
         base::OS::Abort();
       }
     }
   }
 
-  // Save the message for reporting if the the exception remains uncaught.
-  thread_local_top()->has_pending_message_ = report_exception;
-
   // Set the exception being thrown.
   set_pending_exception(*exception_handle);
   return heap()->exception();
 }
 
 
 Object* Isolate::ReThrow(Object* exception) {
   DCHECK(!has_pending_exception());
 
   // Set the exception being re-thrown.
@@ skipping 382 matching lines @@
     if (handler->is_finally()) return true;
 
     handler = handler->next();
   }
 
   return false;
 }
 
 
 void Isolate::ReportPendingMessages() {
-  DCHECK(has_pending_exception());
-  bool can_clear_message = PropagatePendingExceptionToExternalTryCatch();
+  Object* exception = pending_exception();
 
-  HandleScope scope(this);
-  if (thread_local_top_.pending_exception_ == heap()->termination_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;
+
+  // Clear the pending message object early to avoid endless recursion.
+  Object* message_obj = thread_local_top_.pending_message_obj_;
+  clear_pending_message();
+
+  bool can_be_caught_externally = false;
+  bool catchable_by_javascript = is_catchable_by_javascript(exception);
+  bool should_report_exception =
+      ShouldReportException(&can_be_caught_externally, catchable_by_javascript);
+
+  if (!catchable_by_javascript) {
     // 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<JSMessageObject> message_obj(
-            JSMessageObject::cast(thread_local_top_.pending_message_obj_));
-        Handle<JSValue> script_wrapper(JSValue::cast(message_obj->script()));
-        Handle<Script> script(Script::cast(script_wrapper->value()));
-        int start_pos = message_obj->start_position();
-        int end_pos = message_obj->end_position();
-        MessageLocation location(script, start_pos, end_pos);
-        MessageHandler::ReportMessage(this, &location, message_obj);
-      }
+    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);
     }
   }
-  if (can_clear_message) clear_pending_message();
 }
 
 
 MessageLocation Isolate::GetMessageLocation() {
   DCHECK(has_pending_exception());
 
   if (thread_local_top_.pending_exception_ != heap()->termination_exception() &&
-      thread_local_top_.has_pending_message_ &&
       !thread_local_top_.pending_message_obj_->IsTheHole()) {
     Handle<JSMessageObject> message_obj(
         JSMessageObject::cast(thread_local_top_.pending_message_obj_));
     Handle<JSValue> script_wrapper(JSValue::cast(message_obj->script()));
     Handle<Script> script(Script::cast(script_wrapper->value()));
     int start_pos = message_obj->start_position();
     int end_pos = message_obj->end_position();
     return MessageLocation(script, start_pos, end_pos);
   }
 
@@ skipping 1167 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