Begin implementing V8 bindings for Mojo

mojo/public/bindings/js/core.cc

+// Copyright 2013 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 "mojo/public/bindings/js/core.h"
+
+#include "gin/arguments.h"
+#include "gin/array_buffer.h"
+#include "gin/converter.h"
+#include "gin/dictionary.h"
+#include "gin/per_isolate_data.h"
+#include "gin/wrapper_info.h"
+#include "mojo/public/bindings/js/handle.h"
+
+namespace mojo {
+namespace js {
+
+namespace {
+
+void Close(const v8::FunctionCallbackInfo<v8::Value>& info) {

[Aaron Boodman, 2013/11/11 19:01:08]

The C++ template stuff I had in the other project would make many of these
functions almost disappear.

You'd just do:

templ->Set("setMonkey", gin::Bind(SetMonkey));
templ->Set("getMonkey", gin::Bind(GetMonkey));
... etc ...

I feel like it will also be useful for people like Jochen who want to start
using it to replacing CppBoundClass. Thoughts?

[abarth-chromium, 2013/11/11 20:17:42]

Yes, I think gin::Bind is super cool.  Would you like me to add that in this CL
or in the next CL.

[Aaron Boodman, 2013/11/11 20:33:23]

If you think it is useful, I will do it this week.

[abarth-chromium, 2013/11/11 21:05:49]

Thanks!

+  gin::Arguments args(info);
+
+  mojo::Handle handle;

[Aaron Boodman, 2013/11/11 19:01:08]

The uninitialized locals that Argument's interface encourages bug me. The
alternative would be to have Next() just return the value directly, and have it
be responsible for returning an empty value on error:

mojo::Handle handle = args.Next<mojo::Handle>();
Thing thing = args.Next<Thing>();
if (args.HasError()) {
  args.ThrowError();
}

This is more typing but eliminates the possibility of uninitialized mistakes.
WDYT?

[abarth-chromium, 2013/11/11 20:17:42]

Sure, we can do that.

[abarth-chromium, 2013/11/11 21:05:49]

Oh, I remember why I did it this way.  The problem is that ArrayBufferView needs
the v8::Isolate in it's contructor, which means GetNext won't be smart enough to
make one.

We could add some traits for initializing these types, but we'd have to know the
superset of what all objects need in their constructions...

I've changed this to initialize all the variables in this file.

+  if (!args.Next(&handle))
+    return args.ThrowTypeError("Expected mojo::Handle.");
+
+  args.Return(mojo::Close(handle));
+}
+
+void Wait(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  gin::Arguments args(info);
+
+  mojo::Handle handle;
+  if (!args.Next(&handle))
+    return args.ThrowTypeError("Expected mojo::Handle.");
+
+  MojoWaitFlags flags;
+  if (!args.Next(&flags))
+    return args.ThrowTypeError("Expected MojoWaitFlags.");
+
+  MojoDeadline deadline;
+  if (!args.Next(&deadline))
+    return args.ThrowTypeError("Expected MojoDeadline.");
+
+  args.Return(mojo::Wait(handle, flags, deadline));
+}
+
+void WaitMany(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  gin::Arguments args(info);
+
+  std::vector<mojo::Handle> handles;
+  if (!args.Next(&handles))
+    return args.ThrowTypeError("Expected array of mojo::Handle.");
+
+  std::vector<MojoWaitFlags> flags;
+  if (!args.Next(&flags))
+    return args.ThrowTypeError("Expected array of MojoWaitFlags.");
+
+  if (handles.size() != flags.size())
+    return args.ThrowTypeError("Arrays must have the same length.");
+
+  MojoDeadline deadline;
+  if (!args.Next(&deadline))
+    return args.ThrowTypeError("Expected MojoDeadline.");
+
+  args.Return(mojo::WaitMany(handles.data(), flags.data(),
+                             handles.size(), deadline));
+}
+
+void CreateMessagePipe(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  gin::Arguments args(info);
+
+  mojo::Handle handle_0 = mojo::kInvalidHandle;
+  mojo::Handle handle_1 = mojo::kInvalidHandle;
+  MojoResult result = mojo::CreateMessagePipe(&handle_0, &handle_1);
+
+  gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(info.GetIsolate());
+  dictionary.Set("result", result);
+  dictionary.Set("handle0", handle_0);
+  dictionary.Set("handle1", handle_1);
+  args.Return(dictionary);
+}
+
+void WriteMessage(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  gin::Arguments args(info);
+
+  mojo::Handle handle;
+  if (!args.Next(&handle))
+    return args.ThrowTypeError("Expected mojo::Handle.");
+
+  gin::ArrayBufferView buffer(args.isolate());
+  if (!args.Next(&buffer))
+    return args.ThrowTypeError("Expected ArrayBufferView.");
+
+  std::vector<mojo::Handle> handles;
+  if (!args.Next(&handles))
+    return args.ThrowTypeError("Expected array of mojo::Handle.");
+
+  MojoWaitFlags flags;
+  if (!args.Next(&flags))
+    return args.ThrowTypeError("Expected MojoWaitFlags.");

[Aaron Boodman, 2013/11/11 19:01:08]

I think you should make Arguments responsible for accumulating errors and
creating an error message:

if (!args.Next(&handle) ||
    !args.Next(&buffer) ||
    !args.Next(&handles) ... {
  return args.ThrowError();
}

I also think you'll want the error messages to indicates the index of the
incorrect argument, which Arguments is in a better position to do than the
client code.

[abarth-chromium, 2013/11/11 20:17:42]

Makes sense.  It won't know how to stringify the types, but reporting the
position is probably more valuable.

[Aaron Boodman, 2013/11/11 21:12:49]

Note: you didn't address this one. I'm fine with it in the next CL though.

+
+  args.Return(mojo::WriteMessage(handle, buffer.bytes(), buffer.num_bytes(),
+                                 handles.data(), handles.size(), flags));
+}
+
+void ReadMessage(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  gin::Arguments args(info);
+
+  mojo::Handle handle;
+  if (!args.Next(&handle))
+    return args.ThrowTypeError("Expected mojo::Handle.");
+
+  gin::ArrayBufferView buffer(args.isolate());
+  if (!args.Next(&buffer))
+    return args.ThrowTypeError("Expected ArrayBufferView.");
+
+  uint32_t num_handles;
+  if (!args.Next(&num_handles))
+    return args.ThrowTypeError("Expected uint32_t.");
+
+  MojoWaitFlags flags;
+  if (!args.Next(&flags))
+    return args.ThrowTypeError("Expected MojoWaitFlags.");
+
+  uint32_t num_bytes = buffer.num_bytes();
+  std::vector<mojo::Handle> handles(num_handles);
+  MojoResult result = mojo::ReadMessage(handle, buffer.bytes(), &num_bytes,
+                                        handles.data(), &num_handles, flags);
+  handles.resize(num_handles);
+
+  // TODO(abarth): We should benchmark this codepath to make sure it's ok to
+  // allocate all this memory on each read.
+  gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(info.GetIsolate());
+  dictionary.Set("result", result);
+  dictionary.Set("bytesRead", num_bytes);
+  dictionary.Set("handles", handles);
+  args.Return(dictionary);
+}
+
+gin::WrapperInfo g_core_wrapper_info = {};
+
+}
+
+v8::Local<v8::ObjectTemplate> CoreTemplate(v8::Isolate* isolate) {
+  gin::PerIsolateData* data = gin::PerIsolateData::From(isolate);
+  v8::Local<v8::ObjectTemplate> templ;
+  if (!data->GetObjectTemplate(&g_core_wrapper_info, &templ)) {
+    templ = v8::ObjectTemplate::New();
+
+    templ->Set(gin::StringToV8(isolate, "close"),
+               v8::FunctionTemplate::New(Close));
+    templ->Set(gin::StringToV8(isolate, "wait"),
+               v8::FunctionTemplate::New(Wait));
+    templ->Set(gin::StringToV8(isolate, "waitMany"),
+               v8::FunctionTemplate::New(WaitMany));
+    templ->Set(gin::StringToV8(isolate, "createMessagePipe"),
+               v8::FunctionTemplate::New(CreateMessagePipe));
+    templ->Set(gin::StringToV8(isolate, "writeMessage"),
+               v8::FunctionTemplate::New(WriteMessage));
+    templ->Set(gin::StringToV8(isolate, "readMessage"),
+               v8::FunctionTemplate::New(ReadMessage));
+
+    data->RegisterObjectTemplate(&g_core_wrapper_info, templ);
+  }
+
+  return templ;
+}
+
+}  // namespace js
+}  // namespace mojo