Move reusable handles from isolate to thread.

runtime/vm/reusable_handles.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_REUSABLE_HANDLES_H_
 #define VM_REUSABLE_HANDLES_H_
 
 #include "vm/allocation.h"
 #include "vm/handles.h"
 #include "vm/object.h"
@@ skipping 12 matching lines @@
 // {
 //   REUSABLE_ARRAY_HANDLESCOPE(isolate);
 //   ....
 //   ....
 //   Array& funcs = reused_array_handle.Handle();
 //   code that uses funcs
 //   ....
 // }
 //
 
+
 #if defined(DEBUG)
 #define REUSABLE_SCOPE(name)                                                   \
   class Reusable##name##HandleScope : public ValueObject {                     \
-    public:                                                                    \
-    explicit Reusable##name##HandleScope(Isolate* isolate)                     \
-        : isolate_(isolate) {                                                  \
-      ASSERT(!isolate->reusable_##name##_handle_scope_active());               \
-      isolate->set_reusable_##name##_handle_scope_active(true);                \
+   public:                                                                     \
+    explicit Reusable##name##HandleScope(Thread* thread)                       \
+        : thread_(thread) {                                                    \
+      ASSERT(!thread->reusable_##name##_handle_scope_active());                \
+      thread->set_reusable_##name##_handle_scope_active(true);                 \
     }                                                                          \
-    Reusable##name##HandleScope() : isolate_(Isolate::Current()) {             \
-      ASSERT(!isolate_->reusable_##name##_handle_scope_active());              \
-      isolate_->set_reusable_##name##_handle_scope_active(true);               \
+    Reusable##name##HandleScope() : thread_(Thread::Current()) {               \
+      ASSERT(!thread_->reusable_##name##_handle_scope_active());               \
+      thread_->set_reusable_##name##_handle_scope_active(true);                \
     }                                                                          \
     ~Reusable##name##HandleScope() {                                           \
-      ASSERT(isolate_->reusable_##name##_handle_scope_active());               \
-      isolate_->set_reusable_##name##_handle_scope_active(false);              \
+      ASSERT(thread_->reusable_##name##_handle_scope_active());                \
+      thread_->set_reusable_##name##_handle_scope_active(false);               \
       Handle().raw_ = name::null();                                            \
     }                                                                          \
     name& Handle() const {                                                     \
-      ASSERT(isolate_->name##_handle_ != NULL);                                \
-      return *isolate_->name##_handle_;                                        \
+      ASSERT(thread_->name##_handle_ != NULL);                                 \
+      return *thread_->name##_handle_;                                         \
     }                                                                          \
-    private:                                                                   \
-    Isolate* isolate_;                                                         \
+   private:                                                                    \
+    Thread* thread_;                                                           \
     DISALLOW_COPY_AND_ASSIGN(Reusable##name##HandleScope);                     \
   };
 #else
 #define REUSABLE_SCOPE(name)                                                   \
   class Reusable##name##HandleScope : public ValueObject {                     \
-    public:                                                                    \
-    explicit Reusable##name##HandleScope(Isolate* isolate)                     \
-        : handle_(isolate->name##_handle_) {                                   \
+   public:                                                                     \
+    explicit Reusable##name##HandleScope(Thread* thread)                       \
+        : handle_(thread->name##_handle_) {                                    \
     }                                                                          \
     Reusable##name##HandleScope()                                              \
-        : handle_(Isolate::Current()->name##_handle_) {                        \
+        : handle_(Thread::Current()->name##_handle_) {                         \
     }                                                                          \
     ~Reusable##name##HandleScope() {                                           \
       handle_->raw_ = name::null();                                            \
     }                                                                          \
     name& Handle() const {                                                     \
       ASSERT(handle_ != NULL);                                                 \
       return *handle_;                                                         \
     }                                                                          \
-    private:                                                                   \
+   private:                                                                    \
     name* handle_;                                                             \
     DISALLOW_COPY_AND_ASSIGN(Reusable##name##HandleScope);                     \
   };
 #endif  // defined(DEBUG)
 REUSABLE_HANDLE_LIST(REUSABLE_SCOPE)
 #undef REUSABLE_SCOPE
 
 #define REUSABLE_ABSTRACT_TYPE_HANDLESCOPE(isolate)                            \
   ReusableAbstractTypeHandleScope reused_abstract_type(isolate);
 #define REUSABLE_ARRAY_HANDLESCOPE(isolate)                                    \
@@ skipping 22 matching lines @@
   ReusableObjectHandleScope reused_object_handle(isolate);
 #define REUSABLE_PC_DESCRIPTORS_HANDLESCOPE(isolate)                           \
   ReusablePcDescriptorsHandleScope reused_pc_descriptors_handle(isolate);
 #define REUSABLE_STRING_HANDLESCOPE(isolate)                                   \
   ReusableStringHandleScope reused_string_handle(isolate);
 #define REUSABLE_TYPE_ARGUMENTS_HANDLESCOPE(isolate)                           \
   ReusableTypeArgumentsHandleScope reused_type_arguments_handle(isolate);
 #define REUSABLE_TYPE_PARAMETER_HANDLESCOPE(isolate)                           \
   ReusableTypeParameterHandleScope reused_type_parameter(isolate);
 
-
 }  // namespace dart
 
 #endif  // VM_REUSABLE_HANDLES_H_