Begin implementing V8 bindings for Mojo

gin/converter.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 "gin/converter.h"
 
 #include "v8/include/v8.h"
 
 using v8::Boolean;
 using v8::Function;
@@ skipping 31 matching lines @@
   return Integer::NewFromUnsigned(val, isolate).As<Value>();
 }
 
 bool Converter<uint32_t>::FromV8(Handle<Value> val, uint32_t* out) {
   if (!val->IsUint32())
     return false;
   *out = val->Uint32Value();
   return true;
 }
 
+Handle<Value> Converter<int64_t>::ToV8(Isolate* isolate, int64_t val) {
+  return Number::New(isolate, static_cast<double>(val)).As<Value>();
+}
+
+bool Converter<int64_t>::FromV8(Handle<Value> val, int64_t* out) {
+  if (!val->IsNumber())
+    return false;
+  *out = val->IntegerValue();

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

I was surprised to see that IntegerValue() returns int64_t. You might want to
add a comment to that effect.

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

Will do.

+  return true;
+}
+
+Handle<Value> Converter<uint64_t>::ToV8(Isolate* isolate, uint64_t val) {
+  return Number::New(isolate, static_cast<double>(val)).As<Value>();
+}
+
+bool Converter<uint64_t>::FromV8(Handle<Value> val, uint64_t* out) {
+  if (!val->IsNumber())
+    return false;
+  *out = static_cast<uint64_t>(val->IntegerValue());
+  return true;
+}
+
 Handle<Value> Converter<double>::ToV8(Isolate* isolate, double val) {
   return Number::New(isolate, val).As<Value>();
 }
 
 bool Converter<double>::FromV8(Handle<Value> val, double* out) {
   if (!val->IsNumber())
     return false;
   *out = val->NumberValue();
   return true;
 }
@@ skipping 18 matching lines @@
 }
 
 bool Converter<Handle<Function> >::FromV8(Handle<Value> val,
                                           Handle<Function>* out) {
   if (!val->IsFunction())
     return false;
   *out = Handle<Function>::Cast(val);
   return true;
 }
 
-Handle<Value> Converter<Handle<Object> >::ToV8(Handle<Object> val) {
+Handle<Value> Converter<Handle<Object> >::ToV8(v8::Isolate* isolate,
+                                               Handle<Object> val) {
   return val.As<Value>();
 }
 
 bool Converter<Handle<Object> >::FromV8(Handle<Value> val,
                                         Handle<Object>* out) {
   if (!val->IsObject())
     return false;
   *out = Handle<Object>::Cast(val);
   return true;
 }
 
 }  // namespace gin