Decode the Dart message into a Dart_CMessage structure before calling the native port callback

runtime/vm/dart_api_state.h

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// 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/thread.h"
 #include "vm/dart_api_impl.h"
 #include "vm/flags.h"
+#include "vm/growable_array.h"
 #include "vm/handles.h"
 #include "vm/object.h"
 #include "vm/os.h"
 #include "vm/raw_object.h"
 #include "vm/visitor.h"
 
 #include "vm/handles_impl.h"
 
 namespace dart {
 
@@ skipping 17 matching lines @@
   // 'data' into new allocated memory. Uses current zone.
   uword Reallocate(uword data, intptr_t old_size, intptr_t new_size) {
     return zone_.Reallocate(data, old_size, new_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(); }
 
  private:
+  BaseZone* GetBaseZone() { return &zone_; }
+
   BaseZone zone_;
 
+  template<typename T> friend class ApiGrowableArray;
   DISALLOW_COPY_AND_ASSIGN(ApiZone);
 };
 
 
 // Implementation of local handles which are handed out from every
 // dart API call, these handles are valid only in the present scope
 // and are destroyed when a Dart_ExitScope() is called.
 class LocalHandle {
  public:
   // Accessors.
@@ skipping 439 matching lines @@
   ApiLocalScope* top_scope_;
 
   // Persistent handles to important objects.
   PersistentHandle* null_;
   PersistentHandle* true_;
   PersistentHandle* false_;
 
   DISALLOW_COPY_AND_ASSIGN(ApiState);
 };
 
+
+class ApiNativeScope {
+ public:
+  ApiNativeScope() {
+    // Currently no support for nesting native scopes.
+    ASSERT(Current() == NULL);
+    Thread::SetThreadLocal(Api::api_native_key_, reinterpret_cast<uword>(this));
+  }
+
+  ~ApiNativeScope() {
+    ASSERT(Current() == this);
+    Thread::SetThreadLocal(Api::api_native_key_, NULL);
+  }
+
+  static inline ApiNativeScope* Current() {
+    return reinterpret_cast<ApiNativeScope*>(
+        Thread::GetThreadLocal(Api::api_native_key_));
+  }
+
+  ApiZone* zone() { return &zone_; }
+
+ private:
+  ApiZone zone_;
+};
+
+
+// Api growable arrays use a zone for allocation. The constructor
+// picks the zone from the current isolate if in an isolate
+// environment. When outside an isolate environment it picks the zone
+// from the current native scope.
+template<typename T>
+class ApiGrowableArray : public BaseGrowableArray<T, ValueObject> {
+ public:
+  explicit ApiGrowableArray(int initial_capacity)
+      : BaseGrowableArray<T, ValueObject>(
+          initial_capacity,
+          ApiNativeScope::Current()->zone()->GetBaseZone()) {}
+  ApiGrowableArray()
+      : BaseGrowableArray<T, ValueObject>(
+          ApiNativeScope::Current()->zone()->GetBaseZone()) {}
+};
+
+
 }  // namespace dart
 
 #endif  // VM_DART_API_STATE_H_