Thread/Isolate refactoring: new(Isolate) -> new(Zone)

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 356 matching lines @@
   }
   // DEPRECATED: Use Zone version.
   static Object& Handle(Isolate* isolate) {
     return Handle(isolate->current_zone(), null_);
   }
 
   static Object& Handle(RawObject* raw_ptr) {
     return Handle(Isolate::Current(), raw_ptr);
   }
 
-  static Object& ZoneHandle(Isolate* isolate, RawObject* raw_ptr) {
+  static Object& ZoneHandle(Zone* zone, RawObject* raw_ptr) {
     Object* obj = reinterpret_cast<Object*>(
-        VMHandles::AllocateZoneHandle(isolate->current_zone()));
+        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_);
   }
 
   static Object& ZoneHandle(RawObject* raw_ptr) {
     return ZoneHandle(Isolate::Current(), raw_ptr);
   }
 
   static RawObject* null() { return null_; }
@@ skipping 433 matching lines @@
 
 
 class PassiveObject : public Object {
  public:
   void operator=(RawObject* value) {
     raw_ = value;
   }
   void operator^=(RawObject* value) {
     raw_ = value;
   }
-  static PassiveObject& Handle(Isolate* I, RawObject* raw_ptr) {
+
+  static PassiveObject& Handle(Zone* zone, RawObject* raw_ptr) {
     PassiveObject* obj = reinterpret_cast<PassiveObject*>(
-        VMHandles::AllocateHandle(I->current_zone()));
+        VMHandles::AllocateHandle(zone));
     obj->raw_ = raw_ptr;
     obj->set_vtable(0);
     return *obj;
   }
+  // DEPRECATED - use Zone version.
+  static PassiveObject& Handle(Isolate* I, RawObject* raw_ptr) {
+    return Handle(I->current_zone(), raw_ptr);
+  }
   static PassiveObject& Handle(RawObject* raw_ptr) {
     return Handle(Isolate::Current(), raw_ptr);
   }
   static PassiveObject& Handle() {
     return Handle(Isolate::Current(), Object::null());
   }
-  // DEPRECATED
-  // TODO(koda): Add Zone version.
+  static PassiveObject& Handle(Zone* zone) {
+    return Handle(zone, Object::null());
+  }
+  // DEPRECATED - use Zone version.
   static PassiveObject& Handle(Isolate* I) {
     return Handle(I, Object::null());
   }
-  // DEPRECATED
-  // TODO(koda): Add Zone version.
-  static PassiveObject& ZoneHandle(Isolate* I, RawObject* raw_ptr) {
+  static PassiveObject& ZoneHandle(Zone* zone, RawObject* raw_ptr) {
     PassiveObject* obj = reinterpret_cast<PassiveObject*>(
-        VMHandles::AllocateZoneHandle(I->current_zone()));
+        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);
   }
   static PassiveObject& ZoneHandle() {
     return ZoneHandle(Isolate::Current(), Object::null());
   }
-  // DEPRECATED
-  // TODO(koda): Add Zone version.
+  static PassiveObject& ZoneHandle(Zone* zone) {
+    return ZoneHandle(zone, Object::null());
+  }
+  // DEPRECATED - use Zone version.
   static PassiveObject& ZoneHandle(Isolate* I) {
-    return ZoneHandle(I, Object::null());
+    return ZoneHandle(I->current_zone(), Object::null());
   }
 
  private:
   PassiveObject() : Object() {}
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(PassiveObject);
 };
 
 
 class Class : public Object {
@@ skipping 6942 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_