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