Unzip initialization lists and constructors in JSCell hierarchy (5/7)
[WebKit-https.git] / Source / WebCore / bindings / js / JSDOMBinding.h
index 803429f..c1c837e 100644 (file)
 #include "JSDOMWrapper.h"
 #include "DOMWrapperWorld.h"
 #include "Document.h"
+#include "Element.h"
+#include "StyleBase.h"
 #include <heap/Weak.h>
-#include <runtime/Completion.h>
+#include <runtime/FunctionPrototype.h>
 #include <runtime/Lookup.h>
+#include <runtime/ObjectPrototype.h>
 #include <wtf/Forward.h>
 #include <wtf/Noncopyable.h>
 
-namespace JSC {
-    class JSGlobalData;
-    class DebuggerCallFrame;
-}
-
 namespace WebCore {
 
-    class Document;
     class Frame;
-    class JSNode;
     class KURL;
-    class Node;
-    class ScriptController;
-    class ScriptCachedFrameData;
 
     typedef int ExceptionCode;
 
-    // FIXME: This class should collapse into JSDOMWrapper once all JSDOMWrappers are
-    // updated to store a globalObject pointer.
-    class JSDOMWrapperWithGlobalPointer : public JSDOMWrapper {
-    public:
-        JSDOMGlobalObject* globalObject() const
-        {
-            return static_cast<JSDOMGlobalObject*>(JSDOMWrapper::globalObject());
-        }
-
-        ScriptExecutionContext* scriptExecutionContext() const
-        {
-            // FIXME: Should never be 0, but can be due to bug 27640.
-            return globalObject()->scriptExecutionContext();
-        }
-
-        static JSC::Structure* createStructure(JSC::JSGlobalData& globalData, JSC::JSValue prototype)
-        {
-            return JSC::Structure::create(globalData, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount, &s_info);
-        }
-
-    protected:
-        JSDOMWrapperWithGlobalPointer(JSC::Structure* structure, JSDOMGlobalObject* globalObject)
-            : JSDOMWrapper(globalObject, structure)
-        {
-            // FIXME: This ASSERT is valid, but fires in fast/dom/gc-6.html when trying to create
-            // new JavaScript objects on detached windows due to DOMWindow::document()
-            // needing to reach through the frame to get to the Document*.  See bug 27640.
-            // ASSERT(globalObject->scriptExecutionContext());
-        }
-    };
-
     // Base class for all constructor objects in the JSC bindings.
-    class DOMConstructorObject : public JSDOMWrapperWithGlobalPointer {
+    class DOMConstructorObject : public JSDOMWrapper {
     public:
-        static JSC::Structure* createStructure(JSC::JSGlobalData& globalData, JSC::JSValue prototype)
+        static JSC::Structure* createStructure(JSC::JSGlobalData& globalData, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
         {
-            return JSC::Structure::create(globalData, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount, &s_info);
+            return JSC::Structure::create(globalData, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), AnonymousSlotCount, &s_info);
         }
 
     protected:
-        static const unsigned StructureFlags = JSC::ImplementsHasInstance | JSC::OverridesMarkChildren | JSDOMWrapperWithGlobalPointer::StructureFlags;
+        static const unsigned StructureFlags = JSC::ImplementsHasInstance | JSC::OverridesVisitChildren | JSDOMWrapper::StructureFlags;
         DOMConstructorObject(JSC::Structure* structure, JSDOMGlobalObject* globalObject)
-            : JSDOMWrapperWithGlobalPointer(structure, globalObject)
+            : JSDOMWrapper(structure, globalObject)
         {
+            finishCreation(globalObject->globalData());
         }
     };
 
@@ -113,9 +76,6 @@ namespace WebCore {
         }
     };
     
-    void markActiveObjectsForContext(JSC::MarkStack&, JSC::JSGlobalData&, ScriptExecutionContext*);
-    void markDOMObjectWrapper(JSC::MarkStack&, JSC::JSGlobalData& globalData, void* object);
-
     JSC::Structure* getCachedDOMStructure(JSDOMGlobalObject*, const JSC::ClassInfo*);
     JSC::Structure* cacheDOMStructure(JSDOMGlobalObject*, JSC::Structure*, const JSC::ClassInfo*);
 
@@ -131,7 +91,7 @@ namespace WebCore {
     {
         if (JSC::Structure* structure = getCachedDOMStructure(globalObject, &WrapperClass::s_info))
             return structure;
-        return cacheDOMStructure(globalObject, WrapperClass::createStructure(exec->globalData(), WrapperClass::createPrototype(exec, globalObject)), &WrapperClass::s_info);
+        return cacheDOMStructure(globalObject, WrapperClass::createStructure(exec->globalData(), globalObject, WrapperClass::createPrototype(exec, globalObject)), &WrapperClass::s_info);
     }
 
     template<class WrapperClass> inline JSC::Structure* deprecatedGetDOMStructure(JSC::ExecState* exec)
@@ -177,13 +137,12 @@ namespace WebCore {
         world->m_wrappers.remove(domObject);
     }
     
-    #define CREATE_DOM_OBJECT_WRAPPER(exec, globalObject, className, object) createWrapper<JS##className>(exec, globalObject, static_cast<className*>(object))
-    #define CREATE_DOM_NODE_WRAPPER(exec, globalObject, className, object) static_cast<JSNode*>(createWrapper<JS##className>(exec, globalObject, static_cast<className*>(object)))
+    #define CREATE_DOM_WRAPPER(exec, globalObject, className, object) createWrapper<JS##className>(exec, globalObject, static_cast<className*>(object))
     template<class WrapperClass, class DOMClass> inline JSDOMWrapper* createWrapper(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, DOMClass* node)
     {
         ASSERT(node);
         ASSERT(!getCachedWrapper(currentWorld(exec), node));
-        WrapperClass* wrapper = new (exec) WrapperClass(getDOMStructure<WrapperClass>(exec, globalObject), globalObject, node);
+        WrapperClass* wrapper = WrapperClass::create(getDOMStructure<WrapperClass>(exec, globalObject), globalObject, node);
         // FIXME: The entire function can be removed, once we fix caching.
         // This function is a one-off hack to make Nodes cache in the right global object.
         cacheWrapper(currentWorld(exec), node, wrapper);
@@ -199,6 +158,26 @@ namespace WebCore {
         return createWrapper<WrapperClass>(exec, globalObject, domObject);
     }
 
+    inline void* root(Node* node)
+    {
+        if (node->inDocument())
+            return node->document();
+
+        while (node->parentOrHostNode())
+            node = node->parentOrHostNode();
+        return node;
+    }
+
+    inline void* root(StyleBase* styleBase)
+    {
+        while (styleBase->parent())
+            styleBase = styleBase->parent();
+
+        if (Node* node = styleBase->node())
+            return root(node);
+        return styleBase;
+    }
+
     const JSC::HashTable* getHashTableForGlobalData(JSC::JSGlobalData&, const JSC::HashTable* staticTable);
 
     void reportException(JSC::ExecState*, JSC::JSValue exception);
@@ -251,23 +230,6 @@ namespace WebCore {
     // NaN if the value can't be converted to a date.
     double valueToDate(JSC::ExecState*, JSC::JSValue);
 
-    // FIXME: These are a stop-gap until all toJS calls can be converted to pass a globalObject
-    template <typename T>
-    inline JSC::JSValue toJS(JSC::ExecState* exec, T* ptr)
-    {
-        return toJS(exec, deprecatedGlobalObjectForPrototype(exec), ptr);
-    }
-    template <typename T>
-    inline JSC::JSValue toJS(JSC::ExecState* exec, PassRefPtr<T> ptr)
-    {
-        return toJS(exec, deprecatedGlobalObjectForPrototype(exec), ptr.get());
-    }
-    template <typename T>
-    inline JSC::JSValue toJSNewlyCreated(JSC::ExecState* exec, T* ptr)
-    {
-        return toJSNewlyCreated(exec, deprecatedGlobalObjectForPrototype(exec), ptr);
-    }
-
     template <typename T>
     inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, PassRefPtr<T> ptr)
     {
@@ -292,8 +254,7 @@ namespace WebCore {
     JSC::JSValue objectToStringFunctionGetter(JSC::ExecState*, JSC::JSValue, const JSC::Identifier& propertyName);
 
     Frame* toDynamicFrame(JSC::ExecState*);
-    bool processingUserGesture();
-    
+
     inline JSC::JSValue jsString(JSC::ExecState* exec, const String& s)
     {
         StringImpl* stringImpl = s.impl();
@@ -304,8 +265,9 @@ namespace WebCore {
             return jsString(exec, stringToUString(s));
 
         JSStringCache& stringCache = currentWorld(exec)->m_stringCache;
-        if (JSC::JSString* wrapper = stringCache.get(stringImpl))
-            return wrapper;
+        JSStringCache::iterator it = stringCache.find(stringImpl);
+        if (it != stringCache.end())
+            return it->second.get();
 
         return jsStringSlowCase(exec, stringCache, stringImpl);
     }