Remove some Isolate::current_zone() calls, as it gets the zone from mutator thread not the current …

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 1083 matching lines @@
         return true;
       }
     }
     return false;
   } else {
     return !(obj.IsInstance() || obj.IsNull());
   }
 }
 
 
-static RawObject* LookupObjectId(Isolate* isolate,
+static RawObject* LookupObjectId(Thread* thread,
                                  const char* arg,
                                  ObjectIdRing::LookupResult* kind) {
   *kind = ObjectIdRing::kValid;
   if (strncmp(arg, "int-", 4) == 0) {
     arg += 4;
     int64_t value = 0;
     if (!OS::StringToInt64(arg, &value) ||
         !Smi::IsValid(value)) {
       *kind = ObjectIdRing::kInvalid;
       return Object::null();
     }
-    const Integer& obj = Integer::Handle(isolate->current_zone(),
+    const Integer& obj = Integer::Handle(thread->zone(),
         Smi::New(static_cast<intptr_t>(value)));
     return obj.raw();
   } else if (strcmp(arg, "bool-true") == 0) {
     return Bool::True().raw();
   } else if (strcmp(arg, "bool-false") == 0) {
     return Bool::False().raw();
   } else if (strcmp(arg, "null") == 0) {
     return Object::null();
   }
 
-  ObjectIdRing* ring = isolate->object_id_ring();
+  ObjectIdRing* ring = thread->isolate()->object_id_ring();
   ASSERT(ring != NULL);
   intptr_t id = -1;
   if (!GetIntegerId(arg, &id)) {
     *kind = ObjectIdRing::kInvalid;
     return Object::null();
   }
   return ring->GetObjectForId(id, kind);
 }
 
 
@@ skipping 40 matching lines @@
       if (script_url.Equals(requested_url)) {
         return script.raw();
       }
     }
   }
 
   // Not found.
   return Object::sentinel().raw();
 }
 
-static RawObject* LookupHeapObjectClasses(Isolate* isolate,
+static RawObject* LookupHeapObjectClasses(Thread* thread,
                                           char** parts, int num_parts) {
   // Class ids look like: "classes/17"
   if (num_parts < 2) {
     return Object::sentinel().raw();
   }
+  Isolate* isolate = thread->isolate();
+  Zone* zone = thread->zone();
   ClassTable* table = isolate->class_table();
   intptr_t id;
   if (!GetIntegerId(parts[1], &id) ||
       !table->IsValidIndex(id)) {
     return Object::sentinel().raw();
   }
-  Class& cls = Class::Handle(table->At(id));
+  Class& cls = Class::Handle(zone, table->At(id));
   if (num_parts == 2) {
     return cls.raw();
   }
   if (strcmp(parts[2], "closures") == 0) {
     // Closure ids look like: "classes/17/closures/11"
     if (num_parts != 4) {
       return Object::sentinel().raw();
     }
     intptr_t id;
     if (!GetIntegerId(parts[3], &id)) {
       return Object::sentinel().raw();
     }
-    Function& func = Function::Handle();
+    Function& func = Function::Handle(zone);
     func ^= cls.ClosureFunctionFromIndex(id);
     if (func.IsNull()) {
       return Object::sentinel().raw();
     }
     return func.raw();
 
   } else if (strcmp(parts[2], "fields") == 0) {
     // Field ids look like: "classes/17/fields/11"
     if (num_parts != 4) {
       return Object::sentinel().raw();
     }
     intptr_t id;
     if (!GetIntegerId(parts[3], &id)) {
       return Object::sentinel().raw();
     }
-    Field& field = Field::Handle(cls.FieldFromIndex(id));
+    Field& field = Field::Handle(zone, cls.FieldFromIndex(id));
     if (field.IsNull()) {
       return Object::sentinel().raw();
     }
     return field.raw();
 
   } else if (strcmp(parts[2], "functions") == 0) {
     // Function ids look like: "classes/17/functions/11"
     if (num_parts != 4) {
       return Object::sentinel().raw();
     }
     const char* encoded_id = parts[3];
-    String& id = String::Handle(isolate->current_zone(),
-        String::New(encoded_id));
+    String& id = String::Handle(zone, String::New(encoded_id));
     id = String::DecodeIRI(id);
     if (id.IsNull()) {
       return Object::sentinel().raw();
     }
-    Function& func = Function::Handle(cls.LookupFunction(id));
+    Function& func = Function::Handle(zone, cls.LookupFunction(id));
     if (func.IsNull()) {
       return Object::sentinel().raw();
     }
     return func.raw();
 
   } else if (strcmp(parts[2], "implicit_closures") == 0) {
     // Function ids look like: "classes/17/implicit_closures/11"
     if (num_parts != 4) {
       return Object::sentinel().raw();
     }
     intptr_t id;
     if (!GetIntegerId(parts[3], &id)) {
       return Object::sentinel().raw();
     }
-    Function& func = Function::Handle();
+    Function& func = Function::Handle(zone);
     func ^= cls.ImplicitClosureFunctionFromIndex(id);
     if (func.IsNull()) {
       return Object::sentinel().raw();
     }
     return func.raw();
 
   } else if (strcmp(parts[2], "dispatchers") == 0) {
     // Dispatcher Function ids look like: "classes/17/dispatchers/11"
     if (num_parts != 4) {
       return Object::sentinel().raw();
     }
     intptr_t id;
     if (!GetIntegerId(parts[3], &id)) {
       return Object::sentinel().raw();
     }
-    Function& func = Function::Handle();
+    Function& func = Function::Handle(zone);
     func ^= cls.InvocationDispatcherFunctionFromIndex(id);
     if (func.IsNull()) {
       return Object::sentinel().raw();
     }
     return func.raw();
 
   } else if (strcmp(parts[2], "types") == 0) {
     // Type ids look like: "classes/17/types/11"
     if (num_parts != 4) {
       return Object::sentinel().raw();
     }
     intptr_t id;
     if (!GetIntegerId(parts[3], &id)) {
       return Object::sentinel().raw();
     }
-    Type& type = Type::Handle();
+    Type& type = Type::Handle(zone);
     type ^= cls.CanonicalTypeFromIndex(id);
     if (type.IsNull()) {
       return Object::sentinel().raw();
     }
     return type.raw();
   }
 
   // Not found.
   return Object::sentinel().raw();
 }
 
 
-static RawObject* LookupHeapObjectTypeArguments(Isolate* isolate,
-                                          char** parts, int num_parts) {
+static RawObject* LookupHeapObjectTypeArguments(Thread* thread,
+                                                char** parts, int num_parts) {
+  Isolate* isolate = thread->isolate();
   // TypeArguments ids look like: "typearguments/17"
   if (num_parts < 2) {
     return Object::sentinel().raw();
   }
   intptr_t id;
   if (!GetIntegerId(parts[1], &id)) {
     return Object::sentinel().raw();
   }
   ObjectStore* object_store = isolate->object_store();
-  const Array& table = Array::Handle(object_store->canonical_type_arguments());
+  const Array& table = Array::Handle(thread->zone(),
+                                     object_store->canonical_type_arguments());
   ASSERT(table.Length() > 0);
   const intptr_t table_size = table.Length() - 1;
   if ((id < 0) || (id >= table_size) || (table.At(id) == Object::null())) {
     return Object::sentinel().raw();
   }
   return table.At(id);
 }
 
 
 static RawObject* LookupHeapObjectCode(Isolate* isolate,
@@ skipping 63 matching lines @@
   MessageSnapshotReader reader(message->data(),
                                message->len(),
                                Thread::Current());
   return reader.ReadObject();
 }
 
 
 static RawObject* LookupHeapObject(Isolate* isolate,
                                    const char* id_original,
                                    ObjectIdRing::LookupResult* result) {
-  char* id = Thread::Current()->zone()->MakeCopyOfString(id_original);
+  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;
   }
 
   if (strcmp(parts[0], "objects") == 0) {
     // Object ids look like "objects/1123"
-    Object& obj = Object::Handle(isolate->current_zone());
+    Object& obj = Object::Handle(thread->zone());
     ObjectIdRing::LookupResult lookup_result;
-    obj = LookupObjectId(isolate, parts[1], &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(isolate, parts, num_parts);
+    return LookupHeapObjectClasses(thread, parts, num_parts);
   } else if (strcmp(parts[0], "typearguments") == 0) {
-    return LookupHeapObjectTypeArguments(isolate, parts, num_parts);
+    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);
   }
 
   // Not found.
   return Object::sentinel().raw();
 }
 
@@ skipping 313 matching lines @@
   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;
   }
