Pass in the isolate parameter to the weak persistent callback handler so that

runtime/include/dart_api.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 INCLUDE_DART_API_H_
 #define INCLUDE_DART_API_H_
 
 /** \mainpage Dart Embedding API Reference
@@ skipping 54 matching lines @@
 
 #include <assert.h>
 
 /*
  * =======
  * Handles
  * =======
  */
 
 /**
+ * An isolate is the unit of concurrency in Dart. Each isolate has
+ * its own memory and thread of control. No state is shared between
+ * isolates. Instead, isolates communicate by message passing.
+ *
+ * Each thread keeps track of its current isolate, which is the
+ * isolate which is ready to execute on the current thread. The
+ * current isolate may be NULL, in which case no isolate is ready to
+ * execute. Most of the Dart apis require there to be a current
+ * isolate in order to function without error. The current isolate is
+ * set by any call to Dart_CreateIsolate or Dart_EnterIsolate.
+ */
+typedef struct _Dart_Isolate* Dart_Isolate;
+
+/**
  * An object reference managed by the Dart VM garbage collector.
  *
  * Because the garbage collector may move objects, it is unsafe to
  * refer to objects directly. Instead, we refer to objects through
  * handles, which are known to the garbage collector and updated
  * automatically when the object is moved. Handles should be passed
  * by value (except in cases like out-parameters) and should never be
  * allocated on the heap.
  *
  * Most functions in the Dart Embedding API return a handle. When a
@@ skipping 103 matching lines @@
  * The type Dart_Handle represents a handle (both local and persistent).
  * The type Dart_PersistentHandle is a Dart_Handle and it is used to
  * document that a persistent handle is expected as a parameter to a call
  * or the return value from a call is a persistent handle.
  */
 typedef struct _Dart_Handle* Dart_Handle;
 typedef Dart_Handle Dart_PersistentHandle;
 typedef struct _Dart_WeakPersistentHandle* Dart_WeakPersistentHandle;
 
 typedef void (*Dart_WeakPersistentHandleFinalizer)(
+    Dart_Isolate isolate,
     Dart_WeakPersistentHandle handle,
     void* peer);
 typedef void (*Dart_PeerFinalizer)(void* peer);
 
 /**
  * Is this an error handle?
  *
  * Requires there to be a current isolate.
  */
 DART_EXPORT bool Dart_IsError(Dart_Handle handle);
@@ skipping 231 matching lines @@
  *
  * \return Success if the weak persistent handle was
  *   created. Otherwise, returns an error.
  */
 DART_EXPORT Dart_WeakPersistentHandle Dart_NewWeakPersistentHandle(
     Dart_Handle object,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback);
 
 DART_EXPORT void Dart_DeleteWeakPersistentHandle(
+    Dart_Isolate isolate,
     Dart_WeakPersistentHandle object);
 
 /**
  * Allocates a prologue weak persistent handle for an object.
  *
  * Prologue weak persistent handles are similar to weak persistent
  * handles but exhibit different behavior during garbage collections
  * that invoke the prologue and epilogue callbacks.  While weak
  * persistent handles always weakly reference their referents,
  * prologue weak persistent handles weakly reference their referents
@@ skipping 134 matching lines @@
 /**
  * Gets the version string for the Dart VM.
  *
  * The version of the Dart VM can be accessed without initializing the VM.
  *
  * \return The version string for the embedded Dart VM.
  */
 DART_EXPORT const char* Dart_VersionString();
 
 /**
- * An isolate is the unit of concurrency in Dart. Each isolate has
- * its own memory and thread of control. No state is shared between
- * isolates. Instead, isolates communicate by message passing.
- *
- * Each thread keeps track of its current isolate, which is the
- * isolate which is ready to execute on the current thread. The
- * current isolate may be NULL, in which case no isolate is ready to
- * execute. Most of the Dart apis require there to be a current
- * isolate in order to function without error. The current isolate is
- * set by any call to Dart_CreateIsolate or Dart_EnterIsolate.
- */
-typedef struct _Dart_Isolate* Dart_Isolate;
-
-/**
  * An isolate creation and initialization callback function.
  *
  * This callback, provided by the embedder, is called when the vm
  * needs to create an isolate. The callback should create an isolate
  * by calling Dart_CreateIsolate and load any scripts required for
  * execution.
  *
  * When the function returns false, it is the responsibility of this
  * function to ensure that Dart_ShutdownIsolate has been called if
  * required (for example, if the isolate was created successfully by
@@ skipping 1916 matching lines @@
  * NOTE: If multiple callbacks with the same name are registered, only the
  * last callback registered will be remembered.
  */
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data);
 
 
 #endif  /* INCLUDE_DART_API_H_ */  /* NOLINT */