- Remove entirely disconnected unhandled exception handler.

runtime/vm/isolate.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/isolate.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "vm/code_observers.h"
@@ skipping 79 matching lines @@
   const char* name() const;
   void MessageNotify(Message::Priority priority);
   bool HandleMessage(Message* message);
 
 #if defined(DEBUG)
   // Check that it is safe to access this handler.
   void CheckAccess();
 #endif
   bool IsCurrentIsolate() const;
   virtual Isolate* isolate() const { return isolate_; }
-  bool UnhandledExceptionCallbackHandler(const Object& message,
-                                         const UnhandledException& error);
 
  private:
   // Keep in sync with isolate_patch.dart.
   enum {
     kPauseMsg = 1,
     kResumeMsg = 2,
     kPingMsg = 3,
     kKillMsg = 4,
 
     kImmediateAction = 0,
     kBeforeNextEventAction = 1,
     kAsEventAction = 2
   };
 
   // A result of false indicates that the isolate should terminate the
   // processing of further events.
   bool HandleLibMessage(const Array& message);
 
-  bool ProcessUnhandledException(const Object& message, const Error& result);
-  RawFunction* ResolveCallbackFunction();
+  bool ProcessUnhandledException(const Error& result);
   Isolate* isolate_;
 };
 
 
 IsolateMessageHandler::IsolateMessageHandler(Isolate* isolate)
     : isolate_(isolate) {
 }
 
 
 IsolateMessageHandler::~IsolateMessageHandler() {
@@ skipping 133 matching lines @@
 
   // If the message is in band we lookup the handler to dispatch to.  If the
   // receive port was closed, we drop the message without deserializing it.
   // Illegal port is a special case for artificially enqueued isolate library
   // messages which are handled in C++ code below.
   Object& msg_handler = Object::Handle(I);
   if (!message->IsOOB() && (message->dest_port() != Message::kIllegalPort)) {
     msg_handler = DartLibraryCalls::LookupHandler(message->dest_port());
     if (msg_handler.IsError()) {
       delete message;
-      return ProcessUnhandledException(Object::null_instance(),
-                                       Error::Cast(msg_handler));
+      return ProcessUnhandledException(Error::Cast(msg_handler));
     }
     if (msg_handler.IsNull()) {
       // If the port has been closed then the message will be dropped at this
       // point. Make sure to post to the delivery failure port in that case.
       if (message->RedirectToDeliveryFailurePort()) {
         PortMap::PostMessage(message);
       } else {
         delete message;
       }
       return true;
     }
   }
 
   // Parse the message.
   SnapshotReader reader(message->data(), message->len(), Snapshot::kMessage, I);
   const Object& msg_obj = Object::Handle(I, reader.ReadObject());
   if (msg_obj.IsError()) {
     // An error occurred while reading the message.
     delete message;
-    return ProcessUnhandledException(Object::null_instance(),
-                                     Error::Cast(msg_obj));
+    return ProcessUnhandledException(Error::Cast(msg_obj));
   }
   if (!msg_obj.IsNull() && !msg_obj.IsInstance()) {
     // TODO(turnidge): We need to decide what an isolate does with
     // malformed messages.  If they (eventually) come from a remote
     // machine, then it might make sense to drop the message entirely.
     // In the case that the message originated locally, which is
     // always true for now, then this should never occur.
     UNREACHABLE();
   }
 
@@ skipping 41 matching lines @@
         if (oob_tag.IsSmi() &&
             (Smi::Cast(oob_tag).Value() == Message::kDelayedIsolateLibOOBMsg)) {
           success = HandleLibMessage(Array::Cast(msg_arr));
         }
       }
     }
   } else {
     const Object& result = Object::Handle(I,
         DartLibraryCalls::HandleMessage(msg_handler, msg));
     if (result.IsError()) {
-      success = ProcessUnhandledException(msg, Error::Cast(result));
+      success = ProcessUnhandledException(Error::Cast(result));
     } else {
       ASSERT(result.IsNull());
     }
   }
   delete message;
   return success;
 }
 
 
