1/*
2 * Copyright (C) 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
3 * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
15 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#ifndef JSCallbackObject_h
28#define JSCallbackObject_h
29
30#include "JSObjectRef.h"
31#include "JSValueRef.h"
32#include "JSObject.h"
33#include <wtf/PassOwnPtr.h>
34
35namespace JSC {
36
37struct JSCallbackObjectData : WeakHandleOwner {
38    JSCallbackObjectData(void* privateData, JSClassRef jsClass)
39        : privateData(privateData)
40        , jsClass(jsClass)
41    {
42        JSClassRetain(jsClass);
43    }
44
45    ~JSCallbackObjectData()
46    {
47        JSClassRelease(jsClass);
48    }
49
50    JSValue getPrivateProperty(const Identifier& propertyName) const
51    {
52        if (!m_privateProperties)
53            return JSValue();
54        return m_privateProperties->getPrivateProperty(propertyName);
55    }
56
57    void setPrivateProperty(JSGlobalData& globalData, JSCell* owner, const Identifier& propertyName, JSValue value)
58    {
59        if (!m_privateProperties)
60            m_privateProperties = adoptPtr(new JSPrivatePropertyMap);
61        m_privateProperties->setPrivateProperty(globalData, owner, propertyName, value);
62    }
63
64    void deletePrivateProperty(const Identifier& propertyName)
65    {
66        if (!m_privateProperties)
67            return;
68        m_privateProperties->deletePrivateProperty(propertyName);
69    }
70
71    void markChildren(MarkStack& markStack)
72    {
73        if (!m_privateProperties)
74            return;
75        m_privateProperties->markChildren(markStack);
76    }
77
78    void* privateData;
79    JSClassRef jsClass;
80    struct JSPrivatePropertyMap {
81        JSValue getPrivateProperty(const Identifier& propertyName) const
82        {
83            PrivatePropertyMap::const_iterator location = m_propertyMap.find(propertyName.impl());
84            if (location == m_propertyMap.end())
85                return JSValue();
86            return location->second.get();
87        }
88
89        void setPrivateProperty(JSGlobalData& globalData, JSCell* owner, const Identifier& propertyName, JSValue value)
90        {
91            WriteBarrier<Unknown> empty;
92            m_propertyMap.add(propertyName.impl(), empty).first->second.set(globalData, owner, value);
93        }
94
95        void deletePrivateProperty(const Identifier& propertyName)
96        {
97            m_propertyMap.remove(propertyName.impl());
98        }
99
100        void markChildren(MarkStack& markStack)
101        {
102            for (PrivatePropertyMap::iterator ptr = m_propertyMap.begin(); ptr != m_propertyMap.end(); ++ptr) {
103                if (ptr->second)
104                    markStack.append(&ptr->second);
105            }
106        }
107
108    private:
109        typedef HashMap<RefPtr<StringImpl>, WriteBarrier<Unknown>, IdentifierRepHash> PrivatePropertyMap;
110        PrivatePropertyMap m_propertyMap;
111    };
112    OwnPtr<JSPrivatePropertyMap> m_privateProperties;
113    virtual void finalize(Handle<Unknown>, void*);
114};
115
116
117template <class Base>
118class JSCallbackObject : public Base {
119public:
120    JSCallbackObject(ExecState*, JSGlobalObject*, Structure*, JSClassRef, void* data);
121    JSCallbackObject(JSGlobalData&, JSClassRef, Structure*);
122
123    void setPrivate(void* data);
124    void* getPrivate();
125
126    static const ClassInfo s_info;
127
128    JSClassRef classRef() const { return m_callbackObjectData->jsClass; }
129    bool inherits(JSClassRef) const;
130
131    static Structure* createStructure(JSGlobalData& globalData, JSValue proto)
132    {
133        return Structure::create(globalData, proto, TypeInfo(ObjectType, StructureFlags), Base::AnonymousSlotCount, &s_info);
134    }
135
136    JSValue getPrivateProperty(const Identifier& propertyName) const
137    {
138        return m_callbackObjectData->getPrivateProperty(propertyName);
139    }
140
141    void setPrivateProperty(JSGlobalData& globalData, const Identifier& propertyName, JSValue value)
142    {
143        m_callbackObjectData->setPrivateProperty(globalData, this, propertyName, value);
144    }
145
146    void deletePrivateProperty(const Identifier& propertyName)
147    {
148        m_callbackObjectData->deletePrivateProperty(propertyName);
149    }
150
151protected:
152    static const unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesHasInstance | OverridesMarkChildren | OverridesGetPropertyNames | Base::StructureFlags;
153
154private:
155    virtual UString className() const;
156
157    virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
158    virtual bool getOwnPropertyDescriptor(ExecState*, const Identifier&, PropertyDescriptor&);
159
160    virtual void put(ExecState*, const Identifier&, JSValue, PutPropertySlot&);
161
162    virtual bool deleteProperty(ExecState*, const Identifier&);
163    virtual bool deleteProperty(ExecState*, unsigned);
164
165    virtual bool hasInstance(ExecState* exec, JSValue value, JSValue proto);
166
167    virtual void getOwnPropertyNames(ExecState*, PropertyNameArray&, EnumerationMode mode = ExcludeDontEnumProperties);
168
169    virtual double toNumber(ExecState*) const;
170    virtual UString toString(ExecState*) const;
171
172    virtual ConstructType getConstructData(ConstructData&);
173    virtual CallType getCallData(CallData&);
174
175    virtual void markChildren(MarkStack& markStack)
176    {
177        Base::markChildren(markStack);
178        m_callbackObjectData->markChildren(markStack);
179    }
180
181    void init(ExecState*);
182
183    static JSCallbackObject* asCallbackObject(JSValue);
184
185    static EncodedJSValue JSC_HOST_CALL call(ExecState*);
186    static EncodedJSValue JSC_HOST_CALL construct(ExecState*);
187
188    static JSValue staticValueGetter(ExecState*, JSValue, const Identifier&);
189    static JSValue staticFunctionGetter(ExecState*, JSValue, const Identifier&);
190    static JSValue callbackGetter(ExecState*, JSValue, const Identifier&);
191
192    OwnPtr<JSCallbackObjectData> m_callbackObjectData;
193};
194
195} // namespace JSC
196
197// include the actual template class implementation
198#include "JSCallbackObjectFunctions.h"
199
200#endif // JSCallbackObject_h
201