Move ApiLocalScope out of class ApiState into class Thread so that the API local handles and zone e…

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 "include/dart_api.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 ApiLocalScope;
 class Array;
 class CHA;
 class Class;
 class Code;
 class Error;
 class ExceptionHandlers;
 class Field;
 class Function;
 class GrowableObjectArray;
 class HandleScope;
@@ skipping 102 matching lines @@
 
   // OSThread corresponding to this thread.
   OSThread* os_thread() const { return os_thread_; }
   void set_os_thread(OSThread* os_thread) {
     os_thread_ = os_thread;
   }
 
   // The topmost zone used for allocation in this thread.
   Zone* zone() const { return zone_; }
 
+  // The reusable api local scope for this thread.
+  ApiLocalScope* api_reusable_scope() const { return api_reusable_scope_; }
+  void set_api_reusable_scope(ApiLocalScope* value) {
+    ASSERT(value == NULL || api_reusable_scope_ == NULL);
+    api_reusable_scope_ = value;
+  }
+
+  // The api local scope for this thread, this where all local handles
+  // are allocated.
+  ApiLocalScope* api_top_scope() const { return api_top_scope_; }
+  void set_api_top_scope(ApiLocalScope* value) { api_top_scope_ = value; }
+
   // The isolate that this thread is operating on, or NULL if none.
   Isolate* isolate() const { return isolate_; }
   static intptr_t isolate_offset() {
     return OFFSET_OF(Thread, isolate_);
   }
   bool IsMutatorThread() const;
 
   // Is |this| executing Dart code?
   bool IsExecutingDartCode() const;
 
@@ skipping 43 matching lines @@
   }
 
   StackResource* top_resource() const { return top_resource_; }
   void set_top_resource(StackResource* value) {
     top_resource_ = value;
   }
   static intptr_t top_resource_offset() {
     return OFFSET_OF(Thread, top_resource_);
   }
 
+  // Heap of the isolate that this thread is operating on.
+  Heap* heap() const { return heap_; }
   static intptr_t heap_offset() {
     return OFFSET_OF(Thread, heap_);
   }
 
   int32_t no_handle_scope_depth() const {
 #if defined(DEBUG)
     return no_handle_scope_depth_;
 #else
     return 0;
 #endif
@@ skipping 143 matching lines @@
 
 #define REUSABLE_HANDLE(object)                                                \
   object& object##Handle() const {                                             \
     return *object##_handle_;                                                  \
   }
   REUSABLE_HANDLE_LIST(REUSABLE_HANDLE)
 #undef REUSABLE_HANDLE
 
   RawGrowableObjectArray* pending_functions();
 
+  // Visit all object pointers.
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
+
+  bool IsValidLocalHandle(Dart_Handle object) const;
+  int CountLocalHandles() const;
+  int ZoneSizeInBytes() const;
+  void UnwindScopes(uword stack_marker);
+
   void InitVMConstants();
 
  private:
   template<class T> T* AllocateReusableHandle();
 
   OSThread* os_thread_;
   Isolate* isolate_;
   Heap* heap_;
   Zone* zone_;
+  ApiLocalScope* api_reusable_scope_;
+  ApiLocalScope* api_top_scope_;
   uword top_exit_frame_info_;
   StackResource* top_resource_;
   LongJumpScope* long_jump_base_;
   StoreBufferBlock* store_buffer_block_;
   int32_t no_callback_scope_depth_;
 #if defined(DEBUG)
   HandleScope* top_handle_scope_;
   intptr_t no_handle_scope_depth_;
   int32_t no_safepoint_scope_depth_;
 #endif
@@ skipping 78 matching lines @@
 // Disable thread interrupts.
 class DisableThreadInterruptsScope : public StackResource {
  public:
   explicit DisableThreadInterruptsScope(Thread* thread);
   ~DisableThreadInterruptsScope();
 };
 
 }  // namespace dart
 
 #endif  // VM_THREAD_H_