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::Handle; | 13 using v8::Handle; |
14 using v8::Integer; | 14 using v8::Integer; |
15 using v8::Isolate; | 15 using v8::Isolate; |
16 using v8::Number; | 16 using v8::Number; |
17 using v8::Object; | 17 using v8::Object; |
18 using v8::String; | 18 using v8::String; |
19 using v8::Value; | 19 using v8::Value; |
20 | 20 |
21 namespace gin { | 21 namespace gin { |
22 | 22 |
23 Handle<Value> Converter<bool>::ToV8(Isolate* isolate, bool val) { | 23 Handle<Value> Converter<bool>::ToV8(Isolate* isolate, bool val) { |
24 return Boolean::New(val).As<Value>(); | 24 return Boolean::New(val).As<Value>(); |
25 } | 25 } |
26 | 26 |
27 bool Converter<bool>::FromV8(Handle<Value> val, bool* out) { | 27 bool Converter<bool>::FromV8(Isolate* isolate, Handle<Value> val, bool* out) { |
28 *out = val->BooleanValue(); | 28 *out = val->BooleanValue(); |
29 return true; | 29 return true; |
30 } | 30 } |
31 | 31 |
32 Handle<Value> Converter<int32_t>::ToV8(Isolate* isolate, int32_t val) { | 32 Handle<Value> Converter<int32_t>::ToV8(Isolate* isolate, int32_t val) { |
33 return Integer::New(val, isolate).As<Value>(); | 33 return Integer::New(val, isolate).As<Value>(); |
34 } | 34 } |
35 | 35 |
36 bool Converter<int32_t>::FromV8(Handle<Value> val, int32_t* out) { | 36 bool Converter<int32_t>::FromV8(Isolate* isolate, Handle<Value> val, |
| 37 int32_t* out) { |
37 if (!val->IsInt32()) | 38 if (!val->IsInt32()) |
38 return false; | 39 return false; |
39 *out = val->Int32Value(); | 40 *out = val->Int32Value(); |
40 return true; | 41 return true; |
41 } | 42 } |
42 | 43 |
43 Handle<Value> Converter<uint32_t>::ToV8(Isolate* isolate, uint32_t val) { | 44 Handle<Value> Converter<uint32_t>::ToV8(Isolate* isolate, uint32_t val) { |
44 return Integer::NewFromUnsigned(val, isolate).As<Value>(); | 45 return Integer::NewFromUnsigned(val, isolate).As<Value>(); |
45 } | 46 } |
46 | 47 |
47 bool Converter<uint32_t>::FromV8(Handle<Value> val, uint32_t* out) { | 48 bool Converter<uint32_t>::FromV8(Isolate* isolate, Handle<Value> val, |
| 49 uint32_t* out) { |
48 if (!val->IsUint32()) | 50 if (!val->IsUint32()) |
49 return false; | 51 return false; |
50 *out = val->Uint32Value(); | 52 *out = val->Uint32Value(); |
51 return true; | 53 return true; |
52 } | 54 } |
53 | 55 |
54 Handle<Value> Converter<int64_t>::ToV8(Isolate* isolate, int64_t val) { | 56 Handle<Value> Converter<int64_t>::ToV8(Isolate* isolate, int64_t val) { |
55 return Number::New(isolate, static_cast<double>(val)).As<Value>(); | 57 return Number::New(isolate, static_cast<double>(val)).As<Value>(); |
56 } | 58 } |
57 | 59 |
58 bool Converter<int64_t>::FromV8(Handle<Value> val, int64_t* out) { | 60 bool Converter<int64_t>::FromV8(Isolate* isolate, Handle<Value> val, |
| 61 int64_t* out) { |
59 if (!val->IsNumber()) | 62 if (!val->IsNumber()) |
60 return false; | 63 return false; |
61 // Even though IntegerValue returns int64_t, JavaScript cannot represent | 64 // Even though IntegerValue returns int64_t, JavaScript cannot represent |
62 // the full precision of int64_t, which means some rounding might occur. | 65 // the full precision of int64_t, which means some rounding might occur. |
63 *out = val->IntegerValue(); | 66 *out = val->IntegerValue(); |
64 return true; | 67 return true; |
65 } | 68 } |
66 | 69 |
67 Handle<Value> Converter<uint64_t>::ToV8(Isolate* isolate, uint64_t val) { | 70 Handle<Value> Converter<uint64_t>::ToV8(Isolate* isolate, uint64_t val) { |
68 return Number::New(isolate, static_cast<double>(val)).As<Value>(); | 71 return Number::New(isolate, static_cast<double>(val)).As<Value>(); |
69 } | 72 } |
70 | 73 |
71 bool Converter<uint64_t>::FromV8(Handle<Value> val, uint64_t* out) { | 74 bool Converter<uint64_t>::FromV8(Isolate* isolate, Handle<Value> val, |
| 75 uint64_t* out) { |
72 if (!val->IsNumber()) | 76 if (!val->IsNumber()) |
73 return false; | 77 return false; |
74 *out = static_cast<uint64_t>(val->IntegerValue()); | 78 *out = static_cast<uint64_t>(val->IntegerValue()); |
75 return true; | 79 return true; |
76 } | 80 } |
77 | 81 |
78 Handle<Value> Converter<double>::ToV8(Isolate* isolate, double val) { | 82 Handle<Value> Converter<double>::ToV8(Isolate* isolate, double val) { |
79 return Number::New(isolate, val).As<Value>(); | 83 return Number::New(isolate, val).As<Value>(); |
80 } | 84 } |
81 | 85 |
82 bool Converter<double>::FromV8(Handle<Value> val, double* out) { | 86 bool Converter<double>::FromV8(Isolate* isolate, Handle<Value> val, |
| 87 double* out) { |
83 if (!val->IsNumber()) | 88 if (!val->IsNumber()) |
84 return false; | 89 return false; |
85 *out = val->NumberValue(); | 90 *out = val->NumberValue(); |
86 return true; | 91 return true; |
87 } | 92 } |
88 | 93 |
89 Handle<Value> Converter<std::string>::ToV8(Isolate* isolate, | 94 Handle<Value> Converter<std::string>::ToV8(Isolate* isolate, |
90 const std::string& val) { | 95 const std::string& val) { |
91 return String::NewFromUtf8(isolate, | 96 return String::NewFromUtf8(isolate, |
92 val.data(), | 97 val.data(), |
93 String::kNormalString, | 98 String::kNormalString, |
94 static_cast<uint32_t>(val.length())); | 99 static_cast<uint32_t>(val.length())); |
95 } | 100 } |
96 | 101 |
97 bool Converter<std::string>::FromV8(Handle<Value> val, | 102 bool Converter<std::string>::FromV8(Isolate* isolate, Handle<Value> val, |
98 std::string* out) { | 103 std::string* out) { |
99 if (!val->IsString()) | 104 if (!val->IsString()) |
100 return false; | 105 return false; |
101 Handle<String> str = Handle<String>::Cast(val); | 106 Handle<String> str = Handle<String>::Cast(val); |
102 int length = str->Utf8Length(); | 107 int length = str->Utf8Length(); |
103 out->resize(length); | 108 out->resize(length); |
104 str->WriteUtf8(&(*out)[0], length, NULL, String::NO_NULL_TERMINATION); | 109 str->WriteUtf8(&(*out)[0], length, NULL, String::NO_NULL_TERMINATION); |
105 return true; | 110 return true; |
106 } | 111 } |
107 | 112 |
108 bool Converter<Handle<Function> >::FromV8(Handle<Value> val, | 113 bool Converter<Handle<Function> >::FromV8(Isolate* isolate, Handle<Value> val, |
109 Handle<Function>* out) { | 114 Handle<Function>* out) { |
110 if (!val->IsFunction()) | 115 if (!val->IsFunction()) |
111 return false; | 116 return false; |
112 *out = Handle<Function>::Cast(val); | 117 *out = Handle<Function>::Cast(val); |
113 return true; | 118 return true; |
114 } | 119 } |
115 | 120 |
116 Handle<Value> Converter<Handle<Object> >::ToV8(v8::Isolate* isolate, | 121 Handle<Value> Converter<Handle<Object> >::ToV8(Isolate* isolate, |
117 Handle<Object> val) { | 122 Handle<Object> val) { |
118 return val.As<Value>(); | 123 return val.As<Value>(); |
119 } | 124 } |
120 | 125 |
121 bool Converter<Handle<Object> >::FromV8(Handle<Value> val, | 126 bool Converter<Handle<Object> >::FromV8(Isolate* isolate, Handle<Value> val, |
122 Handle<Object>* out) { | 127 Handle<Object>* out) { |
123 if (!val->IsObject()) | 128 if (!val->IsObject()) |
124 return false; | 129 return false; |
125 *out = Handle<Object>::Cast(val); | 130 *out = Handle<Object>::Cast(val); |
126 return true; | 131 return true; |
127 } | 132 } |
128 | 133 |
129 Handle<Value> Converter<Handle<ArrayBuffer> >::ToV8(v8::Isolate* isolate, | 134 Handle<Value> Converter<Handle<ArrayBuffer> >::ToV8(Isolate* isolate, |
130 Handle<ArrayBuffer> val) { | 135 Handle<ArrayBuffer> val) { |
131 return val.As<Value>(); | 136 return val.As<Value>(); |
132 } | 137 } |
133 | 138 |
134 bool Converter<Handle<ArrayBuffer> >::FromV8(Handle<Value> val, | 139 bool Converter<Handle<ArrayBuffer> >::FromV8(Isolate* isolate, |
| 140 Handle<Value> val, |
135 Handle<ArrayBuffer>* out) { | 141 Handle<ArrayBuffer>* out) { |
136 if (!val->IsArrayBuffer()) | 142 if (!val->IsArrayBuffer()) |
137 return false; | 143 return false; |
138 *out = Handle<ArrayBuffer>::Cast(val); | 144 *out = Handle<ArrayBuffer>::Cast(val); |
139 return true; | 145 return true; |
140 } | 146 } |
141 | 147 |
142 Handle<Value> Converter<Handle<External> >::ToV8(v8::Isolate* isolate, | 148 Handle<Value> Converter<Handle<External> >::ToV8(Isolate* isolate, |
143 Handle<External> val) { | 149 Handle<External> val) { |
144 return val.As<Value>(); | 150 return val.As<Value>(); |
145 } | 151 } |
146 | 152 |
147 bool Converter<Handle<External> >::FromV8(Handle<Value> val, | 153 bool Converter<Handle<External> >::FromV8(Isolate* isolate, |
| 154 v8::Handle<Value> val, |
148 Handle<External>* out) { | 155 Handle<External>* out) { |
149 if (!val->IsExternal()) | 156 if (!val->IsExternal()) |
150 return false; | 157 return false; |
151 *out = Handle<External>::Cast(val); | 158 *out = Handle<External>::Cast(val); |
152 return true; | 159 return true; |
153 } | 160 } |
154 | 161 |
155 Handle<Value> Converter<Handle<Value> >::ToV8(v8::Isolate* isolate, | 162 Handle<Value> Converter<Handle<Value> >::ToV8(Isolate* isolate, |
156 Handle<Value> val) { | 163 Handle<Value> val) { |
157 return val; | 164 return val; |
158 } | 165 } |
159 | 166 |
160 bool Converter<Handle<Value> >::FromV8(Handle<Value> val, | 167 bool Converter<Handle<Value> >::FromV8(Isolate* isolate, Handle<Value> val, |
161 Handle<Value>* out) { | 168 Handle<Value>* out) { |
162 *out = val; | 169 *out = val; |
163 return true; | 170 return true; |
164 } | 171 } |
165 | 172 |
166 v8::Handle<v8::String> StringToSymbol(v8::Isolate* isolate, | 173 v8::Handle<v8::String> StringToSymbol(v8::Isolate* isolate, |
167 const std::string& val) { | 174 const std::string& val) { |
168 return String::NewFromUtf8(isolate, | 175 return String::NewFromUtf8(isolate, |
169 val.data(), | 176 val.data(), |
170 String::kInternalizedString, | 177 String::kInternalizedString, |
171 static_cast<uint32_t>(val.length())); | 178 static_cast<uint32_t>(val.length())); |
172 } | 179 } |
173 | 180 |
174 std::string V8ToString(v8::Handle<v8::Value> value) { | 181 std::string V8ToString(v8::Handle<v8::Value> value) { |
175 if (value.IsEmpty()) | 182 if (value.IsEmpty()) |
176 return std::string(); | 183 return std::string(); |
177 std::string result; | 184 std::string result; |
178 if (!ConvertFromV8(value, &result)) | 185 if (!ConvertFromV8(NULL, value, &result)) |
179 return std::string(); | 186 return std::string(); |
180 return result; | 187 return result; |
181 } | 188 } |
182 | 189 |
183 } // namespace gin | 190 } // namespace gin |
OLD | NEW |