Begin implementing V8 bindings for Mojo

mojo/public/bindings/js/v8_wrapper.cc

Index: mojo/public/bindings/js/v8_wrapper.cc
diff --git a/mojo/public/bindings/js/v8_wrapper.cc b/mojo/public/bindings/js/v8_wrapper.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f39f714380422cb7f0817887c812670a9de03ee2
--- /dev/null
+++ b/mojo/public/bindings/js/v8_wrapper.cc
@@ -0,0 +1,50 @@
+// 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/v8_wrapper.h"
+
+namespace mojo {
+namespace js {
+
+WrapperInfo* WrapperInfo::From(v8::Handle<v8::Object> object) {
+  if (object->InternalFieldCount() != kNumberOfInternalFields)
+    return NULL;
+  return static_cast<WrapperInfo*>(
+      object->GetAlignedPointerFromInternalField(kWrapperInfoIndex));
+}
+
+// Wrapper<int32_t> -----------------------------------------------------------
+
+v8::Handle<v8::Value> Wrapper<int32_t>::ToObject(v8::Isolate* isolate,
+                                                 int32_t native) {
+  return v8::Integer::New(native);
+}
+
+int32_t Wrapper<int32_t>::ToNative(v8::Handle<v8::Value> value) {
+  return value->Int32Value();

[Aaron Boodman, 2013/11/09 08:26:02]

You probably want some way for this method to indicate conversion failure.

[abarth-chromium, 2013/11/09 08:52:37]

As written, the conversion can't really fail.  If I'm understanding the API
correctly, this is the moral equivalent of writing

(value)|0

in JavaScript.  Specifically, I believe it calls valueOf and then forces the
result to a number.  For example ({})|0 is 0.

Another option is to check IsNumber first and have a conversion that can fall. 
That might be more predictable for callers because it's not going to call
valueOf at surprising times.

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

For number it can't fail, but for, e.g., mojo::Handle, it can. Unless you want
it to just return null/undef for failure in those cases. That could be OK.

I think it is my personal preference as a user of APIs that they are strict,
throw errors, and don't coerce everything every which way automatically. It's
more common for me to get the argument list wrong than it is for me to actually
want to pass {} and have it be treated as a number.

+}
+
+// Wrapper<uint32_t> ----------------------------------------------------------
+
+v8::Handle<v8::Value> Wrapper<uint32_t>::ToObject(v8::Isolate* isolate,
+                                                  uint32_t native) {
+  return v8::Integer::NewFromUnsigned(native);
+}
+
+uint32_t Wrapper<uint32_t>::ToNative(v8::Handle<v8::Value> value) {
+  return value->Uint32Value();
+}
+
+// Wrapper<uint64_t> ----------------------------------------------------------
+
+v8::Handle<v8::Value> Wrapper<uint64_t>::ToObject(v8::Isolate* isolate,
+                                                  uint64_t native) {
+  return v8::Integer::NewFromUnsigned(native);
+}
+
+uint64_t Wrapper<uint64_t>::ToNative(v8::Handle<v8::Value> value) {
+  return value->IntegerValue();
+}
+}  // namespace js
+}  // mojo