Add Zone-based handle allocation interface and reduce use of Isolate-based interfaces.

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"
 #include "vm/json_stream.h"
 #include "vm/bitmap.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
 #include "vm/handles.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/method_recognizer.h"
 #include "vm/os.h"
 #include "vm/raw_object.h"
 #include "vm/report.h"
 #include "vm/scanner.h"
 #include "vm/tags.h"
+#include "vm/thread.h"
 #include "vm/verified_memory.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, use_jscre);
 
 // Forward declarations.
 #define DEFINE_FORWARD_DECLARATION(clazz)                                      \
   class clazz;
 CLASS_LIST(DEFINE_FORWARD_DECLARATION)
@@ skipping 18 matching lines @@
 #if defined(DEBUG)
 #define CHECK_HANDLE() CheckHandle();
 #else
 #define CHECK_HANDLE()
 #endif
 
 #define BASE_OBJECT_IMPLEMENTATION(object, super)                              \
  public:  /* NOLINT */                                                         \
   Raw##object* raw() const { return reinterpret_cast<Raw##object*>(raw_); }    \
   bool Is##object() const { return true; }                                     \
-  static object& Handle(Isolate* isolate, Raw##object* raw_ptr) {              \
+  static object& Handle(Zone* zone, Raw##object* raw_ptr) {                    \
     object* obj =                                                              \
-        reinterpret_cast<object*>(VMHandles::AllocateHandle(isolate));         \
+      reinterpret_cast<object*>(VMHandles::AllocateHandle(zone));              \
     initializeHandle(obj, raw_ptr);                                            \
     return *obj;                                                               \
   }                                                                            \
+  /* DEPRECATED: Use Zone version. */                                          \
+  static object& Handle(Isolate* isolate, Raw##object* raw_ptr) {              \
+    return Handle(isolate->current_zone(), raw_ptr);                           \
+  }                                                                            \
   static object& Handle() {                                                    \
-    return Handle(Isolate::Current(), object::null());                         \
+    return Handle(Thread::Current()->zone(), object::null());                  \
   }                                                                            \
+  static object& Handle(Zone* zone) {                                          \
+    return Handle(zone, object::null());                                       \
+  }                                                                            \
+  /* DEPRECATED: Use Zone version. */                                          \
   static object& Handle(Isolate* isolate) {                                    \
-    return Handle(isolate, object::null());                                    \
+    return Handle(isolate->current_zone(), object::null());                    \
   }                                                                            \
   static object& Handle(Raw##object* raw_ptr) {                                \
-    return Handle(Isolate::Current(), raw_ptr);                                \
+    return Handle(Thread::Current()->zone(), raw_ptr);                         \
   }                                                                            \
-  static object& CheckedHandle(Isolate* isolate, RawObject* raw_ptr) {         \
+  static object& CheckedHandle(Zone* zone, RawObject* raw_ptr) {               \
     object* obj =                                                              \
-        reinterpret_cast<object*>(VMHandles::AllocateHandle(isolate));         \
+        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(Isolate::Current(), raw_ptr);                         \
+    return CheckedHandle(Thread::Current()->zone(), raw_ptr);                  \
   }                                                                            \
-  static object& ZoneHandle(Isolate* isolate, Raw##object* raw_ptr) {          \
+  static object& ZoneHandle(Zone* zone, Raw##object* raw_ptr) {                \
     object* obj = reinterpret_cast<object*>(                                   \
-        VMHandles::AllocateZoneHandle(isolate));                               \
+        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, object::null());                                \
+    return ZoneHandle(isolate->current_zone(), object::null());                \
   }                                                                            \
   static object& ZoneHandle() {                                                \
-    return ZoneHandle(Isolate::Current(), object::null());                     \
+    return ZoneHandle(Thread::Current()->zone(), object::null());              \
   }                                                                            \
   static object& ZoneHandle(Raw##object* raw_ptr) {                            \
-    return ZoneHandle(Isolate::Current(), raw_ptr);                            \
+    return ZoneHandle(Thread::Current()->zone(), raw_ptr);                     \
   }                                                                            \
-  static object& CheckedZoneHandle(Isolate* isolate, RawObject* raw_ptr) {     \
+  static object& CheckedZoneHandle(Zone* zone, RawObject* raw_ptr) {           \
     object* obj = reinterpret_cast<object*>(                                   \
-        VMHandles::AllocateZoneHandle(isolate));                               \
+        VMHandles::AllocateZoneHandle(zone));                                  \
     initializeHandle(obj, raw_ptr);                                            \
     if (!obj->Is##object()) {                                                  \
       FATAL2("Handle check failed: saw %s expected %s",                        \
              obj->ToCString(), #object);                                       \
     }                                                                          \
     return *obj;                                                               \
   }                                                                            \
   static object& CheckedZoneHandle(RawObject* raw_ptr) {                       \
-    return CheckedZoneHandle(Isolate::Current(), raw_ptr);                     \
+    return CheckedZoneHandle(Thread::Current()->zone(), raw_ptr);              \
   }                                                                            \
   /* T::Cast cannot be applied to a null Object, because the object vtable */  \
   /* is not setup for type T, although some methods are supposed to work   */  \
   /* with null, for example Instance::Equals().                            */  \
   static const object& Cast(const Object& obj) {                               \
     ASSERT(obj.Is##object());                                                  \
     return reinterpret_cast<const object&>(obj);                               \
   }                                                                            \
   static Raw##object* RawCast(RawObject* raw) {                                \
     ASSERT(Object::Handle(raw).Is##object());                                  \
@@ skipping 181 matching lines @@
   void Print() const;
 
   bool IsZoneHandle() const {
     return VMHandles::IsZoneHandle(reinterpret_cast<uword>(this));
   }
 
   bool IsReadOnlyHandle() const;
 
   bool IsNotTemporaryScopedHandle() const;
 
-  static Object& Handle(Isolate* isolate, RawObject* raw_ptr) {
-    Object* obj = reinterpret_cast<Object*>(VMHandles::AllocateHandle(isolate));
+  static Object& Handle(Zone* zone, RawObject* raw_ptr) {
+    Object* obj = reinterpret_cast<Object*>(VMHandles::AllocateHandle(zone));
     initializeHandle(obj, raw_ptr);
     return *obj;
   }
+  // DEPRECATED: Use Zone version.
+  static Object& Handle(Isolate* isolate, RawObject* raw_ptr) {
+    return Handle(isolate->current_zone(), raw_ptr);
+  }
   static Object* ReadOnlyHandle() {
     Object* obj = reinterpret_cast<Object*>(
         Dart::AllocateReadOnlyHandle());
     initializeHandle(obj, Object::null());
     return obj;
   }
 
   static Object& Handle() {
     return Handle(Isolate::Current(), null_);
   }
 
+  static Object& Handle(Zone* zone) {
+    return Handle(zone, null_);
+  }
+  // DEPRECATED: Use Zone version.
   static Object& Handle(Isolate* isolate) {
-    return Handle(isolate, null_);
+    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) {
     Object* obj = reinterpret_cast<Object*>(
-        VMHandles::AllocateZoneHandle(isolate));
+        VMHandles::AllocateZoneHandle(isolate->current_zone()));
     initializeHandle(obj, raw_ptr);
     return *obj;
   }
 
   static Object& ZoneHandle() {
     return ZoneHandle(Isolate::Current(), null_);
   }
 
   static Object& ZoneHandle(RawObject* raw_ptr) {
     return ZoneHandle(Isolate::Current(), raw_ptr);
@@ skipping 437 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) {
-    PassiveObject* obj =
-        reinterpret_cast<PassiveObject*>(VMHandles::AllocateHandle(I));
+    PassiveObject* obj = reinterpret_cast<PassiveObject*>(
+        VMHandles::AllocateHandle(I->current_zone()));
     obj->raw_ = raw_ptr;
     obj->set_vtable(0);
     return *obj;
   }
   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(Isolate* I) {
     return Handle(I, Object::null());
   }
+  // DEPRECATED
+  // TODO(koda): Add Zone version.
   static PassiveObject& ZoneHandle(Isolate* I, RawObject* raw_ptr) {
     PassiveObject* obj = reinterpret_cast<PassiveObject*>(
-        VMHandles::AllocateZoneHandle(I));
+        VMHandles::AllocateZoneHandle(I->current_zone()));
     obj->raw_ = raw_ptr;
     obj->set_vtable(0);
     return *obj;
   }
   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(Isolate* I) {
     return ZoneHandle(I, Object::null());
   }
 
  private:
   PassiveObject() : Object() {}
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(PassiveObject);
 };
 
@@ skipping 6858 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_