-  const String& expr_str =
-      String::Handle(isolate->current_zone(), String::New(expr));
+  Zone* zone = Thread::Current()->zone();
+  const String& expr_str = String::Handle(zone, String::New(expr));
   ObjectIdRing::LookupResult lookup_result;
-  Object& obj = Object::Handle(LookupHeapObject(isolate, target_id,
-                                                &lookup_result));
+  Object& obj = Object::Handle(zone, 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;
   }
   if (obj.IsLibrary()) {
     const Library& lib = Library::Cast(obj);
-    const Object& result = Object::Handle(lib.Evaluate(expr_str,
-                                                       Array::empty_array(),
-                                                       Array::empty_array()));
+    const Object& result = Object::Handle(zone,
+        lib.Evaluate(expr_str, Array::empty_array(), Array::empty_array()));
     result.PrintJSON(js, true);
     return true;
   }
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
-    const Object& result = Object::Handle(cls.Evaluate(expr_str,
-                                                       Array::empty_array(),
-                                                       Array::empty_array()));
+    const Object& result = Object::Handle(zone,
+        cls.Evaluate(expr_str, Array::empty_array(), Array::empty_array()));
     result.PrintJSON(js, true);
     return true;
   }
   if ((obj.IsInstance() || obj.IsNull()) &&
       !ContainsNonInstance(obj)) {
     // We don't use Instance::Cast here because it doesn't allow null.
-    Instance& instance = Instance::Handle(isolate->current_zone());
+    Instance& instance = Instance::Handle(zone);
     instance ^= obj.raw();
     const Object& result =
-        Object::Handle(instance.Evaluate(expr_str,
-                                         Array::empty_array(),
-                                         Array::empty_array()));
+        Object::Handle(zone, instance.Evaluate(expr_str,
+                                               Array::empty_array(),
+                                               Array::empty_array()));
     result.PrintJSON(js, true);
     return true;
   }
   js->PrintError(kInvalidParams,
                  "%s: invalid 'targetId' parameter: "
                  "id '%s' does not correspond to a "
                  "library, class, or instance", js->method(), target_id);
   return true;
 }
 
@@ skipping 13 matching lines @@
     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();
   const char* expr = js->LookupParam("expression");
-  const String& expr_str = String::Handle(isolate->current_zone(),
-      String::New(expr));
+  const String& expr_str = String::Handle(zone, String::New(expr));
 
-  const Object& result = Object::Handle(frame->Evaluate(expr_str));
+  const Object& result = Object::Handle(zone, frame->Evaluate(expr_str));
   result.PrintJSON(js, true);
   return true;
 }
 
 
 class GetInstancesVisitor : public ObjectGraph::Visitor {
  public:
   GetInstancesVisitor(const Class& cls, const Array& storage)
       : cls_(cls), storage_(storage), count_(0) {}
 
@@ skipping 1454 matching lines @@
     ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 
 }  // namespace dart