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

runtime/vm/growable_array.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.
 // Defines growable array classes, that differ where they are allocated:
 // - GrowableArray: allocate on stack.
 // - ZoneGrowableArray: allocated in the zone.
 
 #ifndef VM_GROWABLE_ARRAY_H_
 #define VM_GROWABLE_ARRAY_H_
 
 #include "platform/utils.h"
 #include "vm/allocation.h"
 #include "vm/isolate.h"
 #include "vm/zone.h"
 
 namespace dart {
 
 template<typename T, typename B>
 class BaseGrowableArray : public B {
  public:
   BaseGrowableArray() : length_(0), capacity_(0), data_(NULL), zone_(NULL) {
     ASSERT(Isolate::Current() != NULL);
     zone_ = Isolate::Current()->current_zone();
+#ifdef DEBUG
+    isolate_zone_ = true;
+#endif
   }
 
-  explicit BaseGrowableArray(int initial_capacity)
-      : length_(0), capacity_(0), data_(NULL), zone_(NULL) {
-    ASSERT(Isolate::Current() != NULL);
-    zone_ = Isolate::Current()->current_zone();
+  explicit BaseGrowableArray(int initial_capacity, Zone* zone = NULL)

[siva, 2012/02/04 01:55:43]

BaseGrowableArray is not used anywhere but here, why not change the constructor
to take a Zone parameter instead of making it an optional parameter with a
default value.

We will have GrowableArray pass in the current zone of the Isolate or the zone
parameter it was passed in.

That way you would not need also these debug assertions and the isolate_zone_
variable etc.

[Søren Gjesse, 2012/02/06 16:25:52]

Done.

+      : length_(0), capacity_(0), data_(NULL), zone_(zone) {
+    if (zone == NULL) {
+      ASSERT(Isolate::Current() != NULL);
+      zone_ = Isolate::Current()->current_zone();
+    }
+#ifdef DEBUG
+    if (Isolate::Current() != NULL) {
+      isolate_zone_ = (zone_ == Isolate::Current()->current_zone());
+    } else {
+      isolate_zone_ = false;
+    }
+#endif
     if (initial_capacity > 0) {
       capacity_ = Utils::RoundUpToPowerOfTwo(initial_capacity);
       data_ = reinterpret_cast<T*>(zone_->Allocate(capacity_ * sizeof(T)));
     }
   }
 
   int length() const { return length_; }
   T* data() const { return data_; }
   bool is_empty() const { return length_ == 0; }
 
@@ skipping 30 matching lines @@
   }
 
   // Sort the array in place.
   inline void Sort(int compare(const T*, const T*));
 
  private:
   int length_;
   int capacity_;
   T* data_;
   Zone* zone_;  // Zone in which we are allocating the array.
+#ifdef DEBUG
+  bool isolate_zone_;
+#endif
 
   void Resize(int new_length);
 
   DISALLOW_COPY_AND_ASSIGN(BaseGrowableArray);
 };
 
 
 template<typename T, typename B>
 inline void BaseGrowableArray<T, B>::Sort(
     int compare(const T*, const T*)) {
   typedef int (*CompareFunction)(const void*, const void*);
   qsort(data_, length_, sizeof(T), reinterpret_cast<CompareFunction>(compare));
 }
 
 
 template<typename T, typename B>
 void BaseGrowableArray<T, B>::Resize(int new_length) {
   if (new_length > capacity_) {
-    ASSERT(Isolate::Current() != NULL);
-    // Check that we allocating in the array's zone.
-    ASSERT(zone_ == Isolate::Current()->current_zone());
+#ifdef DEBUG
+    if (isolate_zone_) {
+      ASSERT(Isolate::Current() != NULL);
+      // Check that we allocating in the array's zone.
+      ASSERT(zone_ == Isolate::Current()->current_zone());
+    }
+#endif
     int new_capacity = Utils::RoundUpToPowerOfTwo(new_length);
     T* new_data = reinterpret_cast<T*>(
         zone_->Reallocate(reinterpret_cast<uword>(data_),
                           capacity_ * sizeof(T),
                           new_capacity * sizeof(T)));
     ASSERT(new_data != NULL);
     data_ = new_data;
     capacity_ = new_capacity;
   }
   length_ = new_length;
 }
 
 
 template<typename T>
 class GrowableArray : public BaseGrowableArray<T, ValueObject> {
  public:
-  explicit GrowableArray(int initial_capacity)
-      : BaseGrowableArray<T, ValueObject>(initial_capacity) {}
+  GrowableArray(int initial_capacity, Zone* zone = NULL)
+      : BaseGrowableArray<T, ValueObject>(initial_capacity, zone) {}

[siva, 2012/02/04 01:55:43]

Have two versions of the constructor, the one argument one which will invoke the
BaseGrowableArray constructor with the current zone of the isolate and the two
argument one which will pass in the zone parameter it got to the
BaseGrowableArray constructor.

[Søren Gjesse, 2012/02/06 16:25:52]

Done.

   GrowableArray() : BaseGrowableArray<T, ValueObject>() {}
 };
 
 
 template<typename T>
 class ZoneGrowableArray : public BaseGrowableArray<T, ZoneAllocated> {
  public:
   explicit ZoneGrowableArray(int initial_capacity)
       : BaseGrowableArray<T, ZoneAllocated>(initial_capacity) {}
   ZoneGrowableArray() : BaseGrowableArray<T, ZoneAllocated>() {}
 };
 
 }  // namespace dart
 
 #endif  // VM_GROWABLE_ARRAY_H_