Migrate most uses of Isolate::current_zone to Thread::zone.

runtime/vm/object.cc

 // Copyright (c) 2012, 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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 4150 matching lines @@
   return LibraryPrefix::null();
 }
 
 
 const char* Class::ToCString() const {
   const char* format = "%s Class: %s";
   const Library& lib = Library::Handle(library());
   const char* library_name = lib.IsNull() ? "" : lib.ToCString();
   const char* class_name = String::Handle(Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, library_name, class_name) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, library_name, class_name);
   return chars;
 }
 
 
 void Class::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   if ((raw() == Class::null()) || (id() == kFreeListElement)) {
     // TODO(turnidge): This is weird and needs to be changed.
     jsobj.AddProperty("type", "null");
@@ skipping 150 matching lines @@
   } else {
     return ident();
   }
 }
 
 
 const char* UnresolvedClass::ToCString() const {
   const char* format = "unresolved class '%s'";
   const char* cname =  String::Handle(Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, cname) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, cname);
   return chars;
 }
 
 
 void UnresolvedClass::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
@@ skipping 733 matching lines @@
 const char* TypeArguments::ToCString() const {
   if (IsNull()) {
     return "NULL TypeArguments";
   }
   const char* format = "%s [%s]";
   const char* prev_cstr = "TypeArguments:";
   for (int i = 0; i < Length(); i++) {
     const AbstractType& type_at = AbstractType::Handle(TypeAt(i));
     const char* type_cstr = type_at.IsNull() ? "null" : type_at.ToCString();
     intptr_t len = OS::SNPrint(NULL, 0, format, prev_cstr, type_cstr) + 1;
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+    char* chars = Thread::Current()->zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, prev_cstr, type_cstr);
     prev_cstr = chars;
   }
   return prev_cstr;
 }
 
 
 const char* PatchClass::ToCString() const {
   const char* kFormat = "PatchClass for %s";
   const Class& cls = Class::Handle(patched_class());
   const char* cls_name = cls.ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, cls_name) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, cls_name);
   return chars;
 }
 
 
 void PatchClass::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
@@ skipping 794 matching lines @@
       }
       ASSERT(library_name != NULL);
       lib_class_format = (library_name[0] == '\0') ? "%s%s_" : "%s_%s_";
     } else {
       library_name = "";
       lib_class_format = "%s%s.";
     }
     reserve_len +=
         OS::SNPrint(NULL, 0, lib_class_format, library_name, class_name);
     ASSERT(chars != NULL);
-    *chars = Isolate::Current()->current_zone()->Alloc<char>(reserve_len + 1);
+    *chars = Thread::Current()->zone()->Alloc<char>(reserve_len + 1);
     written = OS::SNPrint(
         *chars, reserve_len + 1, lib_class_format, library_name, class_name);
   } else {
     written = ConstructFunctionFullyQualifiedCString(parent,
                                                      chars,
                                                      reserve_len,
                                                      with_lib,
                                                      lib_kind);
   }
   ASSERT(*chars != NULL);
@@ skipping 984 matching lines @@
     case RawFunction::kIrregexpFunction:
       kind_str = "irregexp-function";
       break;
     default:
       UNREACHABLE();
   }
   const char* kFormat = "Function '%s':%s%s%s%s.";
   const char* function_name = String::Handle(name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name,
                              static_str, abstract_str, kind_str, const_str) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name,
               static_str, abstract_str, kind_str, const_str);
   return chars;
 }
 
 
 static void AddFunctionServiceId(const JSONObject& jsobj,
                                  const Function& f,
                                  const Class& cls) {
   // Special kinds of functions use indices in their respective lists.
@@ skipping 371 matching lines @@
   }
   const char* kF0 = is_static() ? " static" : "";
   const char* kF1 = is_final() ? " final" : "";
   const char* kF2 = is_const() ? " const" : "";
   const char* kFormat = "Field <%s.%s>:%s%s%s";
   const char* field_name = String::Handle(name()).ToCString();
   const Class& cls = Class::Handle(owner());
   const char* cls_name = String::Handle(cls.Name()).ToCString();
   intptr_t len =
       OS::SNPrint(NULL, 0, kFormat, cls_name, field_name, kF0, kF1, kF2) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, cls_name, field_name, kF0, kF1, kF2);
   return chars;
 }
 
 void Field::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   Class& cls = Class::Handle(owner());
   intptr_t id = cls.FindFieldIndex(*this);
   ASSERT(id >= 0);
   intptr_t cid = cls.id();
