Rationalize service method handler names

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 "platform/globals.h"
 
 #include "vm/compiler.h"
@@ skipping 712 matching lines @@
   return NULL;
 }
 
 
 static const MethodParameter* get_isolate_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolate(Isolate* isolate, JSONStream* js) {
+static bool GetIsolate(Isolate* isolate, JSONStream* js) {
   isolate->PrintJSON(js, false);
   return true;
 }
 
 
 static const MethodParameter* get_stack_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetStack(Isolate* isolate, JSONStream* js) {
+static bool GetStack(Isolate* isolate, JSONStream* js) {
   DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "Stack");
   JSONArray jsarr(&jsobj, "frames");
   intptr_t num_frames = stack->Length();
   for (intptr_t i = 0; i < num_frames; i++) {
     ActivationFrame* frame = stack->FrameAt(i);
     JSONObject jsobj(&jsarr);
     frame->PrintToJSONObject(&jsobj);
     // TODO(turnidge): Implement depth differently -- differentiate
@@ skipping 24 matching lines @@
       jsobj.AddProperty("text", text);
     }
   }
   const String& message = String::Handle(String::New(js.ToCString()));
   uint8_t data[] = {0, 128, 255};
   // TODO(koda): Add 'testing' event family.
   SendEvent(kEventFamilyDebug, message, data, sizeof(data));
 }
 
 
