If an unhandled exception occurs in Dart_RunLoop, pass it out to the caller.

runtime/vm/isolate.cc

 // Copyright (c) 2011, 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 "vm/assert.h"
 #include "vm/bigint_store.h"
 #include "vm/code_index_table.h"
 #include "vm/compiler_stats.h"
 #include "vm/dart_api_state.h"
+#include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/debuginfo.h"
 #include "vm/heap.h"
 #include "vm/message_queue.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/port.h"
 #include "vm/random.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
@@ skipping 211 matching lines @@
 void Isolate::SetCreateCallback(Dart_IsolateCreateCallback cb) {
   create_callback_ = cb;
 }
 
 
 Dart_IsolateCreateCallback Isolate::CreateCallback() {
   return create_callback_;
 }
 
 
-void Isolate::StandardRunLoop() {
+static RawInstance* DeserializeMessage(void* data) {
+  // Create a snapshot object using the buffer.
+  const Snapshot* snapshot = Snapshot::SetupFromBuffer(data);
+  ASSERT(snapshot->IsMessageSnapshot());
+
+  // Read object back from the snapshot.
+  Isolate* isolate = Isolate::Current();
+  SnapshotReader reader(snapshot, isolate->heap(), isolate->object_store());
+  Instance& instance = Instance::Handle();
+  instance ^= reader.ReadObject();
+  return instance.raw();
+}
+
+
+
+RawObject* Isolate::StandardRunLoop() {
   ASSERT(long_jump_base() != NULL);
   ASSERT(post_message_callback() == &StandardPostMessageCallback);
   ASSERT(close_port_callback() == &StandardClosePortCallback);
 
   while (live_ports() > 0) {
     ASSERT(this == Isolate::Current());
     Zone zone(this);
     HandleScope handle_scope(this);
 
     PortMessage* message = message_queue()->Dequeue(0);
     if (message != NULL) {
-      Dart_EnterScope();
-      Dart_Handle result = Dart_HandleMessage(
-          message->dest_port(), message->reply_port(), message->data());
-      if (Dart_IsError(result)) {
-        // TODO(turnidge): Consider passing this error out to
-        // Dart_RunLoop so that the embedder can choose how to handle
-        // it.
-        fprintf(stderr, "%s\n", Dart_GetError(result));
-        Dart_ExitScope();
-        exit(255);
+      const Instance& msg =
+          Instance::Handle(DeserializeMessage(message->data()));
+      const Object& result = Object::Handle(
+          DartLibraryCalls::HandleMessage(
+              message->dest_port(), message->reply_port(), msg));
+      delete message;
+      if (result.IsUnhandledException()) {
+        return result.raw();
       }
-      Dart_ExitScope();
-      delete message;
     }
   }
+
+  // Indicates success.
+  return Object::null();
 }
 
 
 void Isolate::VisitObjectPointers(ObjectPointerVisitor* visitor,
                                   bool validate_frames) {
   ASSERT(visitor != NULL);
 
   // Visit objects in the object store.
   object_store()->VisitObjectPointers(visitor);
 
@@ skipping 22 matching lines @@
   }
 
   // Visit the top context which is stored in the isolate.
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&top_context_));
 
   // Visit objects in the debugger.
   debugger()->VisitObjectPointers(visitor);
 }
 
 }  // namespace dart