OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "gin/converter.h" | 5 #include "gin/converter.h" |
6 | 6 |
7 #include "v8/include/v8.h" | 7 #include "v8/include/v8.h" |
8 | 8 |
9 using v8::ArrayBuffer; | 9 using v8::ArrayBuffer; |
10 using v8::Boolean; | 10 using v8::Boolean; |
11 using v8::External; | 11 using v8::External; |
12 using v8::Function; | 12 using v8::Function; |
| 13 using v8::Int32; |
13 using v8::Integer; | 14 using v8::Integer; |
14 using v8::Isolate; | 15 using v8::Isolate; |
15 using v8::Local; | 16 using v8::Local; |
| 17 using v8::Maybe; |
| 18 using v8::MaybeLocal; |
16 using v8::Number; | 19 using v8::Number; |
17 using v8::Object; | 20 using v8::Object; |
18 using v8::String; | 21 using v8::String; |
| 22 using v8::Uint32; |
19 using v8::Value; | 23 using v8::Value; |
20 | 24 |
| 25 namespace { |
| 26 |
| 27 template <typename T, typename U> |
| 28 bool FromMaybe(Maybe<T> maybe, U* out) { |
| 29 if (maybe.IsNothing()) |
| 30 return false; |
| 31 *out = static_cast<U>(maybe.FromJust()); |
| 32 return true; |
| 33 } |
| 34 |
| 35 } // namespace |
| 36 |
21 namespace gin { | 37 namespace gin { |
22 | 38 |
23 Local<Value> Converter<bool>::ToV8(Isolate* isolate, bool val) { | 39 Local<Value> Converter<bool>::ToV8(Isolate* isolate, bool val) { |
24 return Boolean::New(isolate, val).As<Value>(); | 40 return Boolean::New(isolate, val).As<Value>(); |
25 } | 41 } |
26 | 42 |
27 bool Converter<bool>::FromV8(Isolate* isolate, Local<Value> val, bool* out) { | 43 bool Converter<bool>::FromV8(Isolate* isolate, Local<Value> val, bool* out) { |
28 *out = val->BooleanValue(); | 44 return FromMaybe(val->BooleanValue(isolate->GetCurrentContext()), out); |
29 return true; | |
30 } | 45 } |
31 | 46 |
32 Local<Value> Converter<int32_t>::ToV8(Isolate* isolate, int32_t val) { | 47 Local<Value> Converter<int32_t>::ToV8(Isolate* isolate, int32_t val) { |
33 return Integer::New(isolate, val).As<Value>(); | 48 return Integer::New(isolate, val).As<Value>(); |
34 } | 49 } |
35 | 50 |
36 bool Converter<int32_t>::FromV8(Isolate* isolate, | 51 bool Converter<int32_t>::FromV8(Isolate* isolate, |
37 Local<Value> val, | 52 Local<Value> val, |
38 int32_t* out) { | 53 int32_t* out) { |
39 if (!val->IsInt32()) | 54 if (!val->IsInt32()) |
40 return false; | 55 return false; |
41 *out = val->Int32Value(); | 56 *out = val.As<Int32>()->Value(); |
42 return true; | 57 return true; |
43 } | 58 } |
44 | 59 |
45 Local<Value> Converter<uint32_t>::ToV8(Isolate* isolate, uint32_t val) { | 60 Local<Value> Converter<uint32_t>::ToV8(Isolate* isolate, uint32_t val) { |
46 return Integer::NewFromUnsigned(isolate, val).As<Value>(); | 61 return Integer::NewFromUnsigned(isolate, val).As<Value>(); |
47 } | 62 } |
48 | 63 |
49 bool Converter<uint32_t>::FromV8(Isolate* isolate, | 64 bool Converter<uint32_t>::FromV8(Isolate* isolate, |
50 Local<Value> val, | 65 Local<Value> val, |
51 uint32_t* out) { | 66 uint32_t* out) { |
52 if (!val->IsUint32()) | 67 if (!val->IsUint32()) |
53 return false; | 68 return false; |
54 *out = val->Uint32Value(); | 69 *out = val.As<Uint32>()->Value(); |
55 return true; | 70 return true; |
56 } | 71 } |
57 | 72 |
58 Local<Value> Converter<int64_t>::ToV8(Isolate* isolate, int64_t val) { | 73 Local<Value> Converter<int64_t>::ToV8(Isolate* isolate, int64_t val) { |
59 return Number::New(isolate, static_cast<double>(val)).As<Value>(); | 74 return Number::New(isolate, static_cast<double>(val)).As<Value>(); |
60 } | 75 } |
61 | 76 |
62 bool Converter<int64_t>::FromV8(Isolate* isolate, | 77 bool Converter<int64_t>::FromV8(Isolate* isolate, |
63 Local<Value> val, | 78 Local<Value> val, |
64 int64_t* out) { | 79 int64_t* out) { |
65 if (!val->IsNumber()) | 80 if (!val->IsNumber()) |
66 return false; | 81 return false; |
67 // Even though IntegerValue returns int64_t, JavaScript cannot represent | 82 // Even though IntegerValue returns int64_t, JavaScript cannot represent |
68 // the full precision of int64_t, which means some rounding might occur. | 83 // the full precision of int64_t, which means some rounding might occur. |
69 *out = val->IntegerValue(); | 84 return FromMaybe(val->IntegerValue(isolate->GetCurrentContext()), out); |
70 return true; | |
71 } | 85 } |
72 | 86 |
73 Local<Value> Converter<uint64_t>::ToV8(Isolate* isolate, uint64_t val) { | 87 Local<Value> Converter<uint64_t>::ToV8(Isolate* isolate, uint64_t val) { |
74 return Number::New(isolate, static_cast<double>(val)).As<Value>(); | 88 return Number::New(isolate, static_cast<double>(val)).As<Value>(); |
75 } | 89 } |
76 | 90 |
77 bool Converter<uint64_t>::FromV8(Isolate* isolate, | 91 bool Converter<uint64_t>::FromV8(Isolate* isolate, |
78 Local<Value> val, | 92 Local<Value> val, |
79 uint64_t* out) { | 93 uint64_t* out) { |
80 if (!val->IsNumber()) | 94 if (!val->IsNumber()) |
81 return false; | 95 return false; |
82 *out = static_cast<uint64_t>(val->IntegerValue()); | 96 return FromMaybe(val->IntegerValue(isolate->GetCurrentContext()), out); |
83 return true; | |
84 } | 97 } |
85 | 98 |
86 Local<Value> Converter<float>::ToV8(Isolate* isolate, float val) { | 99 Local<Value> Converter<float>::ToV8(Isolate* isolate, float val) { |
87 return Number::New(isolate, val).As<Value>(); | 100 return Number::New(isolate, val).As<Value>(); |
88 } | 101 } |
89 | 102 |
90 bool Converter<float>::FromV8(Isolate* isolate, Local<Value> val, float* out) { | 103 bool Converter<float>::FromV8(Isolate* isolate, Local<Value> val, float* out) { |
91 if (!val->IsNumber()) | 104 if (!val->IsNumber()) |
92 return false; | 105 return false; |
93 *out = static_cast<float>(val->NumberValue()); | 106 *out = static_cast<float>(val.As<Number>()->Value()); |
94 return true; | 107 return true; |
95 } | 108 } |
96 | 109 |
97 Local<Value> Converter<double>::ToV8(Isolate* isolate, double val) { | 110 Local<Value> Converter<double>::ToV8(Isolate* isolate, double val) { |
98 return Number::New(isolate, val).As<Value>(); | 111 return Number::New(isolate, val).As<Value>(); |
99 } | 112 } |
100 | 113 |
101 bool Converter<double>::FromV8(Isolate* isolate, | 114 bool Converter<double>::FromV8(Isolate* isolate, |
102 Local<Value> val, | 115 Local<Value> val, |
103 double* out) { | 116 double* out) { |
104 if (!val->IsNumber()) | 117 if (!val->IsNumber()) |
105 return false; | 118 return false; |
106 *out = val->NumberValue(); | 119 *out = val.As<Number>()->Value(); |
107 return true; | 120 return true; |
108 } | 121 } |
109 | 122 |
110 Local<Value> Converter<base::StringPiece>::ToV8(Isolate* isolate, | 123 Local<Value> Converter<base::StringPiece>::ToV8(Isolate* isolate, |
111 const base::StringPiece& val) { | 124 const base::StringPiece& val) { |
112 return String::NewFromUtf8(isolate, val.data(), String::kNormalString, | 125 return String::NewFromUtf8(isolate, val.data(), |
113 static_cast<uint32_t>(val.length())); | 126 v8::NewStringType::kNormal, |
| 127 static_cast<uint32_t>(val.length())) |
| 128 .ToLocalChecked(); |
114 } | 129 } |
115 | 130 |
116 Local<Value> Converter<std::string>::ToV8(Isolate* isolate, | 131 Local<Value> Converter<std::string>::ToV8(Isolate* isolate, |
117 const std::string& val) { | 132 const std::string& val) { |
118 return Converter<base::StringPiece>::ToV8(isolate, val); | 133 return Converter<base::StringPiece>::ToV8(isolate, val); |
119 } | 134 } |
120 | 135 |
121 bool Converter<std::string>::FromV8(Isolate* isolate, | 136 bool Converter<std::string>::FromV8(Isolate* isolate, |
122 Local<Value> val, | 137 Local<Value> val, |
123 std::string* out) { | 138 std::string* out) { |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
187 | 202 |
188 bool Converter<Local<Value>>::FromV8(Isolate* isolate, | 203 bool Converter<Local<Value>>::FromV8(Isolate* isolate, |
189 Local<Value> val, | 204 Local<Value> val, |
190 Local<Value>* out) { | 205 Local<Value>* out) { |
191 *out = val; | 206 *out = val; |
192 return true; | 207 return true; |
193 } | 208 } |
194 | 209 |
195 v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate, | 210 v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate, |
196 const base::StringPiece& val) { | 211 const base::StringPiece& val) { |
197 return String::NewFromUtf8(isolate, | 212 return String::NewFromUtf8(isolate, val.data(), |
198 val.data(), | 213 v8::NewStringType::kInternalized, |
199 String::kInternalizedString, | 214 static_cast<uint32_t>(val.length())) |
200 static_cast<uint32_t>(val.length())); | 215 .ToLocalChecked(); |
201 } | 216 } |
202 | 217 |
203 std::string V8ToString(v8::Local<v8::Value> value) { | 218 std::string V8ToString(v8::Local<v8::Value> value) { |
204 if (value.IsEmpty()) | 219 if (value.IsEmpty()) |
205 return std::string(); | 220 return std::string(); |
206 std::string result; | 221 std::string result; |
207 if (!ConvertFromV8(NULL, value, &result)) | 222 if (!ConvertFromV8(NULL, value, &result)) |
208 return std::string(); | 223 return std::string(); |
209 return result; | 224 return result; |
210 } | 225 } |
211 | 226 |
212 } // namespace gin | 227 } // namespace gin |
OLD | NEW |