Move reusable handles from isolate to thread.

runtime/vm/thread.h

 // Copyright (c) 2015, 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_THREAD_H_
 #define VM_THREAD_H_
 
 #include "vm/globals.h"
+#include "vm/handles.h"
 #include "vm/os_thread.h"
 #include "vm/store_buffer.h"
 #include "vm/runtime_entry_list.h"
 
 namespace dart {
 
+class AbstractType;
+class Array;
 class CHA;
+class Class;
+class Code;
+class Error;
+class ExceptionHandlers;
+class Field;
+class Function;
+class GrowableObjectArray;
 class HandleScope;
 class Heap;
+class Instance;
 class Isolate;
+class Library;
 class Log;
 class LongJumpScope;
 class Object;
+class PcDescriptors;
 class RawBool;
 class RawObject;
 class RawCode;
 class RawString;
 class RuntimeEntry;
 class StackResource;
+class String;
 class TimelineEventBlock;
+class TypeArguments;
+class TypeParameter;
 class Zone;
 
+#define REUSABLE_HANDLE_LIST(V)                                                \
+  V(AbstractType)                                                              \
+  V(Array)                                                                     \
+  V(Class)                                                                     \
+  V(Code)                                                                      \
+  V(Error)                                                                     \
+  V(ExceptionHandlers)                                                         \
+  V(Field)                                                                     \
+  V(Function)                                                                  \
+  V(GrowableObjectArray)                                                       \
+  V(Instance)                                                                  \
+  V(Library)                                                                   \
+  V(Object)                                                                    \
+  V(PcDescriptors)                                                             \
+  V(String)                                                                    \
+  V(TypeArguments)                                                             \
+  V(TypeParameter)                                                             \
+
+
 // List of VM-global objects/addresses cached in each Thread object.
 #define CACHED_VM_OBJECTS_LIST(V)                                              \
   V(RawObject*, object_null_, Object::null(), NULL)                            \
   V(RawBool*, bool_true_, Object::bool_true().raw(), NULL)                     \
   V(RawBool*, bool_false_, Object::bool_false().raw(), NULL)                   \
   V(RawCode*, update_store_buffer_code_,                                       \
     StubCode::UpdateStoreBuffer_entry()->code(), NULL)                         \
   V(RawCode*, fix_callers_target_code_,                                        \
     StubCode::FixCallersTarget_entry()->code(), NULL)                          \
   V(RawCode*, fix_allocation_stub_code_,                                       \
@@ skipping 254 matching lines @@
   ThreadId id() const {
     ASSERT(id_ != OSThread::kInvalidThreadId);
     return id_;
   }
 
   void SetThreadInterrupter(ThreadInterruptCallback callback, void* data);
 
   bool IsThreadInterrupterEnabled(ThreadInterruptCallback* callback,
                                   void** data) const;
 
+#if defined(DEBUG)
+#define REUSABLE_HANDLE_SCOPE_ACCESSORS(object)                                \
+  void set_reusable_##object##_handle_scope_active(bool value) {               \
+    reusable_##object##_handle_scope_active_ = value;                          \
+  }                                                                            \
+  bool reusable_##object##_handle_scope_active() const {                       \
+    return reusable_##object##_handle_scope_active_;                           \
+  }
+  REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_SCOPE_ACCESSORS)
+#undef REUSABLE_HANDLE_SCOPE_ACCESSORS
+
+bool IsAnyReusableHandleScopeActive() const {
+#define IS_REUSABLE_HANDLE_SCOPE_ACTIVE(object)                                \
+  if (reusable_##object##_handle_scope_active_) return true;
+  REUSABLE_HANDLE_LIST(IS_REUSABLE_HANDLE_SCOPE_ACTIVE)
+  return false;
+#undef IS_REUSABLE_HANDLE_SCOPE_ACTIVE
+}
+#endif  // defined(DEBUG)
+
+#define REUSABLE_HANDLE(object)                                                \
+  object& object##Handle() const {                                             \
+    return *object##_handle_;                                                  \
+  }
+  REUSABLE_HANDLE_LIST(REUSABLE_HANDLE)
+#undef REUSABLE_HANDLE
+
+  void VisitObjectPointers(ObjectPointerVisitor* visitor);
+
  private:
+  template<class T> T* AllocateReusableHandle();
+
   static ThreadLocalKey thread_key_;
 
   const ThreadId id_;
   ThreadInterruptCallback thread_interrupt_callback_;
   void* thread_interrupt_data_;
   Isolate* isolate_;
   Heap* heap_;
   State state_;
   Mutex timeline_block_lock_;
   StoreBufferBlock* store_buffer_block_;
   class Log* log_;
   uword vm_tag_;
 #define DECLARE_MEMBERS(type_name, member_name, expr, default_init_value)      \
   type_name member_name;
 CACHED_CONSTANTS_LIST(DECLARE_MEMBERS)
 #undef DECLARE_MEMBERS
 
 #define DECLARE_MEMBERS(name)      \
   uword name##_entry_point_;
 RUNTIME_ENTRY_LIST(DECLARE_MEMBERS)
 #undef DECLARE_MEMBERS
 
 #define DECLARE_MEMBERS(returntype, name, ...)      \
   uword name##_entry_point_;
 LEAF_RUNTIME_ENTRY_LIST(DECLARE_MEMBERS)
 #undef DECLARE_MEMBERS
 
+  // Reusable handles support.
+#define REUSABLE_HANDLE_FIELDS(object)                                         \
+  object* object##_handle_;
+  REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_FIELDS)
+#undef REUSABLE_HANDLE_FIELDS
+
+#if defined(DEBUG)
+#define REUSABLE_HANDLE_SCOPE_VARIABLE(object)                                 \
+  bool reusable_##object##_handle_scope_active_;
+  REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_SCOPE_VARIABLE);
+#undef REUSABLE_HANDLE_SCOPE_VARIABLE
+#endif  // defined(DEBUG)
+
+  VMHandles reusable_handles_;
+
   explicit Thread(bool init_vm_constants = true);
 
   void InitVMConstants();
 
   void ClearState() {
     memset(&state_, 0, sizeof(state_));
   }
 
   void StoreBufferRelease(
       StoreBuffer::ThresholdPolicy policy = StoreBuffer::kCheckThreshold);
   void StoreBufferAcquire();
 
   void set_zone(Zone* zone) {
     state_.zone = zone;
   }
 
   void set_top_exit_frame_info(uword top_exit_frame_info) {
     state_.top_exit_frame_info = top_exit_frame_info;
   }
 
   static void SetCurrent(Thread* current);
 
   void Schedule(Isolate* isolate, bool bypass_safepoint = false);
   void Unschedule(bool bypass_safepoint = false);
 
+#define REUSABLE_FRIEND_DECLARATION(name)                                      \
+  friend class Reusable##name##HandleScope;
+REUSABLE_HANDLE_LIST(REUSABLE_FRIEND_DECLARATION)
+#undef REUSABLE_FRIEND_DECLARATION
+
   friend class ApiZone;
   friend class Isolate;
   friend class StackZone;
   friend class ThreadRegistry;
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 }  // namespace dart
 
 #endif  // VM_THREAD_H_