@@ skipping 189 matching lines @@
 
   const Class& cls = Class::Handle(
       Isolate::Current()->class_table()->At(guarded_cid()));
   const char* class_name = String::Handle(cls.Name()).ToCString();
 
   if (RawObject::IsBuiltinListClassId(guarded_cid()) &&
       !is_nullable() &&
       is_final()) {
     ASSERT(guarded_list_length() != kUnknownFixedLength);
     if (guarded_list_length() == kNoFixedLength) {
-      return Isolate::Current()->current_zone()->PrintToString(
+      return Thread::Current()->zone()->PrintToString(
           "<%s [*]>", class_name);
     } else {
-      return Isolate::Current()->current_zone()->PrintToString(
+      return Thread::Current()->zone()->PrintToString(
           "<%s [%" Pd " @%" Pd "]>",
           class_name,
           guarded_list_length(),
           guarded_list_length_in_object_offset());
     }
   }
 
-  return Isolate::Current()->current_zone()->PrintToString("<%s %s>",
+  return Thread::Current()->zone()->PrintToString("<%s %s>",
     is_nullable() ? "nullable" : "not-nullable",
     class_name);
 }
 
 
 void Field::InitializeGuardedListLengthInObjectOffset() const {
   if (needs_length_check() &&
       (guarded_list_length() != Field::kUnknownFixedLength)) {
     const intptr_t offset = GetListLengthOffset(guarded_cid());
     set_guarded_list_length_in_object_offset(offset);
@@ skipping 2451 matching lines @@
 
 RawLibrary* Library::TypedDataLibrary() {
   return Isolate::Current()->object_store()->typed_data_library();
 }
 
 
 const char* Library::ToCString() const {
   const char* kFormat = "Library:'%s'";
   const String& name = String::Handle(url());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, name.ToCString()) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, name.ToCString());
   return chars;
 }
 
 
 void Library::PrintJSONImpl(JSONStream* stream, bool ref) const {
   const char* library_name = String::Handle(name()).ToCString();
   intptr_t id = index();
   ASSERT(id >= 0);
   JSONObject jsobj(stream);
@@ skipping 393 matching lines @@
 
 void LibraryPrefix::set_importer(const Library& value) const {
   StorePointer(&raw_ptr()->importer_, value.raw());
 }
 
 
 const char* LibraryPrefix::ToCString() const {
   const char* kFormat = "LibraryPrefix:'%s'";
   const String& prefix = String::Handle(name());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, prefix.ToCString()) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, prefix.ToCString());
   return chars;
 }
 
 
 void LibraryPrefix::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
@@ skipping 35 matching lines @@
     }
   }
   return metadata.raw();
 }
 
 
 const char* Namespace::ToCString() const {
   const char* kFormat = "Namespace for library '%s'";
   const Library& lib = Library::Handle(library());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, lib.ToCString()) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, lib.ToCString());
   return chars;
 }
 
 
 void Namespace::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
@@ skipping 487 matching lines @@
     while (iter.MoveNext()) {
       len += OS::SNPrint(NULL, 0, kFormat, addr_width,
                          iter.PcOffset(),
                          KindAsStr(iter.Kind()),
                          iter.DeoptId(),
                          iter.TokenPos(),
                          iter.TryIndex());
     }
   }
   // Allocate the buffer.
-  char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* buffer = Thread::Current()->zone()->Alloc<char>(len);
   // Layout the fields in the buffer.
   intptr_t index = 0;
   Iterator iter(*this, RawPcDescriptors::kAnyKind);
   while (iter.MoveNext()) {
     index += OS::SNPrint((buffer + index), (len - index), kFormat, addr_width,
                          iter.PcOffset(),
                          KindAsStr(iter.Kind()),
                          iter.DeoptId(),
                          iter.TokenPos(),
                          iter.TryIndex());
@@ skipping 167 matching lines @@
   return result.raw();
 }
 
 
 const char* Stackmap::ToCString() const {
   if (IsNull()) {
     return "{null}";
   } else {
     const char* kFormat = "%#" Px ": ";
     intptr_t fixed_length = OS::SNPrint(NULL, 0, kFormat, PcOffset()) + 1;
-    Isolate* isolate = Isolate::Current();
+    Thread* thread = Thread::Current();
     // Guard against integer overflow in the computation of alloc_size.
     //
     // TODO(kmillikin): We could just truncate the string if someone
     // tries to print a 2 billion plus entry stackmap.
     if (Length() > (kIntptrMax - fixed_length)) {
       FATAL1("Length() is unexpectedly large (%" Pd ")", Length());
     }
     intptr_t alloc_size = fixed_length + Length();
-    char* chars = isolate->current_zone()->Alloc<char>(alloc_size);
+    char* chars = thread->zone()->Alloc<char>(alloc_size);
     intptr_t index = OS::SNPrint(chars, alloc_size, kFormat, PcOffset());
     for (intptr_t i = 0; i < Length(); i++) {
       chars[index++] = IsObject(i) ? '1' : '0';
     }
     chars[index] = '\0';
     return chars;
   }
 }
 
 
@@ skipping 94 matching lines @@
     return "LocalVarDescriptors(NULL)";
   }
   intptr_t len = 1;  // Trailing '\0'.
   String& var_name = String::Handle();
   for (intptr_t i = 0; i < Length(); i++) {
     RawLocalVarDescriptors::VarInfo info;
     var_name = GetName(i);
     GetInfo(i, &info);
     len += PrintVarInfo(NULL, 0, i, var_name, info);
   }
