Dart: Removes all but native calls and the handle watcher from the snapshot.

sky/engine/bindings/mojo_natives.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sky/engine/config.h"
 #include "sky/engine/bindings/mojo_natives.h"
 
 #include <stdio.h>
 #include <string.h>
 #include <vector>
@@ skipping 25 matching lines @@
   V(MojoDataPipe_BeginWriteData, 3)        \
   V(MojoDataPipe_EndWriteData, 2)          \
   V(MojoDataPipe_ReadData, 4)              \
   V(MojoDataPipe_BeginReadData, 3)         \
   V(MojoDataPipe_EndReadData, 2)           \
   V(MojoMessagePipe_Create, 1)             \
   V(MojoMessagePipe_Write, 5)              \
   V(MojoMessagePipe_Read, 5)               \
   V(MojoHandle_Close, 1)                   \
   V(MojoHandle_Wait, 3)                    \
-  V(MojoHandle_Register, 1)                \
+  V(MojoHandle_Register, 2)                \
   V(MojoHandle_WaitMany, 3)                \
   V(MojoHandleWatcher_SendControlData, 4)  \
   V(MojoHandleWatcher_RecvControlData, 1)  \
   V(MojoHandleWatcher_SetControlHandle, 1) \
   V(MojoHandleWatcher_GetControlHandle, 0)
 
 MOJO_NATIVE_LIST(DECLARE_FUNCTION);
 
 static struct NativeEntries {
   const char* name;
@@ skipping 34 matching lines @@
 
 static void SetNullReturn(Dart_NativeArguments arguments) {
   Dart_SetReturnValue(arguments, Dart_Null());
 }
 
 static void SetInvalidArgumentReturn(Dart_NativeArguments arguments) {
   Dart_SetIntegerReturnValue(
       arguments, static_cast<int64_t>(MOJO_RESULT_INVALID_ARGUMENT));
 }
 
-static Dart_Handle MojoLib() {
-  return DartBuiltin::LookupLibrary("dart:mojo.core");
-}
-
-static Dart_Handle SignalsStateToDart(Dart_Handle klass,
-                                      const MojoHandleSignalsState& state) {
-  Dart_Handle arg1 = Dart_NewInteger(state.satisfied_signals);
-  Dart_Handle arg2 = Dart_NewInteger(state.satisfiable_signals);
-  Dart_Handle args[] = {arg1, arg2};
-  return Dart_New(klass, Dart_Null(), 2, args);
+static Dart_Handle SignalsStateToDart(const MojoHandleSignalsState& state) {
+  Dart_Handle list = Dart_NewList(2);
+  Dart_Handle arg0 = Dart_NewInteger(state.satisfied_signals);
+  Dart_Handle arg1 = Dart_NewInteger(state.satisfiable_signals);
+  Dart_ListSetAt(list, 0, arg0);
+  Dart_ListSetAt(list, 1, arg1);
+  return list;
 }
 
 #define CHECK_INTEGER_ARGUMENT(args, num, result, failure)                     \
   {                                                                            \
     Dart_Handle __status;                                                      \
     __status = Dart_GetNativeIntegerArgument(args, num, result);               \
     if (Dart_IsError(__status)) {                                              \
       Set##failure##Return(arguments);                                         \
       return;                                                                  \
     }                                                                          \
   }                                                                            \
 
 struct CloserCallbackPeer {
   MojoHandle handle;
 };
 
 static void MojoHandleCloserCallback(void* isolate_data,
                                      Dart_WeakPersistentHandle handle,
                                      void* peer) {
   CloserCallbackPeer* callback_peer =
       reinterpret_cast<CloserCallbackPeer*>(peer);
   if (callback_peer->handle != MOJO_HANDLE_INVALID) {
     MojoClose(callback_peer->handle);
   }
   delete callback_peer;
 }
 
-// Setup a weak persistent handle for a Dart MojoHandle that calls MojoClose
-// on the handle when the MojoHandle is GC'd or the VM is going down.
+// Setup a weak persistent handle for a MojoHandle that calls MojoClose on the
+// handle when the MojoHandle is GC'd or the VM is going down.
 void MojoHandle_Register(Dart_NativeArguments arguments) {
-  // An instance of Dart class MojoHandle.
   Dart_Handle mojo_handle_instance = Dart_GetNativeArgument(arguments, 0);
   if (!Dart_IsInstance(mojo_handle_instance)) {
     SetInvalidArgumentReturn(arguments);
     return;
   }
-  // TODO(zra): Here, we could check that mojo_handle_instance is really a
-  // MojoHandle instance, but with the Dart API it's not too easy to get a Type
-  // object from the class name outside of the root library. For now, we'll rely
-  // on the existence of the right fields to be sufficient.
-
-  Dart_Handle raw_mojo_handle_instance = Dart_GetField(
-      mojo_handle_instance, ToDart("_handle"));
-  if (Dart_IsError(raw_mojo_handle_instance)) {
-    SetInvalidArgumentReturn(arguments);
-    return;
-  }
-
-  Dart_Handle mojo_handle = Dart_GetField(
-      raw_mojo_handle_instance, ToDart("h"));
-  if (Dart_IsError(mojo_handle)) {
-    SetInvalidArgumentReturn(arguments);
-    return;
-  }
 
   int64_t raw_handle = static_cast<int64_t>(MOJO_HANDLE_INVALID);
-  Dart_Handle result = Dart_IntegerToInt64(mojo_handle, &raw_handle);
-  if (Dart_IsError(result)) {
-    SetInvalidArgumentReturn(arguments);
-    return;
-  }
-
+  CHECK_INTEGER_ARGUMENT(arguments, 1, &raw_handle, InvalidArgument);
   if (raw_handle == static_cast<int64_t>(MOJO_HANDLE_INVALID)) {
     SetInvalidArgumentReturn(arguments);
     return;
   }
 
+  // Set up a finalizer.
   CloserCallbackPeer* callback_peer = new CloserCallbackPeer();
   callback_peer->handle = static_cast<MojoHandle>(raw_handle);
   Dart_NewWeakPersistentHandle(mojo_handle_instance,
                                reinterpret_cast<void*>(callback_peer),
                                sizeof(CloserCallbackPeer),
                                MojoHandleCloserCallback);
   Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(MOJO_RESULT_OK));
 }
 
 void MojoHandle_Close(Dart_NativeArguments arguments) {
@@ skipping 11 matching lines @@
   int64_t deadline = 0;
   CHECK_INTEGER_ARGUMENT(arguments, 0, &handle, InvalidArgument);
   CHECK_INTEGER_ARGUMENT(arguments, 1, &signals, InvalidArgument);
   CHECK_INTEGER_ARGUMENT(arguments, 2, &deadline, InvalidArgument);
 
   MojoHandleSignalsState state;
   MojoResult r = mojo::Wait(mojo::Handle(static_cast<MojoHandle>(handle)),
                             static_cast<MojoHandleSignals>(signals),
                             static_cast<MojoDeadline>(deadline), &state);
 
-  Dart_Handle klass = Dart_GetClass(
-      MojoLib(), ToDart("MojoHandleSignalsState"));
-  DART_CHECK_VALID(klass);
-
   // The return value is structured as a list of length 2:
   // [0] MojoResult
   // [1] MojoHandleSignalsState. (may be null)
   Dart_Handle list = Dart_NewList(2);
   Dart_ListSetAt(list, 0, Dart_NewInteger(r));
   if (mojo::WaitManyResult(r).AreSignalsStatesValid()) {
-    Dart_ListSetAt(list, 1, SignalsStateToDart(klass, state));
+    Dart_ListSetAt(list, 1, SignalsStateToDart(state));
   } else {
     Dart_ListSetAt(list, 1, Dart_Null());
   }
   Dart_SetReturnValue(arguments, list);
 }
 
 void MojoHandle_WaitMany(Dart_NativeArguments arguments) {
   int64_t deadline = 0;
   Dart_Handle handles = Dart_GetNativeArgument(arguments, 0);
   Dart_Handle signals = Dart_GetNativeArgument(arguments, 1);
@@ skipping 28 matching lines @@
     Dart_IntegerToInt64(dart_handle, &mojo_handle);
     Dart_IntegerToInt64(dart_signal, &mojo_signal);
     mojo_handles[i] = mojo::Handle(mojo_handle);
     mojo_signals[i] = static_cast<MojoHandleSignals>(mojo_signal);
   }
 
   std::vector<MojoHandleSignalsState> states(handles_len);
   mojo::WaitManyResult wmr = mojo::WaitMany(
       mojo_handles, mojo_signals, static_cast<MojoDeadline>(deadline), &states);
 
-  Dart_Handle klass = Dart_GetClass(
-      MojoLib(), ToDart("MojoHandleSignalsState"));
-  DART_CHECK_VALID(klass);
-
   // The return value is structured as a list of length 3:
   // [0] MojoResult
   // [1] index of handle that caused a return (may be null)
   // [2] list of MojoHandleSignalsState. (may be null)
   Dart_Handle list = Dart_NewList(3);
   Dart_ListSetAt(list, 0, Dart_NewInteger(wmr.result));
   if (wmr.IsIndexValid())
     Dart_ListSetAt(list, 1, Dart_NewInteger(wmr.index));
   else
     Dart_ListSetAt(list, 1, Dart_Null());
   if (wmr.AreSignalsStatesValid()) {
     Dart_Handle stateList = Dart_NewList(handles_len);
     for (int i = 0; i < handles_len; i++) {
-      Dart_ListSetAt(stateList, i, SignalsStateToDart(klass, states[i]));
+      Dart_ListSetAt(stateList, i, SignalsStateToDart(states[i]));
     }
     Dart_ListSetAt(list, 2, stateList);
   } else {
     Dart_ListSetAt(list, 2, Dart_Null());
   }
   Dart_SetReturnValue(arguments, list);
 }
 
 void MojoSharedBuffer_Create(Dart_NativeArguments arguments) {
   int64_t num_bytes = 0;
@@ skipping 504 matching lines @@
   CHECK_INTEGER_ARGUMENT(arguments, 0, &control_handle, InvalidArgument);
   mojo_control_handle = control_handle;
   Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(MOJO_RESULT_OK));
 }
 
 void MojoHandleWatcher_GetControlHandle(Dart_NativeArguments arguments) {
   Dart_SetIntegerReturnValue(arguments, mojo_control_handle);
 }
 
 }  // namespace blink