-RawFunction* IsolateMessageHandler::ResolveCallbackFunction() {
-  ASSERT(I->object_store()->unhandled_exception_handler() != NULL);
-  String& callback_name = String::Handle(I);
-  if (I->object_store()->unhandled_exception_handler() != String::null()) {
-    callback_name = I->object_store()->unhandled_exception_handler();
-  } else {
-    callback_name = String::New("_unhandledExceptionCallback");
-  }
-  Library& lib = Library::Handle(I, I->object_store()->isolate_library());
-  Function& func = Function::Handle(I, lib.LookupLocalFunction(callback_name));
-  if (func.IsNull()) {
-    lib = I->object_store()->root_library();
-    // Note: bootstrap code in builtin library may attempt to resolve a
-    // callback function before the script is fully loaded, in which case
-    // the root library may not be registered yet.
-    if (!lib.IsNull()) {
-      func = lib.LookupLocalFunction(callback_name);
-    }
-  }
-  return func.raw();
-}
-
-
-bool IsolateMessageHandler::UnhandledExceptionCallbackHandler(
-    const Object& message, const UnhandledException& error) {
-  const Instance& cause = Instance::Handle(I, error.exception());
-  const Instance& stacktrace = Instance::Handle(I, error.stacktrace());
-
-  // Wrap these args into an IsolateUncaughtException object.
-  const Array& exception_args = Array::Handle(I, Array::New(3));
-  exception_args.SetAt(0, message);
-  exception_args.SetAt(1, cause);
-  exception_args.SetAt(2, stacktrace);
-  const Object& exception = Object::Handle(I,
-      Exceptions::Create(Exceptions::kIsolateUnhandledException,
-                         exception_args));
-  if (exception.IsError()) {
-    return false;
-  }
-  ASSERT(exception.IsInstance());
-
-  // Invoke script's callback function.
-  Object& function = Object::Handle(I, ResolveCallbackFunction());
-  if (function.IsNull() || function.IsError()) {
-    return false;
-  }
-  const Array& callback_args = Array::Handle(I, Array::New(1));
-  callback_args.SetAt(0, exception);
-  const Object& result = Object::Handle(I,
-      DartEntry::InvokeFunction(Function::Cast(function), callback_args));
-  if (result.IsError()) {
-    const Error& err = Error::Cast(result);
-    OS::PrintErr("failed calling unhandled exception callback: %s\n",
-                 err.ToErrorCString());
-    return false;
-  }
-
-  ASSERT(result.IsBool());
-  bool continue_from_exception = Bool::Cast(result).value();
-  if (continue_from_exception) {
-    I->object_store()->clear_sticky_error();
-  }
-  return continue_from_exception;
-}
-
 #if defined(DEBUG)
 void IsolateMessageHandler::CheckAccess() {
   ASSERT(IsCurrentIsolate());
 }
 #endif
 
 
 bool IsolateMessageHandler::IsCurrentIsolate() const {
   return (I == Isolate::Current());
 }
 
 
