- Implement VM parts of https://codereview.chromium.org/1240743003/

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 1214 matching lines @@
   IsolateSpawnState* state = NULL;
   {
     // TODO(turnidge): Is this locking required here at all anymore?
     MutexLocker ml(isolate->mutex());
     state = isolate->spawn_state();
   }
   {
     StartIsolateScope start_scope(isolate);
     StackZone zone(isolate);
     HandleScope handle_scope(isolate);
+
+    // If particular values were requested for this newly spawned isolate, then
+    // they are set here before the isolate starts executing user code.
+    isolate->SetErrorsFatal(state->errors_are_fatal());
+    if (state->on_exit_port() != ILLEGAL_PORT) {
+      const SendPort& listener =
+          SendPort::Handle(SendPort::New(state->on_exit_port()));
+      isolate->AddExitListener(listener, Instance::null_instance());
+    }
+    if (state->on_error_port() != ILLEGAL_PORT) {
+      const SendPort& listener =
+          SendPort::Handle(SendPort::New(state->on_error_port()));
+      isolate->AddErrorListener(listener);
+    }
+
+    // Switch back to spawning isolate.
+
+
     if (!ClassFinalizer::ProcessPendingClasses()) {
       // Error is in sticky error already.
       return false;
     }
 
     Object& result = Object::Handle();
     result = state->ResolveFunction();
     bool is_spawn_uri = state->is_spawn_uri();
     if (result.IsError()) {
       StoreError(isolate, result);
@@ skipping 700 matching lines @@
   ASSERT(!obj.IsError());
   Instance& instance = Instance::Handle(isolate);
   instance ^= obj.raw();  // Can't use Instance::Cast because may be null.
   return instance.raw();
 }
 
 
 IsolateSpawnState::IsolateSpawnState(Dart_Port parent_port,
                                      const Function& func,
                                      const Instance& message,
-                                     bool paused)
+                                     bool paused,
+                                     bool errors_are_fatal,
+                                     Dart_Port on_exit_port,
+                                     Dart_Port on_error_port)
     : isolate_(NULL),
       parent_port_(parent_port),
+      on_exit_port_(on_exit_port),
+      on_error_port_(on_error_port),
       script_url_(NULL),
       package_root_(NULL),
       library_url_(NULL),
       class_name_(NULL),
       function_name_(NULL),
       serialized_args_(NULL),
       serialized_args_len_(0),
       serialized_message_(NULL),
       serialized_message_len_(0),
       isolate_flags_(),
-      paused_(paused) {
+      paused_(paused),
+      errors_are_fatal_(errors_are_fatal) {
   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());
   }
   bool can_send_any_object = true;
   SerializeObject(message,
                   &serialized_message_,
                   &serialized_message_len_,
                   can_send_any_object);
   // Inherit flags from spawning isolate.
   isolate_flags()->CopyFrom(Isolate::Current()->flags());
 }
 
 
 IsolateSpawnState::IsolateSpawnState(Dart_Port parent_port,
                                      const char* script_url,
                                      const char* package_root,
                                      const Instance& args,
                                      const Instance& message,
-                                     bool paused)
+                                     bool paused,
+                                     bool errors_are_fatal,
+                                     Dart_Port on_exit_port,
+                                     Dart_Port on_error_port)
     : isolate_(NULL),
       parent_port_(parent_port),
+      on_exit_port_(on_exit_port),
+      on_error_port_(on_error_port),
       package_root_(NULL),
       library_url_(NULL),
       class_name_(NULL),
       function_name_(NULL),
       serialized_args_(NULL),
       serialized_args_len_(0),
       serialized_message_(NULL),
       serialized_message_len_(0),
       isolate_flags_(),
-      paused_(paused) {
+      paused_(paused),
+      errors_are_fatal_(errors_are_fatal) {
   script_url_ = strdup(script_url);
   if (package_root != NULL) {
     package_root_ = strdup(package_root);
   }
   library_url_ = NULL;
   function_name_ = strdup("main");
   bool can_send_any_object = false;
   SerializeObject(args,
                   &serialized_args_,
                   &serialized_args_len_,
@@ skipping 98 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart