Get rid of deprecated methods accessing mutator_thread_ instead of current thread

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 1501 matching lines @@
       if (bpt_id < isolate->debugger()->limitBreakpointId()) {
         *result = ObjectIdRing::kCollected;
         return NULL;
       }
     }
   }
   return NULL;
 }
 
 
-static bool PrintInboundReferences(Isolate* isolate,
+static bool PrintInboundReferences(Thread* thread,
                                    Object* target,
                                    intptr_t limit,
                                    JSONStream* js) {
-  ObjectGraph graph(isolate);
+  ObjectGraph graph(thread);
   Array& path = Array::Handle(Array::New(limit * 2));
   intptr_t length = graph.InboundReferences(target, path);
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "InboundReferences");
   {
     JSONArray elements(&jsobj, "references");
     Object& source = Object::Handle();
     Smi& slot_offset = Smi::Handle();
     Class& source_class = Class::Handle();
     Field& field = Field::Handle();
@@ skipping 67 matching lines @@
   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 PrintInboundReferences(isolate, &obj, limit, js);
+  return PrintInboundReferences(thread, &obj, limit, js);
 }
 
 
-static bool PrintRetainingPath(Isolate* isolate,
+static bool PrintRetainingPath(Thread* thread,
                                Object* obj,
                                intptr_t limit,
                                JSONStream* js) {
-  ObjectGraph graph(isolate);
+  ObjectGraph graph(thread);
   Array& path = Array::Handle(Array::New(limit * 2));
   intptr_t length = graph.RetainingPath(obj, path);
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "RetainingPath");
   jsobj.AddProperty("length", length);
   JSONArray elements(&jsobj, "elements");
   Object& element = Object::Handle();
   Smi& slot_offset = Smi::Handle();
   Class& element_class = Class::Handle();
   Array& element_field_map = Array::Handle();
@@ skipping 73 matching lines @@
   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(isolate, &obj, limit, js);
+  return PrintRetainingPath(thread, &obj, limit, js);
 }
 
 
 static const MethodParameter* get_retained_size_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
 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) {
       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(isolate);
+    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(isolate);
+  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,
@@ skipping 154 matching lines @@
   const Object& obj =
       Object::Handle(LookupHeapObject(isolate, 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(isolate);
+  ObjectGraph graph(Thread::Current());
   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 694 matching lines @@
   // 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) {
   uint8_t* buffer = NULL;
   WriteStream stream(&buffer, &allocator, 1 * MB);
-  ObjectGraph graph(isolate);
+  ObjectGraph graph(Thread::Current());
   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;
     {
@@ skipping 669 matching lines @@
     ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 
 }  // namespace dart