Getting rid of Isolate::current_zone() usage. Pass thread instead of isolate where it makes sense.

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 511 matching lines @@
   for (i = 0; enums[i] != NULL; i++) {
     if (strcmp(value, enums[i]) == 0) {
       return values[i];
     }
   }
   // Default value.
   return values[i];
 }
 
 
-typedef bool (*ServiceMethodEntry)(Isolate* isolate, JSONStream* js);
+typedef bool (*ServiceMethodEntry)(Thread* thread, JSONStream* js);
 
 
 struct ServiceMethodDescriptor {
   const char* name;
   const ServiceMethodEntry entry;
   const MethodParameter* const * parameters;
 };
 
 
 // TODO(johnmccutchan): Do we reject unexpected parameters?
@@ skipping 100 matching lines @@
       }
     }
     const char* c_method_name = method_name.ToCString();
 
     ServiceMethodDescriptor* method = FindMethod(c_method_name);
     if (method != NULL) {
       if (!ValidateParameters(method->parameters, &js)) {
         js.PostReply();
         return;
       }
-      if (method->entry(I, &js)) {
+      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;
     }
 
     EmbedderServiceHandler* handler = FindIsolateEmbedderHandler(c_method_name);
@@ skipping 340 matching lines @@
                                       id);
 }
 
 
 static const MethodParameter* get_isolate_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetIsolate(Isolate* isolate, JSONStream* js) {
-  isolate->PrintJSON(js, false);
+static bool GetIsolate(Thread* thread, JSONStream* js) {
+  thread->isolate()->PrintJSON(js, false);
   return true;
 }
 
 
 static const MethodParameter* get_stack_params[] = {
   ISOLATE_PARAMETER,
   new BoolParameter("_full", false),
   NULL,
 };
 
 
-static bool GetStack(Isolate* isolate, JSONStream* js) {
+static bool GetStack(Thread* thread, JSONStream* js) {
+  Isolate* isolate = thread->isolate();
   DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
   // Do we want the complete script object and complete local variable objects?
   // This is true for dump requests.
   const bool full = BoolParameter::Parse(js->LookupParam("_full"), false);
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "Stack");
   {
     JSONArray jsarr(&jsobj, "frames");
 
     intptr_t num_frames = stack->Length();
@@ skipping 44 matching lines @@
         event.AddPropertyTimeMillis("timestamp", OS::GetCurrentTimeMillis());
       }
     }
   }
   const String& message = String::Handle(String::New(js.ToCString()));
   uint8_t data[] = {0, 128, 255};
   SendEventWithData(echo_stream.id(), "_Echo", message, data, sizeof(data));
 }
 
 
-static bool TriggerEchoEvent(Isolate* isolate, JSONStream* js) {
+static bool TriggerEchoEvent(Thread* thread, JSONStream* js) {
   if (Service::echo_stream.enabled()) {
-    Service::SendEchoEvent(isolate, js->LookupParam("text"));
+    Service::SendEchoEvent(thread->isolate(), js->LookupParam("text"));
   }
   JSONObject jsobj(js);
   return HandleCommonEcho(&jsobj, js);
 }
 
 
-static bool DumpIdZone(Isolate* isolate, JSONStream* js) {
+static bool DumpIdZone(Thread* thread, JSONStream* js) {
   // TODO(johnmccutchan): Respect _idZone parameter passed to RPC. For now,
   // always send the ObjectIdRing.
   //
-  ObjectIdRing* ring = isolate->object_id_ring();
+  ObjectIdRing* ring = thread->isolate()->object_id_ring();
   ASSERT(ring != NULL);
   // When printing the ObjectIdRing, force object id reuse policy.
   RingServiceIdZone reuse_zone;
   reuse_zone.Init(ring, ObjectIdRing::kReuseId);
   js->set_id_zone(&reuse_zone);
   ring->PrintJSON(js);
   return true;
 }
 
 
-static bool Echo(Isolate* isolate, JSONStream* js) {
+static bool Echo(Thread* thread, 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 287 matching lines @@
   Code& code = Code::Handle(Code::FindCode(pc, timestamp));
   if (!code.IsNull()) {
     return code.raw();
   }
 
   // Not found.
   return Object::sentinel().raw();
 }
 
 
-static RawObject* LookupHeapObjectMessage(Isolate* isolate,
+static RawObject* LookupHeapObjectMessage(Thread* thread,
                                           char** parts, int num_parts) {
   if (num_parts != 2) {
     return Object::sentinel().raw();
   }
   uword message_id = 0;
   if (!GetUnsignedIntegerId(parts[1], &message_id, 16)) {
     return Object::sentinel().raw();
   }
   MessageHandler::AcquiredQueues aq;
-  isolate->message_handler()->AcquireQueues(&aq);
+  thread->isolate()->message_handler()->AcquireQueues(&aq);
   Message* message = aq.queue()->FindMessageById(message_id);
   if (message == NULL) {
     // The user may try to load an expired message.
     return Object::sentinel().raw();
   }
   MessageSnapshotReader reader(message->data(),
                                message->len(),
-                               Thread::Current());
+                               thread);
   return reader.ReadObject();
 }
 
 
-static RawObject* LookupHeapObject(Isolate* isolate,
+static RawObject* LookupHeapObject(Thread* thread,
                                    const char* id_original,
                                    ObjectIdRing::LookupResult* result) {
-  Thread* thread = Thread::Current();
   char* id = thread->zone()->MakeCopyOfString(id_original);
 
   // Parse the id by splitting at each '/'.
   const int MAX_PARTS = 8;
   char* parts[MAX_PARTS];
   int num_parts = 0;
   int i = 0;
   int start_pos = 0;
   while (id[i] != '\0') {
     if (id[i] == '/') {
       id[i++] = '\0';
       parts[num_parts++] = &id[start_pos];
       if (num_parts == MAX_PARTS) {
         break;
       }
       start_pos = i;
     } else {
       i++;
     }
   }
   if (num_parts < MAX_PARTS) {
     parts[num_parts++] = &id[start_pos];
   }
 
   if (result != NULL) {
     *result = ObjectIdRing::kValid;
   }
 
+  Isolate* isolate = thread->isolate();
   if (strcmp(parts[0], "objects") == 0) {
     // Object ids look like "objects/1123"
     Object& obj = Object::Handle(thread->zone());
     ObjectIdRing::LookupResult lookup_result;
     obj = LookupObjectId(thread, parts[1], &lookup_result);
     if (lookup_result != ObjectIdRing::kValid) {
       if (result != NULL) {
         *result = lookup_result;
       }
       return Object::sentinel().raw();
     }
     return obj.raw();
 
   } else if (strcmp(parts[0], "libraries") == 0) {
     return LookupHeapObjectLibraries(isolate, parts, num_parts);
   } else if (strcmp(parts[0], "classes") == 0) {
     return LookupHeapObjectClasses(thread, parts, num_parts);
   } else if (strcmp(parts[0], "typearguments") == 0) {
     return LookupHeapObjectTypeArguments(thread, parts, num_parts);
   } else if (strcmp(parts[0], "code") == 0) {
     return LookupHeapObjectCode(isolate, parts, num_parts);
   } else if (strcmp(parts[0], "messages") == 0) {
-    return LookupHeapObjectMessage(isolate, parts, num_parts);
+    return LookupHeapObjectMessage(thread, parts, num_parts);
   }
 
   // Not found.
   return Object::sentinel().raw();
 }
 
 
 enum SentinelType {
   kCollectedSentinel,
   kExpiredSentinel,
@@ skipping 101 matching lines @@
   return true;
 }
 
 
 static const MethodParameter* get_inbound_references_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetInboundReferences(Isolate* isolate, JSONStream* js) {
-  Thread* thread = Thread::Current();
-  ASSERT(isolate == thread->isolate());
-
+static bool GetInboundReferences(Thread* thread, 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 (limit_cstr == NULL) {
     PrintMissingParamError(js, "limit");
     return true;
   }
   intptr_t limit;
   if (!GetIntegerId(limit_cstr, &limit)) {
     PrintInvalidParamError(js, "limit");
     return true;
   }
 
   Object& obj = Object::Handle(thread->zone());
   ObjectIdRing::LookupResult lookup_result;
   {
     HANDLESCOPE(thread);
-    obj = LookupHeapObject(isolate, target_id, &lookup_result);
+    obj = LookupHeapObject(thread, target_id, &lookup_result);
   }
   if (obj.raw() == Object::sentinel().raw()) {
     if (lookup_result == ObjectIdRing::kCollected) {
       PrintSentinel(js, kCollectedSentinel);
     } else if (lookup_result == ObjectIdRing::kExpired) {
       PrintSentinel(js, kExpiredSentinel);
     } else {
       PrintInvalidParamError(js, "targetId");
     }
     return true;
@@ skipping 57 matching lines @@
   return true;
 }
 
 
 static const MethodParameter* get_retaining_path_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetRetainingPath(Isolate* isolate, JSONStream* js) {
-  Thread* thread = Thread::Current();
-  ASSERT(isolate == thread->isolate());
-
+static bool GetRetainingPath(Thread* thread, 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 (limit_cstr == NULL) {
     PrintMissingParamError(js, "limit");
     return true;
   }
   intptr_t limit;
   if (!GetIntegerId(limit_cstr, &limit)) {
     PrintInvalidParamError(js, "limit");
     return true;
   }
 
   Object& obj = Object::Handle(thread->zone());
   ObjectIdRing::LookupResult lookup_result;
   {
     HANDLESCOPE(thread);
-    obj = LookupHeapObject(isolate, target_id, &lookup_result);
+    obj = LookupHeapObject(thread, target_id, &lookup_result);
   }
   if (obj.raw() == Object::sentinel().raw()) {
     if (lookup_result == ObjectIdRing::kCollected) {
       PrintSentinel(js, kCollectedSentinel);
     } else if (lookup_result == ObjectIdRing::kExpired) {
       PrintSentinel(js, kExpiredSentinel);
     } else {
       PrintInvalidParamError(js, "targetId");
     }
     return true;
   }
   return PrintRetainingPath(thread, &obj, limit, js);
 }
 
 
 static const MethodParameter* get_retained_size_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetRetainedSize(Isolate* isolate, JSONStream* js) {
+static bool GetRetainedSize(Thread* thread, 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,
+  Object& obj = Object::Handle(LookupHeapObject(thread, target_id,
                                                 &lookup_result));
   if (obj.raw() == Object::sentinel().raw()) {
     if (lookup_result == ObjectIdRing::kCollected) {
       PrintSentinel(js, kCollectedSentinel);
     } else if (lookup_result == ObjectIdRing::kExpired) {
       PrintSentinel(js, kExpiredSentinel);
     } else {
       PrintInvalidParamError(js, "targetId");
     }
     return true;
   }
-  Thread* thread = Thread::Current();
   // TODO(rmacnak): There is no way to get the size retained by a class object.
   // SizeRetainedByClass should be a separate RPC.
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
     ObjectGraph graph(thread);
     intptr_t retained_size = graph.SizeRetainedByClass(cls.id());
     const Object& result = Object::Handle(Integer::New(retained_size));
     result.PrintJSON(js, true);
     return true;
   }
 
   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* evaluate_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool Evaluate(Isolate* isolate, JSONStream* js) {
-  if (!isolate->compilation_allowed()) {
+static bool Evaluate(Thread* thread, JSONStream* js) {
+  if (!thread->isolate()->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
                    "Cannot evaluate when running a precompiled program.");
     return true;
   }
   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;
   }
-  Zone* zone = Thread::Current()->zone();
+  Zone* zone = thread->zone();
   const String& expr_str = String::Handle(zone, String::New(expr));
   ObjectIdRing::LookupResult lookup_result;
-  Object& obj = Object::Handle(zone, LookupHeapObject(isolate, target_id,
+  Object& obj = Object::Handle(zone, LookupHeapObject(thread, target_id,
                                                       &lookup_result));
   if (obj.raw() == Object::sentinel().raw()) {
     if (lookup_result == ObjectIdRing::kCollected) {
       PrintSentinel(js, kCollectedSentinel);
     } else if (lookup_result == ObjectIdRing::kExpired) {
       PrintSentinel(js, kExpiredSentinel);
     } else {
       PrintInvalidParamError(js, "targetId");
     }
     return true;
@@ skipping 33 matching lines @@
 
 
 static const MethodParameter* evaluate_in_frame_params[] = {
   ISOLATE_PARAMETER,
   new UIntParameter("frameIndex", true),
   new MethodParameter("expression", true),
   NULL,
 };
 
 
-static bool EvaluateInFrame(Isolate* isolate, JSONStream* js) {
+static bool EvaluateInFrame(Thread* thread, JSONStream* js) {
+  Isolate* isolate = thread->isolate();
   if (!isolate->compilation_allowed()) {
     js->PrintError(kFeatureDisabled,
                    "Cannot evaluate when running a precompiled program.");
     return true;
   }
   DebuggerStackTrace* stack = isolate->debugger()->StackTrace();
   intptr_t framePos = UIntParameter::Parse(js->LookupParam("frameIndex"));
   if (framePos > stack->Length()) {
     PrintInvalidParamError(js, "frameIndex");
     return true;
   }
   ActivationFrame* frame = stack->FrameAt(framePos);
 
-  Zone* zone = Thread::Current()->zone();
+  Zone* zone = thread->zone();
   const char* expr = js->LookupParam("expression");
   const String& expr_str = String::Handle(zone, String::New(expr));
 
   const Object& result = Object::Handle(zone, frame->Evaluate(expr_str));
   result.PrintJSON(js, true);
   return true;
 }
 
 
 class GetInstancesVisitor : public ObjectGraph::Visitor {
@@ skipping 27 matching lines @@
   intptr_t count_;
 };
 
 
 static const MethodParameter* get_instances_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetInstances(Isolate* isolate, JSONStream* js) {
+static bool GetInstances(Thread* thread, 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 (limit_cstr == NULL) {
     PrintMissingParamError(js, "limit");
     return true;
   }
   intptr_t limit;
   if (!GetIntegerId(limit_cstr, &limit)) {
     PrintInvalidParamError(js, "limit");
     return true;
   }
   const Object& obj =
-      Object::Handle(LookupHeapObject(isolate, target_id, NULL));
+      Object::Handle(LookupHeapObject(thread, target_id, NULL));
   if (obj.raw() == Object::sentinel().raw() ||
       !obj.IsClass()) {
     PrintInvalidParamError(js, "classId");
     return true;
   }
   const Class& cls = Class::Cast(obj);
   Array& storage = Array::Handle(Array::New(limit));
   GetInstancesVisitor visitor(cls, storage);
-  ObjectGraph graph(Thread::Current());
+  ObjectGraph graph(thread);
   graph.IterateObjects(&visitor);
   intptr_t count = visitor.count();
   if (count < limit) {
     // Truncate the list using utility method for GrowableObjectArray.
     GrowableObjectArray& wrapper = GrowableObjectArray::Handle(
         GrowableObjectArray::New(storage));
     wrapper.SetLength(count);
     storage = Array::MakeArray(wrapper);
   }
   JSONObject jsobj(js);
@@ skipping 60 matching lines @@
                                const Script& script,
                                const Class& cls,
                                const Function& func) const {
     return func.raw() == func_.raw();
   }
  private:
   const Function& func_;
 };
 
 
-static bool GetHitsOrSites(Isolate* isolate, JSONStream* js, bool as_sites) {
-  Thread* thread = Thread::Current();
+static bool GetHitsOrSites(Thread* thread, JSONStream* js, bool as_sites) {
   if (!js->HasParam("targetId")) {
     CodeCoverage::PrintJSON(thread, js, NULL, as_sites);
     return true;
   }
   const char* target_id = js->LookupParam("targetId");
-  Object& obj = Object::Handle(LookupHeapObject(isolate, target_id, NULL));
+  Object& obj = Object::Handle(LookupHeapObject(thread, target_id, NULL));
   if (obj.raw() == Object::sentinel().raw()) {
     PrintInvalidParamError(js, "targetId");
     return true;
   }
   if (obj.IsScript()) {
     ScriptCoverageFilter sf(Script::Cast(obj));
     CodeCoverage::PrintJSON(thread, js, &sf, as_sites);
     return true;
   }
   if (obj.IsLibrary()) {
@@ skipping 20 matching lines @@
 }
 
 
 static const MethodParameter* get_coverage_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("targetId", false),
   NULL,
 };
 
 
-static bool GetCoverage(Isolate* isolate, JSONStream* js) {
+static bool GetCoverage(Thread* thread, JSONStream* js) {
   // TODO(rmacnak): Remove this response; it is subsumed by GetCallSiteData.
-  return GetHitsOrSites(isolate, js, false);
+  return GetHitsOrSites(thread, js, false);
 }
 
 
 static const MethodParameter* get_call_site_data_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("targetId", false),
   NULL,
 };
 
 
-static bool GetCallSiteData(Isolate* isolate, JSONStream* js) {
-  return GetHitsOrSites(isolate, js, true);
+static bool GetCallSiteData(Thread* thread, JSONStream* js) {
+  return GetHitsOrSites(thread, js, true);
 }
 
 
-static bool AddBreakpointCommon(Isolate* isolate,
+static bool AddBreakpointCommon(Thread* thread,
                                 JSONStream* js,
                                 const String& script_uri) {
   const char* line_param = js->LookupParam("line");
   intptr_t line = UIntParameter::Parse(line_param);
   const char* col_param = js->LookupParam("column");
   intptr_t col = -1;
   if (col_param != NULL) {
     col = UIntParameter::Parse(col_param);
     if (col == 0) {
       // Column number is 1-based.
       PrintInvalidParamError(js, "column");
       return true;
     }
   }
   ASSERT(!script_uri.IsNull());
   Breakpoint* bpt = NULL;
-  bpt = isolate->debugger()->SetBreakpointAtLineCol(script_uri, line, col);
+  bpt = thread->isolate()->debugger()->
+      SetBreakpointAtLineCol(script_uri, line, col);
   if (bpt == NULL) {
     js->PrintError(kCannotAddBreakpoint,
                    "%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,
   new IdParameter("scriptId", true),
   new UIntParameter("line", true),
   new UIntParameter("column", false),
   NULL,
 };
 
 
-static bool AddBreakpoint(Isolate* isolate, JSONStream* js) {
+static bool AddBreakpoint(Thread* thread, JSONStream* js) {
   const char* script_id_param = js->LookupParam("scriptId");
-  Object& obj =
-      Object::Handle(LookupHeapObject(isolate, script_id_param, NULL));
+  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(isolate, js, script_uri);
+  return AddBreakpointCommon(thread, js, script_uri);
 }
 
 
 static const MethodParameter* add_breakpoint_with_script_uri_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("scriptUri", true),
   new UIntParameter("line", true),
   new UIntParameter("column", false),
   NULL,
 };
 
 
-static bool AddBreakpointWithScriptUri(Isolate* isolate, JSONStream* js) {
+static bool AddBreakpointWithScriptUri(Thread* thread, JSONStream* js) {
   const char* script_uri_param = js->LookupParam("scriptUri");
   const String& script_uri = String::Handle(String::New(script_uri_param));
-  return AddBreakpointCommon(isolate, js, script_uri);
+  return AddBreakpointCommon(thread, js, script_uri);
 }
 
 
 static const MethodParameter* add_breakpoint_at_entry_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("functionId", true),
   NULL,
 };
 
 
-static bool AddBreakpointAtEntry(Isolate* isolate, JSONStream* js) {
+static bool AddBreakpointAtEntry(Thread* thread, JSONStream* js) {
   const char* function_id = js->LookupParam("functionId");
-  Object& obj = Object::Handle(LookupHeapObject(isolate, function_id, NULL));
+  Object& obj = Object::Handle(LookupHeapObject(thread, function_id, NULL));
   if (obj.raw() == Object::sentinel().raw() || !obj.IsFunction()) {
     PrintInvalidParamError(js, "functionId");
     return true;
   }
   const Function& function = Function::Cast(obj);
   Breakpoint* bpt =
-      isolate->debugger()->SetBreakpointAtEntry(function, false);
+      thread->isolate()->debugger()->SetBreakpointAtEntry(function, false);
   if (bpt == NULL) {
     js->PrintError(kCannotAddBreakpoint,
                    "%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,
   new IdParameter("objectId", true),
   NULL,
 };
 
 
-static bool AddBreakpointAtActivation(Isolate* isolate, JSONStream* js) {
+static bool AddBreakpointAtActivation(Thread* thread, JSONStream* js) {
   const char* object_id = js->LookupParam("objectId");
-  Object& obj = Object::Handle(LookupHeapObject(isolate, object_id, NULL));
+  Object& obj = Object::Handle(LookupHeapObject(thread, object_id, NULL));
   if (obj.raw() == Object::sentinel().raw() || !obj.IsInstance()) {
     PrintInvalidParamError(js, "objectId");
     return true;
   }
   const Instance& closure = Instance::Cast(obj);
   Breakpoint* bpt =
-      isolate->debugger()->SetBreakpointAtActivation(closure);
+      thread->isolate()->debugger()->SetBreakpointAtActivation(closure);
   if (bpt == NULL) {
     js->PrintError(kCannotAddBreakpoint,
                    "%s: Cannot add breakpoint at activation",
                    js->method());
     return true;
   }
   bpt->PrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* remove_breakpoint_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool RemoveBreakpoint(Isolate* isolate, JSONStream* js) {
+static bool RemoveBreakpoint(Thread* thread, JSONStream* js) {
   if (!js->HasParam("breakpointId")) {
     PrintMissingParamError(js, "breakpointId");
     return true;
   }
   const char* bpt_id = js->LookupParam("breakpointId");
   ObjectIdRing::LookupResult lookup_result;
+  Isolate* isolate = thread->isolate();
   Breakpoint* bpt = LookupBreakpoint(isolate, bpt_id, &lookup_result);
   // TODO(turnidge): Should we return a different error for bpts whic
   // have been already removed?
   if (bpt == NULL) {
     PrintInvalidParamError(js, "breakpointId");
     return true;
   }
   isolate->debugger()->RemoveBreakpoint(bpt->id());
   PrintSuccess(js);
   return true;
 }
 
 
-static RawClass* GetMetricsClass(Isolate* isolate) {
-  Zone* zone = isolate->current_zone();
+static RawClass* GetMetricsClass(Thread* thread) {
+  Zone* zone = thread->zone();
   const Library& prof_lib =
       Library::Handle(zone, Library::DeveloperLibrary());
   ASSERT(!prof_lib.IsNull());
   const String& metrics_cls_name =
       String::Handle(zone, String::New("Metrics"));
   ASSERT(!metrics_cls_name.IsNull());
   const Class& metrics_cls =
       Class::Handle(zone, prof_lib.LookupClass(metrics_cls_name));
   ASSERT(!metrics_cls.IsNull());
   return metrics_cls.raw();
 }
 
 
 
-static bool HandleNativeMetricsList(Isolate* isolate, JSONStream* js) {
+static bool HandleNativeMetricsList(Thread* thread, JSONStream* js) {
   JSONObject obj(js);
   obj.AddProperty("type", "MetricList");
   {
     JSONArray metrics(&obj, "metrics");
-    Metric* current = isolate->metrics_list_head();
+    Metric* current = thread->isolate()->metrics_list_head();
     while (current != NULL) {
       metrics.AddValue(current);
       current = current->next();
     }
   }
   return true;
 }
 
 
-static bool HandleNativeMetric(Isolate* isolate,
-                                JSONStream* js,
-                                const char* id) {
-  Metric* current = isolate->metrics_list_head();
+static bool HandleNativeMetric(Thread* thread, JSONStream* js, const char* id) {
+  Metric* current = thread->isolate()->metrics_list_head();
   while (current != NULL) {
     const char* name = current->name();
     ASSERT(name != NULL);
     if (strcmp(name, id) == 0) {
       current->PrintJSON(js);
       return true;
     }
     current = current->next();
   }
   PrintInvalidParamError(js, "metricId");
   return true;
 }
 
 
-static bool HandleDartMetricsList(Isolate* isolate, JSONStream* js) {
-  Zone* zone = isolate->current_zone();
-  const Class& metrics_cls = Class::Handle(zone, GetMetricsClass(isolate));
+static bool HandleDartMetricsList(Thread* thread, JSONStream* js) {
+  Zone* zone = thread->zone();
+  const Class& metrics_cls =
+      Class::Handle(zone, GetMetricsClass(thread));
   const String& print_metrics_name =
       String::Handle(String::New("_printMetrics"));
   ASSERT(!print_metrics_name.IsNull());
   const Function& print_metrics = Function::Handle(
       zone,
       metrics_cls.LookupStaticFunctionAllowPrivate(print_metrics_name));
   ASSERT(!print_metrics.IsNull());
   const Array& args = Object::empty_array();
   const Object& result =
       Object::Handle(zone, DartEntry::InvokeFunction(print_metrics, args));
   ASSERT(!result.IsNull());
   ASSERT(result.IsString());
   TextBuffer* buffer = js->buffer();
   buffer->AddString(String::Cast(result).ToCString());
   return true;
 }
 
 
-static bool HandleDartMetric(Isolate* isolate, JSONStream* js, const char* id) {
-  Zone* zone = isolate->current_zone();
-  const Class& metrics_cls = Class::Handle(zone, GetMetricsClass(isolate));
+static bool HandleDartMetric(Thread* thread, JSONStream* js, const char* id) {
+  Zone* zone = thread->zone();
+  const Class& metrics_cls =
+      Class::Handle(zone, GetMetricsClass(thread));
   const String& print_metric_name =
       String::Handle(String::New("_printMetric"));
   ASSERT(!print_metric_name.IsNull());
   const Function& print_metric = Function::Handle(
       zone,
       metrics_cls.LookupStaticFunctionAllowPrivate(print_metric_name));
   ASSERT(!print_metric.IsNull());
   const String& arg0 = String::Handle(String::New(id));
   ASSERT(!arg0.IsNull());
   const Array& args = Array::Handle(Array::New(1));
@@ skipping 11 matching lines @@
   return true;
 }
 
 
 static const MethodParameter* get_isolate_metric_list_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetIsolateMetricList(Isolate* isolate, JSONStream* js) {
+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(isolate, js);
+    return HandleNativeMetricsList(thread, js);
   }
-  return HandleDartMetricsList(isolate, js);
+  return HandleDartMetricsList(thread, js);
 }
 
 
 static const MethodParameter* get_isolate_metric_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetIsolateMetric(Isolate* isolate, JSONStream* js) {
+static bool GetIsolateMetric(Thread* thread, 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) {
     PrintInvalidParamError(js, "metricId");
     return true;
   }
   // Check if id begins with "metrics/native/".
   static const char* kNativeMetricIdPrefix = "metrics/native/";
   static intptr_t kNativeMetricIdPrefixLen = strlen(kNativeMetricIdPrefix);
   const bool native_metric =
       strncmp(metric_id, kNativeMetricIdPrefix, kNativeMetricIdPrefixLen) == 0;
   if (native_metric) {
     const char* id = metric_id + kNativeMetricIdPrefixLen;
-    return HandleNativeMetric(isolate, js, id);
+    return HandleNativeMetric(thread, js, id);
   }
   const char* id = metric_id + kMetricIdPrefixLen;
-  return HandleDartMetric(isolate, js, id);
+  return HandleDartMetric(thread, js, id);
 }
 
 
 static const MethodParameter* get_vm_metric_list_params[] = {
   NO_ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetVMMetricList(Isolate* isolate, JSONStream* js) {
+static bool GetVMMetricList(Thread* thread, JSONStream* js) {
   return false;
 }
 
 
 static const MethodParameter* get_vm_metric_params[] = {
   NO_ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetVMMetric(Isolate* isolate, JSONStream* js) {
+static bool GetVMMetric(Thread* thread, 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 Resume(Isolate* isolate, JSONStream* js) {
+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.
     if ((step_param != NULL) && (strcmp(step_param, "Into") == 0)) {
       isolate->debugger()->EnterSingleStepMode();
     }
     isolate->message_handler()->set_pause_on_start(false);
     isolate->set_last_resume_timestamp();
     if (Service::debug_stream.enabled()) {
       ServiceEvent event(isolate, ServiceEvent::kResume);
@@ skipping 30 matching lines @@
   return true;
 }
 
 
 static const MethodParameter* pause_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool Pause(Isolate* isolate, JSONStream* js) {
+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,
   NULL,
 };
 
 
-static bool GetTagProfile(Isolate* isolate, JSONStream* js) {
+static bool GetTagProfile(Thread* thread, JSONStream* js) {
   JSONObject miniProfile(js);
   miniProfile.AddProperty("type", "TagProfile");
-  isolate->vm_tag_counters()->PrintToJSONObject(&miniProfile);
+  thread->isolate()->vm_tag_counters()->PrintToJSONObject(&miniProfile);
   return true;
 }
 
 
 static const char* tags_enum_names[] = {
   "None",
   "UserVM",
   "UserOnly",
   "VMUser",
   "VMOnly",
@@ skipping 13 matching lines @@
 
 static const MethodParameter* get_cpu_profile_params[] = {
   ISOLATE_PARAMETER,
   new EnumParameter("tags", true, tags_enum_names),
   new BoolParameter("_codeTransitionTags", false),
   NULL,
 };
 
 
 // TODO(johnmccutchan): Rename this to GetCpuSamples.
-static bool GetCpuProfile(Isolate* isolate, JSONStream* js) {
+static bool GetCpuProfile(Thread* thread, JSONStream* js) {
   Profile::TagOrder tag_order =
       EnumMapper(js->LookupParam("tags"), tags_enum_names, tags_enum_values);
   intptr_t extra_tags = 0;
   if (BoolParameter::Parse(js->LookupParam("_codeTransitionTags"))) {
     extra_tags |= ProfilerService::kCodeTransitionTagsBit;
   }
   ProfilerService::PrintJSON(js, tag_order, extra_tags);
   return true;
 }
 
 
 static const MethodParameter* get_allocation_samples_params[] = {
   ISOLATE_PARAMETER,
   new EnumParameter("tags", true, tags_enum_names),
   new IdParameter("classId", false),
   NULL,
 };
 
 
-static bool GetAllocationSamples(Isolate* isolate, JSONStream* js) {
+static bool GetAllocationSamples(Thread* thread, JSONStream* js) {
   Profile::TagOrder tag_order =
       EnumMapper(js->LookupParam("tags"), tags_enum_names, tags_enum_values);
   const char* class_id = js->LookupParam("classId");
   intptr_t cid = -1;
   GetPrefixedIntegerId(class_id, "classes/", &cid);
+  Isolate* isolate = thread->isolate();
   if (IsValidClassId(isolate, cid)) {
     const Class& cls = Class::Handle(GetClassForId(isolate, cid));
     ProfilerService::PrintAllocationJSON(js, tag_order, cls);
   } else {
     PrintInvalidParamError(js, "classId");
   }
   return true;
 }
 
 
 static const MethodParameter* clear_cpu_profile_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool ClearCpuProfile(Isolate* isolate, JSONStream* js) {
+static bool ClearCpuProfile(Thread* thread, JSONStream* js) {
   ProfilerService::ClearSamples();
   PrintSuccess(js);
   return true;
 }
 
 
 static const MethodParameter* get_allocation_profile_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetAllocationProfile(Isolate* isolate, JSONStream* js) {
+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;
     } else {
       PrintInvalidParamError(js, "reset");
       return true;
     }
   }
   if (js->HasParam("gc")) {
     if (js->ParamIs("gc", "full")) {
       should_collect = true;
     } else {
       PrintInvalidParamError(js, "gc");
       return true;
     }
   }
+  Isolate* isolate = thread->isolate();
   if (should_reset_accumulator) {
     isolate->UpdateLastAllocationProfileAccumulatorResetTimestamp();
     isolate->class_table()->ResetAllocationAccumulators();
   }
   if (should_collect) {
     isolate->UpdateLastAllocationProfileGCTimestamp();
     isolate->heap()->CollectAllGarbage();
   }
   isolate->class_table()->AllocationProfilePrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* get_heap_map_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetHeapMap(Isolate* isolate, JSONStream* js) {
+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,
   NULL,
 };
 
 
-static bool RequestHeapSnapshot(Isolate* isolate, JSONStream* js) {
+static bool RequestHeapSnapshot(Thread* thread, JSONStream* js) {
   if (Service::graph_stream.enabled()) {
-    Service::SendGraphEvent(isolate);
+    Service::SendGraphEvent(thread);
   }
   // TODO(koda): Provide some id that ties this request to async response(s).
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "OK");
   return true;
 }
 
 
-void Service::SendGraphEvent(Isolate* isolate) {
+void Service::SendGraphEvent(Thread* thread) {
   uint8_t* buffer = NULL;
   WriteStream stream(&buffer, &allocator, 1 * MB);
-  ObjectGraph graph(Thread::Current());
+  ObjectGraph graph(thread);
   intptr_t node_count = graph.Serialize(&stream);
 
   // Chrome crashes receiving a single tens-of-megabytes blob, so send the
   // snapshot in megabyte-sized chunks instead.
   const intptr_t kChunkSize = 1 * MB;
   intptr_t num_chunks =
       (stream.bytes_written() + (kChunkSize - 1)) / kChunkSize;
   for (intptr_t i = 0; i < num_chunks; i++) {
     JSONStream js;
     {
       JSONObject jsobj(&js);
       jsobj.AddProperty("jsonrpc", "2.0");
       jsobj.AddProperty("method", "streamNotify");
       {
         JSONObject params(&jsobj, "params");
         params.AddProperty("streamId", graph_stream.id());
         {
           JSONObject event(&params, "event");
           event.AddProperty("type", "Event");
           event.AddProperty("kind", "_Graph");
-          event.AddProperty("isolate", isolate);
+          event.AddProperty("isolate", thread->isolate());
           event.AddPropertyTimeMillis("timestamp", OS::GetCurrentTimeMillis());
 
           event.AddProperty("chunkIndex", i);
           event.AddProperty("chunkCount", num_chunks);
           event.AddProperty("nodeCount", node_count);
         }
       }
     }
 
     const String& message = String::Handle(String::New(js.ToCString()));
@@ skipping 80 matching lines @@
   uword addr_;
 };
 
 
 static const MethodParameter* get_object_by_address_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static RawObject* GetObjectHelper(Isolate* isolate, uword addr) {
-  Object& object = Object::Handle(isolate->current_zone());
+static RawObject* GetObjectHelper(Thread* thread, uword addr) {
+  Object& object = Object::Handle(thread->zone());
 
   {
     NoSafepointScope no_safepoint;
+    Isolate* isolate = thread->isolate();
     ContainsAddressVisitor visitor(isolate, addr);
     object = isolate->heap()->FindObject(&visitor);
   }
 
   if (!object.IsNull()) {
     return object.raw();
   }
 
   {
     NoSafepointScope no_safepoint;
     ContainsAddressVisitor visitor(Dart::vm_isolate(), addr);
     object = Dart::vm_isolate()->heap()->FindObject(&visitor);
   }
 
   return object.raw();
 }
 
 
-static bool GetObjectByAddress(Isolate* isolate, JSONStream* js) {
+static bool GetObjectByAddress(Thread* thread, 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");
-  const Object& obj = Object::Handle(isolate->current_zone(),
-      GetObjectHelper(isolate, addr));
+  const Object& obj = Object::Handle(thread->zone(),
+      GetObjectHelper(thread, addr));
   if (obj.IsNull()) {
     PrintSentinel(js, kFreeSentinel);
   } else {
     obj.PrintJSON(js, ref);
   }
   return true;
 }
 
 
 static const MethodParameter* get_ports_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetPorts(Isolate* isolate, JSONStream* js) {
-  MessageHandler* message_handler = isolate->message_handler();
+static bool GetPorts(Thread* thread, JSONStream* js) {
+  MessageHandler* message_handler = thread->isolate()->message_handler();
   PortMap::PrintPortsForMessageHandler(message_handler, js);
   return true;
 }
 
 
-static bool RespondWithMalformedJson(Isolate* isolate,
-                                      JSONStream* js) {
+static bool RespondWithMalformedJson(Thread* thread, 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 RespondWithMalformedObject(Isolate* isolate,
-                                        JSONStream* js) {
+static bool RespondWithMalformedObject(Thread* thread, JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("bart", "simpson");
   return true;
 }
 
 
 static const MethodParameter* get_object_params[] = {
   ISOLATE_PARAMETER,
   new UIntParameter("offset", false),
   new UIntParameter("count", false),
   NULL,
 };
 
 
-static bool GetObject(Isolate* isolate, JSONStream* js) {
+static bool GetObject(Thread* thread, JSONStream* js) {
   const char* id = js->LookupParam("objectId");
   if (id == NULL) {
     PrintMissingParamError(js, "objectId");
     return true;
   }
   if (js->HasParam("offset")) {
     intptr_t value = UIntParameter::Parse(js->LookupParam("offset"));
     if (value < 0) {
       PrintInvalidParamError(js, "offset");
       return true;
     }
     js->set_offset(value);
   }
   if (js->HasParam("count")) {
     intptr_t value = UIntParameter::Parse(js->LookupParam("count"));
     if (value < 0) {
       PrintInvalidParamError(js, "count");
       return true;
     }
     js->set_count(value);
   }
 
   // Handle heap objects.
   ObjectIdRing::LookupResult lookup_result;
   const Object& obj =
-      Object::Handle(LookupHeapObject(isolate, id, &lookup_result));
+      Object::Handle(LookupHeapObject(thread, id, &lookup_result));
   if (obj.raw() != Object::sentinel().raw()) {
     // We found a heap object for this id.  Return it.
     obj.PrintJSON(js, false);
     return true;
   } else if (lookup_result == ObjectIdRing::kCollected) {
     PrintSentinel(js, kCollectedSentinel);
     return true;
   } else if (lookup_result == ObjectIdRing::kExpired) {
     PrintSentinel(js, kExpiredSentinel);
     return true;
   }
 
   // Handle non-heap objects.
-  Breakpoint* bpt = LookupBreakpoint(isolate, id, &lookup_result);
+  Breakpoint* bpt = LookupBreakpoint(thread->isolate(), id, &lookup_result);
   if (bpt != NULL) {
     bpt->PrintJSON(js);
     return true;
   } else if (lookup_result == ObjectIdRing::kCollected) {
     PrintSentinel(js, kCollectedSentinel);
     return true;
   }
 
   PrintInvalidParamError(js, "objectId");
   return true;
 }
 
 
 static const MethodParameter* get_class_list_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetClassList(Isolate* isolate, JSONStream* js) {
-  ClassTable* table = isolate->class_table();
+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,
   NULL,
 };
 
 
-static bool GetTypeArgumentsList(Isolate* isolate, JSONStream* js) {
+static bool GetTypeArgumentsList(Thread* thread, JSONStream* js) {
   bool only_with_instantiations = false;
   if (js->ParamIs("onlyWithInstantiations", "true")) {
     only_with_instantiations = true;
   }
-  ObjectStore* object_store = isolate->object_store();
+  ObjectStore* object_store = thread->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)));
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "TypeArgumentsList");
   jsobj.AddProperty("canonicalTypeArgumentsTableSize", table_size);
   jsobj.AddProperty("canonicalTypeArgumentsTableUsed", table_used);
   JSONArray members(&jsobj, "typeArguments");
   for (intptr_t i = 0; i < table_size; i++) {
     type_args ^= table.At(i);
     if (!type_args.IsNull()) {
       if (!only_with_instantiations || type_args.HasInstantiations()) {
         members.AddValue(type_args);
       }
     }
   }
   return true;
 }
 
 
 static const MethodParameter* get_version_params[] = {
   NO_ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetVersion(Isolate* isolate, JSONStream* js) {
+static bool GetVersion(Thread* thread, JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "Version");
   jsobj.AddProperty("major", static_cast<intptr_t>(3));
   jsobj.AddProperty("minor", static_cast<intptr_t>(0));
   jsobj.AddProperty("_privateMajor", static_cast<intptr_t>(0));
   jsobj.AddProperty("_privateMinor", static_cast<intptr_t>(0));
   return true;
 }
 
 
@@ skipping 41 matching lines @@
   jsobj.AddPropertyTimeMillis("startTime", start_time_millis);
   // Construct the isolate list.
   {
     JSONArray jsarr(&jsobj, "isolates");
     ServiceIsolateVisitor visitor(&jsarr);
     Isolate::VisitIsolates(&visitor);
   }
 }
 
 
-static bool GetVM(Isolate* isolate, JSONStream* js) {
+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(Isolate* isolate, JSONStream* js) {
+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,
 };
 
 
 static const MethodParameter* set_exception_pause_mode_params[] = {
   ISOLATE_PARAMETER,
   new EnumParameter("mode", true, exception_pause_mode_names),
   NULL,
 };
 
 
-static bool SetExceptionPauseMode(Isolate* isolate, JSONStream* js) {
+static bool SetExceptionPauseMode(Thread* thread, JSONStream* js) {
   const char* mode = js->LookupParam("mode");
   if (mode == NULL) {
     PrintMissingParamError(js, "mode");
     return true;
   }
   Dart_ExceptionPauseInfo info =
       EnumMapper(mode, exception_pause_mode_names, exception_pause_mode_values);
   if (info == kInvalidExceptionPauseInfo) {
     PrintInvalidParamError(js, "mode");
     return true;
   }
+  Isolate* isolate = thread->isolate();
   isolate->debugger()->SetExceptionPauseInfo(info);
   if (Service::debug_stream.enabled()) {
     ServiceEvent event(isolate, ServiceEvent::kDebuggerSettingsUpdate);
     Service::HandleEvent(&event);
   }
   PrintSuccess(js);
   return true;
 }
 
 
 static const MethodParameter* get_flag_list_params[] = {
   NO_ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool GetFlagList(Isolate* isolate, JSONStream* js) {
+static bool GetFlagList(Thread* thread, JSONStream* js) {
   Flags::PrintJSON(js);
   return true;
 }
 
 
 static const MethodParameter* set_flags_params[] = {
   NO_ISOLATE_PARAMETER,
   NULL,
 };
 
 
-static bool SetFlag(Isolate* isolate, JSONStream* js) {
+static bool SetFlag(Thread* thread, 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;
   }
@@ skipping 11 matching lines @@
 
 
 static const MethodParameter* set_library_debuggable_params[] = {
   ISOLATE_PARAMETER,
   new IdParameter("libraryId", true),
   new BoolParameter("isDebuggable", true),
   NULL,
 };
 
 
-static bool SetLibraryDebuggable(Isolate* isolate, JSONStream* js) {
+static bool SetLibraryDebuggable(Thread* thread, JSONStream* js) {
   const char* lib_id = js->LookupParam("libraryId");
   ObjectIdRing::LookupResult lookup_result;
-  Object& obj = Object::Handle(LookupHeapObject(isolate, lib_id,
+  Object& obj = Object::Handle(LookupHeapObject(thread, lib_id,
                                                 &lookup_result));
   const bool is_debuggable =
       BoolParameter::Parse(js->LookupParam("isDebuggable"), false);
   if (obj.IsLibrary()) {
     const Library& lib = Library::Cast(obj);
     lib.set_debuggable(is_debuggable);
     PrintSuccess(js);
     return true;
   }
   PrintInvalidParamError(js, "libraryId");
   return true;
 }
 
 
 static const MethodParameter* set_name_params[] = {
   ISOLATE_PARAMETER,
   new MethodParameter("name", true),
   NULL,
 };
 
 
-static bool SetName(Isolate* isolate, JSONStream* js) {
+static bool SetName(Thread* thread, JSONStream* js) {
+  Isolate* isolate = thread->isolate();
   isolate->set_debugger_name(js->LookupParam("name"));
   if (Service::isolate_stream.enabled()) {
     ServiceEvent event(isolate, ServiceEvent::kIsolateUpdate);
     Service::HandleEvent(&event);
   }
   PrintSuccess(js);
   return true;
 }
 
 
 static const MethodParameter* set_vm_name_params[] = {
   new MethodParameter("name", true),
   NULL,
 };
 
 
-static bool SetVMName(Isolate* isolate, JSONStream* js) {
+static bool SetVMName(Thread* thread, JSONStream* js) {
   const char* name_param = js->LookupParam("name");
   free(vm_name);
   vm_name = strdup(name_param);
   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,
   new IdParameter("classId", true),
   new BoolParameter("enable", true),
   NULL,
 };
 
 
-static bool SetTraceClassAllocation(Isolate* isolate, JSONStream* js) {
+static bool SetTraceClassAllocation(Thread* thread, JSONStream* js) {
   const char* class_id = js->LookupParam("classId");
   const bool enable = BoolParameter::Parse(js->LookupParam("enable"));
   intptr_t cid = -1;
   GetPrefixedIntegerId(class_id, "classes/", &cid);
+  Isolate* isolate = thread->isolate();
   if (!IsValidClassId(isolate, cid)) {
     PrintInvalidParamError(js, "classId");
     return true;
   }
   const Class& cls = Class::Handle(GetClassForId(isolate, cid));
   ASSERT(!cls.IsNull());
   cls.SetTraceAllocation(enable);
   PrintSuccess(js);
   return true;
 }
@@ skipping 105 matching lines @@
     ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 
 }  // namespace dart