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

runtime/vm/dart_api_impl.h

 // Copyright (c) 2011, 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_IMPL_H_
 #define VM_DART_API_IMPL_H_
 
 #include "vm/allocation.h"
 #include "vm/native_arguments.h"
 #include "vm/object.h"
@@ skipping 38 matching lines @@
 #define CHECK_NO_ISOLATE(isolate)                                              \
   do {                                                                         \
     TRACE_API_CALL(CURRENT_FUNC);                                              \
     if ((isolate) != NULL) {                                                   \
       FATAL1("%s expects there to be no current isolate. Did you "             \
              "forget to call Dart_ExitIsolate?", CURRENT_FUNC);                \
     }                                                                          \
   } while (0)
 
 // Checks that the current isolate is not NULL and that it has an API scope.
-#define CHECK_ISOLATE_SCOPE(isolate)                                           \
+#define CHECK_API_SCOPE(thread)                                                \
   do {                                                                         \
-    Isolate* tmp = (isolate);                                                  \
-    CHECK_ISOLATE(tmp);                                                        \
-    ApiState* state = tmp->api_state();                                        \
-    ASSERT(state);                                                             \
-    if (state->top_scope() == NULL) {                                          \
+    Thread* tmpT = (thread);                                                   \
+    Isolate* tmpI = tmpT->isolate();                                           \
+    CHECK_ISOLATE(tmpI);                                                       \
+    if (tmpT->api_top_scope() == NULL) {                                       \
       FATAL1("%s expects to find a current scope. Did you forget to call "     \
            "Dart_EnterScope?", CURRENT_FUNC);                                  \
     }                                                                          \
   } while (0)
 
 #define DARTSCOPE(thread)                                                      \
   Thread* T = (thread);                                                        \
-  Isolate* I = T->isolate();                                                   \
-  CHECK_ISOLATE_SCOPE(I);                                                      \
+  CHECK_API_SCOPE(T);                                                          \
   HANDLESCOPE(T);
 
 
 #define RETURN_TYPE_ERROR(zone, dart_handle, type)                             \
   do {                                                                         \
     const Object& tmp =                                                        \
         Object::Handle(zone, Api::UnwrapHandle((dart_handle)));                \
     if (tmp.IsNull()) {                                                        \
       return Api::NewError("%s expects argument '%s' to be non-null.",         \
                            CURRENT_FUNC, #dart_handle);                        \
@@ skipping 32 matching lines @@
     }
     ~Scope() {
       Dart_ExitScope();
     }
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Scope);
   };
 
   // Creates a new local handle.
-  static Dart_Handle NewHandle(Isolate* isolate, RawObject* raw);
+  static Dart_Handle NewHandle(Thread* thread, RawObject* raw);
 
   // Unwraps the raw object from the handle.
   static RawObject* UnwrapHandle(Dart_Handle object);
 
   // Unwraps a raw Type from the handle.  The handle will be null if
   // the object was not of the requested Type.
 #define DECLARE_UNWRAP(Type)                                                   \
   static const Type& Unwrap##Type##Handle(Zone* zone,                          \
                                           Dart_Handle object);
   CLASS_LIST_FOR_HANDLES(DECLARE_UNWRAP)
 #undef DECLARE_UNWRAP
 
   // Unwraps the raw object from the handle using a reused handle.
   static const String& UnwrapStringHandle(
       const ReusableObjectHandleScope& reused, Dart_Handle object);
   static const Instance& UnwrapInstanceHandle(
       const ReusableObjectHandleScope& reused, Dart_Handle object);
 
   // Returns an Error handle if isolate is in an inconsistent state
   // or there was an error while finalizing classes.
   // Returns a Success handle when no error condition exists.
-  static Dart_Handle CheckAndFinalizePendingClasses(Isolate *isolate);
+  static Dart_Handle CheckAndFinalizePendingClasses(Thread *thread);
 
   // Casts the internal Isolate* type to the external Dart_Isolate type.
   static Dart_Isolate CastIsolate(Isolate* isolate);
 
   // Gets the handle used to designate successful return.
   static Dart_Handle Success() { return Api::True(); }
 
   // Sets up the acquired error object after initializing an Isolate. This
   // object is pre-created because we will not be able to allocate this
   // object when the error actually occurs. When the error occurs there will
@@ skipping 49 matching lines @@
   static Dart_Handle False() {
     return false_handle_;
   }
 
   // Gets a handle to EmptyString.
   static Dart_Handle EmptyString() {
     return empty_string_handle_;
   }
 
   // Retrieves the top ApiLocalScope.
-  static ApiLocalScope* TopScope(Isolate* isolate);
+  static ApiLocalScope* TopScope(Thread* thread);
 
   // Performs one-time initialization needed by the API.
   static void InitOnce();
 
   // Allocates handles for objects in the VM isolate.
   static void InitHandles();
 
   // Helper function to get the peer value of an external string object.
   static bool StringGetPeerHelper(NativeArguments* args,
                                   int arg_index,
@@ skipping 36 matching lines @@
   static void SetDoubleReturnValue(NativeArguments* args, double retval) {
     args->SetReturnUnsafe(Double::New(retval));
   }
   static void SetWeakHandleReturnValue(NativeArguments* args,
                                        Dart_WeakPersistentHandle retval);
 
   static RawString* CallEnvironmentCallback(Thread* thread,
                                             const String& name);
 
  private:
-  static Dart_Handle InitNewHandle(Isolate* isolate, RawObject* raw);
+  static Dart_Handle InitNewHandle(Thread* thread, RawObject* raw);
 
   // Thread local key used by the API. Currently holds the current
   // ApiNativeScope if any.
   static ThreadLocalKey api_native_key_;
   static Dart_Handle true_handle_;
   static Dart_Handle false_handle_;
   static Dart_Handle null_handle_;
   static Dart_Handle empty_string_handle_;
 
   friend class ApiNativeScope;
@@ skipping 18 matching lines @@
     return Api::NewError("%s: Cannot load after Dart_Precompile",              \
                          CURRENT_FUNC);                                        \
   }                                                                            \
 
 #define ASSERT_CALLBACK_STATE(thread)                                         \
   ASSERT(thread->no_callback_scope_depth() == 0)
 
 }  // namespace dart.
 
 #endif  // VM_DART_API_IMPL_H_