2009-07-07 Nate Chapin <japhet@chromium.org>
[WebKit-https.git] / WebCore / bindings / v8 / V8Binding.h
1 /*
2 * Copyright (C) 2009 Google Inc. All rights reserved.
3
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7
8 *     * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *     * Redistributions in binary form must reproduce the above
11 * copyright notice, this list of conditions and the following disclaimer
12 * in the documentation and/or other materials provided with the
13 * distribution.
14 *     * Neither the name of Google Inc. nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
17
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #ifndef V8Binding_h
32 #define V8Binding_h
33
34 #include "MathExtras.h"
35 #include "PlatformString.h"
36
37 #include <v8.h>
38
39 namespace WebCore {
40
41     // Convert v8 types to a WebCore::String. If the V8 string is not already
42     // an external string then it is transformed into an external string at this
43     // point to avoid repeated conversions.
44     String v8StringToWebCoreString(v8::Handle<v8::String>, bool externalize);
45     String v8ValueToWebCoreString(v8::Handle<v8::Value>);
46
47     // Convert v8 types to a WebCore::AtomicString.
48     AtomicString v8StringToAtomicWebCoreString(v8::Handle<v8::String>);
49     AtomicString v8ValueToAtomicWebCoreString(v8::Handle<v8::Value>);
50
51     // Convert a string to a V8 string.
52     v8::Handle<v8::String> v8String(const String&);
53
54     inline String toString(const String& string)\r
55     {\r
56         return string;\r
57     }
58
59     // Return a V8 external string that shares the underlying buffer with the given
60     // WebCore string. The reference counting mechanism is used to keep the
61     // underlying buffer alive while the string is still live in the V8 engine.
62     v8::Local<v8::String> v8ExternalString(const String&);
63
64     // Convert a value to a 32-bit integer.  The conversion fails if the
65     // value cannot be converted to an integer or converts to nan or to an infinity.
66     inline int toInt32(v8::Handle<v8::Value> value, bool& ok)
67     {
68         ok = true;
69
70         // Fast case.  The value is already a 32-bit integer.
71         if (value->IsInt32())
72             return value->Int32Value();
73
74         // Can the value be converted to a number?
75         v8::Local<v8::Number> numberObject = value->ToNumber();
76         if (numberObject.IsEmpty()) {
77             ok = false;
78             return 0;
79         }
80
81         // Does the value convert to nan or to an infinity?
82         double numberValue = numberObject->Value();
83         if (isnan(numberValue) || isinf(numberValue)) {
84             ok = false;
85             return 0;
86         }
87
88         // Can the value be converted to a 32-bit integer?
89         v8::Local<v8::Int32> intValue = value->ToInt32();
90         if (intValue.IsEmpty()) {
91             ok = false;
92             return 0;
93         }
94
95         // Return the result of the int32 conversion.
96         return intValue->Value();
97     }
98
99     // Convert a value to a 32-bit integer assuming the conversion cannot fail.
100     inline int toInt32(v8::Handle<v8::Value> value)
101     {
102         bool ok;
103         return toInt32(value, ok);
104     }
105
106     inline float toFloat(v8::Local<v8::Value> value)
107     {
108         return static_cast<float>(value->NumberValue());
109     }
110
111     // FIXME: Drop this in favor of the type specific v8ValueToWebCoreString when we rework the code generation.
112     inline String toWebCoreString(v8::Handle<v8::Value> object)
113     {
114         return v8ValueToWebCoreString(object);
115     }
116
117     // The string returned by this function is still owned by the argument
118     // and will be deallocated when the argument is deallocated.
119     inline const uint16_t* fromWebCoreString(const String& str)
120     {
121         return reinterpret_cast<const uint16_t*>(str.characters());
122     }
123
124     inline bool isUndefinedOrNull(v8::Handle<v8::Value> value)
125     {
126         return value->IsNull() || value->IsUndefined();
127     }
128
129     inline v8::Handle<v8::Boolean> v8Boolean(bool value)
130     {
131         return value ? v8::True() : v8::False();
132     }
133    
134     inline String toWebCoreStringWithNullCheck(v8::Handle<v8::Value> value)
135     {
136         if (value->IsNull()) 
137             return String();
138         return v8ValueToWebCoreString(value);
139     }
140
141     inline String toWebCoreStringWithNullOrUndefinedCheck(v8::Handle<v8::Value> value)
142     {
143         if (value->IsNull() || value->IsUndefined())
144             return String();
145         return toWebCoreString(value);
146     }
147  
148     inline v8::Handle<v8::String> v8UndetectableString(const String& str)
149     {
150         return v8::String::NewUndetectable(fromWebCoreString(str), str.length());
151     }
152
153     inline v8::Handle<v8::Value> v8StringOrNull(const String& str)
154     {
155         return str.isNull() ? v8::Handle<v8::Value>(v8::Null()) : v8::Handle<v8::Value>(v8String(str));
156     }
157
158     inline v8::Handle<v8::Value> v8StringOrUndefined(const String& str)
159     {
160         return str.isNull() ? v8::Handle<v8::Value>(v8::Undefined()) : v8::Handle<v8::Value>(v8String(str));
161     }
162
163     inline v8::Handle<v8::Value> v8StringOrFalse(const String& str)
164     {
165         return str.isNull() ? v8::Handle<v8::Value>(v8::False()) : v8::Handle<v8::Value>(v8String(str));
166     }
167 } // namespace WebCore
168
169 #endif // V8Binding_h