Add the c++ code part of bindings2/

sky/engine/bindings2/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 <stdio.h>
 #include <string.h>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
+#include "builtin.h"
 #include "dart/runtime/include/dart_api.h"
-#include "mojo/dart/embedder/builtin.h"
 #include "mojo/public/c/system/core.h"
 #include "mojo/public/cpp/system/core.h"
 
-namespace mojo {
-namespace dart {
+namespace blink {
+
+#define REGISTER_FUNCTION(name, count)                                         \
+  { "" #name, name, count },
+#define DECLARE_FUNCTION(name, count)                                          \
+  extern void name(Dart_NativeArguments args);
 
 #define MOJO_NATIVE_LIST(V)                \
   V(MojoSharedBuffer_Create, 2)            \
   V(MojoSharedBuffer_Duplicate, 2)         \
   V(MojoSharedBuffer_Map, 5)               \
   V(MojoSharedBuffer_Unmap, 1)             \
   V(MojoDataPipe_Create, 3)                \
   V(MojoDataPipe_WriteData, 4)             \
   V(MojoDataPipe_BeginWriteData, 3)        \
   V(MojoDataPipe_EndWriteData, 2)          \
@@ skipping 54 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() {
-  Dart_Handle core_lib_name = Dart_NewStringFromCString("dart:mojo_core");
-  return Dart_LookupLibrary(core_lib_name);
+  return DartBuiltins::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);
 }
 
@@ skipping 30 matching lines @@
   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, Dart_NewStringFromCString("_handle"));
+      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, Dart_NewStringFromCString("h"));
+      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;
@@ skipping 29 matching lines @@
   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(), Dart_NewStringFromCString("MojoHandleSignalsState"));
+      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));
   } else {
@@ skipping 38 matching lines @@
     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(), Dart_NewStringFromCString("MojoHandleSignalsState"));
+      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));
@@ skipping 519 matching lines @@
   int64_t control_handle;
   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 dart
-}  // namespace mojo
+}  // namespace blink