Remove legacy restart code

runtime/vm/service.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/service.h"
 
 #include "include/dart_api.h"
 #include "include/dart_native_api.h"
 #include "platform/globals.h"
 
@@ skipping 795 matching lines @@
   HANDLESCOPE(T);
   JSONStream js;
   js.Setup(zone.GetZone(), SendPort::Cast(reply_port).Id(), id, method_name,
            parameter_keys, parameter_values);
   js.PrintError(kExtensionError, "Error in extension `%s`: %s", js.method(),
                 error.ToErrorCString());
   js.PostReply();
 }
 
 
-void Service::InvokeMethod(Isolate* I,
-                           const Array& msg,
-                           bool parameters_are_dart_objects) {
+RawError* Service::InvokeMethod(Isolate* I,
+                                const Array& msg,
+                                bool parameters_are_dart_objects) {
   Thread* T = Thread::Current();
   ASSERT(I == T->isolate());
   ASSERT(I != NULL);
   ASSERT(T->execution_state() == Thread::kThreadInVM);
   ASSERT(!msg.IsNull());
   ASSERT(msg.Length() == 6);
 
   {
     StackZone zone(T);
     HANDLESCOPE(T);
@@ skipping 41 matching lines @@
         // Change the default ring's policy.
         RingServiceIdZone* zone =
             reinterpret_cast<RingServiceIdZone*>(js.id_zone());
         zone->set_policy(ObjectIdRing::kReuseId);
       } else {
         // TODO(johnmccutchan): Support creating, deleting, and selecting
         // custom service id zones.
         // For now, always return an error.
         PrintInvalidParamError(&js, "_idZone");
         js.PostReply();
-        return;
+        return T->get_and_clear_sticky_error();
       }
     }
     const char* c_method_name = method_name.ToCString();
 
     const ServiceMethodDescriptor* method = FindMethod(c_method_name);
     if (method != NULL) {
       if (!ValidateParameters(method->parameters, &js)) {
         js.PostReply();
-        return;
+        return T->get_and_clear_sticky_error();
       }
       if (method->entry(T, &js)) {
         js.PostReply();
       } else {
         // NOTE(turnidge): All message handlers currently return true,
         // so this case shouldn't be reached, at present.
         UNIMPLEMENTED();
       }
-      return;
+      return T->get_and_clear_sticky_error();
     }
 
     EmbedderServiceHandler* handler = FindIsolateEmbedderHandler(c_method_name);
     if (handler == NULL) {
       handler = FindRootEmbedderHandler(c_method_name);
     }
 
     if (handler != NULL) {
       EmbedderHandleMessage(handler, &js);
-      return;
+      return T->get_and_clear_sticky_error();
     }
 
     const Instance& extension_handler =
         Instance::Handle(Z, I->LookupServiceExtensionHandler(method_name));
     if (!extension_handler.IsNull()) {
       ScheduleExtensionHandler(extension_handler, method_name, param_keys,
                                param_values, reply_port, seq);
       // Schedule was successful. Extension code will post a reply
       // asynchronously.
-      return;
+      return T->get_and_clear_sticky_error();
     }
 
     PrintUnrecognizedMethodError(&js);
     js.PostReply();
-    return;
+    return T->get_and_clear_sticky_error();
   }
 }
 
 
-void Service::HandleRootMessage(const Array& msg_instance) {
+RawError* Service::HandleRootMessage(const Array& msg_instance) {
   Isolate* isolate = Isolate::Current();
-  InvokeMethod(isolate, msg_instance);
+  return InvokeMethod(isolate, msg_instance);
 }
 
 
-void Service::HandleObjectRootMessage(const Array& msg_instance) {
+RawError* Service::HandleObjectRootMessage(const Array& msg_instance) {
   Isolate* isolate = Isolate::Current();
-  InvokeMethod(isolate, msg_instance, true);
+  return InvokeMethod(isolate, msg_instance, true);
 }
 
 
-void Service::HandleIsolateMessage(Isolate* isolate, const Array& msg) {
+RawError* Service::HandleIsolateMessage(Isolate* isolate, const Array& msg) {
   ASSERT(isolate != NULL);
-  InvokeMethod(isolate, msg);
-  MaybePause(isolate);
+  const Error& error = Error::Handle(InvokeMethod(isolate, msg));
+  return MaybePause(isolate, error);
 }
 
 
 static void Finalizer(void* isolate_callback_data,
                       Dart_WeakPersistentHandle handle,
                       void* buffer) {
   free(buffer);
 }
 
 
@@ skipping 1577 matching lines @@
 }
 
 
 void Service::CheckForPause(Isolate* isolate, JSONStream* stream) {
   // Should we pause?
   isolate->set_should_pause_post_service_request(
       BoolParameter::Parse(stream->LookupParam("pause"), false));
 }
 
 
-void Service::MaybePause(Isolate* isolate) {
+RawError* Service::MaybePause(Isolate* isolate, const Error& error) {
   // Don't pause twice.
   if (!isolate->IsPaused()) {
     if (isolate->should_pause_post_service_request()) {
       isolate->set_should_pause_post_service_request(false);
-      isolate->PausePostRequest();
+      // Before pausing, restore the sticky error. The debugger will return it
+      // from PausePostRequest.
+      Thread::Current()->set_sticky_error(error);
+      return isolate->PausePostRequest();
     }
   }
+  return error.raw();
 }
 
 
 static bool AddBreakpointCommon(Thread* thread,
                                 JSONStream* js,
                                 const String& script_uri) {
   if (!thread->isolate()->compilation_allowed()) {
     js->PrintError(
         kFeatureDisabled,
         "Cannot use breakpoints when running a precompiled program.");
@@ skipping 1295 matching lines @@
   }
 }
 
 
 static bool GetVM(Thread* thread, JSONStream* js) {
   Service::PrintJSONForVM(js, false);
   return true;
 }
 
 
-static const MethodParameter* restart_vm_params[] = {
-    NO_ISOLATE_PARAMETER, NULL,
-};
-
-
-static bool RestartVM(Thread* thread, JSONStream* js) {
-  Isolate::KillAllIsolates(Isolate::kVMRestartMsg);
-  PrintSuccess(js);
-  return true;
-}
-
-
 static const char* exception_pause_mode_names[] = {
     "All", "None", "Unhandled", NULL,
 };
 
 
 static Dart_ExceptionPauseInfo exception_pause_mode_values[] = {
     kPauseOnAllExceptions, kNoPauseOnExceptions, kPauseOnUnhandledExceptions,
     kInvalidExceptionPauseInfo,
 };
 
@@ skipping 249 matching lines @@
   { "_getVMMetricList", GetVMMetricList,
     get_vm_metric_list_params },
   { "_getVMTimeline", GetVMTimeline,
     get_vm_timeline_params },
   { "_getVMTimelineFlags", GetVMTimelineFlags,
     get_vm_timeline_flags_params },
   { "pause", Pause,
     pause_params },
   { "removeBreakpoint", RemoveBreakpoint,
     remove_breakpoint_params },
-  { "_restartVM", RestartVM,
-    restart_vm_params },
   { "reloadSources", ReloadSources,
     reload_sources_params },
   { "_reloadSources", ReloadSources,
     reload_sources_params },
   { "resume", Resume,
     resume_params },
   { "_requestHeapSnapshot", RequestHeapSnapshot,
     request_heap_snapshot_params },
   { "setExceptionPauseMode", SetExceptionPauseMode,
     set_exception_pause_mode_params },
@@ skipping 19 matching lines @@
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart