Distinguish internal kill messages from user-initiated kill messages.

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 "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
@@ skipping 265 matching lines @@
         intptr_t len = 0;
         SerializeObject(message, &data, &len, false);
         this->PostMessage(
             new Message(Message::kIllegalPort,
                         data, len,
                         Message::kNormalPriority),
             priority == Isolate::kBeforeNextEventAction /* at_head */);
       }
       break;
     }
-    case Isolate::kKillMsg: {
+    case Isolate::kKillMsg:
+    case Isolate::kInternalKillMsg: {
       // [ OOB, kKillMsg, terminate capability, priority ]
       if (message.Length() != 4) return Error::null();
       Object& obj = Object::Handle(I, message.At(3));
       if (!obj.IsSmi()) return Error::null();
       const intptr_t priority = Smi::Cast(obj).Value();
       if (priority == Isolate::kImmediateAction) {
         obj = message.At(2);
         // Signal that the isolate should stop execution.
         if (I->VerifyTerminateCapability(obj)) {
-          const String& msg = String::Handle(String::New(
-              "isolate terminated by Isolate.kill"));
-          return UnwindError::New(msg);
+          if (msg_type == Isolate::kKillMsg) {
+            const String& msg = String::Handle(String::New(
+                "isolate terminated by Isolate.kill"));
+            const UnwindError& error =
+                UnwindError::Handle(UnwindError::New(msg));
+            error.set_is_user_initiated(true);
+            return error.raw();
+          } else {
+            // TODO(turnidge): We should give the message handler a way
+            // to detect when an isolate is unwinding.
+            I->message_handler()->set_pause_on_start(false);
+            I->message_handler()->set_pause_on_exit(false);
+            const String& msg = String::Handle(String::New(
+                "isolate terminated by vm"));
+            return UnwindError::New(msg);
+          }
         } else {
           return Error::null();
         }
       } else {
         ASSERT((priority == Isolate::kBeforeNextEventAction) ||
                (priority == Isolate::kAsEventAction));
         // Update the message so that it will be handled immediately when it
         // is picked up from the message queue the next time.
         message.SetAt(
             0, Smi::Handle(I, Smi::New(Message::kDelayedIsolateLibOOBMsg)));
@@ skipping 1098 matching lines @@
 static void ShutdownIsolate(uword parameter) {
   Isolate* isolate = reinterpret_cast<Isolate*>(parameter);
   {
     // Print the error if there is one.  This may execute dart code to
     // print the exception object, so we need to use a StartIsolateScope.
     Thread* thread = Thread::Current();
     StartIsolateScope start_scope(isolate);
     ASSERT(thread->isolate() == isolate);
     StackZone zone(thread);
     HandleScope handle_scope(thread);
-    Error& error = Error::Handle();
-    error = isolate->object_store()->sticky_error();
+    const Error& error = Error::Handle(isolate->object_store()->sticky_error());
     if (!error.IsNull() && !error.IsUnwindError()) {
       OS::PrintErr("in ShutdownIsolate: %s\n", error.ToErrorCString());
     }
     Dart::RunShutdownCallback();
   }
   {
     // Shut the isolate down.
     SwitchIsolateScope switch_scope(isolate);
     Dart::ShutdownIsolate();
   }
@@ skipping 32 matching lines @@
   }
   if ((interrupt_bits & kMessageInterrupt) != 0) {
     bool ok = message_handler()->HandleOOBMessages();
     if (!ok) {
       // False result from HandleOOBMessages signals that the isolate should
       // be terminating.
       if (FLAG_trace_isolates) {
         OS::Print("[!] Terminating isolate due to OOB message:\n"
                   "\tisolate:    %s\n", name());
       }
-      // TODO(turnidge): If the isolate is being killed by
-      // Isolate.kill, then we probably want to respect pause_on_exit.
-      // If the isolate is being killed due to vm restart we don't.
-      message_handler()->set_pause_on_start(false);
-      message_handler()->set_pause_on_exit(false);
-      const String& msg = String::Handle(String::New("isolate terminated"));
-      return UnwindError::New(msg);
+      const Error& error = Error::Handle(object_store()->sticky_error());
+      object_store()->clear_sticky_error();
+      ASSERT(!error.IsNull());
+      return error.raw();
     }
   }
   return Error::null();
 }
 
 
 uword Isolate::GetAndClearStackOverflowFlags() {
   uword stack_overflow_flags = stack_overflow_flags_;
   stack_overflow_flags_ = 0;
   return stack_overflow_flags;
@@ skipping 72 matching lines @@
 void Isolate::LowLevelShutdown() {
   // Ensure we have a zone and handle scope so that we can call VM functions,
   // but we no longer allocate new heap objects.
   Thread* thread = Thread::Current();
   StackZone stack_zone(thread);
   HandleScope handle_scope(thread);
   NoSafepointScope no_safepoint_scope;
 
   // Notify exit listeners that this isolate is shutting down.
   if (object_store() != NULL) {
-    // TODO(turnidge): If the isolate is being killed by Isolate.kill,
-    // then we want to notify event listeners.  If the isolate is
-    // being killed due to vm restart we probably don't.
-    NotifyExitListeners();
+    const Error& error = Error::Handle(object_store()->sticky_error());
+    if (error.IsNull() ||
+        !error.IsUnwindError() ||
+        UnwindError::Cast(error).is_user_initiated()) {
+      NotifyExitListeners();
+    }
   }
 
   // Clean up debugger resources.
   debugger()->Shutdown();
 
   // Close all the ports owned by this isolate.
   PortMap::ClosePorts(message_handler());
 
   // Fail fast if anybody tries to post any more messsages to this isolate.
   delete message_handler();
@@ skipping 704 matching lines @@
   Dart_CObject* list_values[4];
   kill_msg.type = Dart_CObject_kArray;
   kill_msg.value.as_array.length = 4;
   kill_msg.value.as_array.values = list_values;
 
   Dart_CObject oob;
   oob.type = Dart_CObject_kInt32;
   oob.value.as_int32 = Message::kIsolateLibOOBMsg;
   list_values[0] = &oob;
 
-  Dart_CObject kill;
-  kill.type = Dart_CObject_kInt32;
-  kill.value.as_int32 = Isolate::kKillMsg;
-  list_values[1] = &kill;
+  Dart_CObject msg_type;
+  msg_type.type = Dart_CObject_kInt32;
+  msg_type.value.as_int32 = Isolate::kInternalKillMsg;
+  list_values[1] = &msg_type;
 
   Dart_CObject cap;
   cap.type = Dart_CObject_kCapability;
   cap.value.as_capability.id = terminate_capability();
   list_values[2] = &cap;
 
   Dart_CObject imm;
   imm.type = Dart_CObject_kInt32;
   imm.value.as_int32 = Isolate::kImmediateAction;
   list_values[3] = &imm;
@@ skipping 253 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart