Remove legacy restart code

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/text_buffer.h"
@@ skipping 296 matching lines @@
             0, Smi::Handle(zone, Smi::New(Message::kDelayedIsolateLibOOBMsg)));
         message.SetAt(3,
                       Smi::Handle(zone, Smi::New(Isolate::kImmediateAction)));
         this->PostMessage(
             SerializeMessage(Message::kIllegalPort, message),
             priority == Isolate::kBeforeNextEventAction /* at_head */);
       }
       break;
     }
     case Isolate::kKillMsg:
-    case Isolate::kInternalKillMsg:
-    case Isolate::kVMRestartMsg: {
+    case Isolate::kInternalKillMsg: {
       // [ OOB, kKillMsg, terminate capability, priority ]
       if (message.Length() != 4) return Error::null();
       Object& obj = Object::Handle(zone, 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);
         if (I->VerifyTerminateCapability(obj)) {
           // We will kill the current isolate by returning an UnwindError.
           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 if (msg_type == Isolate::kInternalKillMsg) {
             const String& msg =
                 String::Handle(String::New("isolate terminated by vm"));
             return UnwindError::New(msg);
-          } else if (msg_type == Isolate::kVMRestartMsg) {
-            // If this is the main isolate, this request to restart
-            // will be caught and handled in the embedder.  Otherwise
-            // this unwind error will cause the isolate to exit.
-            const String& msg = String::Handle(
-                String::New("isolate terminated for vm restart"));
-            const UnwindError& error =
-                UnwindError::Handle(UnwindError::New(msg));
-            error.set_is_vm_restart(true);
-            return error.raw();
           } else {
             UNREACHABLE();
           }
         } else {
           return Error::null();
         }
       } else {
         ASSERT((priority == Isolate::kBeforeNextEventAction) ||
                (priority == Isolate::kAsEventAction));
         // Update the message so that it will be handled immediately when it
@@ skipping 165 matching lines @@
     // element is a Smi describing the OOB destination. Messages that do not
     // confirm to this layout are silently ignored.
     if (msg.IsArray()) {
       const Array& oob_msg = Array::Cast(msg);
       if (oob_msg.Length() > 0) {
         const Object& oob_tag = Object::Handle(zone, oob_msg.At(0));
         if (oob_tag.IsSmi()) {
           switch (Smi::Cast(oob_tag).Value()) {
             case Message::kServiceOOBMsg: {
               if (FLAG_support_service) {
-                Service::HandleIsolateMessage(I, oob_msg);
+                const Error& error =
+                    Error::Handle(Service::HandleIsolateMessage(I, oob_msg));
+                if (!error.IsNull()) {
+                  status = ProcessUnhandledException(error);
+                }
               } else {
                 UNREACHABLE();
               }
               break;
             }
             case Message::kIsolateLibOOBMsg: {
               const Error& error = Error::Handle(HandleLibMessage(oob_msg));
               if (!error.IsNull()) {
                 status = ProcessUnhandledException(error);
               }
@@ skipping 98 matching lines @@
   return (I == Isolate::Current());
 }
 
 
 static MessageHandler::MessageStatus StoreError(Thread* thread,
                                                 const Error& error) {
   thread->set_sticky_error(error);
   if (error.IsUnwindError()) {
     const UnwindError& unwind = UnwindError::Cast(error);
     if (!unwind.is_user_initiated()) {
-      if (unwind.is_vm_restart()) {
-        return MessageHandler::kRestart;
-      } else {
-        return MessageHandler::kShutdown;
-      }
+      return MessageHandler::kShutdown;
     }
   }
   return MessageHandler::kError;
 }
 
 
 MessageHandler::MessageStatus IsolateMessageHandler::ProcessUnhandledException(
     const Error& result) {
   // Generate the error and stacktrace strings for the error message.
   String& exc_str = String::Handle(T->zone());
@@ skipping 358 matching lines @@
 int64_t Isolate::UptimeMicros() const {
   return OS::GetCurrentMonotonicMicros() - start_time_micros_;
 }
 
 
 bool Isolate::IsPaused() const {
   return (debugger_ != NULL) && (debugger_->PauseEvent() != NULL);
 }
 
 
-void Isolate::PausePostRequest() {
+RawError* Isolate::PausePostRequest() {
   if (!FLAG_support_debugger) {
-    return;
+    return Error::null();
   }
   if (debugger_ == NULL) {
-    return;
+    return Error::null();
   }
   ASSERT(!IsPaused());
   const Error& error = Error::Handle(debugger_->PausePostRequest());
   if (!error.IsNull()) {
-    Exceptions::PropagateError(error);
+    if (Thread::Current()->top_exit_frame_info() == 0) {
+      return error.raw();
+    } else {
+      Exceptions::PropagateError(error);
+      UNREACHABLE();
+    }
   }
+  return Error::null();
 }
 
 
 void Isolate::BuildName(const char* name_prefix) {
   ASSERT(name_ == NULL);
   if (name_prefix == NULL) {
     name_prefix = "isolate";
   }
   set_debugger_name(name_prefix);
   if (ServiceIsolate::NameEquals(name_prefix)) {
@@ skipping 1891 matching lines @@
 void IsolateSpawnState::DecrementSpawnCount() {
   ASSERT(spawn_count_monitor_ != NULL);
   ASSERT(spawn_count_ != NULL);
   MonitorLocker ml(spawn_count_monitor_);
   ASSERT(*spawn_count_ > 0);
   *spawn_count_ = *spawn_count_ - 1;
   ml.Notify();
 }
 
 }  // namespace dart