Keep zone cached in SnapshotReader to allow removing ZoneHandle(Isolate*) interface.

runtime/lib/string.cc

 // Copyright (c) 2011, 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/bootstrap_natives.h"
 
 #include "include/dart_api.h"
 #include "vm/exceptions.h"
 #include "vm/dart_api_impl.h"
 #include "vm/isolate.h"
@@ skipping 44 matching lines @@
   intptr_t end = end_obj.Value();
   if ((end < start) || (end > length)) {
     Exceptions::ThrowArgumentError(end_obj);
   }
 
   // Unbox the array and determine the maximum element width.
   bool is_one_byte_string = true;
   intptr_t array_len = end - start;
   intptr_t utf16_len = array_len;
   int32_t* utf32_array = zone->Alloc<int32_t>(array_len);
-  Instance& index_object = Instance::Handle(isolate);
+  Instance& index_object = Instance::Handle(zone);
   for (intptr_t i = 0; i < array_len; i++) {
     index_object ^= a.At(start + i);
     if (!index_object.IsSmi()) {
       Exceptions::ThrowArgumentError(index_object);
     }
     intptr_t value = Smi::Cast(index_object).Value();
     if (Utf::IsOutOfRange(value)) {
       Exceptions::ThrowByType(Exceptions::kArgument, Object::empty_array());
       UNREACHABLE();
     }
@@ skipping 87 matching lines @@
 
 
 DEFINE_NATIVE_ENTRY(StringBase_joinReplaceAllResult, 4) {
   const String& base = String::CheckedHandle(arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(GrowableObjectArray,
                                matches_growable, arguments->NativeArgAt(1));
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, length_obj, arguments->NativeArgAt(2));
   GET_NON_NULL_NATIVE_ARGUMENT(Bool, is_onebyte_obj, arguments->NativeArgAt(3));
 
   intptr_t len = matches_growable.Length();
-  const Array& matches = Array::Handle(isolate, matches_growable.data());
+  const Array& matches = Array::Handle(zone, matches_growable.data());
 
   const intptr_t length = length_obj.Value();
   if (length < 0) {
     Exceptions::ThrowArgumentError(length_obj);
   }
 
   // Start out assuming result is one-byte if replacements are.
   bool is_onebyte = is_onebyte_obj.value();
   if (is_onebyte) {
     // If any of the base string slices are not one-byte, the result will be
     // a two-byte string.
     if (!base.IsOneByteString() && !base.IsExternalOneByteString()) {
       is_onebyte = CheckSlicesOneByte(base, matches, len);
     }
   }
 
   const intptr_t base_length = base.Length();
-  String& result = String::Handle(isolate);
+  String& result = String::Handle(zone);
   if (is_onebyte) {
     result ^= OneByteString::New(length, Heap::kNew);
   } else {
     result ^= TwoByteString::New(length, Heap::kNew);
   }
-  Instance& object = Instance::Handle(isolate);
+  Instance& object = Instance::Handle(zone);
   intptr_t write_index = 0;
   for (intptr_t i = 0; i < len; i++) {
     object ^= matches.At(i);
     if (object.IsSmi()) {
       intptr_t slice_start = Smi::Cast(object).Value();
       intptr_t slice_length = -1;
       // Slices with limited ranges are stored in a single negative Smi.
       if (slice_start < 0) {
         intptr_t bits = -slice_start;
         slice_start = bits >> kLengthSize;
@@ skipping 49 matching lines @@
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, end_obj, arguments->NativeArgAt(2));
 
   const intptr_t start = start_obj.Value();
   const intptr_t end = end_obj.Value();
   return OneByteString::New(receiver, start, end - start, Heap::kNew);
 }
 
 
 // This is high-performance code.
 DEFINE_NATIVE_ENTRY(OneByteString_splitWithCharCode, 2) {
-  const String& receiver = String::CheckedHandle(isolate,
+  const String& receiver = String::CheckedHandle(zone,
                                                  arguments->NativeArgAt(0));
   ASSERT(receiver.IsOneByteString());
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, smi_split_code, arguments->NativeArgAt(1));
   const intptr_t len = receiver.Length();
   const intptr_t split_code = smi_split_code.Value();
   const GrowableObjectArray& result = GrowableObjectArray::Handle(
-      isolate,
+      zone,
       GrowableObjectArray::New(16, Heap::kNew));
-  String& str = String::Handle(isolate);
+  String& str = String::Handle(zone);
   intptr_t start = 0;
   intptr_t i = 0;
   for (; i < len; i++) {
     if (split_code == OneByteString::CharAt(receiver, i)) {
       str = OneByteString::SubStringUnchecked(receiver,
                                               start,
                                               (i - start),
                                               Heap::kNew);
       result.Add(str);
       start = i + 1;
@@ skipping 153 matching lines @@
     }
     return TwoByteString::New(array, start * sizeof(uint16_t), length, space);
   } else if (RawObject::IsTypedDataViewClassId(list.GetClassId())) {
     const intptr_t cid = list.GetClassId();
     if (cid != kTypedDataUint16ArrayViewCid) {
       Exceptions::ThrowArgumentError(list);
     }
     if (end > Smi::Value(TypedDataView::Length(list))) {
       Exceptions::ThrowArgumentError(end_obj);
     }
-    const Instance& data_obj = Instance::Handle(isolate,
+    const Instance& data_obj = Instance::Handle(zone,
                                                 TypedDataView::Data(list));
     intptr_t data_offset = Smi::Value(TypedDataView::OffsetInBytes(list));
     if (data_obj.IsTypedData()) {
       const TypedData& array = TypedData::Cast(data_obj);
       return TwoByteString::New(array, data_offset + start * sizeof(uint16_t),
                                 length, space);
     } else if (data_obj.IsExternalTypedData()) {
       const ExternalTypedData& array = ExternalTypedData::Cast(data_obj);
       return TwoByteString::New(array, data_offset + start * sizeof(uint16_t),
                                 length, space);
     }
   } else if (list.IsArray()) {
     const Array& array = Array::Cast(list);
     if (end > array.Length()) {
       Exceptions::ThrowArgumentError(end_obj);
     }
-    const String& string = String::Handle(isolate,
+    const String& string = String::Handle(zone,
                                           TwoByteString::New(length, space));
     for (int i = 0; i < length; i++) {
       intptr_t value =
           Smi::Value(reinterpret_cast<RawSmi*>(array.At(start + i)));
       TwoByteString::SetCharAt(string, i, value);
     }
     return string.raw();
   } else if (list.IsGrowableObjectArray()) {
     const GrowableObjectArray& array = GrowableObjectArray::Cast(list);
     if (end > array.Length()) {
       Exceptions::ThrowArgumentError(end_obj);
     }
-    const String& string = String::Handle(isolate,
+    const String& string = String::Handle(zone,
                                           TwoByteString::New(length, space));
     for (int i = 0; i < length; i++) {
       intptr_t value =
           Smi::Value(reinterpret_cast<RawSmi*>(array.At(start + i)));
       TwoByteString::SetCharAt(string, i, value);
     }
     return string.raw();
   }
   UNREACHABLE();
   return Object::null();
@@ skipping 116 matching lines @@
       ? String::Handle(OneByteString::New(length_value, Heap::kNew))
       : String::Handle(TwoByteString::New(length_value, Heap::kNew));
   NoGCScope no_gc;
 
   uint16_t* data_position = reinterpret_cast<uint16_t*>(codeUnits.DataAddr(0));
   String::Copy(result, 0, data_position, length_value);
   return result.raw();
 }
 
 }  // namespace dart