Added support for isolate unhandled exceptions.

runtime/vm/isolate.cc

 // Copyright (c) 2012, 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 "lib/mirrors.h"
 #include "vm/compiler_stats.h"
@@ skipping 23 matching lines @@
 
 
 class IsolateMessageHandler : public MessageHandler {
  public:
   explicit IsolateMessageHandler(Isolate* isolate);
   ~IsolateMessageHandler();
 
   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* GetIsolate() const { return isolate_; }
+  bool UnhandledExceptionCallbackHandler(const Object& message,
+                                         const UnhandledException& error);
 
  private:
   Isolate* isolate_;
 };
 
 
 IsolateMessageHandler::IsolateMessageHandler(Isolate* isolate)
     : isolate_(isolate) {
 }
 
@@ skipping 33 matching lines @@
     // 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();
   }
 
   Instance& msg = Instance::Handle();
   msg ^= msg_obj.raw();  // Can't use Instance::Cast because may be null.
 
+  bool success = true;
   if (message->IsOOB()) {
     // For now the only OOB messages are Mirrors messages.
     HandleMirrorsMessage(isolate_, message->reply_port(), msg);
-    delete message;
   } else {
     const Object& result = Object::Handle(
         DartLibraryCalls::HandleMessage(
             message->dest_port(), message->reply_port(), msg));
-    delete message;
     if (result.IsError()) {
       isolate_->object_store()->set_sticky_error(Error::Cast(result));
-      return false;
+      if (result.IsUnhandledException()) {
+        const UnhandledException& error = UnhandledException::Cast(result);
+        RawInstance* exception = error.exception();
+        if ((exception != isolate_->object_store()->out_of_memory()) &&
+            (exception != isolate_->object_store()->stack_overflow())) {
+          success = UnhandledExceptionCallbackHandler(msg, error);
+          if (!success && (Isolate::UnhandledExceptionCallback() != NULL)) {
+            // Notify embedder that an unhandled exception occurred.
+            Dart_EnterScope();
+            Dart_Handle error_handle = Api::NewHandle(isolate_, error.raw());
+            (Isolate::UnhandledExceptionCallback())(error_handle);
+            // TODO(tball): add some sort of blocker to ensure embedder
+            // doesn't run any more code on this isolate.
+            Dart_ExitScope();
+          }
+        }
+      }

[siva, 2012/11/21 00:45:04]

I presume a return of success == true would keep the isolate running. Does this
mean that when we get an OOM or stack overflow exception we will keep running. I
would have assumed that success should be set to false in those two cases.

Also shouldn't we be calling the Isolate::UnahandledExceptionCallback for the
OOM and stack overflow cases.

[Tom Ball, 2012/11/21 05:22:38]

PTAL -- I refactored it and fixed when the UnhandledExceptionCallback is called
(and hopefully it's easier to read).

+    } else {
+      ASSERT(result.IsNull());
     }
-    ASSERT(result.IsNull());
   }
-  return true;
+  delete message;
+  return success;
 }
 
 
+bool IsolateMessageHandler::UnhandledExceptionCallbackHandler(
+    const Object& message, const UnhandledException& error) {
+  RawInstance* callback =
+      isolate_->object_store()->unhandled_exception_closure();
+  Instance& closure = Instance::Handle(callback);
+  if (closure.IsNull()) {
+    return false;  // Error wasn't handled by callback.
+  }
+  const Instance& stacktrace =
+      Instance::Handle(isolate_, error.stacktrace());
+
+  // Wrap these args into an IsolateUncaughtException object.
+  GrowableArray<const Object*> exception_args(3);
+  exception_args.Add(&message);
+  exception_args.Add(&error);
+  exception_args.Add(&stacktrace);
+  Object& exception = Object::Handle();
+  exception = Exceptions::Create(Exceptions::kIsolateUnhandledException,
+                                 exception_args);
+  if (exception.IsError()) {
+    return false;
+  }
+
+  // Invoke script's callback closure.
+  GrowableArray<const Object*> callback_args(1);
+  callback_args.Add(&exception);
+  const Array& kNoArgumentNames = Array::Handle(isolate_);
+  RawObject* response = DartEntry::InvokeClosure(closure,
+                                                 callback_args,
+                                                 kNoArgumentNames);
+  // TODO(tball): log any nested exceptions.
+  return (response == Bool::True());
+}
+
+
 #if defined(DEBUG)
 void IsolateMessageHandler::CheckAccess() {
   ASSERT(IsCurrentIsolate());
 }
 #endif
 
 
 bool IsolateMessageHandler::IsCurrentIsolate() const {
   return (isolate_ == Isolate::Current());
 }
@@ skipping 306 matching lines @@
               "\tisolate:    %s\n", name());
   }
   // TODO(5411455): For now just make sure there are no current isolates
   // as we are shutting down the isolate.
   SetCurrent(NULL);
 }
 
 
 Dart_IsolateCreateCallback Isolate::create_callback_ = NULL;
 Dart_IsolateInterruptCallback Isolate::interrupt_callback_ = NULL;
+Dart_IsolateUnhandledExceptionCallback
+    Isolate::unhandled_exception_callback_ = NULL;
 Dart_IsolateShutdownCallback Isolate::shutdown_callback_ = NULL;
 
 
 void Isolate::VisitObjectPointers(ObjectPointerVisitor* visitor,
                                   bool visit_prologue_weak_handles,
                                   bool validate_frames) {
   ASSERT(visitor != NULL);
 
   // Visit objects in the object store.
   object_store()->VisitObjectPointers(visitor);
@@ skipping 32 matching lines @@
 
 
 void Isolate::VisitWeakPersistentHandles(HandleVisitor* visitor,
                                          bool visit_prologue_weak_handles) {
   if (api_state() != NULL) {
     api_state()->VisitWeakHandles(visitor, visit_prologue_weak_handles);
   }
 }
 
 }  // namespace dart