-  char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
+  char* buffer = Thread::Current()->zone()->Alloc<char>(len + 1);
   buffer[0] = '\0';
   intptr_t num_chars = 0;
   for (intptr_t i = 0; i < Length(); i++) {
     RawLocalVarDescriptors::VarInfo info;
     var_name = GetName(i);
     GetInfo(i, &info);
     num_chars += PrintVarInfo((buffer + num_chars),
                               (len - num_chars),
                               i, var_name, info);
   }
@@ skipping 222 matching lines @@
                        info.handler_pc_offset,
                        num_types,
                        info.outer_try_index);
     for (int k = 0; k < num_types; k++) {
       type ^= handled_types.At(k);
       ASSERT(!type.IsNull());
       len += OS::SNPrint(NULL, 0, kFormat2, k, type.ToCString());
     }
   }
   // Allocate the buffer.
-  char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* buffer = Thread::Current()->zone()->Alloc<char>(len);
   // Layout the fields in the buffer.
   intptr_t num_chars = 0;
   for (intptr_t i = 0; i < num_entries(); i++) {
     GetHandlerInfo(i, &info);
     handled_types = GetHandledTypes(i);
     const intptr_t num_types =
         handled_types.IsNull() ? 0 : handled_types.Length();
     num_chars += OS::SNPrint((buffer + num_chars),
                              (len - num_chars),
                              kFormat,
@@ skipping 88 matching lines @@
   GrowableArray<DeoptInstr*> deopt_instrs;
   Unpack(deopt_table, packed, &deopt_instrs);
 
   // Compute the buffer size required.
   intptr_t len = 1;  // Trailing '\0'.
   for (intptr_t i = 0; i < deopt_instrs.length(); i++) {
     len += OS::SNPrint(NULL, 0, "[%s]", deopt_instrs[i]->ToCString());
   }
 
   // Allocate the buffer.
-  char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* buffer = Thread::Current()->zone()->Alloc<char>(len);
 
   // Layout the fields in the buffer.
   intptr_t index = 0;
   for (intptr_t i = 0; i < deopt_instrs.length(); i++) {
     index += OS::SNPrint((buffer + index),
                          (len - index),
                          "[%s]",
                          deopt_instrs[i]->ToCString());
   }
 
@@ skipping 16 matching lines @@
 
 
 const char* ICData::ToCString() const {
   const char* kFormat = "ICData target:'%s' num-args: %" Pd
                         " num-checks: %" Pd "";
   const String& name = String::Handle(target_name());
   const intptr_t num_args = NumArgsTested();
   const intptr_t num_checks = NumberOfChecks();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, name.ToCString(),
       num_args, num_checks) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, name.ToCString(), num_args, num_checks);
   return chars;
 }
 
 
 void ICData::set_owner(const Function& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->owner_, value.raw());
 }
 
@@ skipping 1242 matching lines @@
       return iter.DeoptId();
     }
   }
   return Isolate::kNoDeoptId;
 }
 
 
 const char* Code::ToCString() const {
   const char* kFormat = "Code entry:%p";
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, EntryPoint()) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, EntryPoint());
   return chars;
 }
 
 
 RawString* Code::Name() const {
   const Object& obj = Object::Handle(owner());
   if (obj.IsNull()) {
     // Regular stub.
     const char* name = StubCode::NameOfStub(EntryPoint());
@@ skipping 298 matching lines @@
     result.set_num_variables(num_variables);
   }
   return result.raw();
 }
 
 
 const char* Context::ToCString() const {
   if (IsNull()) {
     return "Context (Null)";
   }
-  Zone* zone = Isolate::Current()->current_zone();
+  Zone* zone = Thread::Current()->zone();
   const Context& parent_ctx = Context::Handle(parent());
   if (parent_ctx.IsNull()) {
     return zone->PrintToString("Context@%p num_variables:% " Pd "",
                                this->raw(), num_variables());
   } else {
     const char* parent_str = parent_ctx.ToCString();
     return zone->PrintToString(
         "Context@%p num_variables:% " Pd " parent:{ %s }",
         this->raw(), num_variables(), parent_str);
   }
@@ skipping 180 matching lines @@
   const char* prev_cstr = "ContextScope:";
   String& name = String::Handle();
   for (int i = 0; i < num_variables(); i++) {
     name = NameAt(i);
     const char* cname = name.ToCString();
     intptr_t pos = TokenIndexAt(i);
     intptr_t idx = ContextIndexAt(i);
     intptr_t lvl = ContextLevelAt(i);
     intptr_t len =
         OS::SNPrint(NULL, 0, format, prev_cstr, cname, pos, lvl, idx) + 1;
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+    char* chars = Thread::Current()->zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, prev_cstr, cname, pos, lvl, idx);
     prev_cstr = chars;
   }
   return prev_cstr;
 }
 
 
 void ContextScope::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
