Return an error in many service RPCs if the isolate is not runnable

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 216 matching lines @@
 static void PrintUnrecognizedMethodError(JSONStream* js) {
   js->PrintError(kMethodNotFound, NULL);
 }
 
 
 static void PrintSuccess(JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "Success");
 }
 
+
 static bool GetIntegerId(const char* s, intptr_t* id, int base = 10) {
   if ((s == NULL) || (*s == '\0')) {
     // Empty string.
     return false;
   }
   if (id == NULL) {
     // No id pointer.
     return false;
   }
   intptr_t r = 0;
@@ skipping 150 matching lines @@
   }
 
   const char* name() const {
     return name_;
   }
 
   bool required() const {
     return required_;
   }
 
+  virtual void PrintError(const char* name,
+                          const char* value,
+                          JSONStream* js) const {
+    PrintInvalidParamError(js, name);
+  }
+
  private:
   const char* name_;
   bool required_;
 };
 
 
 class NoSuchParameter : public MethodParameter {
  public:
   explicit NoSuchParameter(const char* name)
     : MethodParameter(name, false) {
   }
 
   virtual bool Validate(const char* value) const {
     return (value == NULL);
   }
 };
 
 
-#define NO_ISOLATE_PARAMETER new NoSuchParameter("isolateId")
-
-
 class BoolParameter : public MethodParameter {
  public:
   BoolParameter(const char* name, bool required)
       : MethodParameter(name, required) {
   }
 
   virtual bool Validate(const char* value) const {
     if (value == NULL) {
       return false;
     }
@@ skipping 74 matching lines @@
   IdParameter(const char* name, bool required)
       : MethodParameter(name, required) {
   }
 
   virtual bool Validate(const char* value) const {
     return (value != NULL);
   }
 };
 
 
+class RunnableIsolateParameter : public MethodParameter {
+ public:
+  explicit RunnableIsolateParameter(const char* name)
+      : MethodParameter(name, true) {
+  }
+
+  virtual bool Validate(const char* value) const {
+    Isolate* isolate = Isolate::Current();
+    return (value != NULL) && (isolate != NULL) && (isolate->is_runnable());
+  }
+
+  virtual void PrintError(const char* name,
+                          const char* value,
+                          JSONStream* js) const {
+    js->PrintError(kIsolateMustBeRunnable,
+                   "Isolate must be runnable before this request is made.");
+  }
+};
+
+
 #define ISOLATE_PARAMETER new IdParameter("isolateId", true)
-
+#define NO_ISOLATE_PARAMETER new NoSuchParameter("isolateId")
+#define RUNNABLE_ISOLATE_PARAMETER new RunnableIsolateParameter("isolateId")
 
 class EnumParameter : public MethodParameter {
  public:
   EnumParameter(const char* name, bool required, const char* const* enums)
       : MethodParameter(name, required),
         enums_(enums) {
   }
 
   virtual bool Validate(const char* value) const {
     if (value == NULL) {
@@ skipping 167 matching lines @@
     const MethodParameter* parameter = parameters[i];
     const char* name = parameter->name();
     const bool required = parameter->required();
     const char* value = js->LookupParam(name);
     const bool has_parameter = (value != NULL);
     if (required && !has_parameter) {
       PrintMissingParamError(js, name);
       return false;
     }
     if (has_parameter && !parameter->Validate(value)) {
-      PrintInvalidParamError(js, name);
+      parameter->PrintError(name, value, js);
       return false;
     }
   }
   return true;
 }
 
 
 void Service::PostError(const String& method_name,
                         const Array& parameter_keys,
                         const Array& parameter_values,
@@ skipping 441 matching lines @@
 };
 
 
 static bool GetIsolate(Thread* thread, JSONStream* js) {
   thread->isolate()->PrintJSON(js, false);
   return true;
 }
 
 
 static const MethodParameter* get_stack_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new BoolParameter("_full", false),
   NULL,
 };
 
 
 static bool GetStack(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
         "Cannot get stack when running a precompiled program.");
     return true;
@@ skipping 588 matching lines @@
       // reporting suprious references when repeatedly looking for the
       // references to an object.
       path.SetAt(i * 2, Object::null_object());
     }
   }
   return true;
 }
 
 
 static const MethodParameter* get_inbound_references_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool GetInboundReferences(Thread* thread, JSONStream* js) {
   const char* target_id = js->LookupParam("targetId");
   if (target_id == NULL) {
     PrintMissingParamError(js, "targetId");
     return true;
   }
@@ skipping 78 matching lines @@
   // after looking for a retaining path.
   for (intptr_t i = 0; i < limit; ++i) {
     path.SetAt(i * 2, Object::null_object());
   }
 
   return true;
 }
 
 
 static const MethodParameter* get_retaining_path_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool GetRetainingPath(Thread* thread, JSONStream* js) {
   const char* target_id = js->LookupParam("targetId");
   if (target_id == NULL) {
     PrintMissingParamError(js, "targetId");
     return true;
   }
@@ skipping 22 matching lines @@
     } else {
       PrintInvalidParamError(js, "targetId");
     }
     return true;
   }
   return PrintRetainingPath(thread, &obj, limit, js);
 }
 
 
 static const MethodParameter* get_retained_size_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new IdParameter("targetId", true),
   NULL,
 };
 
 
 static bool GetRetainedSize(Thread* thread, JSONStream* js) {
   const char* target_id = js->LookupParam("targetId");
   ASSERT(target_id != NULL);
   ObjectIdRing::LookupResult lookup_result;
   Object& obj = Object::Handle(LookupHeapObject(thread, target_id,
@@ skipping 21 matching lines @@
 
   ObjectGraph graph(thread);
   intptr_t retained_size = graph.SizeRetainedByInstance(obj);
   const Object& result = Object::Handle(Integer::New(retained_size));
   result.PrintJSON(js, true);
   return true;
 }
 
 
 static const MethodParameter* get_reachable_size_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new IdParameter("targetId", true),
   NULL,
 };
 
 
 static bool GetReachableSize(Thread* thread, JSONStream* js) {
   const char* target_id = js->LookupParam("targetId");
   ASSERT(target_id != NULL);
   ObjectIdRing::LookupResult lookup_result;
   Object& obj = Object::Handle(LookupHeapObject(thread, target_id,
@@ skipping 21 matching lines @@
 
   ObjectGraph graph(thread);
   intptr_t retained_size = graph.SizeReachableByInstance(obj);
   const Object& result = Object::Handle(Integer::New(retained_size));
   result.PrintJSON(js, true);
   return true;
 }
 
 
 static const MethodParameter* evaluate_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool Evaluate(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
                    "Cannot evaluate when running a precompiled program.");
     return true;
   }
@@ skipping 50 matching lines @@
   }
   js->PrintError(kInvalidParams,
                  "%s: invalid 'targetId' parameter: "
                  "id '%s' does not correspond to a "
                  "library, class, or instance", js->method(), target_id);
   return true;
 }
 
 
 static const MethodParameter* evaluate_in_frame_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new UIntParameter("frameIndex", true),
   new MethodParameter("expression", true),
   NULL,
 };
 
 
 static bool EvaluateInFrame(Thread* thread, JSONStream* js) {
   Isolate* isolate = thread->isolate();
   if (!isolate->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
@@ skipping 44 matching lines @@
   intptr_t count() const { return count_; }
 
  private:
   const Class& cls_;
   const Array& storage_;
   intptr_t count_;
 };
 
 
 static const MethodParameter* get_instances_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool GetInstances(Thread* thread, JSONStream* js) {
   const char* target_id = js->LookupParam("classId");
   if (target_id == NULL) {
     PrintMissingParamError(js, "classId");
     return true;
   }
@@ skipping 137 matching lines @@
   js->PrintError(kInvalidParams,
                  "%s: invalid 'targetId' parameter: "
                  "id '%s' does not correspond to a "
                  "script, library, class, or function",
                  js->method(), target_id);
   return true;
 }
 
 
 static const MethodParameter* get_coverage_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new IdParameter("targetId", false),
   NULL,
 };
 
 
 static bool GetCoverage(Thread* thread, JSONStream* js) {
   // TODO(rmacnak): Remove this response; it is subsumed by GetCallSiteData.
   return GetHitsOrSites(thread, js, false);
 }
 
 
 static const char* kCallSitesStr = "_CallSites";
 static const char* kCoverageStr = "Coverage";
 static const char* kPossibleBreakpointsStr = "PossibleBreakpoints";
 
 
 static const char* const report_enum_names[] = {
   kCallSitesStr,
   kCoverageStr,
   kPossibleBreakpointsStr,
   NULL,
 };
 
 
 static const EnumListParameter* reports_parameter =
     new EnumListParameter("reports", true, report_enum_names);
 
 
 static const MethodParameter* get_source_report_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   reports_parameter,
   new IdParameter("scriptId", false),
   new UIntParameter("tokenPos", false),
   new UIntParameter("endTokenPos", false),
   new BoolParameter("forceCompile", false),
   NULL,
 };
 
 
 static bool GetSourceReport(Thread* thread, JSONStream* js) {
@@ skipping 46 matching lines @@
       return true;
     }
   }
   SourceReport report(report_set, compile_mode);
   report.PrintJSON(js, script, start_pos, end_pos);
   return true;
 }
 
 
 static const MethodParameter* get_call_site_data_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new IdParameter("targetId", false),
   NULL,
 };
 
 
 static bool GetCallSiteData(Thread* thread, JSONStream* js) {
   return GetHitsOrSites(thread, js, true);
 }
 
 
@@ skipping 26 matching lines @@
                    "%s: Cannot add breakpoint at line '%s'",
                    js->method(), line_param);
     return true;
   }
   bpt->PrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* add_breakpoint_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new IdParameter("scriptId", true),
   new UIntParameter("line", true),
   new UIntParameter("column", false),
   NULL,
 };
 
 
 static bool AddBreakpoint(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
         "Cannot use breakpoints when running a precompiled program.");
     return true;
   }
   const char* script_id_param = js->LookupParam("scriptId");
   Object& obj = Object::Handle(LookupHeapObject(thread, script_id_param, NULL));
   if (obj.raw() == Object::sentinel().raw() || !obj.IsScript()) {
     PrintInvalidParamError(js, "scriptId");
     return true;
   }
   const Script& script = Script::Cast(obj);
   const String& script_uri = String::Handle(script.url());
   ASSERT(!script_uri.IsNull());
   return AddBreakpointCommon(thread, js, script_uri);
 }
 
 
 static const MethodParameter* add_breakpoint_with_script_uri_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new IdParameter("scriptUri", true),
   new UIntParameter("line", true),
   new UIntParameter("column", false),
   NULL,
 };
 
 
 static bool AddBreakpointWithScriptUri(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
         "Cannot use breakpoints when running a precompiled program.");
     return true;
   }
   const char* script_uri_param = js->LookupParam("scriptUri");
   const String& script_uri = String::Handle(String::New(script_uri_param));
   return AddBreakpointCommon(thread, js, script_uri);
 }
 
 
 static const MethodParameter* add_breakpoint_at_entry_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new IdParameter("functionId", true),
   NULL,
 };
 
 
 static bool AddBreakpointAtEntry(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
         "Cannot use breakpoints when running a precompiled program.");
     return true;
