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

runtime/vm/dart_api_state.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_DART_API_STATE_H_
 #define VM_DART_API_STATE_H_
 
 #include "include/dart_api.h"
 
 #include "platform/utils.h"
@@ skipping 650 matching lines @@
 };
 
 
 // Implementation of the API State used in dart api for maintaining
 // local scopes, persistent handles etc. These are setup on a per isolate
 // basis and destroyed when the isolate is shutdown.
 class ApiState {
  public:
   ApiState() : persistent_handles_(),
                weak_persistent_handles_(),
-               reusable_scope_(NULL),
-               top_scope_(NULL),
                null_(NULL),
                true_(NULL),
                false_(NULL),
                acquired_error_(NULL) {}
   ~ApiState() {
-    while (top_scope_ != NULL) {
-      ApiLocalScope* scope = top_scope_;
-      top_scope_ = top_scope_->previous();
-      delete scope;
-    }
     if (null_ != NULL) {
       persistent_handles().FreeHandle(null_);
       null_ = NULL;
     }
     if (true_ != NULL) {
       persistent_handles().FreeHandle(true_);
       true_ = NULL;
     }
     if (false_ != NULL) {
       persistent_handles().FreeHandle(false_);
       false_ = NULL;
     }
     if (acquired_error_ != NULL) {
       persistent_handles().FreeHandle(acquired_error_);
       acquired_error_ = NULL;
     }
   }
 
   // Accessors.
-  ApiLocalScope* reusable_scope() const { return reusable_scope_; }
-  void set_reusable_scope(ApiLocalScope* value) {
-    ASSERT(value == NULL || reusable_scope_ == NULL);
-    reusable_scope_ = value;
-  }
-  ApiLocalScope* top_scope() const { return top_scope_; }
-  void set_top_scope(ApiLocalScope* value) { top_scope_ = value; }
-
   PersistentHandles& persistent_handles() { return persistent_handles_; }
 
   FinalizablePersistentHandles& weak_persistent_handles() {
     return weak_persistent_handles_;
   }
 
-  void UnwindScopes(uword stack_marker) {
-    // Unwind all scopes using the same stack_marker, i.e. all scopes allocated
-    // under the same top_exit_frame_info.
-    while (top_scope_ != NULL &&
-           top_scope_->stack_marker() != 0 &&
-           top_scope_->stack_marker() == stack_marker) {
-      ApiLocalScope* scope = top_scope_;
-      top_scope_ = top_scope_->previous();
-      delete scope;
-    }
-  }
-
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
-    ApiLocalScope* scope = top_scope_;
-    while (scope != NULL) {
-      scope->local_handles()->VisitObjectPointers(visitor);
-      scope = scope->previous();
-    }
     persistent_handles().VisitObjectPointers(visitor);
   }
 
   void VisitWeakHandles(HandleVisitor* visitor) {
     weak_persistent_handles().VisitHandles(visitor);
   }
 
-  bool IsValidLocalHandle(Dart_Handle object) const {
-    ApiLocalScope* scope = top_scope_;
-    while (scope != NULL) {
-      if (scope->local_handles()->IsValidHandle(object)) {
-        return true;
-      }
-      scope = scope->previous();
-    }
-    return false;
-  }
-
   bool IsValidPersistentHandle(Dart_PersistentHandle object) const {
     return persistent_handles_.IsValidHandle(object);
   }
 
   bool IsValidWeakPersistentHandle(Dart_WeakPersistentHandle object) const {
     return weak_persistent_handles_.IsValidHandle(object);
   }
 
   bool IsProtectedHandle(PersistentHandle* object) const {
     if (object == NULL) return false;
     return object == null_ || object == true_ || object == false_;
   }
 
-  int CountLocalHandles() const {
-    int total = 0;
-    ApiLocalScope* scope = top_scope_;
-    while (scope != NULL) {
-      total += scope->local_handles()->CountHandles();
-      scope = scope->previous();
-    }
-    return total;
-  }
   int CountPersistentHandles() const {
     return persistent_handles_.CountHandles();
   }
-  int ZoneSizeInBytes() const {
-    int total = 0;
-    ApiLocalScope* scope = top_scope_;
-    while (scope != NULL) {
-      total += scope->zone()->SizeInBytes();
-      scope = scope->previous();
-    }
-    return total;
-  }
 
   void SetupAcquiredError() {
     ASSERT(acquired_error_ == NULL);
     const String& msg = String::Handle(
         String::New("Internal Dart data pointers have been acquired, "
                     "please release them using Dart_TypedDataReleaseData."));
     acquired_error_ = persistent_handles().AllocateHandle();
     acquired_error_->set_raw(ApiError::New(msg));
   }
 
   PersistentHandle* AcquiredError() const {
     ASSERT(acquired_error_ != NULL);
     return acquired_error_;
   }
 
   WeakTable* acquired_table() { return &acquired_table_; }
 
  private:
   PersistentHandles persistent_handles_;
   FinalizablePersistentHandles weak_persistent_handles_;
-  ApiLocalScope* reusable_scope_;
-  ApiLocalScope* top_scope_;
   WeakTable acquired_table_;
 
   // Persistent handles to important objects.
   PersistentHandle* null_;
   PersistentHandle* true_;
   PersistentHandle* false_;
   PersistentHandle* acquired_error_;
 
   DISALLOW_COPY_AND_ASSIGN(ApiState);
 };
@@ skipping 13 matching lines @@
   ref->set_peer(peer);
   ref->set_callback(callback);
   // This may trigger GC, so it must be called last.
   ref->SetExternalSize(external_size, isolate);
   return ref;
 }
 
 }  // namespace dart
 
 #endif  // VM_DART_API_STATE_H_