-static bool HandleIsolateTriggerEchoEvent(Isolate* isolate, JSONStream* js) {
+static bool _TriggerEchoEvent(Isolate* isolate, JSONStream* js) {
   Service::SendEchoEvent(isolate, js->LookupParam("text"));
   JSONObject jsobj(js);
   return HandleCommonEcho(&jsobj, js);
 }
 
 
-static bool HandleIsolateEcho(Isolate* isolate, JSONStream* js) {
+static bool _Echo(Isolate* isolate, JSONStream* js) {
   JSONObject jsobj(js);
   return HandleCommonEcho(&jsobj, js);
 }
 
 
 static bool ContainsNonInstance(const Object& obj) {
   if (obj.IsArray()) {
     const Array& array = Array::Cast(obj);
     Object& element = Object::Handle();
     for (intptr_t i = 0; i < array.Length(); ++i) {
@@ skipping 433 matching lines @@
   return true;
 }
 
 
 static const MethodParameter* get_inbound_references_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetInboundReferences(Isolate* isolate,
-                                              JSONStream* js) {
+static bool GetInboundReferences(Isolate* isolate, JSONStream* js) {
   const char* target_id = js->LookupParam("targetId");
   if (target_id == NULL) {
     PrintMissingParamError(js, "targetId");
     return true;
   }
   const char* limit_cstr = js->LookupParam("limit");
   if (target_id == NULL) {
     PrintMissingParamError(js, "limit");
     return true;
   }
@@ skipping 83 matching lines @@
   return true;
 }
 
 
 static const MethodParameter* get_retaining_path_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetRetainingPath(Isolate* isolate,
-                                          JSONStream* js) {
+static bool GetRetainingPath(Isolate* isolate, JSONStream* js) {
   const char* target_id = js->LookupParam("targetId");
   if (target_id == NULL) {
     PrintMissingParamError(js, "targetId");
     return true;
   }
   const char* limit_cstr = js->LookupParam("limit");
   if (target_id == NULL) {
     PrintMissingParamError(js, "limit");
     return true;
   }
@@ skipping 27 matching lines @@
   return PrintRetainingPath(isolate, &obj, limit, js);
 }
 
 
 static const MethodParameter* get_retained_size_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetRetainedSize(Isolate* isolate, JSONStream* js) {
+static bool GetRetainedSize(Isolate* isolate, JSONStream* js) {
   const char* target_id = js->LookupParam("targetId");
   if (target_id == NULL) {
     PrintMissingParamError(js, "targetId");
     return true;
   }
   ObjectIdRing::LookupResult lookup_result;
   Object& obj = Object::Handle(LookupHeapObject(isolate, target_id,
                                                 &lookup_result));
   if (obj.raw() == Object::sentinel().raw()) {
     if (lookup_result == ObjectIdRing::kCollected) {
@@ skipping 32 matching lines @@
   return true;
 }
 
 
 static const MethodParameter* eval_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateEval(Isolate* isolate, JSONStream* js) {
+static bool Eval(Isolate* isolate, JSONStream* js) {
   const char* target_id = js->LookupParam("targetId");
   if (target_id == NULL) {
     PrintMissingParamError(js, "targetId");
     return true;
   }
   const char* expr = js->LookupParam("expression");
   if (expr == NULL) {
     PrintMissingParamError(js, "expression");
     return true;
   }
@@ skipping 46 matching lines @@
 }
 
 
 static const MethodParameter* get_call_site_data_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("targetId", true),
   NULL,
 };
 
 
-static bool HandleIsolateGetCallSiteData(Isolate* isolate, JSONStream* js) {
+static bool GetCallSiteData(Isolate* isolate, JSONStream* js) {
   const char* target_id = js->LookupParam("targetId");
   Object& obj = Object::Handle(LookupHeapObject(isolate, target_id, NULL));
   if (obj.raw() == Object::sentinel().raw()) {
     PrintInvalidParamError(js, "targetId");
     return true;
   }
   if (obj.IsFunction()) {
     const Function& func = Function::Cast(obj);
     const GrowableObjectArray& ics =
         GrowableObjectArray::Handle(func.CollectICsWithSourcePositions());
@@ skipping 47 matching lines @@
   intptr_t count_;
 };
 
 
 static const MethodParameter* get_instances_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetInstances(Isolate* isolate, JSONStream* js) {
+static bool GetInstances(Isolate* isolate, JSONStream* js) {
   const char* target_id = js->LookupParam("classId");
   if (target_id == NULL) {
     PrintMissingParamError(js, "classId");
     return true;
   }
   const char* limit_cstr = js->LookupParam("limit");
   if (target_id == NULL) {
     PrintMissingParamError(js, "limit");
     return true;
   }
@@ skipping 88 matching lines @@
   const Function& func_;
 };
 
 
 static const MethodParameter* get_coverage_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetCoverage(Isolate* isolate, JSONStream* js) {
+static bool GetCoverage(Isolate* isolate, JSONStream* js) {
   if (!js->HasParam("targetId")) {
     CodeCoverage::PrintJSON(isolate, js, NULL);
     return true;
   }
   const char* target_id = js->LookupParam("targetId");
   Object& obj = Object::Handle(LookupHeapObject(isolate, target_id, NULL));
   if (obj.raw() == Object::sentinel().raw()) {
     PrintInvalidParamError(js, "targetId");
     return true;
   }
@@ skipping 25 matching lines @@
 
 
 static const MethodParameter* add_breakpoint_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("scriptId", true),
   new UIntParameter("line", true),
   NULL,
 };
 
 
-static bool HandleIsolateAddBreakpoint(Isolate* isolate, JSONStream* js) {
+static bool AddBreakpoint(Isolate* isolate, JSONStream* js) {
   const char* line_param = js->LookupParam("line");
   intptr_t line = UIntParameter::Parse(line_param);
   const char* script_id = js->LookupParam("scriptId");
   Object& obj = Object::Handle(LookupHeapObject(isolate, script_id, NULL));
   if (obj.raw() == Object::sentinel().raw() || !obj.IsScript()) {
     PrintInvalidParamError(js, "scriptId");
     return true;
   }
   const Script& script = Script::Cast(obj);
   const String& script_url = String::Handle(script.url());
   SourceBreakpoint* bpt =
       isolate->debugger()->SetBreakpointAtLine(script_url, line);
   if (bpt == NULL) {
     PrintError(js, "Unable to set breakpoint at line %s", line_param);
     return true;
   }
   bpt->PrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* add_breakpoint_at_entry_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("functionId", true),
   NULL,
 };
 
 
-static bool HandleIsolateAddBreakpointAtEntry(Isolate* isolate,
-                                              JSONStream* js) {
+static bool AddBreakpointAtEntry(Isolate* isolate, JSONStream* js) {
   const char* function_id = js->LookupParam("functionId");
   Object& obj = Object::Handle(LookupHeapObject(isolate, function_id, NULL));
   if (obj.raw() == Object::sentinel().raw() || !obj.IsFunction()) {
     PrintInvalidParamError(js, "functionId");
     return true;
   }
   const Function& function = Function::Cast(obj);
   SourceBreakpoint* bpt =
       isolate->debugger()->SetBreakpointAtEntry(function);
   if (bpt == NULL) {
     const String& funcName = String::Handle(function.PrettyName());
     PrintError(js, "Unable to set breakpoint at function '%s'",
                funcName.ToCString());
     return true;
   }
   bpt->PrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* remove_breakpoint_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateRemoveBreakpoint(Isolate* isolate, JSONStream* js) {
+static bool RemoveBreakpoint(Isolate* isolate, JSONStream* js) {
   if (!js->HasParam("breakpointId")) {
     PrintMissingParamError(js, "breakpointId");
     return true;
   }
   const char* bpt_id = js->LookupParam("breakpointId");
   SourceBreakpoint* bpt = LookupBreakpoint(isolate, bpt_id);
   if (bpt == NULL) {
     fprintf(stderr, "ERROR1");
     PrintInvalidParamError(js, "breakpointId");
     return true;
@@ skipping 96 matching lines @@
     ASSERT(result.IsString());
     TextBuffer* buffer = js->buffer();
     buffer->AddString(String::Cast(result).ToCString());
     return true;
   }
   PrintError(js, "Dart Metric %s not found\n", id);
   return true;
 }
 
 
-static const MethodParameter* get_metric_list_params[] = {
+static const MethodParameter* get_isolate_metric_list_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetMetricList(Isolate* isolate, JSONStream* js) {
+static bool GetIsolateMetricList(Isolate* isolate, 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(isolate, js);
   }
   return HandleDartMetricsList(isolate, js);
 }
 
 
-static const MethodParameter* get_metric_params[] = {
+static const MethodParameter* get_isolate_metric_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetMetric(Isolate* isolate, JSONStream* js) {
+static bool GetIsolateMetric(Isolate* isolate, JSONStream* js) {
   const char* metric_id = js->LookupParam("metricId");
   if (metric_id == NULL) {
     PrintMissingParamError(js, "metricId");
     return true;
   }
   // Verify id begins with "metrics/".
   static const char* kMetricIdPrefix = "metrics/";
   static intptr_t kMetricIdPrefixLen = strlen(kMetricIdPrefix);
   if (strncmp(metric_id, kMetricIdPrefix, kMetricIdPrefixLen) != 0) {
     PrintError(js, "Metric %s not found\n", metric_id);
@@ skipping 11 matching lines @@
   return HandleDartMetric(isolate, js, id);
 }
 
 
 static const MethodParameter* get_vm_metric_list_params[] = {
   NO_ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleVMGetMetricList(Isolate* isolate, JSONStream* js) {
+static bool GetVMMetricList(Isolate* isolate, JSONStream* js) {
   return false;
 }
 
 
 static const MethodParameter* get_vm_metric_params[] = {
   NO_ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleVMGetMetric(Isolate* isolate, JSONStream* js) {
+static bool GetVMMetric(Isolate* isolate, JSONStream* js) {
   const char* metric_id = js->LookupParam("metricId");
   if (metric_id == NULL) {
     PrintMissingParamError(js, "metricId");
   }
   return false;
 }
 
 
 static const MethodParameter* resume_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateResume(Isolate* isolate, JSONStream* js) {
+static bool Resume(Isolate* isolate, JSONStream* js) {
   const char* step_param = js->LookupParam("step");
   if (isolate->message_handler()->paused_on_start()) {
     isolate->message_handler()->set_pause_on_start(false);
     JSONObject jsobj(js);
     jsobj.AddProperty("type", "Success");
     jsobj.AddProperty("id", "");
     {
       DebuggerEvent resumeEvent(isolate, DebuggerEvent::kIsolateResumed);
       Service::HandleDebuggerEvent(&resumeEvent);
     }
@@ skipping 31 matching lines @@
   return true;
 }
 
 
 static const MethodParameter* get_breakpoints_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetBreakpoints(Isolate* isolate, JSONStream* js) {
+static bool GetBreakpoints(Isolate* isolate, JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "BreakpointList");
   JSONArray jsarr(&jsobj, "breakpoints");
   isolate->debugger()->PrintBreakpointsToJSONArray(&jsarr);
   return true;
 }
 
 
 static const MethodParameter* pause_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolatePause(Isolate* isolate, JSONStream* js) {
+static bool Pause(Isolate* isolate, JSONStream* js) {
   // TODO(turnidge): Don't double-interrupt the isolate here.
   isolate->ScheduleInterrupts(Isolate::kApiInterrupt);
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "Success");
   jsobj.AddProperty("id", "");
   return true;
 }
 
 
 static const MethodParameter* get_tag_profile_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetTagProfile(Isolate* isolate, JSONStream* js) {
+static bool GetTagProfile(Isolate* isolate, JSONStream* js) {
   JSONObject miniProfile(js);
   miniProfile.AddProperty("type", "TagProfile");
   miniProfile.AddProperty("id", "profile/tag");
   isolate->vm_tag_counters()->PrintToJSONObject(&miniProfile);
   return true;
 }
 
 
 static const char* tags_enum_names[] = {
   "None",
@@ skipping 15 matching lines @@
 };
 
 
 static const MethodParameter* get_cpu_profile_params[] = {
   ISOLATE_PARAMETER,
   new EnumParameter("tags", true, tags_enum_names),
   NULL,
 };
 
 
-static bool HandleIsolateGetCpuProfile(Isolate* isolate, JSONStream* js) {
+static bool GetCpuProfile(Isolate* isolate, JSONStream* js) {
   ProfilerService::TagOrder tag_order =
       EnumMapper(js->LookupParam("tags"), tags_enum_names, tags_enum_values);
   ProfilerService::PrintJSON(js, tag_order);
   return true;
 }
 
 
 static const MethodParameter* get_allocation_profile_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetAllocationProfile(Isolate* isolate,
-                                              JSONStream* js) {
+static bool GetAllocationProfile(Isolate* isolate, JSONStream* js) {
   bool should_reset_accumulator = false;
   bool should_collect = false;
   if (js->HasParam("reset")) {
     if (js->ParamIs("reset", "true")) {
       should_reset_accumulator = true;
     } else {
       PrintInvalidParamError(js, "reset");
       return true;
     }
   }
@@ skipping 17 matching lines @@
   return true;
 }
 
 
 static const MethodParameter* get_heap_map_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetHeapMap(Isolate* isolate, JSONStream* js) {
+static bool GetHeapMap(Isolate* isolate, JSONStream* js) {
   isolate->heap()->PrintHeapMapToJSONStream(isolate, js);
   return true;
 }
 
 
 static const MethodParameter* request_heap_snapshot_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateRequestHeapSnapshot(Isolate* isolate, JSONStream* js) {
+static bool RequestHeapSnapshot(Isolate* isolate, JSONStream* js) {
   Service::SendGraphEvent(isolate);
   // TODO(koda): Provide some id that ties this request to async response(s).
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "OK");
   jsobj.AddProperty("id", "ok");
   return true;
 }
 
 
 void Service::SendGraphEvent(Isolate* isolate) {
@@ skipping 35 matching lines @@
   uword addr_;
 };
 
 
 static const MethodParameter* get_object_by_address_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetObjectByAddress(Isolate* isolate, JSONStream* js) {
+static bool GetObjectByAddress(Isolate* isolate, JSONStream* js) {
   const char* addr_str = js->LookupParam("address");
   if (addr_str == NULL) {
     PrintMissingParamError(js, "address");
     return true;
   }
 
   // Handle heap objects.
   uword addr = 0;
   if (!GetUnsignedIntegerId(addr_str, &addr, 16)) {
     PrintInvalidParamError(js, "address");
     return true;
   }
   bool ref = js->HasParam("ref") && js->ParamIs("ref", "true");
   Object& object = Object::Handle(isolate);
   {
     NoGCScope no_gc;
     ContainsAddressVisitor visitor(isolate, addr);
     object = isolate->heap()->FindObject(&visitor);
   }
   object.PrintJSON(js, ref);
   return true;
 }
 
 
-static bool HandleIsolateRespondWithMalformedJson(Isolate* isolate,
-                                                  JSONStream* js) {
+static bool _RespondWithMalformedJson(Isolate* isolate,
+                                      JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("a", "a");
   JSONObject jsobj1(js);
   jsobj1.AddProperty("a", "a");
   JSONObject jsobj2(js);
   jsobj2.AddProperty("a", "a");
   JSONObject jsobj3(js);
   jsobj3.AddProperty("a", "a");
   return true;
 }
 
 
-static bool HandleIsolateRespondWithMalformedObject(Isolate* isolate,
-                                                    JSONStream* js) {
+static bool _RespondWithMalformedObject(Isolate* isolate,
+                                        JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("bart", "simpson");
   return true;
 }
 
 
 static const MethodParameter* get_object_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetObject(Isolate* isolate, JSONStream* js) {
+static bool GetObject(Isolate* isolate, JSONStream* js) {
   const char* id = js->LookupParam("objectId");
   if (id == NULL) {
     PrintMissingParamError(js, "objectId");
     return true;
   }
 
   // Handle heap objects.
   ObjectIdRing::LookupResult lookup_result;
   const Object& obj =
       Object::Handle(LookupHeapObject(isolate, id, &lookup_result));
@@ skipping 20 matching lines @@
   return true;
 }
 
 
 static const MethodParameter* get_class_list_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetClassList(Isolate* isolate, JSONStream* js) {
+static bool GetClassList(Isolate* isolate, JSONStream* js) {
   ClassTable* table = isolate->class_table();
   JSONObject jsobj(js);
   table->PrintToJSONObject(&jsobj);
   return true;
 }
 
 
 static const MethodParameter* get_type_arguments_list_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleIsolateGetTypeArgumentsList(Isolate* isolate,
-                                              JSONStream* js) {
+static bool GetTypeArgumentsList(Isolate* isolate, JSONStream* js) {
   bool only_with_instantiations = false;
   if (js->ParamIs("onlyWithInstantiations", "true")) {
     only_with_instantiations = true;
   }
   ObjectStore* object_store = isolate->object_store();
   const Array& table = Array::Handle(object_store->canonical_type_arguments());
   ASSERT(table.Length() > 0);
   TypeArguments& type_args = TypeArguments::Handle();
   const intptr_t table_size = table.Length() - 1;
   const intptr_t table_used = Smi::Value(Smi::RawCast(table.At(table_size)));
@@ skipping 33 matching lines @@
   JSONArray* jsarr_;
 };
 
 
 static const MethodParameter* get_vm_params[] = {
   NO_ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleVM(Isolate* isolate, JSONStream* js) {
+static bool GetVM(Isolate* isolate, JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "VM");
   jsobj.AddProperty("id", "vm");
   jsobj.AddProperty("architectureBits", static_cast<intptr_t>(kBitsPerWord));
   jsobj.AddProperty("targetCPU", CPU::Id());
   jsobj.AddProperty("hostCPU", HostCPUFeatures::hardware());
   jsobj.AddPropertyF("date", "%" Pd64 "", OS::GetCurrentTimeMillis());
   jsobj.AddProperty("version", Version::String());
   // Send pid as a string because it allows us to avoid any issues with
   // pids > 53-bits (when consumed by JavaScript).
@@ skipping 16 matching lines @@
   return true;
 }
 
 
 static const MethodParameter* get_flag_list_params[] = {
   NO_ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleVMFlagList(Isolate* isolate, JSONStream* js) {
+static bool GetFlagList(Isolate* isolate, JSONStream* js) {
   Flags::PrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* set_flags_params[] = {
   NO_ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool HandleVMSetFlag(Isolate* isolate, JSONStream* js) {
+static bool SetFlag(Isolate* isolate, JSONStream* js) {
   const char* flag_name = js->LookupParam("name");
   if (flag_name == NULL) {
     PrintMissingParamError(js, "name");
     return true;
   }
   const char* flag_value = js->LookupParam("value");
   if (flag_value == NULL) {
     PrintMissingParamError(js, "value");
     return true;
   }
   JSONObject jsobj(js);
   const char* error = NULL;
   if (Flags::SetFlag(flag_name, flag_value, &error)) {
     jsobj.AddProperty("type", "Success");
     jsobj.AddProperty("id", "");
     return true;
   } else {
     jsobj.AddProperty("type", "Failure");
     jsobj.AddProperty("id", "");
     jsobj.AddProperty("message", error);
     return true;
   }
 }
 
 
 static ServiceMethodDescriptor service_methods_[] = {
-  { "_echo", HandleIsolateEcho,
+  { "_echo", _Echo,
     NULL },
-  { "_respondWithMalformedJson", HandleIsolateRespondWithMalformedJson,
+  { "_respondWithMalformedJson", _RespondWithMalformedJson,
     NULL },
-  { "_respondWithMalformedObject", HandleIsolateRespondWithMalformedObject,
+  { "_respondWithMalformedObject", _RespondWithMalformedObject,
     NULL },
-  { "_triggerEchoEvent", HandleIsolateTriggerEchoEvent,
+  { "_triggerEchoEvent", _TriggerEchoEvent,
     NULL },
-  { "addBreakpoint", HandleIsolateAddBreakpoint,
+  { "addBreakpoint", AddBreakpoint,
     add_breakpoint_params },
-  { "addBreakpointAtEntry", HandleIsolateAddBreakpointAtEntry,
+  { "addBreakpointAtEntry", AddBreakpointAtEntry,
     add_breakpoint_at_entry_params },
-  { "eval", HandleIsolateEval,
+  { "eval", Eval,
     eval_params },
-  { "getAllocationProfile", HandleIsolateGetAllocationProfile,
+  { "getAllocationProfile", GetAllocationProfile,
     get_allocation_profile_params },
-  { "getBreakpoints", HandleIsolateGetBreakpoints,
+  { "getBreakpoints", GetBreakpoints,
     get_breakpoints_params },
-  { "getCallSiteData", HandleIsolateGetCallSiteData,
+  { "getCallSiteData", GetCallSiteData,
     get_call_site_data_params },
-  { "getClassList", HandleIsolateGetClassList,
+  { "getClassList", GetClassList,
     get_class_list_params },
-  { "getCoverage", HandleIsolateGetCoverage,
+  { "getCoverage", GetCoverage,
     get_coverage_params },
-  { "getCpuProfile", HandleIsolateGetCpuProfile,
+  { "getCpuProfile", GetCpuProfile,
     get_cpu_profile_params },
-  { "getFlagList", HandleVMFlagList ,
+  { "getFlagList", GetFlagList ,
     get_flag_list_params },
-  { "getHeapMap", HandleIsolateGetHeapMap,
+  { "getHeapMap", GetHeapMap,
     get_heap_map_params },
-  { "getInboundReferences", HandleIsolateGetInboundReferences,
+  { "getInboundReferences", GetInboundReferences,
     get_inbound_references_params },
-  { "getInstances", HandleIsolateGetInstances,
+  { "getInstances", GetInstances,
     get_instances_params },
-  { "getIsolate", HandleIsolate,
+  { "getIsolate", GetIsolate,
     get_isolate_params },
-  { "getIsolateMetric", HandleIsolateGetMetric,
-    get_metric_params },
-  { "getIsolateMetricList", HandleIsolateGetMetricList,
-    get_metric_list_params },
-  { "getObject", HandleIsolateGetObject,
+  { "getIsolateMetric", GetIsolateMetric,
+    get_isolate_metric_params },
+  { "getIsolateMetricList", GetIsolateMetricList,
+    get_isolate_metric_list_params },
+  { "getObject", GetObject,
     get_object_params },
-  { "getObjectByAddress", HandleIsolateGetObjectByAddress,
+  { "getObjectByAddress", GetObjectByAddress,
     get_object_by_address_params },
-  { "getRetainedSize", HandleIsolateGetRetainedSize,
+  { "getRetainedSize", GetRetainedSize,
     get_retained_size_params },
-  { "getRetainingPath", HandleIsolateGetRetainingPath,
+  { "getRetainingPath", GetRetainingPath,
     get_retaining_path_params },
-  { "getStack", HandleIsolateGetStack,
+  { "getStack", GetStack,
     get_stack_params },
-  { "getTagProfile", HandleIsolateGetTagProfile,
+  { "getTagProfile", GetTagProfile,
     get_tag_profile_params },
-  { "getTypeArgumentsList", HandleIsolateGetTypeArgumentsList,
+  { "getTypeArgumentsList", GetTypeArgumentsList,
     get_type_arguments_list_params },
-  { "getVM", HandleVM ,
+  { "getVM", GetVM,
     get_vm_params },
-  { "getVMMetric", HandleVMGetMetric,
+  { "getVMMetric", GetVMMetric,
     get_vm_metric_params },
-  { "getVMMetricList", HandleVMGetMetricList,
+  { "getVMMetricList", GetVMMetricList,
     get_vm_metric_list_params },
-  { "pause", HandleIsolatePause,
+  { "pause", Pause,
     pause_params },
-  { "removeBreakpoint", HandleIsolateRemoveBreakpoint,
+  { "removeBreakpoint", RemoveBreakpoint,
     remove_breakpoint_params },
-  { "resume", HandleIsolateResume,
+  { "resume", Resume,
     resume_params },
-  { "requestHeapSnapshot", HandleIsolateRequestHeapSnapshot,
+  { "requestHeapSnapshot", RequestHeapSnapshot,
     request_heap_snapshot_params },
-  { "setFlag", HandleVMSetFlag ,
+  { "setFlag", SetFlag ,
     set_flags_params },
 };
 
 
 ServiceMethodDescriptor* FindMethod(const char* method_name) {
   intptr_t num_methods = sizeof(service_methods_) /
                          sizeof(service_methods_[0]);
   for (intptr_t i = 0; i < num_methods; i++) {
     ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 
 }  // namespace dart