-bool IsolateMessageHandler::ProcessUnhandledException(
-    const Object& message, const Error& result) {
+bool IsolateMessageHandler::ProcessUnhandledException(const Error& result) {
+  // Notify the debugger about specific unhandled exceptions which are withheld
+  // when being thrown.
   if (result.IsUnhandledException()) {
-    // Invoke the isolate's uncaught exception handler, if it exists.
     const UnhandledException& error = UnhandledException::Cast(result);
     RawInstance* exception = error.exception();
     if ((exception == I->object_store()->out_of_memory()) ||
         (exception == I->object_store()->stack_overflow())) {
       // We didn't notify the debugger when the stack was full. Do it now.
       I->debugger()->SignalExceptionThrown(Instance::Handle(exception));
     }
-    if ((exception != I->object_store()->out_of_memory()) &&
-        (exception != I->object_store()->stack_overflow())) {
-      if (UnhandledExceptionCallbackHandler(message, error)) {
-        return true;
-      }
-    }
   }
 
   // Invoke the isolate's unhandled exception callback if there is one.
   if (Isolate::UnhandledExceptionCallback() != NULL) {
     Dart_EnterScope();
     Dart_Handle error = Api::NewHandle(I, result.raw());
     (Isolate::UnhandledExceptionCallback())(error);
     Dart_ExitScope();
   }
 
@@ skipping 449 matching lines @@
   }
   {
     StartIsolateScope start_scope(isolate);
     StackZone zone(isolate);
     HandleScope handle_scope(isolate);
     if (!ClassFinalizer::ProcessPendingClasses()) {
       // Error is in sticky error already.
       return false;
     }
 
-    // Set up specific unhandled exception handler.
-    const String& callback_name = String::Handle(
-        isolate, String::New(state->exception_callback_name()));
-    isolate->object_store()->
-        set_unhandled_exception_handler(callback_name);
-
     Object& result = Object::Handle();
     result = state->ResolveFunction();
     bool is_spawn_uri = state->is_spawn_uri();
     if (result.IsError()) {
       StoreError(isolate, result);
       return false;
     }
     ASSERT(result.IsFunction());
     Function& func = Function::Handle(isolate);
     func ^= result.raw();
@@ skipping 596 matching lines @@
                                      const Function& func,
                                      const Instance& message,
                                      bool paused)
     : isolate_(NULL),
       parent_port_(parent_port),
       script_url_(NULL),
       package_root_(NULL),
       library_url_(NULL),
       class_name_(NULL),
       function_name_(NULL),
-      exception_callback_name_(NULL),
       serialized_args_(NULL),
       serialized_args_len_(0),
       serialized_message_(NULL),
       serialized_message_len_(0),
       paused_(paused) {
   script_url_ = NULL;
   const Class& cls = Class::Handle(func.Owner());
   const Library& lib = Library::Handle(cls.library());
   const String& lib_url = String::Handle(lib.url());
   library_url_ = strdup(lib_url.ToCString());
 
   const String& func_name = String::Handle(func.name());
   function_name_ = strdup(func_name.ToCString());
   if (!cls.IsTopLevel()) {
     const String& class_name = String::Handle(cls.Name());
     class_name_ = strdup(class_name.ToCString());
   }
-  exception_callback_name_ = strdup("_unhandledExceptionCallback");
   SerializeObject(message, &serialized_message_, &serialized_message_len_);
 }
 
 
 IsolateSpawnState::IsolateSpawnState(Dart_Port parent_port,
                                      const char* script_url,
                                      const char* package_root,
                                      const Instance& args,
                                      const Instance& message,
                                      bool paused)
     : isolate_(NULL),
       parent_port_(parent_port),
       package_root_(NULL),
       library_url_(NULL),
       class_name_(NULL),
       function_name_(NULL),
-      exception_callback_name_(NULL),
       serialized_args_(NULL),
       serialized_args_len_(0),
       serialized_message_(NULL),
       serialized_message_len_(0),
       paused_(paused) {
   script_url_ = strdup(script_url);
   if (package_root != NULL) {
     package_root_ = strdup(package_root);
   }
   library_url_ = NULL;
   function_name_ = strdup("main");
-  exception_callback_name_ = strdup("_unhandledExceptionCallback");
   SerializeObject(args, &serialized_args_, &serialized_args_len_);
   SerializeObject(message, &serialized_message_, &serialized_message_len_);
 }
 
 
 IsolateSpawnState::~IsolateSpawnState() {
   free(script_url_);
   free(package_root_);
   free(library_url_);
   free(function_name_);
   free(class_name_);
-  free(exception_callback_name_);
   free(serialized_args_);
   free(serialized_message_);
 }
 
 
 RawObject* IsolateSpawnState::ResolveFunction() {
   // Resolve the library.
   Library& lib = Library::Handle();
   if (library_url()) {
     const String& lib_url = String::Handle(String::New(library_url()));
@@ skipping 55 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart