[V8][Refactoring] Remove V8Proxy::throwSyntaxError()
[WebKit-https.git] / Source / WebCore / bindings / v8 / V8Proxy.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 V8Proxy_h
32 #define V8Proxy_h
33
34 #include "PlatformSupport.h"
35 #include "SharedPersistent.h"
36 #include "StatsCounter.h"
37 #include "V8AbstractEventListener.h"
38 #include "V8DOMWindowShell.h"
39 #include "V8DOMWrapper.h"
40 #include "V8GCController.h"
41 #include "V8Utilities.h"
42 #include "WrapperTypeInfo.h"
43 #include <v8.h>
44 #include <wtf/Forward.h>
45 #include <wtf/PassRefPtr.h> // so generated bindings don't have to
46 #include <wtf/Vector.h>
47 #include <wtf/text/TextPosition.h>
48
49 #if defined(ENABLE_DOM_STATS_COUNTERS) && PLATFORM(CHROMIUM)
50 #define INC_STATS(name) StatsCounter::incrementStatsCounter(name)
51 #else
52 #define INC_STATS(name)
53 #endif
54
55 namespace WebCore {
56
57     class CachedScript;
58     class DOMWindow;
59     class Frame;
60     class Node;
61     class ScriptExecutionContext;
62     class ScriptSourceCode;
63     class SecurityOrigin;
64     class V8BindingPerContextData;
65     class V8EventListener;
66     class V8IsolatedContext;
67     class WorldContextHandle;
68
69     // The following Batch structs and methods are used for setting multiple
70     // properties on an ObjectTemplate, used from the generated bindings
71     // initialization (ConfigureXXXTemplate). This greatly reduces the binary
72     // size by moving from code driven setup to data table driven setup.
73
74     // BatchedAttribute translates into calls to SetAccessor() on either the
75     // instance or the prototype ObjectTemplate, based on |onProto|.
76     struct BatchedAttribute {
77         const char* const name;
78         v8::AccessorGetter getter;
79         v8::AccessorSetter setter;
80         WrapperTypeInfo* data;
81         v8::AccessControl settings;
82         v8::PropertyAttribute attribute;
83         bool onProto;
84     };
85
86     void batchConfigureAttributes(v8::Handle<v8::ObjectTemplate>, v8::Handle<v8::ObjectTemplate>, const BatchedAttribute*, size_t attributeCount);
87
88     inline void configureAttribute(v8::Handle<v8::ObjectTemplate> instance, v8::Handle<v8::ObjectTemplate> proto, const BatchedAttribute& attribute)
89     {
90         (attribute.onProto ? proto : instance)->SetAccessor(v8::String::New(attribute.name),
91             attribute.getter,
92             attribute.setter,
93             v8::External::Wrap(attribute.data),
94             attribute.settings,
95             attribute.attribute);
96     }
97
98     // BatchedConstant translates into calls to Set() for setting up an object's
99     // constants. It sets the constant on both the FunctionTemplate and the
100     // ObjectTemplate. PropertyAttributes is always ReadOnly.
101     struct BatchedConstant {
102         const char* const name;
103         int value;
104     };
105
106     void batchConfigureConstants(v8::Handle<v8::FunctionTemplate>, v8::Handle<v8::ObjectTemplate>, const BatchedConstant*, size_t constantCount);
107
108     struct BatchedCallback {
109         const char* const name;
110         v8::InvocationCallback callback;
111     };
112
113     void batchConfigureCallbacks(v8::Handle<v8::ObjectTemplate>, 
114                                  v8::Handle<v8::Signature>,
115                                  v8::PropertyAttribute,
116                                  const BatchedCallback*, 
117                                  size_t callbackCount);
118
119     const int kMaxRecursionDepth = 22;
120
121     // The list of extensions that are registered for use with V8.
122     typedef WTF::Vector<v8::Extension*> V8Extensions;
123
124     class V8Proxy {
125     public:
126         // The types of javascript errors that can be thrown.
127         enum ErrorType {
128             RangeError,
129             ReferenceError,
130             SyntaxError,
131             TypeError,
132             GeneralError
133         };
134
135         explicit V8Proxy(Frame*);
136
137         ~V8Proxy();
138
139         Frame* frame() { return m_frame; }
140
141         void clearForNavigation();
142         void clearForClose();
143
144         void finishedWithEvent(Event*) { }
145
146         // Evaluate JavaScript in a new isolated world. The script gets its own
147         // global scope, its own prototypes for intrinsic JavaScript objects (String,
148         // Array, and so-on), and its own wrappers for all DOM nodes and DOM
149         // constructors.
150         void evaluateInIsolatedWorld(int worldID, const Vector<ScriptSourceCode>& sources, int extensionGroup, WTF::Vector<v8::Local<v8::Value> >* result);
151
152         void setIsolatedWorldSecurityOrigin(int worldID, PassRefPtr<SecurityOrigin>);
153
154         // Evaluate a script file in the current execution environment.
155         // The caller must hold an execution context.
156         // If cannot evalute the script, it returns an error.
157         v8::Local<v8::Value> evaluate(const ScriptSourceCode&, Node*);
158
159         // Run an already compiled script.
160         v8::Local<v8::Value> runScript(v8::Handle<v8::Script>);
161
162         // Call the function with the given receiver and arguments.
163         v8::Local<v8::Value> callFunction(v8::Handle<v8::Function>, v8::Handle<v8::Object>, int argc, v8::Handle<v8::Value> argv[]);
164
165         // call the function with the given receiver and arguments and report times to DevTools.
166         static v8::Local<v8::Value> instrumentedCallFunction(Frame*, v8::Handle<v8::Function>, v8::Handle<v8::Object> receiver, int argc, v8::Handle<v8::Value> args[]);
167
168         // Call the function as constructor with the given arguments.
169         v8::Local<v8::Value> newInstance(v8::Handle<v8::Function>, int argc, v8::Handle<v8::Value> argv[]);
170
171         // Returns the window object associated with a context.
172         static DOMWindow* retrieveWindow(v8::Handle<v8::Context>);
173
174         static DOMWindow* retriveWindowForCallingCOntext();
175
176         // Returns V8Proxy object of the currently executing context.
177         static V8Proxy* retrieve();
178         // Returns V8Proxy object associated with a frame.
179         static V8Proxy* retrieve(Frame*);
180         // Returns V8Proxy object associated with a script execution context.
181         static V8Proxy* retrieve(ScriptExecutionContext*);
182
183         // Returns the frame object of the window object associated with
184         // a context.
185         static Frame* retrieveFrame(v8::Handle<v8::Context>);
186
187         static V8BindingPerContextData* retrievePerContextData(Frame*);
188
189         // The three functions below retrieve WebFrame instances relating the
190         // currently executing JavaScript. Since JavaScript can make function calls
191         // across frames, though, we need to be more precise.
192         //
193         // For example, imagine that a JS function in frame A calls a function in
194         // frame B, which calls native code, which wants to know what the 'active'
195         // frame is.
196         //
197         // The 'entered context' is the context where execution first entered the
198         // script engine; the context that is at the bottom of the JS function stack.
199         // RetrieveFrameForEnteredContext() would return Frame A in our example.
200         // This frame is often referred to as the "dynamic global object."
201         //
202         // The 'current context' is the context the JS engine is currently inside of;
203         // the context that is at the top of the JS function stack.
204         // RetrieveFrameForCurrentContext() would return Frame B in our example.
205         // This frame is often referred to as the "lexical global object."
206         //
207         // Finally, the 'calling context' is the context one below the current
208         // context on the JS function stack. For example, if function f calls
209         // function g, then the calling context will be the context associated with
210         // f. This context is commonly used by DOM security checks because they want
211         // to know who called them.
212         //
213         // If you are unsure which of these functions to use, ask abarth.
214         //
215         // NOTE: These cannot be declared as inline function, because VS complains at
216         // linking time.
217         static Frame* retrieveFrameForEnteredContext();
218         static Frame* retrieveFrameForCurrentContext();
219         static DOMWindow* retrieveWindowForCallingContext();
220         static Frame* retrieveFrameForCallingContext();
221
222         // Returns V8 Context of a frame. If none exists, creates
223         // a new context. It is potentially slow and consumes memory.
224         static v8::Local<v8::Context> context(Frame*);
225         static v8::Local<v8::Context> mainWorldContext(Frame*);
226         static v8::Local<v8::Context> currentContext();
227
228         // If the current context causes out of memory, JavaScript setting
229         // is disabled and it returns true.
230         static bool handleOutOfMemory();
231
232         static v8::Handle<v8::Value> checkNewLegal(const v8::Arguments&);
233
234         static v8::Handle<v8::Script> compileScript(v8::Handle<v8::String> code, const String& fileName, const TextPosition& scriptStartPosition, v8::ScriptData* = 0);
235
236         // If the exception code is different from zero, a DOM exception is
237         // schedule to be thrown.
238         static void setDOMException(int exceptionCode, v8::Isolate* = 0);
239
240         // Schedule an error object to be thrown.
241         static v8::Handle<v8::Value> throwError(ErrorType, const char* message, v8::Isolate* = 0);
242
243         // Helpers for throwing syntax and type errors with predefined messages.
244         static v8::Handle<v8::Value> throwTypeError();
245
246         v8::Local<v8::Context> context();
247         v8::Local<v8::Context> mainWorldContext();
248         bool matchesCurrentContext();
249
250         // FIXME: This should eventually take DOMWrapperWorld argument!
251         V8DOMWindowShell* windowShell() const { return m_windowShell.get(); }
252
253         bool setContextDebugId(int id);
254         static int contextDebugId(v8::Handle<v8::Context>);
255
256         // Registers a v8 extension to be available on webpages. Will only
257         // affect v8 contexts initialized after this call. Takes ownership of
258         // the v8::Extension object passed.
259         static void registerExtension(v8::Extension*);
260
261         static void registerExtensionWithV8(v8::Extension*);
262         static bool registeredExtensionWithV8(v8::Extension*);
263
264         static const V8Extensions& extensions();
265
266         // Report an unsafe attempt to access the given frame on the console.
267         static void reportUnsafeAccessTo(Frame* target);
268
269     private:
270         void resetIsolatedWorlds();
271
272         PassOwnPtr<v8::ScriptData> precompileScript(v8::Handle<v8::String>, CachedScript*);
273
274         static const char* rangeExceptionName(int exceptionCode);
275         static const char* eventExceptionName(int exceptionCode);
276         static const char* xmlHttpRequestExceptionName(int exceptionCode);
277         static const char* domExceptionName(int exceptionCode);
278         static const char* xpathExceptionName(int exceptionCode);
279
280 #if ENABLE(SVG)
281         static const char* svgExceptionName(int exceptionCode);
282 #endif
283
284 #if ENABLE(SQL_DATABASE)
285         static const char* sqlExceptionName(int exceptionCode);
286 #endif
287
288         Frame* m_frame;
289
290         // For the moment, we have one of these.  Soon we will have one per DOMWrapperWorld.
291         RefPtr<V8DOMWindowShell> m_windowShell;
292
293         // All of the extensions registered with the context.
294         static V8Extensions m_extensions;
295
296         // The isolated worlds we are tracking for this frame. We hold them alive
297         // here so that they can be used again by future calls to
298         // evaluateInIsolatedWorld().
299         //
300         // Note: although the pointer is raw, the instance is kept alive by a strong
301         // reference to the v8 context it contains, which is not made weak until we
302         // call world->destroy().
303         //
304         // FIXME: We want to eventually be holding window shells instead of the
305         //        IsolatedContext directly.
306         typedef HashMap<int, V8IsolatedContext*> IsolatedWorldMap;
307         IsolatedWorldMap m_isolatedWorlds;
308         
309         typedef HashMap<int, RefPtr<SecurityOrigin> > IsolatedWorldSecurityOriginMap;
310         IsolatedWorldSecurityOriginMap m_isolatedWorldSecurityOrigins;
311     };
312
313     v8::Local<v8::Context> toV8Context(ScriptExecutionContext*, const WorldContextHandle& worldContext);
314
315     // Used by an interceptor callback that it hasn't found anything to
316     // intercept.
317     inline static v8::Local<v8::Object> notHandledByInterceptor()
318     {
319         return v8::Local<v8::Object>();
320     }
321
322     inline static v8::Local<v8::Boolean> deletionNotHandledByInterceptor()
323     {
324         return v8::Local<v8::Boolean>();
325     }
326
327     inline v8::Handle<v8::Primitive> throwError(const char* message, v8::Isolate* isolate = 0)
328     {
329         if (!v8::V8::IsExecutionTerminating())
330             V8Proxy::throwError(V8Proxy::TypeError, message, isolate);
331         return v8::Undefined();
332     }
333
334     inline v8::Handle<v8::Primitive> throwError(const char* message, V8Proxy::ErrorType type, v8::Isolate* isolate = 0)
335     {
336         if (!v8::V8::IsExecutionTerminating())
337             V8Proxy::throwError(type, message, isolate);
338         return v8::Undefined();
339     }
340
341     inline v8::Handle<v8::Primitive> throwError(ExceptionCode ec, v8::Isolate* isolate = 0)
342     {
343         if (!v8::V8::IsExecutionTerminating())
344             V8Proxy::setDOMException(ec, isolate);
345         return v8::Undefined();
346     }
347
348     inline v8::Handle<v8::Primitive> throwError(v8::Local<v8::Value> exception, v8::Isolate* isolate = 0)
349     {
350         if (!v8::V8::IsExecutionTerminating())
351             v8::ThrowException(exception);
352         return v8::Undefined();
353     }
354
355     enum IndependentMode {
356         MarkIndependent,
357         DoNotMarkIndependent
358     };
359 }
360
361 #endif // V8Proxy_h