1. Restructure reusable handles to make individual Scopes for each handle type

runtime/vm/isolate.h

 // Copyright (c) 2013, 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_ISOLATE_H_
 #define VM_ISOLATE_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/thread.h"
@@ skipping 46 matching lines @@
 class Simulator;
 class StackResource;
 class StackZone;
 class StubCode;
 class TypeArguments;
 class TypeParameter;
 class ObjectHistogram;
 class ObjectIdRing;
 
 
-#define REUSABLE_HANDLE_LIST(V)                                                \
-  V(Object)                                                                    \
-  V(Array)                                                                     \
-  V(String)                                                                    \
-  V(Instance)                                                                  \
-  V(Function)                                                                  \
-  V(Field)                                                                     \
-  V(Class)                                                                     \
-  V(TypeParameter)                                                             \
-  V(TypeArguments)                                                             \
-
-
 class IsolateVisitor {
  public:
   IsolateVisitor() {}
   virtual ~IsolateVisitor() {}
 
   virtual void VisitIsolate(Isolate* isolate) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IsolateVisitor);
 };
 
+#define REUSABLE_HANDLE_LIST(V)                                                \
+  V(Object)                                                                    \
+  V(Array)                                                                     \
+  V(String)                                                                    \
+  V(Instance)                                                                  \
+  V(Function)                                                                  \
+  V(Field)                                                                     \
+  V(Class)                                                                     \
+  V(TypeParameter)                                                             \
+  V(TypeArguments)                                                             \
 
 class Isolate : public BaseIsolate {
  public:
   ~Isolate();
 
   static inline Isolate* Current() {
     return reinterpret_cast<Isolate*>(Thread::GetThreadLocal(isolate_key));
   }
 
   static void SetCurrent(Isolate* isolate);
@@ skipping 332 matching lines @@
 
   void set_thread_state(InterruptableThreadState* state) {
     ASSERT((thread_state_ == NULL) || (state == NULL));
     thread_state_ = state;
   }
 
   InterruptableThreadState* thread_state() const {
     return thread_state_;
   }
 
+#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
+#endif  // defined(DEBUG)
+
+#define REUSABLE_HANDLE(object)                                                \
+  object& object##Handle() const {                                             \
+    return *object##_handle_;                                                  \
+  }
+  REUSABLE_HANDLE_LIST(REUSABLE_HANDLE)
+#undef REUSABLE_HANDLE
+
   static void VisitIsolates(IsolateVisitor* visitor);
 
  private:
   Isolate();
 
   void BuildName(const char* name_prefix);
   void PrintInvokedFunctions();
 
   template<class T> T* AllocateReusableHandle();
 
@@ skipping 46 matching lines @@
 
   IsolateProfilerData* profiler_data_;
   Mutex profiler_data_mutex_;
   InterruptableThreadState* thread_state_;
 
   // Isolate list next pointer.
   Isolate* next_;
 
   // Reusable handles support.
 #define REUSABLE_HANDLE_FIELDS(object)                                         \
-  object* object##_handle_;                                                    \
-
+  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_;
 
   static Dart_IsolateCreateCallback create_callback_;
   static Dart_IsolateInterruptCallback interrupt_callback_;
   static Dart_IsolateUnhandledExceptionCallback unhandled_exception_callback_;
   static Dart_IsolateShutdownCallback shutdown_callback_;
   static Dart_FileOpenCallback file_open_callback_;
   static Dart_FileReadCallback file_read_callback_;
   static Dart_FileWriteCallback file_write_callback_;
   static Dart_FileCloseCallback file_close_callback_;
   static Dart_EntropySource entropy_source_callback_;
   static Dart_IsolateInterruptCallback vmstats_callback_;
   static Dart_ServiceIsolateCreateCalback service_create_callback_;
 
   // Manage list of existing isolates.
   static void AddIsolateTolist(Isolate* isolate);
   static void RemoveIsolateFromList(Isolate* isolate);
   static void CheckForDuplicateThreadState(InterruptableThreadState* state);
   static Monitor* isolates_list_monitor_;
   static Isolate* isolates_list_head_;
 
-  friend class ReusableHandleScope;
-  friend class ReusableObjectHandleScope;
+#define REUSABLE_FRIEND_DECLARATION(name)                                      \
+  friend class Reusable##name##HandleScope;
+REUSABLE_HANDLE_LIST(REUSABLE_FRIEND_DECLARATION)
+#undef REUSABLE_FRIEND_DECLARATION
 
   DISALLOW_COPY_AND_ASSIGN(Isolate);
 };
 
 
 // When we need to execute code in an isolate, we use the
 // StartIsolateScope.
 class StartIsolateScope {
  public:
   explicit StartIsolateScope(Isolate* new_isolate)
@@ skipping 80 matching lines @@
   char* script_url_;
   char* library_url_;
   char* class_name_;
   char* function_name_;
   char* exception_callback_name_;
 };
 
 }  // namespace dart
 
 #endif  // VM_ISOLATE_H_