@@ skipping 436 matching lines @@
   StorePointer(&raw_ptr()->exception_, exception.raw());
 }
 
 
 void UnhandledException::set_stacktrace(const Instance& stacktrace) const {
   StorePointer(&raw_ptr()->stacktrace_, stacktrace.raw());
 }
 
 
 const char* UnhandledException::ToErrorCString() const {
-  Isolate* isolate = Isolate::Current();
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
   HANDLESCOPE(isolate);
   Object& strtmp = Object::Handle();
   const char* exc_str;
   if (exception() == isolate->object_store()->out_of_memory()) {
     exc_str = "Out of Memory";
   } else if (exception() == isolate->object_store()->stack_overflow()) {
     exc_str = "Stack Overflow";
   } else {
     const Instance& exc = Instance::Handle(exception());
     strtmp = DartLibraryCalls::ToString(exc);
     if (!strtmp.IsError()) {
       exc_str = strtmp.ToCString();
     } else {
       exc_str = "<Received error while converting exception to string>";
     }
   }
   const Instance& stack = Instance::Handle(stacktrace());
   strtmp = DartLibraryCalls::ToString(stack);
   const char* stack_str =
       "<Received error while converting stack trace to string>";
   if (!strtmp.IsError()) {
     stack_str = strtmp.ToCString();
   }
   const char* format = "Unhandled exception:\n%s\n%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, exc_str, stack_str);
-  char* chars = isolate->current_zone()->Alloc<char>(len);
+  char* chars = thread->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, exc_str, stack_str);
   return chars;
 }
 
 
 const char* UnhandledException::ToCString() const {
   return "UnhandledException";
 }
 
 
@@ skipping 145 matching lines @@
       if (obj.IsInstance() && !obj.IsSmi() && !obj.IsCanonical()) {
         if (obj.IsNumber() || obj.IsString()) {
           obj = Instance::Cast(obj).CheckAndCanonicalize(NULL);
           ASSERT(!obj.IsNull());
           this->SetFieldAtOffset(field_offset, obj);
         } else {
           ASSERT(error_str != NULL);
           const char* kFormat = "field: %s\n";
           const intptr_t len =
               OS::SNPrint(NULL, 0, kFormat, obj.ToCString()) + 1;
-          char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+          char* chars = Thread::Current()->zone()->Alloc<char>(len);
           OS::SNPrint(chars, len, kFormat, obj.ToCString());
           *error_str = chars;
           return false;
         }
       }
     }
   } else {
 #if defined(DEBUG)
     // Make sure that we are not missing any fields.
     CheckForPointers has_pointers(Isolate::Current());
@@ skipping 313 matching lines @@
     TypeArguments& type_arguments = TypeArguments::Handle();
     const intptr_t num_type_arguments = cls.NumTypeArguments();
     if (num_type_arguments > 0) {
       type_arguments = GetTypeArguments();
     }
     const Type& type =
         Type::Handle(Type::New(cls, type_arguments, Scanner::kNoSourcePos));
     const String& type_name = String::Handle(type.UserVisibleName());
     // Calculate the size of the string.
     intptr_t len = OS::SNPrint(NULL, 0, kFormat, type_name.ToCString()) + 1;
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+    char* chars = Thread::Current()->zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, kFormat, type_name.ToCString());
     return chars;
   }
 }
 
 
 void Instance::PrintSharedInstanceJSON(JSONObject* jsobj,
                                        bool ref) const {
   AddCommonObjectProperties(jsobj, "Instance", ref);
   if (ref) {
@@ skipping 1129 matching lines @@
   if (HasResolvedTypeClass()) {
     class_name = String::Handle(
         Class::Handle(type_class()).Name()).ToCString();
   } else {
     class_name = UnresolvedClass::Handle(unresolved_class()).ToCString();
   }
   if (type_arguments.IsNull()) {
     const char* format = "%sType: class '%s'";
     const intptr_t len =
         OS::SNPrint(NULL, 0, format, unresolved, class_name) + 1;
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+    char* chars = Thread::Current()->zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, unresolved, class_name);
     return chars;
   } else if (IsResolved() && IsFinalized() && IsRecursive()) {
     const char* format = "Type: (@%" Px " H%" Px ") class '%s', args:[%s]";
     const intptr_t hash = Hash();
     const char* args_cstr = TypeArguments::Handle(arguments()).ToCString();
     const intptr_t len =
         OS::SNPrint(NULL, 0, format, raw(), hash, class_name, args_cstr) + 1;
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+    char* chars = Thread::Current()->zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, raw(), hash, class_name, args_cstr);
     return chars;
   } else {
     const char* format = "%sType: class '%s', args:[%s]";
     const char* args_cstr = TypeArguments::Handle(arguments()).ToCString();
     const intptr_t len =
         OS::SNPrint(NULL, 0, format, unresolved, class_name, args_cstr) + 1;
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+    char* chars = Thread::Current()->zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, unresolved, class_name, args_cstr);
     return chars;
   }
 }
 
 
 void Type::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "Type");
@@ skipping 164 matching lines @@
 
 const char* TypeRef::ToCString() const {
   const char* type_cstr = String::Handle(Class::Handle(
       type_class()).Name()).ToCString();
   AbstractType& ref_type = AbstractType::Handle(type());
   if (ref_type.IsFinalized()) {
     const char* format = "TypeRef: %s<...> (@%" Px " H%" Px ")";
     const intptr_t hash = ref_type.Hash();
     const intptr_t len =
         OS::SNPrint(NULL, 0, format, type_cstr, ref_type.raw(), hash) + 1;
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+    char* chars = Thread::Current()->zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, type_cstr, ref_type.raw(), hash);
     return chars;
   } else {
     const char* format = "TypeRef: %s<...>";
     const intptr_t len = OS::SNPrint(NULL, 0, format, type_cstr) + 1;
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+    char* chars = Thread::Current()->zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, type_cstr);
     return chars;
   }
 }
 
 
 void TypeRef::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "TypeRef");