@@ skipping 12 matching lines @@
                    "%s: Cannot add breakpoint at function '%s'",
                    js->method(), function.ToCString());
     return true;
   }
   bpt->PrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* add_breakpoint_at_activation_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new IdParameter("objectId", true),
   NULL,
 };
 
 
 static bool AddBreakpointAtActivation(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
         "Cannot use breakpoints when running a precompiled program.");
     return true;
@@ skipping 12 matching lines @@
                    "%s: Cannot add breakpoint at activation",
                    js->method());
     return true;
   }
   bpt->PrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* remove_breakpoint_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool RemoveBreakpoint(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
         "Cannot use breakpoints when running a precompiled program.");
     return true;
   }
@@ skipping 109 matching lines @@
     TextBuffer* buffer = js->buffer();
     buffer->AddString(String::Cast(result).ToCString());
     return true;
   }
   PrintInvalidParamError(js, "metricId");
   return true;
 }
 
 
 static const MethodParameter* get_isolate_metric_list_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool GetIsolateMetricList(Thread* thread, JSONStream* js) {
   bool native_metrics = false;
   if (js->HasParam("type")) {
     if (js->ParamIs("type", "Native")) {
       native_metrics = true;
     } else if (js->ParamIs("type", "Dart")) {
       native_metrics = false;
     } else {
       PrintInvalidParamError(js, "type");
       return true;
     }
   } else {
     PrintMissingParamError(js, "type");
     return true;
   }
   if (native_metrics) {
     return HandleNativeMetricsList(thread, js);
   }
   return HandleDartMetricsList(thread, js);
 }
 
 
 static const MethodParameter* get_isolate_metric_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool GetIsolateMetric(Thread* thread, JSONStream* js) {
   const char* metric_id = js->LookupParam("metricId");
   if (metric_id == NULL) {
     PrintMissingParamError(js, "metricId");
     return true;
   }
@@ skipping 127 matching lines @@
       Int64Parameter::Parse(js->LookupParam("timeOriginMicros"));
   int64_t time_extent_micros =
       Int64Parameter::Parse(js->LookupParam("timeExtentMicros"));
   TimelineEventFilter filter(time_origin_micros, time_extent_micros);
   timeline_recorder->PrintJSON(js, &filter);
   return true;
 }
 
 
 static const MethodParameter* resume_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool Resume(Thread* thread, JSONStream* js) {
   const char* step_param = js->LookupParam("step");
   Isolate* isolate = thread->isolate();
   if (isolate->message_handler()->paused_on_start()) {
     // If the user is issuing a 'Over' or an 'Out' step, that is the
     // same as a regular resume request.
@@ skipping 32 matching lines @@
     PrintSuccess(js);
     return true;
   }
 
   js->PrintError(kVMMustBePaused, NULL);
   return true;
 }
 
 
 static const MethodParameter* pause_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool Pause(Thread* thread, JSONStream* js) {
   // TODO(turnidge): This interrupt message could have been sent from
   // the service isolate directly, but would require some special case
   // code.  That would prevent this isolate getting double-interrupted
   // with OOB messages.
   Isolate* isolate = thread->isolate();
   isolate->SendInternalLibMessage(Isolate::kInterruptMsg,
                                   isolate->pause_capability());
   PrintSuccess(js);
   return true;
 }
 
 
 static const MethodParameter* get_tag_profile_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool GetTagProfile(Thread* thread, JSONStream* js) {
   JSONObject miniProfile(js);
   miniProfile.AddProperty("type", "TagProfile");
   thread->isolate()->vm_tag_counters()->PrintToJSONObject(&miniProfile);
   return true;
 }
