gin/converter.cc

   1 // Copyright 2013 The Chromium Authors
   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 <stdint.h>
   8
   9 #include "base/strings/string_util.h"
  10 #include "base/time/time.h"
  11 #include "v8/include/v8-array-buffer.h"
  12 #include "v8/include/v8-external.h"
  13 #include "v8/include/v8-function.h"
  14 #include "v8/include/v8-maybe.h"
  15 #include "v8/include/v8-object.h"
  16 #include "v8/include/v8-primitive.h"
  17 #include "v8/include/v8-promise.h"
  18 #include "v8/include/v8-value.h"
  19
  20 using v8::ArrayBuffer;
  21 using v8::External;
  22 using v8::Function;
  23 using v8::Int32;
  24 using v8::Integer;
  25 using v8::Isolate;
  26 using v8::Local;
  27 using v8::Maybe;
  28 using v8::MaybeLocal;
  29 using v8::Number;
  30 using v8::Object;
  31 using v8::Promise;
  32 using v8::String;
  33 using v8::Uint32;
  34 using v8::Value;
  35
  36 namespace {
  37
  38 template <typename T, typename U>
  39 bool FromMaybe(Maybe<T> maybe, U* out) {
  40   if (maybe.IsNothing())
  41     return false;
  42   *out = static_cast<U>(maybe.FromJust());
  43   return true;
  44 }
  45
  46 }  // namespace
  47
  48 namespace gin {
  49
  50 Local<Value> Converter<bool>::ToV8(Isolate* isolate, bool val) {
  51   return v8::Boolean::New(isolate, val).As<Value>();
  52 }
  53
  54 bool Converter<bool>::FromV8(Isolate* isolate, Local<Value> val, bool* out) {
  55   *out = val->BooleanValue(isolate);
  56   // BooleanValue cannot throw.
  57   return true;
  58 }
  59
  60 Local<Value> Converter<int32_t>::ToV8(Isolate* isolate, int32_t val) {
  61   return Integer::New(isolate, val).As<Value>();
  62 }
  63
  64 bool Converter<int32_t>::FromV8(Isolate* isolate,
  65                                 Local<Value> val,
  66                                 int32_t* out) {
  67   if (!val->IsInt32())
  68     return false;
  69   *out = val.As<Int32>()->Value();
  70   return true;
  71 }
  72
  73 Local<Value> Converter<uint32_t>::ToV8(Isolate* isolate, uint32_t val) {
  74   return Integer::NewFromUnsigned(isolate, val).As<Value>();
  75 }
  76
  77 bool Converter<uint32_t>::FromV8(Isolate* isolate,
  78                                  Local<Value> val,
  79                                  uint32_t* out) {
  80   if (!val->IsUint32())
  81     return false;
  82   *out = val.As<Uint32>()->Value();
  83   return true;
  84 }
  85
  86 Local<Value> Converter<int64_t>::ToV8(Isolate* isolate, int64_t val) {
  87   return Number::New(isolate, static_cast<double>(val)).As<Value>();
  88 }
  89
  90 bool Converter<int64_t>::FromV8(Isolate* isolate,
  91                                 Local<Value> val,
  92                                 int64_t* out) {
  93   if (!val->IsNumber())
  94     return false;
  95   // Even though IntegerValue returns int64_t, JavaScript cannot represent
  96   // the full precision of int64_t, which means some rounding might occur.
  97   return FromMaybe(val->IntegerValue(isolate->GetCurrentContext()), out);
  98 }
  99
 100 Local<Value> Converter<uint64_t>::ToV8(Isolate* isolate, uint64_t val) {
 101   return Number::New(isolate, static_cast<double>(val)).As<Value>();
 102 }
 103
 104 bool Converter<uint64_t>::FromV8(Isolate* isolate,
 105                                  Local<Value> val,
 106                                  uint64_t* out) {
 107   if (!val->IsNumber())
 108     return false;
 109   return FromMaybe(val->IntegerValue(isolate->GetCurrentContext()), out);
 110 }
 111
 112 Local<Value> Converter<float>::ToV8(Isolate* isolate, float val) {
 113   return Number::New(isolate, val).As<Value>();
 114 }
 115
 116 bool Converter<float>::FromV8(Isolate* isolate, Local<Value> val, float* out) {
 117   if (!val->IsNumber())
 118     return false;
 119   *out = static_cast<float>(val.As<Number>()->Value());
 120   return true;
 121 }
 122
 123 Local<Value> Converter<double>::ToV8(Isolate* isolate, double val) {
 124   return Number::New(isolate, val).As<Value>();
 125 }
 126
 127 bool Converter<double>::FromV8(Isolate* isolate,
 128                                Local<Value> val,
 129                                double* out) {
 130   if (!val->IsNumber())
 131     return false;
 132   *out = val.As<Number>()->Value();
 133   return true;
 134 }
 135
 136 Local<Value> Converter<base::StringPiece>::ToV8(Isolate* isolate,
 137                                                 const base::StringPiece& val) {
 138   return String::NewFromUtf8(isolate, val.data(),
 139                              v8::NewStringType::kNormal,
 140                              static_cast<uint32_t>(val.length()))
 141       .ToLocalChecked();
 142 }
 143
 144 Local<Value> Converter<std::string>::ToV8(Isolate* isolate,
 145                                           const std::string& val) {
 146   return Converter<base::StringPiece>::ToV8(isolate, val);
 147 }
 148
 149 bool Converter<std::string>::FromV8(Isolate* isolate,
 150                                     Local<Value> val,
 151                                     std::string* out) {
 152   if (!val->IsString())
 153     return false;
 154   Local<String> str = Local<String>::Cast(val);
 155   int length = str->Utf8Length(isolate);
 156   out->resize(length);
 157   str->WriteUtf8(isolate, &(*out)[0], length, NULL,
 158                  String::NO_NULL_TERMINATION);
 159   return true;
 160 }
 161
 162 Local<Value> Converter<std::u16string>::ToV8(Isolate* isolate,
 163                                              const std::u16string& val) {
 164   return String::NewFromTwoByte(isolate,
 165                                 reinterpret_cast<const uint16_t*>(val.data()),
 166                                 v8::NewStringType::kNormal, val.size())
 167       .ToLocalChecked();
 168 }
 169
 170 bool Converter<std::u16string>::FromV8(Isolate* isolate,
 171                                        Local<Value> val,
 172                                        std::u16string* out) {
 173   if (!val->IsString())
 174     return false;
 175   Local<String> str = Local<String>::Cast(val);
 176   int length = str->Length();
 177   // Note that the reinterpret cast is because on Windows string16 is an alias
 178   // to wstring, and hence has character type wchar_t not uint16_t.
 179   str->Write(isolate,
 180              reinterpret_cast<uint16_t*>(base::WriteInto(out, length + 1)), 0,
 181              length);
 182   return true;
 183 }
 184
 185 v8::Local<v8::Value> Converter<base::TimeTicks>::ToV8(v8::Isolate* isolate,
 186                                                       base::TimeTicks val) {
 187   return v8::BigInt::New(isolate, val.since_origin().InMicroseconds())
 188       .As<v8::Value>();
 189 }
 190
 191 Local<Value> Converter<Local<Function>>::ToV8(Isolate* isolate,
 192                                               Local<Function> val) {
 193   return val.As<Value>();
 194 }
 195
 196 bool Converter<Local<Function>>::FromV8(Isolate* isolate,
 197                                         Local<Value> val,
 198                                         Local<Function>* out) {
 199   if (!val->IsFunction())
 200     return false;
 201   *out = Local<Function>::Cast(val);
 202   return true;
 203 }
 204
 205 Local<Value> Converter<Local<Object>>::ToV8(Isolate* isolate,
 206                                             Local<Object> val) {
 207   return val.As<Value>();
 208 }
 209
 210 bool Converter<Local<Object>>::FromV8(Isolate* isolate,
 211                                       Local<Value> val,
 212                                       Local<Object>* out) {
 213   if (!val->IsObject())
 214     return false;
 215   *out = Local<Object>::Cast(val);
 216   return true;
 217 }
 218
 219 Local<Value> Converter<Local<Promise>>::ToV8(Isolate* isolate,
 220                                              Local<Promise> val) {
 221   return val.As<Value>();
 222 }
 223
 224 bool Converter<Local<Promise>>::FromV8(Isolate* isolate,
 225                                        Local<Value> val,
 226                                        Local<Promise>* out) {
 227   if (!val->IsPromise())
 228     return false;
 229   *out = Local<Promise>::Cast(val);
 230   return true;
 231 }
 232
 233 Local<Value> Converter<Local<ArrayBuffer>>::ToV8(Isolate* isolate,
 234                                                  Local<ArrayBuffer> val) {
 235   return val.As<Value>();
 236 }
 237
 238 bool Converter<Local<ArrayBuffer>>::FromV8(Isolate* isolate,
 239                                            Local<Value> val,
 240                                            Local<ArrayBuffer>* out) {
 241   if (!val->IsArrayBuffer())
 242     return false;
 243   *out = Local<ArrayBuffer>::Cast(val);
 244   return true;
 245 }
 246
 247 Local<Value> Converter<Local<External>>::ToV8(Isolate* isolate,
 248                                               Local<External> val) {
 249   return val.As<Value>();
 250 }
 251
 252 bool Converter<Local<External>>::FromV8(Isolate* isolate,
 253                                         v8::Local<Value> val,
 254                                         Local<External>* out) {
 255   if (!val->IsExternal())
 256     return false;
 257   *out = Local<External>::Cast(val);
 258   return true;
 259 }
 260
 261 Local<Value> Converter<Local<Value>>::ToV8(Isolate* isolate, Local<Value> val) {
 262   return val;
 263 }
 264
 265 bool Converter<Local<Value>>::FromV8(Isolate* isolate,
 266                                      Local<Value> val,
 267                                      Local<Value>* out) {
 268   *out = val;
 269   return true;
 270 }
 271
 272 v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
 273                                       const base::StringPiece& val) {
 274   return String::NewFromUtf8(isolate, val.data(),
 275                              v8::NewStringType::kInternalized,
 276                              static_cast<uint32_t>(val.length()))
 277       .ToLocalChecked();
 278 }
 279
 280 v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
 281                                      const base::StringPiece16& val) {
 282   return String::NewFromTwoByte(isolate,
 283                                 reinterpret_cast<const uint16_t*>(val.data()),
 284                                 v8::NewStringType::kInternalized, val.length())
 285       .ToLocalChecked();
 286 }
 287
 288 std::string V8ToString(v8::Isolate* isolate, v8::Local<v8::Value> value) {
 289   if (value.IsEmpty())
 290     return std::string();
 291   std::string result;
 292   if (!ConvertFromV8(isolate, value, &result))
 293     return std::string();
 294   return result;
 295 }
 296
 297 }  // namespace gin