@@ skipping 215 matching lines @@
   const char* format =
       "TypeParameter: name %s; index: %d; class: %s; bound: %s";
   const char* name_cstr = String::Handle(Name()).ToCString();
   const Class& cls = Class::Handle(parameterized_class());
   const char* cls_cstr =
       cls.IsNull() ? " null" : String::Handle(cls.Name()).ToCString();
   const AbstractType& upper_bound = AbstractType::Handle(bound());
   const char* bound_cstr = String::Handle(upper_bound.Name()).ToCString();
   intptr_t len = OS::SNPrint(
       NULL, 0, format, name_cstr, index(), cls_cstr, bound_cstr) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, name_cstr, index(), cls_cstr, bound_cstr);
   return chars;
 }
 
 
 void TypeParameter::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "TypeParameter");
   jsobj.AddServiceId(*this);
@@ skipping 194 matching lines @@
   const char* type_cstr = String::Handle(AbstractType::Handle(
       type()).Name()).ToCString();
   const char* bound_cstr = String::Handle(AbstractType::Handle(
       bound()).Name()).ToCString();
   const TypeParameter& type_param = TypeParameter::Handle(type_parameter());
   const char* type_param_cstr = String::Handle(type_param.name()).ToCString();
   const Class& cls = Class::Handle(type_param.parameterized_class());
   const char* cls_cstr = String::Handle(cls.Name()).ToCString();
   intptr_t len = OS::SNPrint(
       NULL, 0, format, type_cstr, bound_cstr, type_param_cstr, cls_cstr) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(
       chars, len, format, type_cstr, bound_cstr, type_param_cstr, cls_cstr);
   return chars;
 }
 
 
 void BoundedType::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "BoundedType");
@@ skipping 25 matching lines @@
 
 
 const char* MixinAppType::ToCString() const {
   const char* format = "MixinAppType: super type: %s; first mixin type: %s";
   const char* super_type_cstr = String::Handle(AbstractType::Handle(
       super_type()).Name()).ToCString();
   const char* first_mixin_type_cstr = String::Handle(AbstractType::Handle(
       MixinTypeAt(0)).Name()).ToCString();
   intptr_t len = OS::SNPrint(
       NULL, 0, format, super_type_cstr, first_mixin_type_cstr) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, super_type_cstr, first_mixin_type_cstr);
   return chars;
 }
 
 
 void MixinAppType::PrintJSONImpl(JSONStream* stream, bool ref) const {
   UNREACHABLE();
 }
 
 
@@ skipping 466 matching lines @@
   }
   UNREACHABLE();
   return 0;
 }
 
 
 const char* Smi::ToCString() const {
   const char* kFormat = "%ld";
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, Value()) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, Value());
   return chars;
 }
 
 
 void Smi::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "Int");
   jsobj.AddFixedServiceId("objects/int-%" Pd "", Value());
@@ skipping 110 matching lines @@
     return this->IsNegative() ? 1 : -1;
   }
   return this->IsNegative() ? -1 : 1;
 }
 
 
 const char* Mint::ToCString() const {
   const char* kFormat = "%lld";
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, value()) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, value());
   return chars;
 }
 
 
 void Mint::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Integer::PrintJSONImpl(stream, ref);
 }
 
 
@@ skipping 110 matching lines @@
 
 
 const char* Double::ToCString() const {
   if (isnan(value())) {
     return "NaN";
   }
   if (isinf(value())) {
     return value() < 0 ? "-Infinity" : "Infinity";
   }
   const int kBufferSize = 128;
-  char* buffer = Isolate::Current()->current_zone()->Alloc<char>(kBufferSize);
+  char* buffer = Thread::Current()->zone()->Alloc<char>(kBufferSize);
   buffer[kBufferSize - 1] = '\0';
   DoubleToCString(value(), buffer, kBufferSize);
   return buffer;
 }
 
 
 void Double::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "Double");