@@ skipping 13 matching lines @@
   Profile::kNoTags,
   Profile::kUserVM,
   Profile::kUser,
   Profile::kVMUser,
   Profile::kVM,
   Profile::kNoTags,  // Default value.
 };
 
 
 static const MethodParameter* get_cpu_profile_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new EnumParameter("tags", true, tags_enum_names),
   new BoolParameter("_codeTransitionTags", false),
   new Int64Parameter("timeOriginMicros", false),
   new Int64Parameter("timeExtentMicros", false),
   NULL,
 };
 
 
 // TODO(johnmccutchan): Rename this to GetCpuSamples.
 static bool GetCpuProfile(Thread* thread, JSONStream* js) {
@@ skipping 10 matching lines @@
   ProfilerService::PrintJSON(js,
                              tag_order,
                              extra_tags,
                              time_origin_micros,
                              time_extent_micros);
   return true;
 }
 
 
 static const MethodParameter* get_cpu_profile_timeline_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new EnumParameter("tags", true, tags_enum_names),
   new Int64Parameter("timeOriginMicros", false),
   new Int64Parameter("timeExtentMicros", false),
   NULL,
 };
 
 
 static bool GetCpuProfileTimeline(Thread* thread, JSONStream* js) {
   Profile::TagOrder tag_order =
       EnumMapper(js->LookupParam("tags"), tags_enum_names, tags_enum_values);
   int64_t time_origin_micros =
       UIntParameter::Parse(js->LookupParam("timeOriginMicros"));
   int64_t time_extent_micros =
       UIntParameter::Parse(js->LookupParam("timeExtentMicros"));
   ProfilerService::PrintTimelineJSON(js,
                                      tag_order,
                                      time_origin_micros,
                                      time_extent_micros);
   return true;
 }
 
 
 static const MethodParameter* get_allocation_samples_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new EnumParameter("tags", true, tags_enum_names),
   new IdParameter("classId", false),
   new Int64Parameter("timeOriginMicros", false),
   new Int64Parameter("timeExtentMicros", false),
   NULL,
 };
 
 
 static bool GetAllocationSamples(Thread* thread, JSONStream* js) {
   Profile::TagOrder tag_order =
@@ skipping 14 matching lines @@
                                          time_origin_micros,
                                          time_extent_micros);
   } else {
     PrintInvalidParamError(js, "classId");
   }
   return true;
 }
 
 
 static const MethodParameter* clear_cpu_profile_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool ClearCpuProfile(Thread* thread, JSONStream* js) {
   ProfilerService::ClearSamples();
   PrintSuccess(js);
   return true;
 }
 
 
 static const MethodParameter* get_allocation_profile_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool GetAllocationProfile(Thread* thread, JSONStream* js) {
   bool should_reset_accumulator = false;
   bool should_collect = false;
   if (js->HasParam("reset")) {
     if (js->ParamIs("reset", "true")) {
       should_reset_accumulator = true;
@@ skipping 18 matching lines @@
   if (should_collect) {
     isolate->UpdateLastAllocationProfileGCTimestamp();
     isolate->heap()->CollectAllGarbage();
   }
   isolate->class_table()->AllocationProfilePrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* get_heap_map_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool GetHeapMap(Thread* thread, JSONStream* js) {
   Isolate* isolate = thread->isolate();
   isolate->heap()->PrintHeapMapToJSONStream(isolate, js);
   return true;
 }
 
 
 static const MethodParameter* request_heap_snapshot_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool RequestHeapSnapshot(Thread* thread, JSONStream* js) {
   if (Service::graph_stream.enabled()) {
     Service::SendGraphEvent(thread);
   }
   // TODO(koda): Provide some id that ties this request to async response(s).
   JSONObject jsobj(js);
@@ skipping 133 matching lines @@
     uword obj_begin = RawObject::ToAddr(obj);
     uword obj_end = obj_begin + obj->Size();
     return obj_begin <= addr_ && addr_ < obj_end;
   }
  private:
   uword addr_;
 };
 
 
 static const MethodParameter* get_object_by_address_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static RawObject* GetObjectHelper(Thread* thread, uword addr) {
   Object& object = Object::Handle(thread->zone());
 
   {
     NoSafepointScope no_safepoint;
     Isolate* isolate = thread->isolate();
@@ skipping 34 matching lines @@
   if (obj.IsNull()) {
     PrintSentinel(js, kFreeSentinel);
   } else {
     obj.PrintJSON(js, ref);
   }
   return true;
 }
 
 
 static const MethodParameter* get_ports_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool GetPorts(Thread* thread, JSONStream* js) {
   MessageHandler* message_handler = thread->isolate()->message_handler();
   PortMap::PrintPortsForMessageHandler(message_handler, js);
   return true;
 }
 
@@ skipping 12 matching lines @@
 
 
 static bool RespondWithMalformedObject(Thread* thread, JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("bart", "simpson");
   return true;
 }
 
 
 static const MethodParameter* get_object_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new UIntParameter("offset", false),
   new UIntParameter("count", false),
   NULL,
 };
 
 
 static bool GetObject(Thread* thread, JSONStream* js) {
   const char* id = js->LookupParam("objectId");
   if (id == NULL) {
     PrintMissingParamError(js, "objectId");
@@ skipping 41 matching lines @@
     PrintSentinel(js, kCollectedSentinel);
     return true;
   }
 
   PrintInvalidParamError(js, "objectId");
   return true;
 }
 
 
 static const MethodParameter* get_class_list_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool GetClassList(Thread* thread, JSONStream* js) {
   ClassTable* table = thread->isolate()->class_table();
   JSONObject jsobj(js);
   table->PrintToJSONObject(&jsobj);
   return true;
 }
 
 
 static const MethodParameter* get_type_arguments_list_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool GetTypeArgumentsList(Thread* thread, JSONStream* js) {
   bool only_with_instantiations = false;
   if (js->ParamIs("onlyWithInstantiations", "true")) {
     only_with_instantiations = true;
   }
   ObjectStore* object_store = thread->isolate()->object_store();
@@ skipping 188 matching lines @@
   } else {
     JSONObject jsobj(js);
     jsobj.AddProperty("type", "Error");
     jsobj.AddProperty("message", error);
     return true;
   }
 }
 
 
 static const MethodParameter* set_library_debuggable_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new IdParameter("libraryId", true),
   new BoolParameter("isDebuggable", true),
   NULL,
 };
 
 
 static bool SetLibraryDebuggable(Thread* thread, JSONStream* js) {
   const char* lib_id = js->LookupParam("libraryId");
   ObjectIdRing::LookupResult lookup_result;
   Object& obj = Object::Handle(LookupHeapObject(thread, lib_id,
@@ skipping 43 matching lines @@
   if (Service::vm_stream.enabled()) {
     ServiceEvent event(NULL, ServiceEvent::kVMUpdate);
     Service::HandleEvent(&event);
   }
   PrintSuccess(js);
   return true;
 }
 
 
 static const MethodParameter* set_trace_class_allocation_params[] = {
-  ISOLATE_PARAMETER,
+  RUNNABLE_ISOLATE_PARAMETER,
   new IdParameter("classId", true),
   new BoolParameter("enable", true),
   NULL,
 };
 
 
 static bool SetTraceClassAllocation(Thread* thread, JSONStream* js) {
   if (!thread->isolate()->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
         "Cannot trace allocation when running a precompiled program.");
@@ skipping 136 matching lines @@
     const ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 
 }  // namespace dart