gin/converter.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gin/converter.h"
   6
   7 #include "v8/include/v8.h"
   8
   9 using v8::ArrayBuffer;
  10 using v8::Boolean;
  11 using v8::External;
  12 using v8::Function;
  13 using v8::Handle;
  14 using v8::Integer;
  15 using v8::Isolate;
  16 using v8::Number;
  17 using v8::Object;
  18 using v8::String;
  19 using v8::Value;
  20
  21 namespace gin {
  22
  23 Handle<Value> Converter<bool>::ToV8(Isolate* isolate, bool val) {
  24   return Boolean::New(val).As<Value>();
  25 }
  26
  27 bool Converter<bool>::FromV8(Handle<Value> val, bool* out) {
  28   *out = val->BooleanValue();
  29   return true;
  30 }
  31
  32 Handle<Value> Converter<int32_t>::ToV8(Isolate* isolate, int32_t val) {
  33   return Integer::New(val, isolate).As<Value>();
  34 }
  35
  36 bool Converter<int32_t>::FromV8(Handle<Value> val, int32_t* out) {
  37   if (!val->IsInt32())
  38     return false;
  39   *out = val->Int32Value();
  40   return true;
  41 }
  42
  43 Handle<Value> Converter<uint32_t>::ToV8(Isolate* isolate, uint32_t val) {
  44   return Integer::NewFromUnsigned(val, isolate).As<Value>();
  45 }
  46
  47 bool Converter<uint32_t>::FromV8(Handle<Value> val, uint32_t* out) {
  48   if (!val->IsUint32())
  49     return false;
  50   *out = val->Uint32Value();
  51   return true;
  52 }
  53
  54 Handle<Value> Converter<int64_t>::ToV8(Isolate* isolate, int64_t val) {
  55   return Number::New(isolate, static_cast<double>(val)).As<Value>();
  56 }
  57
  58 bool Converter<int64_t>::FromV8(Handle<Value> val, int64_t* out) {
  59   if (!val->IsNumber())
  60     return false;
  61   // Even though IntegerValue returns int64_t, JavaScript cannot represent
  62   // the full precision of int64_t, which means some rounding might occur.
  63   *out = val->IntegerValue();
  64   return true;
  65 }
  66
  67 Handle<Value> Converter<uint64_t>::ToV8(Isolate* isolate, uint64_t val) {
  68   return Number::New(isolate, static_cast<double>(val)).As<Value>();
  69 }
  70
  71 bool Converter<uint64_t>::FromV8(Handle<Value> val, uint64_t* out) {
  72   if (!val->IsNumber())
  73     return false;
  74   *out = static_cast<uint64_t>(val->IntegerValue());
  75   return true;
  76 }
  77
  78 Handle<Value> Converter<double>::ToV8(Isolate* isolate, double val) {
  79   return Number::New(isolate, val).As<Value>();
  80 }
  81
  82 bool Converter<double>::FromV8(Handle<Value> val, double* out) {
  83   if (!val->IsNumber())
  84     return false;
  85   *out = val->NumberValue();
  86   return true;
  87 }
  88
  89 Handle<Value> Converter<std::string>::ToV8(Isolate* isolate,
  90                                            const std::string& val) {
  91   return String::NewFromUtf8(isolate,
  92                              val.data(),
  93                              String::kNormalString,
  94                              static_cast<uint32_t>(val.length()));
  95 }
  96
  97 bool Converter<std::string>::FromV8(Handle<Value> val,
  98                                     std::string* out) {
  99   if (!val->IsString())
 100     return false;
 101   Handle<String> str = Handle<String>::Cast(val);
 102   int length = str->Utf8Length();
 103   out->resize(length);
 104   str->WriteUtf8(&(*out)[0], length, NULL, String::NO_NULL_TERMINATION);
 105   return true;
 106 }
 107
 108 bool Converter<Handle<Function> >::FromV8(Handle<Value> val,
 109                                           Handle<Function>* out) {
 110   if (!val->IsFunction())
 111     return false;
 112   *out = Handle<Function>::Cast(val);
 113   return true;
 114 }
 115
 116 Handle<Value> Converter<Handle<Object> >::ToV8(v8::Isolate* isolate,
 117                                                Handle<Object> val) {
 118   return val.As<Value>();
 119 }
 120
 121 bool Converter<Handle<Object> >::FromV8(Handle<Value> val,
 122                                         Handle<Object>* out) {
 123   if (!val->IsObject())
 124     return false;
 125   *out = Handle<Object>::Cast(val);
 126   return true;
 127 }
 128
 129 Handle<Value> Converter<Handle<ArrayBuffer> >::ToV8(v8::Isolate* isolate,
 130                                                     Handle<ArrayBuffer> val) {
 131   return val.As<Value>();
 132 }
 133
 134 bool Converter<Handle<ArrayBuffer> >::FromV8(Handle<Value> val,
 135                                              Handle<ArrayBuffer>* out) {
 136   if (!val->IsArrayBuffer())
 137     return false;
 138   *out = Handle<ArrayBuffer>::Cast(val);
 139   return true;
 140 }
 141
 142 Handle<Value> Converter<Handle<External> >::ToV8(v8::Isolate* isolate,
 143                                                  Handle<External> val) {
 144   return val.As<Value>();
 145 }
 146
 147 bool Converter<Handle<External> >::FromV8(Handle<Value> val,
 148                                           Handle<External>* out) {
 149   if (!val->IsExternal())
 150     return false;
 151   *out = Handle<External>::Cast(val);
 152   return true;
 153 }
 154
 155 Handle<Value> Converter<Handle<Value> >::ToV8(v8::Isolate* isolate,
 156                                               Handle<Value> val) {
 157   return val;
 158 }
 159
 160 bool Converter<Handle<Value> >::FromV8(Handle<Value> val,
 161                                        Handle<Value>* out) {
 162   *out = val;
 163   return true;
 164 }
 165
 166 v8::Handle<v8::String> StringToSymbol(v8::Isolate* isolate,
 167                                       const std::string& val) {
 168   return String::NewFromUtf8(isolate,
 169                              val.data(),
 170                              String::kInternalizedString,
 171                              static_cast<uint32_t>(val.length()));
 172 }
 173
 174
 175 }  // namespace gin