@@ skipping 728 matching lines @@
   chars[--pos] = '0';
   if (Neg()) {
     chars[--pos] = '-';
   }
   ASSERT(pos == 0);
   return chars;
 }
 
 
 static uword BigintAllocator(intptr_t size) {
-  Zone* zone = Isolate::Current()->current_zone();
+  Zone* zone = Thread::Current()->zone();
   return zone->AllocUnsafe(size);
 }
 
 
 const char* Bigint::ToCString() const {
   return ToDecCString(&BigintAllocator);
 }
 
 
 void Bigint::PrintJSONImpl(JSONStream* stream, bool ref) const {
@@ skipping 565 matching lines @@
 }
 
 
 static int32_t MergeHexCharacters(int32_t c1, int32_t c2) {
   return GetHexValue(c1) << 4 | GetHexValue(c2);
 }
 
 
 RawString* String::EncodeIRI(const String& str) {
   const intptr_t len = Utf8::Length(str);
-  Zone* zone = Isolate::Current()->current_zone();
+  Zone* zone = Thread::Current()->zone();
   uint8_t* utf8 = zone->Alloc<uint8_t>(len);
   str.ToUTF8(utf8, len);
   intptr_t num_escapes = 0;
   for (int i = 0; i < len; ++i) {
     uint8_t byte = utf8[i];
     if (!IsURISafeCharacter(byte)) {
       num_escapes += 2;
     }
   }
   const String& dststr = String::Handle(
@@ skipping 43 matching lines @@
         code_point = cpi.Current();
         if (!IsHexCharacter(code_point)) {
           return String::null();
         }
         num_escapes += 2;
       }
     }
   }
   intptr_t utf8_len = len - num_escapes;
   ASSERT(utf8_len >= 0);
-  Zone* zone = Isolate::Current()->current_zone();
+  Zone* zone = Thread::Current()->zone();
   uint8_t* utf8 = zone->Alloc<uint8_t>(utf8_len);
   {
     intptr_t index = 0;
     CodePointIterator cpi(str);
     while (cpi.Next()) {
       ASSERT(index < utf8_len);
       int32_t code_point = cpi.Current();
       if (IsPercent(code_point)) {
         cpi.Next();
         int32_t ch1 = cpi.Current();
@@ skipping 22 matching lines @@
   return result;
 }
 
 
 RawString* String::NewFormattedV(const char* format, va_list args) {
   va_list args_copy;
   va_copy(args_copy, args);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args_copy);
   va_end(args_copy);
 
-  Zone* zone = Isolate::Current()->current_zone();
+  Zone* zone = Thread::Current()->zone();
   char* buffer = zone->Alloc<char>(len + 1);
   OS::VSNPrint(buffer, (len + 1), format, args);
 
   return String::New(buffer);
 }
 
 
 RawString* String::Concat(const String& str1,
                           const String& str2,
                           Heap::Space space) {
@@ skipping 89 matching lines @@
 }
 
 
 const char* String::ToCString() const {
   if (IsOneByteString()) {
     // Quick conversion if OneByteString contains only ASCII characters.
     intptr_t len = Length();
     if (len == 0) {
       return "";
     }
-    Zone* zone = Isolate::Current()->current_zone();
+    Zone* zone = Thread::Current()->zone();
     uint8_t* result = zone->Alloc<uint8_t>(len + 1);
     NoSafepointScope no_safepoint;
     const uint8_t* original_str = OneByteString::CharAddr(*this, 0);
     for (intptr_t i = 0; i < len; i++) {
       if (original_str[i] <= Utf8::kMaxOneByteChar) {
         result[i] = original_str[i];
       } else {
         len = -1;
         break;
       }
     }
     if (len > 0) {
       result[len] = 0;
       return reinterpret_cast<const char*>(result);
     }
   }
   const intptr_t len = Utf8::Length(*this);
-  Zone* zone = Isolate::Current()->current_zone();
+  Zone* zone = Thread::Current()->zone();
   uint8_t* result = zone->Alloc<uint8_t>(len + 1);
   ToUTF8(result, len);
   result[len] = 0;
   return reinterpret_cast<const char*>(result);
 }
 
 
 void String::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   if (raw() == Symbols::OptimizedOut().raw()) {
@@ skipping 183 matching lines @@
   ASSERT(start <= end);
   ASSERT(end <= str.Length());
   intptr_t length = end - start;
   NoSafepointScope no_safepoint;
   const uint8_t* startChar;
   if (str.IsOneByteString()) {
     startChar = OneByteString::CharAddr(str, start);
   } else if (str.IsExternalOneByteString()) {
     startChar = ExternalOneByteString::CharAddr(str, start);
   } else {
-    uint8_t* chars = Isolate::Current()->current_zone()->Alloc<uint8_t>(length);
+    uint8_t* chars = Thread::Current()->zone()->Alloc<uint8_t>(length);
     const Scanner::CharAtFunc char_at = str.CharAtFunc();
     for (intptr_t i = 0; i < length; i++) {
       int32_t ch = char_at(str, start + i);
       if (ch < 128) {
         chars[i] = ch;
       } else {
         return false;  // Not ASCII, so definitely not valid double numeral.
       }
     }
     startChar = chars;
@@ skipping 804 matching lines @@
                                                    old_tags);
     tags = CompareAndSwapTags(old_tags, new_tags);
   } while (tags != old_tags);
 }
 
 
 const char* Array::ToCString() const {
   if (IsNull()) {
     return IsImmutable() ? "_ImmutableList NULL" : "_List NULL";
   }
-  Zone* zone = Isolate::Current()->current_zone();
+  Zone* zone = Thread::Current()->zone();
   const char* format = IsImmutable() ? "_ImmutableList len:%" Pd
                                      : "_List len:%" Pd;
   return zone->PrintToString(format, Length());
 }
 
 
 void Array::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "List");
