Not reviewed, build fix.
[WebKit.git] / WebCore / bindings / js / JSDOMBinding.h
1 /*
2  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009 Apple Inc. All rights reserved.
4  *  Copyright (C) 2007 Samuel Weinig <sam@webkit.org>
5  *  Copyright (C) 2009 Google, Inc. All rights reserved.
6  *
7  *  This library is free software; you can redistribute it and/or
8  *  modify it under the terms of the GNU Lesser General Public
9  *  License as published by the Free Software Foundation; either
10  *  version 2 of the License, or (at your option) any later version.
11  *
12  *  This library is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  *  Lesser General Public License for more details.
16  *
17  *  You should have received a copy of the GNU Lesser General Public
18  *  License along with this library; if not, write to the Free Software
19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22 #ifndef JSDOMBinding_h
23 #define JSDOMBinding_h
24
25 #include "JSDOMGlobalObject.h"
26 #include "JSSVGContextCache.h"
27 #include "Document.h"
28 #include <runtime/Completion.h>
29 #include <runtime/Lookup.h>
30 #include <runtime/WeakGCMap.h>
31 #include <wtf/Noncopyable.h>
32
33 namespace JSC {
34     class JSGlobalData;
35     class DebuggerCallFrame;
36 }
37
38 namespace WebCore {
39
40     class Document;
41     class Frame;
42     class JSNode;
43     class KURL;
44     class Node;
45     class String;
46     class ScriptController;
47     class ScriptCachedFrameData;
48
49     typedef int ExceptionCode;
50
51 #if ENABLE(SVG)
52     class SVGElement;
53 #endif
54
55     // Base class for all objects in this binding except Window.
56     class DOMObject : public JSC::JSObject {
57     protected:
58         explicit DOMObject(NonNullPassRefPtr<JSC::Structure> structure) 
59             : JSObject(structure)
60         {
61         }
62
63         virtual bool defineOwnProperty(JSC::ExecState*, const JSC::Identifier&, JSC::PropertyDescriptor&, bool);
64
65 #ifndef NDEBUG
66         virtual ~DOMObject();
67 #endif
68     };
69
70     // FIXME: This class should collapse into DOMObject once all DOMObjects are
71     // updated to store a globalObject pointer.
72     class DOMObjectWithGlobalPointer : public DOMObject {
73     public:
74         JSDOMGlobalObject* globalObject() const { return static_cast<JSDOMGlobalObject*>(getAnonymousValue(GlobalObjectSlot).asCell()); }
75
76         ScriptExecutionContext* scriptExecutionContext() const
77         {
78             // FIXME: Should never be 0, but can be due to bug 27640.
79             return globalObject()->scriptExecutionContext();
80         }
81
82         static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype)
83         {
84             return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount);
85         }
86
87     protected:
88         static const unsigned AnonymousSlotCount = 1 + DOMObject::AnonymousSlotCount;
89         static const unsigned GlobalObjectSlot = AnonymousSlotCount - 1;
90
91         DOMObjectWithGlobalPointer(NonNullPassRefPtr<JSC::Structure> structure, JSDOMGlobalObject* globalObject)
92             : DOMObject(structure)
93         {
94             // FIXME: This ASSERT is valid, but fires in fast/dom/gc-6.html when trying to create
95             // new JavaScript objects on detached windows due to DOMWindow::document()
96             // needing to reach through the frame to get to the Document*.  See bug 27640.
97             // ASSERT(globalObject->scriptExecutionContext());
98             putAnonymousValue(GlobalObjectSlot, globalObject);
99         }
100         virtual ~DOMObjectWithGlobalPointer() { }
101     };
102
103     // Base class for all constructor objects in the JSC bindings.
104     class DOMConstructorObject : public DOMObjectWithGlobalPointer {
105     public:
106         static PassRefPtr<JSC::Structure> createStructure(JSC::JSValue prototype)
107         {
108             return JSC::Structure::create(prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount);
109         }
110
111     protected:
112         static const unsigned StructureFlags = JSC::ImplementsHasInstance | JSC::OverridesMarkChildren | DOMObjectWithGlobalPointer::StructureFlags;
113         DOMConstructorObject(NonNullPassRefPtr<JSC::Structure> structure, JSDOMGlobalObject* globalObject)
114             : DOMObjectWithGlobalPointer(structure, globalObject)
115         {
116         }
117     };
118
119     // Constructors using this base class depend on being in a Document and
120     // can never be used from a WorkerContext.
121     class DOMConstructorWithDocument : public DOMConstructorObject {
122     public:
123         Document* document() const
124         {
125             return static_cast<Document*>(scriptExecutionContext());
126         }
127
128     protected:
129         DOMConstructorWithDocument(NonNullPassRefPtr<JSC::Structure> structure, JSDOMGlobalObject* globalObject)
130             : DOMConstructorObject(structure, globalObject)
131         {
132             ASSERT(globalObject->scriptExecutionContext()->isDocument());
133         }
134     };
135
136     typedef JSC::WeakGCMap<void*, DOMObject*> DOMObjectWrapperMap;
137     typedef JSC::WeakGCMap<StringImpl*, JSC::JSString*> JSStringCache; 
138
139     class DOMWrapperWorld : public RefCounted<DOMWrapperWorld> {
140     public:
141         static PassRefPtr<DOMWrapperWorld> create(JSC::JSGlobalData* globalData, bool isNormal)
142         {
143             return adoptRef(new DOMWrapperWorld(globalData, isNormal));
144         }
145         ~DOMWrapperWorld();
146
147         void rememberDocument(Document* document) { documentsWithWrappers.add(document); }
148         void forgetDocument(Document* document) { documentsWithWrappers.remove(document); }
149
150         // FIXME: can we make this private?
151         DOMObjectWrapperMap m_wrappers;
152         JSStringCache m_stringCache;
153
154         bool isNormal() const { return m_isNormal; }
155
156     protected:
157         DOMWrapperWorld(JSC::JSGlobalData*, bool isNormal);
158
159     private:
160         JSC::JSGlobalData* m_globalData;
161         HashSet<Document*> documentsWithWrappers;
162         bool m_isNormal;
163     };
164
165     // Map from static HashTable instances to per-GlobalData ones.
166     class DOMObjectHashTableMap {
167     public:
168         static DOMObjectHashTableMap& mapFor(JSC::JSGlobalData&);
169
170         ~DOMObjectHashTableMap()
171         {
172             HashMap<const JSC::HashTable*, JSC::HashTable>::iterator mapEnd = m_map.end();
173             for (HashMap<const JSC::HashTable*, JSC::HashTable>::iterator iter = m_map.begin(); iter != m_map.end(); ++iter)
174                 iter->second.deleteTable();
175         }
176
177         const JSC::HashTable* get(const JSC::HashTable* staticTable)
178         {
179             HashMap<const JSC::HashTable*, JSC::HashTable>::iterator iter = m_map.find(staticTable);
180             if (iter != m_map.end())
181                 return &iter->second;
182             return &m_map.set(staticTable, JSC::HashTable(*staticTable)).first->second;
183         }
184
185     private:
186         HashMap<const JSC::HashTable*, JSC::HashTable> m_map;
187     };
188
189     class WebCoreJSClientData : public JSC::JSGlobalData::ClientData, public Noncopyable {
190         friend class JSGlobalDataWorldIterator;
191
192     public:
193         WebCoreJSClientData(JSC::JSGlobalData* globalData)
194             : m_normalWorld(DOMWrapperWorld::create(globalData, true))
195         {
196             m_worldSet.add(m_normalWorld.get());
197         }
198
199         virtual ~WebCoreJSClientData()
200         {
201             ASSERT(m_worldSet.contains(m_normalWorld.get()));
202             ASSERT(m_worldSet.size() == 1);
203             ASSERT(m_normalWorld->hasOneRef());
204             m_normalWorld.clear();
205             ASSERT(m_worldSet.isEmpty());
206         }
207
208         DOMWrapperWorld* normalWorld() { return m_normalWorld.get(); }
209
210         void getAllWorlds(Vector<DOMWrapperWorld*>& worlds)
211         {
212             copyToVector(m_worldSet, worlds);
213         }
214
215         void rememberWorld(DOMWrapperWorld* world)
216         {
217             ASSERT(!m_worldSet.contains(world));
218             m_worldSet.add(world);
219         }
220         void forgetWorld(DOMWrapperWorld* world)
221         {
222             ASSERT(m_worldSet.contains(world));
223             m_worldSet.remove(world);
224         }
225
226         DOMObjectHashTableMap hashTableMap;
227     private:
228         HashSet<DOMWrapperWorld*> m_worldSet;
229         RefPtr<DOMWrapperWorld> m_normalWorld;
230     };
231
232     DOMObject* getCachedDOMObjectWrapper(JSC::ExecState*, void* objectHandle);
233     bool hasCachedDOMObjectWrapper(JSC::JSGlobalData*, void* objectHandle);
234     void cacheDOMObjectWrapper(JSC::ExecState*, void* objectHandle, DOMObject* wrapper);
235     void forgetDOMNode(JSNode* wrapper, Node* node, Document* document);
236     void forgetDOMObject(DOMObject* wrapper, void* objectHandle);
237
238     JSNode* getCachedDOMNodeWrapper(JSC::ExecState*, Document*, Node*);
239     void cacheDOMNodeWrapper(JSC::ExecState*, Document*, Node*, JSNode* wrapper);
240     void forgetAllDOMNodesForDocument(Document*);
241     void forgetWorldOfDOMNodesForDocument(Document*, DOMWrapperWorld*);
242     void updateDOMNodeDocument(Node*, Document* oldDocument, Document* newDocument);
243
244     void markDOMNodesForDocument(JSC::MarkStack&, Document*);
245     void markActiveObjectsForContext(JSC::MarkStack&, JSC::JSGlobalData&, ScriptExecutionContext*);
246     void markDOMObjectWrapper(JSC::MarkStack&, JSC::JSGlobalData& globalData, void* object);
247     void markDOMNodeWrapper(JSC::MarkStack& markStack, Document* document, Node* node);
248     bool hasCachedDOMObjectWrapperUnchecked(JSC::JSGlobalData*, void* objectHandle);
249     bool hasCachedDOMNodeWrapperUnchecked(Document*, Node*);
250
251     JSC::Structure* getCachedDOMStructure(JSDOMGlobalObject*, const JSC::ClassInfo*);
252     JSC::Structure* cacheDOMStructure(JSDOMGlobalObject*, NonNullPassRefPtr<JSC::Structure>, const JSC::ClassInfo*);
253     JSC::Structure* getCachedDOMStructure(JSC::ExecState*, const JSC::ClassInfo*);
254     JSC::Structure* cacheDOMStructure(JSC::ExecState*, NonNullPassRefPtr<JSC::Structure>, const JSC::ClassInfo*);
255
256     DOMWrapperWorld* currentWorld(JSC::ExecState*);
257     DOMWrapperWorld* normalWorld(JSC::JSGlobalData&);
258     DOMWrapperWorld* mainThreadNormalWorld();
259     inline DOMWrapperWorld* debuggerWorld() { return mainThreadNormalWorld(); }
260     inline DOMWrapperWorld* pluginWorld() { return mainThreadNormalWorld(); }
261
262     JSC::JSObject* getCachedDOMConstructor(JSC::ExecState*, const JSC::ClassInfo*);
263     void cacheDOMConstructor(JSC::ExecState*, const JSC::ClassInfo*, JSC::JSObject* constructor);
264
265     inline JSDOMGlobalObject* deprecatedGlobalObjectForPrototype(JSC::ExecState* exec)
266     {
267         // FIXME: Callers to this function should be using the global object
268         // from which the object is being created, instead of assuming the lexical one.
269         // e.g. subframe.document.body should use the subframe's global object, not the lexical one.
270         return static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject());
271     }
272
273     template<class WrapperClass> inline JSC::Structure* getDOMStructure(JSC::ExecState* exec, JSDOMGlobalObject* globalObject)
274     {
275         if (JSC::Structure* structure = getCachedDOMStructure(globalObject, &WrapperClass::s_info))
276             return structure;
277         return cacheDOMStructure(globalObject, WrapperClass::createStructure(WrapperClass::createPrototype(exec, globalObject)), &WrapperClass::s_info);
278     }
279     template<class WrapperClass> inline JSC::Structure* deprecatedGetDOMStructure(JSC::ExecState* exec)
280     {
281         // FIXME: This function is wrong.  It uses the wrong global object for creating the prototype structure.
282         return getDOMStructure<WrapperClass>(exec, deprecatedGlobalObjectForPrototype(exec));
283     }
284     template<class WrapperClass> inline JSC::JSObject* getDOMPrototype(JSC::ExecState* exec, JSC::JSGlobalObject* globalObject)
285     {
286         return static_cast<JSC::JSObject*>(asObject(getDOMStructure<WrapperClass>(exec, static_cast<JSDOMGlobalObject*>(globalObject))->storedPrototype()));
287     }
288     #define CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, className, object) createDOMObjectWrapper<JS##className>(exec, globalObject, static_cast<className*>(object))
289     template<class WrapperClass, class DOMClass> inline DOMObject* createDOMObjectWrapper(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, DOMClass* object)
290     {
291         ASSERT(object);
292         ASSERT(!getCachedDOMObjectWrapper(exec, object));
293         // FIXME: new (exec) could use a different globalData than the globalData this wrapper is cached on.
294         WrapperClass* wrapper = new (exec) WrapperClass(getDOMStructure<WrapperClass>(exec, globalObject), globalObject, object);
295         cacheDOMObjectWrapper(exec, object, wrapper);
296         return wrapper;
297     }
298     template<class WrapperClass, class DOMClass> inline JSC::JSValue getDOMObjectWrapper(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, DOMClass* object)
299     {
300         if (!object)
301             return JSC::jsNull();
302         if (DOMObject* wrapper = getCachedDOMObjectWrapper(exec, object))
303             return wrapper;
304         return createDOMObjectWrapper<WrapperClass>(exec, globalObject, object);
305     }
306
307 #if ENABLE(SVG)
308     #define CREATE_SVG_OBJECT_WRAPPER(exec, globalObject, className, object, context) createDOMObjectWrapper<JS##className>(exec, globalObject, static_cast<className*>(object), context)
309     template<class WrapperClass, class DOMClass> inline DOMObject* createDOMObjectWrapper(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, DOMClass* object, SVGElement* context)
310     {
311         DOMObject* wrapper = createDOMObjectWrapper<WrapperClass, DOMClass>(exec, globalObject, object);
312         ASSERT(wrapper);
313         if (context)
314             JSSVGContextCache::addWrapper(wrapper, context);
315         return wrapper;
316     }
317     template<class WrapperClass, class DOMClass> inline JSC::JSValue getDOMObjectWrapper(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, DOMClass* object, SVGElement* context)
318     {
319         if (!object)
320             return JSC::jsNull();
321         if (DOMObject* wrapper = getCachedDOMObjectWrapper(exec, object)) {
322             ASSERT(JSSVGContextCache::svgContextForDOMObject(wrapper) == context);
323             return wrapper;
324         }
325         return createDOMObjectWrapper<WrapperClass, DOMClass>(exec, globalObject, object, context);
326     }
327 #endif
328
329     #define CREATE_DOM_NODE_WRAPPER(exec, globalObject, className, object) createDOMNodeWrapper<JS##className>(exec, globalObject, static_cast<className*>(object))
330     template<class WrapperClass, class DOMClass> inline JSNode* createDOMNodeWrapper(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, DOMClass* node)
331     {
332         ASSERT(node);
333         ASSERT(!getCachedDOMNodeWrapper(exec, node->document(), node));
334         WrapperClass* wrapper = new (exec) WrapperClass(getDOMStructure<WrapperClass>(exec, globalObject), globalObject, node);
335         // FIXME: The entire function can be removed, once we fix caching.
336         // This function is a one-off hack to make Nodes cache in the right global object.
337         cacheDOMNodeWrapper(exec, node->document(), node, wrapper);
338         return wrapper;
339     }
340     template<class WrapperClass, class DOMClass> inline JSC::JSValue getDOMNodeWrapper(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, DOMClass* node)
341     {
342         if (!node)
343             return JSC::jsNull();
344         if (JSNode* wrapper = getCachedDOMNodeWrapper(exec, node->document(), node))
345             return wrapper;
346         return createDOMNodeWrapper<WrapperClass>(exec, globalObject, node);
347     }
348
349     const JSC::HashTable* getHashTableForGlobalData(JSC::JSGlobalData&, const JSC::HashTable* staticTable);
350
351     void reportException(JSC::ExecState*, JSC::JSValue exception);
352     void reportCurrentException(JSC::ExecState*);
353
354     // Convert a DOM implementation exception code into a JavaScript exception in the execution state.
355     void setDOMException(JSC::ExecState*, ExceptionCode);
356
357     JSC::JSValue jsString(JSC::ExecState*, const String&); // empty if the string is null
358     JSC::JSValue jsStringSlowCase(JSC::ExecState*, JSStringCache&, StringImpl*);
359     JSC::JSValue jsString(JSC::ExecState*, const KURL&); // empty if the URL is null
360     inline JSC::JSValue jsString(JSC::ExecState* exec, const AtomicString& s)
361     { 
362         return jsString(exec, s.string());
363     }
364         
365     JSC::JSValue jsStringOrNull(JSC::ExecState*, const String&); // null if the string is null
366     JSC::JSValue jsStringOrNull(JSC::ExecState*, const KURL&); // null if the URL is null
367
368     JSC::JSValue jsStringOrUndefined(JSC::ExecState*, const String&); // undefined if the string is null
369     JSC::JSValue jsStringOrUndefined(JSC::ExecState*, const KURL&); // undefined if the URL is null
370
371     JSC::JSValue jsStringOrFalse(JSC::ExecState*, const String&); // boolean false if the string is null
372     JSC::JSValue jsStringOrFalse(JSC::ExecState*, const KURL&); // boolean false if the URL is null
373
374     // See JavaScriptCore for explanation: Should be used for any UString that is already owned by another
375     // object, to let the engine know that collecting the JSString wrapper is unlikely to save memory.
376     JSC::JSValue jsOwnedStringOrNull(JSC::ExecState*, const JSC::UString&); 
377
378     JSC::UString valueToStringWithNullCheck(JSC::ExecState*, JSC::JSValue); // null if the value is null
379     JSC::UString valueToStringWithUndefinedOrNullCheck(JSC::ExecState*, JSC::JSValue); // null if the value is null or undefined
380
381     // Returns a Date instance for the specified value, or null if the value is NaN or infinity.
382     JSC::JSValue jsDateOrNull(JSC::ExecState*, double);
383     // NaN if the value can't be converted to a date.
384     double valueToDate(JSC::ExecState*, JSC::JSValue);
385
386     // FIXME: These are a stop-gap until all toJS calls can be converted to pass a globalObject
387     template <typename T>
388     inline JSC::JSValue toJS(JSC::ExecState* exec, T* ptr)
389     {
390         return toJS(exec, deprecatedGlobalObjectForPrototype(exec), ptr);
391     }
392     template <typename T>
393     inline JSC::JSValue toJS(JSC::ExecState* exec, PassRefPtr<T> ptr)
394     {
395         return toJS(exec, deprecatedGlobalObjectForPrototype(exec), ptr.get());
396     }
397     template <typename T>
398     inline JSC::JSValue toJSNewlyCreated(JSC::ExecState* exec, T* ptr)
399     {
400         return toJSNewlyCreated(exec, deprecatedGlobalObjectForPrototype(exec), ptr);
401     }
402
403     template <typename T>
404     inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, PassRefPtr<T> ptr)
405     {
406         return toJS(exec, globalObject, ptr.get());
407     }
408
409     // Validates that the passed object is a sequence type per section 4.1.13 of the WebIDL spec.
410     JSC::JSObject* toJSSequence(JSC::ExecState*, JSC::JSValue, unsigned&);
411
412     bool checkNodeSecurity(JSC::ExecState*, Node*);
413
414     // Helpers for Window, History, and Location classes to implement cross-domain policy.
415     // Besides the cross-domain check, they need non-caching versions of staticFunctionGetter for
416     // because we do not want current property values involved at all.
417     bool allowsAccessFromFrame(JSC::ExecState*, Frame*);
418     bool allowsAccessFromFrame(JSC::ExecState*, Frame*, String& message);
419     bool shouldAllowNavigation(JSC::ExecState*, Frame*);
420     void printErrorMessageForFrame(Frame*, const String& message);
421     JSC::JSValue objectToStringFunctionGetter(JSC::ExecState*, const JSC::Identifier& propertyName, const JSC::PropertySlot&);
422
423     Frame* toLexicalFrame(JSC::ExecState*);
424     Frame* toDynamicFrame(JSC::ExecState*);
425     bool processingUserGesture(JSC::ExecState*);
426     KURL completeURL(JSC::ExecState*, const String& relativeURL);
427
428     inline DOMWrapperWorld* currentWorld(JSC::ExecState* exec)
429     {
430         return static_cast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->world();
431     }
432     
433     inline JSC::JSValue jsString(JSC::ExecState* exec, const String& s)
434     {
435         StringImpl* stringImpl = s.impl();
436         if (!stringImpl || !stringImpl->length())
437             return jsEmptyString(exec);
438
439         if (stringImpl->length() == 1 && stringImpl->characters()[0] <= 0xFF)
440             return jsString(exec, stringImpl->ustring());
441
442         JSStringCache& stringCache = currentWorld(exec)->m_stringCache;
443         if (JSC::JSString* wrapper = stringCache.get(stringImpl))
444             return wrapper;
445
446         return jsStringSlowCase(exec, stringCache, stringImpl);
447     }
448
449 } // namespace WebCore
450
451 #endif // JSDOMBinding_h