Stop using void* types in the dart embedding api.

runtime/include/dart_api.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 INCLUDE_DART_API_H_
 #define INCLUDE_DART_API_H_
 
 /** \mainpage Dart Embedding API Reference
  *
  * Dart is a class-based programming language for creating structured
@@ skipping 75 matching lines @@
  * Local handles are allocated within the current scope (see
  * Dart_EnterScope) and go away when the current scope exits. Unless
  * otherwise indicated, callers should assume that all functions in
  * the Dart embedding api return local handles.
  *
  * Persistent handles are allocated within the current isolate. They
  * can be used to store objects across scopes. Persistent handles have
  * the lifetime of the current isolate unless they are explicitly
  * deallocated (see Dart_DeletePersistentHandle).
  */
-typedef void* Dart_Handle;
+typedef struct _Dart_Handle* Dart_Handle;
 
 /**
  * Is this an error handle?
  *
  * Requires there to be a current isolate.
  */
 DART_EXPORT bool Dart_IsError(const Dart_Handle& handle);
 
 /**
  * Gets the error message from an error handle.
@@ skipping 170 matching lines @@
  * 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 void* Dart_Isolate;
+typedef struct _Dart_Isolate* Dart_Isolate;
 
 /**
- * A buffer containing a snapshot of the Dart VM. A snapshot can be
- * used to restore the VM quickly to a saved state and is useful for
- * fast startup.
- */
-typedef void Dart_Snapshot;
-
-/**
- * Creates a new isolate. If snapshot data is provided, the isolate
- * will be started using that snapshot data. The new isolate becomes
- * the current isolate.
+ * Creates a new isolate. The new isolate becomes the current isolate.
+ *
+ * A snapshot can be used to restore the VM quickly to a saved state
+ * and is useful for fast startup. If snapshot data is provided, the
+ * isolate will be started using that snapshot data.
  *
  * Requires there to be no current isolate.
  *
  * \param snapshot A buffer containing a VM snapshot or NULL if no
  *   snapshot is provided.
  *
  * \return The new isolate is returned. May be NULL if an error
  *   occurs duing isolate initialization.
  */
-DART_EXPORT Dart_Isolate Dart_CreateIsolate(const Dart_Snapshot* snapshot,
+DART_EXPORT Dart_Isolate Dart_CreateIsolate(const uint8_t* snapshot,
                                             void* callback_data,
                                             char** error);
 // TODO(turnidge): Document behavior when there is already a current
 // isolate.
 
 /**
  * Shuts down the current isolate. After this call, the current
  * isolate is NULL.
  *
  * Requires there to be a current isolate.
@@ skipping 26 matching lines @@
  */
 DART_EXPORT void Dart_ExitIsolate();
 // TODO(turnidge): We don't want users of the api to be able to exit a
 // "pure" dart isolate. Implement and document.
 
 /**
  * Creates a snapshot of the state of the current isolate.
  */
 DART_EXPORT Dart_Handle Dart_CreateSnapshot(uint8_t** snaphot_buffer,
                                             intptr_t* snapshot_size);
-// TODO(turnidge): Does this include the current script or only libs?
-// is it possible to take a snapshot and load more scripts into it?
 
 // --- Messages and Ports ---
 
 /**
  * Messages are used to communicate between isolates.
  */
-typedef void* Dart_Message;
+typedef struct _Dart_Message* Dart_Message;
 
 /**
  * A port is used to send or receive inter-isolate messages
  */
 typedef int64_t Dart_Port;
 
 const Dart_Port kNoReplyPort = 0;
 
 /**
  * A message posting callback.
@@ skipping 736 matching lines @@
 // --- Native functions ---
 
 /**
  * The arguments to a native function.
  *
  * This object is passed to a native function to represent its
  * arguments and return value. It allows access to the arguments to a
  * native function by index. It also allows the return value of a
  * native function to be set.
  */
-typedef void* Dart_NativeArguments;
+typedef struct _Dart_NativeArguments* Dart_NativeArguments;
 
 /**
  * Gets the native argument at some index.
  */
 DART_EXPORT Dart_Handle Dart_GetNativeArgument(Dart_NativeArguments args,
                                                int index);
 // TODO(turnidge): Specify the behavior of an out-of-bounds access.
 
 /**
  * Gets the number of native arguments.
@@ skipping 102 matching lines @@
 
 // --- Profiling support ----
 
 // External pprof support for gathering and dumping symbolic
 // information that can be used for better profile reports for
 // dynamically generated code.
 DART_EXPORT void Dart_InitPprofSupport();
 DART_EXPORT void Dart_GetPprofSymbolInfo(void** buffer, int* buffer_size);
 
 #endif  // INCLUDE_DART_API_H_