@@ skipping 96 matching lines @@
     if (obj.IsInstance() && !obj.IsSmi() && !obj.IsCanonical()) {
       if (obj.IsNumber() || obj.IsString()) {
         obj = Instance::Cast(obj).CheckAndCanonicalize(NULL);
         ASSERT(!obj.IsNull());
         this->SetAt(i, obj);
       } else {
         ASSERT(error_str != NULL);
         const char* kFormat = "element at index %" Pd ": %s\n";
         const intptr_t len =
             OS::SNPrint(NULL, 0, kFormat, i, obj.ToCString()) + 1;
-        char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+        char* chars = Thread::Current()->zone()->Alloc<char>(len);
         OS::SNPrint(chars, len, kFormat, i, obj.ToCString());
         *error_str = chars;
         return false;
       }
     }
   }
   return true;
 }
 
 
@@ skipping 106 matching lines @@
   return result.raw();
 }
 
 
 const char* GrowableObjectArray::ToCString() const {
   if (IsNull()) {
     return "_GrowableList NULL";
   }
   const char* format = "Instance(length:%" Pd ") of '_GrowableList'";
   intptr_t len = OS::SNPrint(NULL, 0, format, Length()) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, Length());
   return chars;
 }
 
 
 void GrowableObjectArray::PrintJSONImpl(JSONStream* stream,
                                         bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "List");
@@ skipping 87 matching lines @@
                                       LinkedHashMap::InstanceSize(),
                                       space);
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   return result.raw();
 }
 
 
 const char* LinkedHashMap::ToCString() const {
-  Zone* zone = Isolate::Current()->current_zone();
+  Zone* zone = Thread::Current()->zone();
   return zone->PrintToString("_LinkedHashMap len:%" Pd, Length());
 }
 
 
 void LinkedHashMap::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "Map");
   jsobj.AddServiceId(*this);
   jsobj.AddProperty("length", Length());
@@ skipping 102 matching lines @@
 
 
 const char* Float32x4::ToCString() const {
   const char* kFormat = "[%f, %f, %f, %f]";
   float _x = x();
   float _y = y();
   float _z = z();
   float _w = w();
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, _x, _y, _z, _w) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, _x, _y, _z, _w);
   return chars;
 }
 
 
 void Float32x4::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
@@ skipping 84 matching lines @@
 
 
 const char* Int32x4::ToCString() const {
   const char* kFormat = "[%08x, %08x, %08x, %08x]";
   int32_t _x = x();
   int32_t _y = y();
   int32_t _z = z();
   int32_t _w = w();
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, _x, _y, _z, _w) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, _x, _y, _z, _w);
   return chars;
 }
 
 
 void Int32x4::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
@@ skipping 59 matching lines @@
   StoreSimd128(&raw_ptr()->value_[0], value);
 }
 
 
 const char* Float64x2::ToCString() const {
   const char* kFormat = "[%f, %f]";
   double _x = x();
   double _y = y();
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, _x, _y) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, _x, _y);
   return chars;
 }
 
 
 void Float64x2::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
@@ skipping 249 matching lines @@
 
 
 const char* Closure::ToCString(const Instance& closure) {
   const Function& fun = Function::Handle(Closure::function(closure));
   const bool is_implicit_closure = fun.IsImplicitClosureFunction();
   const char* fun_sig = String::Handle(fun.UserVisibleSignature()).ToCString();
   const char* from = is_implicit_closure ? " from " : "";
   const char* fun_desc = is_implicit_closure ? fun.ToCString() : "";
   const char* format = "Closure: %s%s%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, fun_sig, from, fun_desc) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, fun_sig, from, fun_desc);
   return chars;
 }
 
 
 RawInstance* Closure::New(const Function& function,
                           const Context& context,
                           Heap::Space space) {
   const Class& cls = Class::Handle(function.signature_class());
   ASSERT(cls.instance_size() == Closure::InstanceSize());
@@ skipping 95 matching lines @@
   const String& trace = String::Handle(FullStacktrace());
   return trace.ToCString();
 }
 
 
 void Stacktrace::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
