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

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 75 matching lines @@
   static object& CheckedHandle(Zone* zone, RawObject* raw_ptr) {               \
     object* obj =                                                              \
         reinterpret_cast<object*>(VMHandles::AllocateHandle(zone));            \
     initializeHandle(obj, raw_ptr);                                            \
     if (!obj->Is##object()) {                                                  \
       FATAL2("Handle check failed: saw %s expected %s",                        \
              obj->ToCString(), #object);                                       \
     }                                                                          \
     return *obj;                                                               \
   }                                                                            \
-  /* DEPRECATED: Use Zone version. */                                          \
-  static object& CheckedHandle(Isolate* isolate, RawObject* raw_ptr) {         \
-    return CheckedHandle(isolate->current_zone(), raw_ptr);                    \
-  }                                                                            \
   static object& CheckedHandle(RawObject* raw_ptr) {                           \
     return CheckedHandle(Thread::Current()->zone(), raw_ptr);                  \
   }                                                                            \
   static object& ZoneHandle(Zone* zone, Raw##object* raw_ptr) {                \
     object* obj = reinterpret_cast<object*>(                                   \
         VMHandles::AllocateZoneHandle(zone));                                  \
     initializeHandle(obj, raw_ptr);                                            \
     return *obj;                                                               \
   }                                                                            \
-  /* DEPRECATED: Use Zone version. */                                          \
-  static object& ZoneHandle(Isolate* isolate, Raw##object* raw_ptr) {          \
-    return ZoneHandle(isolate->current_zone(), raw_ptr);                       \
-  }                                                                            \
   static object* ReadOnlyHandle() {                                            \
     object* obj = reinterpret_cast<object*>(                                   \
         Dart::AllocateReadOnlyHandle());                                       \
     initializeHandle(obj, object::null());                                     \
     return obj;                                                                \
   }                                                                            \
   static object& ZoneHandle(Zone* zone) {                                      \
     return ZoneHandle(zone, object::null());                                   \
   }                                                                            \
-  /* DEPRECATED: Use Zone version. */                                          \
-  static object& ZoneHandle(Isolate* isolate) {                                \
-    return ZoneHandle(isolate->current_zone(), object::null());                \
-  }                                                                            \
   static object& ZoneHandle() {                                                \
     return ZoneHandle(Thread::Current()->zone(), object::null());              \
   }                                                                            \
   static object& ZoneHandle(Raw##object* raw_ptr) {                            \
     return ZoneHandle(Thread::Current()->zone(), raw_ptr);                     \
   }                                                                            \
   static object& CheckedZoneHandle(Zone* zone, RawObject* raw_ptr) {           \
     object* obj = reinterpret_cast<object*>(                                   \
         VMHandles::AllocateZoneHandle(zone));                                  \
     initializeHandle(obj, raw_ptr);                                            \
@@ skipping 237 matching lines @@
   static Object& Handle(RawObject* raw_ptr) {
     return Handle(Isolate::Current(), raw_ptr);
   }
 
   static Object& ZoneHandle(Zone* zone, RawObject* raw_ptr) {
     Object* obj = reinterpret_cast<Object*>(
         VMHandles::AllocateZoneHandle(zone));
     initializeHandle(obj, raw_ptr);
     return *obj;
   }
-  // DEPRECATED: Use Zone version.
-  static Object& ZoneHandle(Isolate* isolate, RawObject* raw_ptr) {
-    return ZoneHandle(isolate->current_zone(), raw_ptr);
-  }
 
   static Object& ZoneHandle() {
-    return ZoneHandle(Isolate::Current(), null_);
+    return ZoneHandle(Thread::Current()->zone(), null_);
   }
 
   static Object& ZoneHandle(RawObject* raw_ptr) {
-    return ZoneHandle(Isolate::Current(), raw_ptr);
+    return ZoneHandle(Thread::Current()->zone(), raw_ptr);
   }
 
   static RawObject* null() { return null_; }
 
   static const Object& null_object() {
     ASSERT(null_object_ != NULL);
     return *null_object_;
   }
   static const Array& null_array() {
     ASSERT(null_array_ != NULL);
@@ skipping 458 matching lines @@
   static PassiveObject& Handle(Isolate* I) {
     return Handle(I, Object::null());
   }
   static PassiveObject& ZoneHandle(Zone* zone, RawObject* raw_ptr) {
     PassiveObject* obj = reinterpret_cast<PassiveObject*>(
         VMHandles::AllocateZoneHandle(zone));
     obj->raw_ = raw_ptr;
     obj->set_vtable(0);
     return *obj;
   }
-  // DEPRECATED - use Zone version.
-  static PassiveObject& ZoneHandle(Isolate* I, RawObject* raw_ptr) {
-    return ZoneHandle(I->current_zone(), raw_ptr);
-  }
   static PassiveObject& ZoneHandle(RawObject* raw_ptr) {
-    return ZoneHandle(Isolate::Current(), raw_ptr);
+    return ZoneHandle(Thread::Current()->zone(), raw_ptr);
   }
   static PassiveObject& ZoneHandle() {
-    return ZoneHandle(Isolate::Current(), Object::null());
+    return ZoneHandle(Thread::Current()->zone(), Object::null());
   }
   static PassiveObject& ZoneHandle(Zone* zone) {
     return ZoneHandle(zone, Object::null());
   }
-  // DEPRECATED - use Zone version.
-  static PassiveObject& ZoneHandle(Isolate* I) {
-    return ZoneHandle(I->current_zone(), Object::null());
-  }
 
  private:
   PassiveObject() : Object() {}
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(PassiveObject);
 };
 
 
 class Class : public Object {
  public:
@@ skipping 6961 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_