Remove isolate parameter when allocating handles

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 57 matching lines @@
     }                                                                          \
   } while (0)
 
 #define DARTSCOPE(thread)                                                      \
   Thread* T = (thread);                                                        \
   Isolate* I = T->isolate();                                                   \
   CHECK_ISOLATE_SCOPE(I);                                                      \
   HANDLESCOPE(T);
 
 
-#define RETURN_TYPE_ERROR(isolate, dart_handle, type)                          \
+#define RETURN_TYPE_ERROR(zone, dart_handle, type)                             \
   do {                                                                         \
     const Object& tmp =                                                        \
-        Object::Handle(isolate, Api::UnwrapHandle((dart_handle)));             \
+        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);                        \
     } else if (tmp.IsError()) {                                                \
       return dart_handle;                                                      \
     }                                                                          \
     return Api::NewError("%s expects argument '%s' to be of type %s.",         \
                          CURRENT_FUNC, #dart_handle, #type);                   \
   } while (0)
 
@@ skipping 33 matching lines @@
 
   // Creates a new local handle.
   static Dart_Handle NewHandle(Isolate* isolate, 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(Isolate* isolate,                    \
+  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);
 
@@ skipping 175 matching lines @@
     return Api::NewError("%s: Cannot load after Dart_Precompile",              \
                          CURRENT_FUNC);                                        \
   }                                                                            \
 
 #define ASSERT_CALLBACK_STATE(isolate)                                         \
   ASSERT(isolate->no_callback_scope_depth() == 0)
 
 }  // namespace dart.
 
 #endif  // VM_DART_API_IMPL_H_