-static intptr_t PrintOneStacktrace(Isolate* isolate,
+static intptr_t PrintOneStacktrace(Zone* zone,
                                    GrowableArray<char*>* frame_strings,
                                    uword pc,
                                    const Function& function,
                                    const Code& code,
                                    intptr_t frame_index) {
   const char* kFormatWithCol = "#%-6d %s (%s:%d:%d)\n";
   const char* kFormatNoCol = "#%-6d %s (%s:%d)\n";
   const char* kFormatNoLine = "#%-6d %s (%s)\n";
   const intptr_t token_pos = code.GetTokenIndexOfPC(pc);
-  const Script& script = Script::Handle(isolate, function.script());
+  const Script& script = Script::Handle(zone, function.script());
   const String& function_name =
-      String::Handle(isolate, function.QualifiedUserVisibleName());
-  const String& url = String::Handle(isolate, script.url());
+      String::Handle(zone, function.QualifiedUserVisibleName());
+  const String& url = String::Handle(zone, script.url());
   intptr_t line = -1;
   intptr_t column = -1;
   if (token_pos > 0) {
     if (script.HasSource()) {
       script.GetTokenLocation(token_pos, &line, &column);
     } else {
       script.GetTokenLocation(token_pos, &line, NULL);
     }
   }
   intptr_t len = 0;
   char* chars = NULL;
   if (column >= 0) {
     len = OS::SNPrint(NULL, 0, kFormatWithCol,
                       frame_index, function_name.ToCString(),
                       url.ToCString(), line, column);
-    chars = isolate->current_zone()->Alloc<char>(len + 1);
+    chars = zone->Alloc<char>(len + 1);
     OS::SNPrint(chars, (len + 1), kFormatWithCol,
                 frame_index,
                 function_name.ToCString(),
                 url.ToCString(), line, column);
   } else if (line >= 0) {
     len = OS::SNPrint(NULL, 0, kFormatNoCol,
                       frame_index, function_name.ToCString(),
                       url.ToCString(), line);
-    chars = isolate->current_zone()->Alloc<char>(len + 1);
+    chars = zone->Alloc<char>(len + 1);
     OS::SNPrint(chars, (len + 1), kFormatNoCol,
                 frame_index, function_name.ToCString(),
                 url.ToCString(), line);
   } else {
     len = OS::SNPrint(NULL, 0, kFormatNoLine,
                       frame_index, function_name.ToCString(),
                       url.ToCString());
-    chars = isolate->current_zone()->Alloc<char>(len + 1);
+    chars = zone->Alloc<char>(len + 1);
     OS::SNPrint(chars, (len + 1), kFormatNoLine,
                 frame_index, function_name.ToCString(),
                 url.ToCString());
   }
   frame_strings->Add(chars);
   return len;
 }
 
 
 const char* Stacktrace::ToCStringInternal(intptr_t* frame_index,
                                           intptr_t max_frames) const {
-  Isolate* isolate = Isolate::Current();
+  Zone* zone = Thread::Current()->zone();
   Function& function = Function::Handle();
   Code& code = Code::Handle();
   // Iterate through the stack frames and create C string description
   // for each frame.
   intptr_t total_len = 0;
   GrowableArray<char*> frame_strings;
   for (intptr_t i = 0; (i < Length()) && (*frame_index < max_frames); i++) {
     function = FunctionAtFrame(i);
     if (function.IsNull()) {
       // Check if null function object indicates a stack trace overflow.
       if ((i < (Length() - 1)) &&
           (FunctionAtFrame(i + 1) != Function::null())) {
         const char* kTruncated = "...\n...\n";
         intptr_t truncated_len = strlen(kTruncated) + 1;
-        char* chars = isolate->current_zone()->Alloc<char>(truncated_len);
+        char* chars = zone->Alloc<char>(truncated_len);
         OS::SNPrint(chars, truncated_len, "%s", kTruncated);
         frame_strings.Add(chars);
         total_len += truncated_len;
       }
     } else if (function.is_visible() || FLAG_show_invisible_frames) {
       code = CodeAtFrame(i);
       ASSERT(function.raw() == code.function());
       uword pc = code.EntryPoint() + Smi::Value(PcOffsetAtFrame(i));
       if (code.is_optimized() && expand_inlined()) {
         // Traverse inlined frames.
         for (InlinedFunctionsIterator it(code, pc);
              !it.Done() && (*frame_index < max_frames); it.Advance()) {
           function = it.function();
           if (function.is_visible() || FLAG_show_invisible_frames) {
             code = it.code();
             ASSERT(function.raw() == code.function());
             uword pc = it.pc();
             ASSERT(pc != 0);
             ASSERT(code.EntryPoint() <= pc);
             ASSERT(pc < (code.EntryPoint() + code.Size()));
             total_len += PrintOneStacktrace(
-                isolate, &frame_strings, pc, function, code, *frame_index);
+                zone, &frame_strings, pc, function, code, *frame_index);
             (*frame_index)++;  // To account for inlined frames.
           }
         }
       } else {
         total_len += PrintOneStacktrace(
-            isolate, &frame_strings, pc, function, code, *frame_index);
+            zone, &frame_strings, pc, function, code, *frame_index);
         (*frame_index)++;
       }
     }
   }
 
   // Now concatenate the frame descriptions into a single C string.
-  char* chars = isolate->current_zone()->Alloc<char>(total_len + 1);
+  char* chars = zone->Alloc<char>(total_len + 1);
   intptr_t index = 0;
   for (intptr_t i = 0; i < frame_strings.length(); i++) {
     index += OS::SNPrint((chars + index),
                          (total_len + 1 - index),
                          "%s",
                          frame_strings[i]);
   }
   chars[total_len] = '\0';
   return chars;
 }
@@ skipping 82 matching lines @@
     return false;
   }
   return true;
 }
 
 
 const char* JSRegExp::ToCString() const {
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
+  char* chars = Thread::Current()->zone()->Alloc<char>(len + 1);
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 
 void JSRegExp::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintSharedInstanceJSON(&jsobj, ref);
   jsobj.AddProperty("kind", "RegExp");
   jsobj.AddServiceId(*this);
@@ skipping 244 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart