Remove more uses of Isolate::current_zone.

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 17 matching lines @@
 DECLARE_DEBUG_FLAG(bool, trace_handles);
 
 // Implementation of Zone support for very fast allocation of small chunks
 // of memory. The chunks cannot be deallocated individually, but instead
 // zones support deallocating all chunks in one fast operation when the
 // scope is exited.
 class ApiZone {
  public:
   // Create an empty zone.
   ApiZone() : zone_() {
-    Isolate* isolate = Isolate::Current();
-    Zone* current_zone = isolate != NULL ? isolate->current_zone() : NULL;
-    zone_.Link(current_zone);
-    if (isolate != NULL) {
-      isolate->set_current_zone(&zone_);
+    Thread* thread = Thread::Current();
+    Zone* zone = thread != NULL ? thread->zone() : NULL;
+    zone_.Link(zone);
+    if (thread != NULL) {
+      thread->set_zone(&zone_);
     }
 #ifdef DEBUG
     if (FLAG_trace_zones) {
       OS::PrintErr("*** Starting a new Api zone 0x%" Px "(0x%" Px ")\n",
                    reinterpret_cast<intptr_t>(this),
                    reinterpret_cast<intptr_t>(&zone_));
     }
 #endif
   }
 
   // Delete all memory associated with the zone.
   ~ApiZone() {
-    Isolate* isolate = Isolate::Current();
+    Thread* thread = Thread::Current();
 #if defined(DEBUG)
-    if (isolate == NULL) {
+    if (thread == NULL) {
       ASSERT(zone_.handles()->CountScopedHandles() == 0);
       ASSERT(zone_.handles()->CountZoneHandles() == 0);
     }
 #endif
-    if ((isolate != NULL) && (isolate->current_zone() == &zone_)) {
-      isolate->set_current_zone(zone_.previous_);
+    if ((thread != NULL) && (thread->zone() == &zone_)) {
+      thread->set_zone(zone_.previous_);
     }
 #ifdef DEBUG
     if (FLAG_trace_zones) {
       OS::PrintErr("*** Deleting Api zone 0x%" Px "(0x%" Px ")\n",
                    reinterpret_cast<intptr_t>(this),
                    reinterpret_cast<intptr_t>(&zone_));
     }
 #endif
   }
 
@@ skipping 20 matching lines @@
   // check for integer overflow.  If you use AllocUnsafe, you are
   // responsible for avoiding integer overflow yourself.
   uword AllocUnsafe(intptr_t size) { return zone_.AllocUnsafe(size); }
 
   // Compute the total size of this zone. This includes wasted space that is
   // due to internal fragmentation in the segments.
   intptr_t SizeInBytes() const { return zone_.SizeInBytes(); }
 
   Zone* GetZone() { return &zone_; }
 
-  void Reinit(Isolate* isolate) {
-    if (isolate == NULL) {
+  void Reinit(Thread* thread) {
+    if (thread == NULL) {
       zone_.Link(NULL);
     } else {
-      zone_.Link(isolate->current_zone());
-      isolate->set_current_zone(&zone_);
+      zone_.Link(thread->zone());
+      thread->set_zone(&zone_);
     }
   }
 
-  void Reset(Isolate* isolate) {
-    if ((isolate != NULL) && (isolate->current_zone() == &zone_)) {
-      isolate->set_current_zone(zone_.previous_);
+  void Reset(Thread* thread) {
+    if ((thread != NULL) && (thread->zone() == &zone_)) {
+      thread->set_zone(zone_.previous_);
     }
     zone_.DeleteAll();
   }
 
  private:
   Zone zone_;
 
   template<typename T> friend class ApiGrowableArray;
   DISALLOW_COPY_AND_ASSIGN(ApiZone);
 };
@@ skipping 459 matching lines @@
 // These local scopes manage handles and memory allocated in the scope.
 class ApiLocalScope {
  public:
   ApiLocalScope(ApiLocalScope* previous, uword stack_marker) :
       previous_(previous), stack_marker_(stack_marker) { }
   ~ApiLocalScope() {
     previous_ = NULL;
   }
 
   // Reinit the ApiLocalScope to new values.
-  void Reinit(Isolate* isolate, ApiLocalScope* previous, uword stack_marker) {
+  void Reinit(Thread* thread, ApiLocalScope* previous, uword stack_marker) {
     previous_ = previous;
     stack_marker_ = stack_marker;
-    zone_.Reinit(isolate);
+    zone_.Reinit(thread);
   }
 
   // Reset the ApiLocalScope so that it can be reused again.
-  void Reset(Isolate* isolate) {
+  void Reset(Thread* thread) {
     local_handles_.Reset();
-    zone_.Reset(isolate);
+    zone_.Reset(thread);
     previous_ = NULL;
     stack_marker_ = 0;
   }
 
   // Accessors.
   ApiLocalScope* previous() const { return previous_; }
   uword stack_marker() const { return stack_marker_; }
   void set_previous(ApiLocalScope* value) { previous_ = value; }
   LocalHandles* local_handles() { return &local_handles_; }
   Zone* zone() { return zone_.GetZone(); }
@@ skipping 376 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_