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;
+  // Even though IntegerValue returns int64_t, JavaScript cannot represent
+  // the full precision of int64_t, which means some rounding might occur.
+  *out = val->IntegerValue();
+  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;
 }
 
+v8::Handle<v8::String> StringToSymbol(v8::Isolate* isolate,
+                                      const std::string& val) {
+  return String::NewFromUtf8(isolate,
+                             val.data(),
+                             String::kInternalizedString,
+                             val.length());
+}
+
+
 }  // namespace gin