Remove operator new from JSCell
[WebKit-https.git] / Source / WebCore / bridge / c / c_instance.cpp
1 /*
2  * Copyright (C) 2003, 2006 Apple Computer, 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
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27
28 #if ENABLE(NETSCAPE_PLUGIN_API)
29
30 #include "c_instance.h"
31
32 #include "CRuntimeObject.h"
33 #include "IdentifierRep.h"
34 #include "JSDOMBinding.h"
35 #include "c_class.h"
36 #include "c_runtime.h"
37 #include "c_utility.h"
38 #include "npruntime_impl.h"
39 #include "runtime_method.h"
40 #include "runtime_root.h"
41 #include <interpreter/CallFrame.h>
42 #include <runtime/ArgList.h>
43 #include <runtime/Error.h>
44 #include <runtime/FunctionPrototype.h>
45 #include <runtime/JSLock.h>
46 #include <runtime/PropertyNameArray.h>
47 #include <wtf/Assertions.h>
48 #include <wtf/StdLibExtras.h>
49 #include <wtf/StringExtras.h>
50 #include <wtf/Vector.h>
51
52 using namespace WebCore;
53
54 namespace JSC {
55 namespace Bindings {
56
57 using JSC::UString;
58
59 static JSC::UString& globalExceptionString()
60 {
61     DEFINE_STATIC_LOCAL(JSC::UString, exceptionStr, ());
62     return exceptionStr;
63 }
64
65 void CInstance::setGlobalException(UString exception)
66 {
67     globalExceptionString() = exception;
68 }
69
70 void CInstance::moveGlobalExceptionToExecState(ExecState* exec)
71 {
72     if (globalExceptionString().isNull())
73         return;
74
75     {
76         JSLock lock(SilenceAssertionsOnly);
77         throwError(exec, createError(exec, globalExceptionString()));
78     }
79
80     globalExceptionString() = UString();
81 }
82
83 CInstance::CInstance(NPObject* o, PassRefPtr<RootObject> rootObject)
84     : Instance(rootObject)
85 {
86     _object = _NPN_RetainObject(o);
87     _class = 0;
88 }
89
90 CInstance::~CInstance() 
91 {
92     _NPN_ReleaseObject(_object);
93 }
94
95 RuntimeObject* CInstance::newRuntimeObject(ExecState* exec)
96 {
97     return CRuntimeObject::create(exec, exec->lexicalGlobalObject(), this);
98 }
99
100 Class *CInstance::getClass() const
101 {
102     if (!_class)
103         _class = CClass::classForIsA(_object->_class);
104     return _class;
105 }
106
107 bool CInstance::supportsInvokeDefaultMethod() const
108 {
109     return _object->_class->invokeDefault;
110 }
111
112 class CRuntimeMethod : public RuntimeMethod {
113 public:
114     static CRuntimeMethod* create(ExecState* exec, JSGlobalObject* globalObject, const Identifier& name, Bindings::MethodList& list)
115     {
116         return new (allocateCell<CRuntimeMethod>(*exec->heap())) CRuntimeMethod(exec, globalObject, name, list);
117     }
118
119     static Structure* createStructure(JSGlobalData& globalData, JSValue prototype)
120     {
121         return Structure::create(globalData, prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info);
122     }
123
124     static const ClassInfo s_info;
125
126 private:
127     CRuntimeMethod(ExecState* exec, JSGlobalObject* globalObject, const Identifier& name, Bindings::MethodList& list)
128         // FIXME: deprecatedGetDOMStructure uses the prototype off of the wrong global object
129         // We need to pass in the right global object for "i".
130         : RuntimeMethod(exec, globalObject, WebCore::deprecatedGetDOMStructure<CRuntimeMethod>(exec), name, list)
131     {
132         ASSERT(inherits(&s_info));
133     }
134
135 };
136
137 const ClassInfo CRuntimeMethod::s_info = { "CRuntimeMethod", &RuntimeMethod::s_info, 0, 0 };
138
139 JSValue CInstance::getMethod(ExecState* exec, const Identifier& propertyName)
140 {
141     MethodList methodList = getClass()->methodsNamed(propertyName, this);
142     return CRuntimeMethod::create(exec, exec->lexicalGlobalObject(), propertyName, methodList);
143 }
144
145 JSValue CInstance::invokeMethod(ExecState* exec, RuntimeMethod* runtimeMethod)
146 {
147     if (!asObject(runtimeMethod)->inherits(&CRuntimeMethod::s_info))
148         return throwError(exec, createTypeError(exec, "Attempt to invoke non-plug-in method on plug-in object."));
149
150     const MethodList& methodList = *runtimeMethod->methods();
151
152     // Overloading methods are not allowed by NPObjects.  Should only be one
153     // name match for a particular method.
154     ASSERT(methodList.size() == 1);
155
156     CMethod* method = static_cast<CMethod*>(methodList[0]);
157
158     NPIdentifier ident = method->identifier();
159     if (!_object->_class->hasMethod(_object, ident))
160         return jsUndefined();
161
162     unsigned count = exec->argumentCount();
163     Vector<NPVariant, 8> cArgs(count);
164
165     unsigned i;
166     for (i = 0; i < count; i++)
167         convertValueToNPVariant(exec, exec->argument(i), &cArgs[i]);
168
169     // Invoke the 'C' method.
170     bool retval = true;
171     NPVariant resultVariant;
172     VOID_TO_NPVARIANT(resultVariant);
173
174     {
175         JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);
176         ASSERT(globalExceptionString().isNull());
177         retval = _object->_class->invoke(_object, ident, cArgs.data(), count, &resultVariant);
178         moveGlobalExceptionToExecState(exec);
179     }
180     
181     if (!retval)
182         throwError(exec, createError(exec, "Error calling method on NPObject."));
183
184     for (i = 0; i < count; i++)
185         _NPN_ReleaseVariantValue(&cArgs[i]);
186
187     JSValue resultValue = convertNPVariantToValue(exec, &resultVariant, m_rootObject.get());
188     _NPN_ReleaseVariantValue(&resultVariant);
189     return resultValue;
190 }
191
192
193 JSValue CInstance::invokeDefaultMethod(ExecState* exec)
194 {
195     if (!_object->_class->invokeDefault)
196         return jsUndefined();
197
198     unsigned count = exec->argumentCount();
199     Vector<NPVariant, 8> cArgs(count);
200
201     unsigned i;
202     for (i = 0; i < count; i++)
203         convertValueToNPVariant(exec, exec->argument(i), &cArgs[i]);
204
205     // Invoke the 'C' method.
206     bool retval = true;
207     NPVariant resultVariant;
208     VOID_TO_NPVARIANT(resultVariant);
209     {
210         JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);
211         ASSERT(globalExceptionString().isNull());
212         retval = _object->_class->invokeDefault(_object, cArgs.data(), count, &resultVariant);
213         moveGlobalExceptionToExecState(exec);
214     }
215     
216     if (!retval)
217         throwError(exec, createError(exec, "Error calling method on NPObject."));
218
219     for (i = 0; i < count; i++)
220         _NPN_ReleaseVariantValue(&cArgs[i]);
221
222     JSValue resultValue = convertNPVariantToValue(exec, &resultVariant, m_rootObject.get());
223     _NPN_ReleaseVariantValue(&resultVariant);
224     return resultValue;
225 }
226
227 bool CInstance::supportsConstruct() const
228 {
229     return _object->_class->construct;
230 }
231     
232 JSValue CInstance::invokeConstruct(ExecState* exec, const ArgList& args)
233 {
234     if (!_object->_class->construct)
235         return jsUndefined();
236
237     unsigned count = args.size();
238     Vector<NPVariant, 8> cArgs(count);
239
240     unsigned i;
241     for (i = 0; i < count; i++)
242         convertValueToNPVariant(exec, args.at(i), &cArgs[i]);
243
244     // Invoke the 'C' method.
245     bool retval = true;
246     NPVariant resultVariant;
247     VOID_TO_NPVARIANT(resultVariant);
248     {
249         JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);
250         ASSERT(globalExceptionString().isNull());
251         retval = _object->_class->construct(_object, cArgs.data(), count, &resultVariant);
252         moveGlobalExceptionToExecState(exec);
253     }
254     
255     if (!retval)
256         throwError(exec, createError(exec, "Error calling method on NPObject."));
257
258     for (i = 0; i < count; i++)
259         _NPN_ReleaseVariantValue(&cArgs[i]);
260
261     JSValue resultValue = convertNPVariantToValue(exec, &resultVariant, m_rootObject.get());
262     _NPN_ReleaseVariantValue(&resultVariant);
263     return resultValue;
264 }
265
266 JSValue CInstance::defaultValue(ExecState* exec, PreferredPrimitiveType hint) const
267 {
268     if (hint == PreferString)
269         return stringValue(exec);
270     if (hint == PreferNumber)
271         return numberValue(exec);
272     return valueOf(exec);
273 }
274
275 JSValue CInstance::stringValue(ExecState* exec) const
276 {
277     char buf[1024];
278     snprintf(buf, sizeof(buf), "NPObject %p, NPClass %p", _object, _object->_class);
279     return jsString(exec, buf);
280 }
281
282 JSValue CInstance::numberValue(ExecState*) const
283 {
284     // FIXME: Implement something sensible.
285     return jsNumber(0);
286 }
287
288 JSValue CInstance::booleanValue() const
289 {
290     // FIXME: Implement something sensible.
291     return jsBoolean(false);
292 }
293
294 JSValue CInstance::valueOf(ExecState* exec) const 
295 {
296     return stringValue(exec);
297 }
298
299 void CInstance::getPropertyNames(ExecState* exec, PropertyNameArray& nameArray)
300 {
301     if (!NP_CLASS_STRUCT_VERSION_HAS_ENUM(_object->_class) || !_object->_class->enumerate)
302         return;
303
304     uint32_t count;
305     NPIdentifier* identifiers;
306
307     {
308         JSLock::DropAllLocks dropAllLocks(SilenceAssertionsOnly);
309         ASSERT(globalExceptionString().isNull());
310         bool ok = _object->_class->enumerate(_object, &identifiers, &count);
311         moveGlobalExceptionToExecState(exec);
312         if (!ok)
313             return;
314     }
315
316     for (uint32_t i = 0; i < count; i++) {
317         IdentifierRep* identifier = static_cast<IdentifierRep*>(identifiers[i]);
318
319         if (identifier->isString())
320             nameArray.add(identifierFromNPIdentifier(exec, identifier->string()));
321         else
322             nameArray.add(Identifier::from(exec, identifier->number()));
323     }
324
325     // FIXME: This should really call NPN_MemFree but that's in WebKit
326     free(identifiers);
327 }
328
329 }
330 }
331
332 #endif // ENABLE(NETSCAPE_PLUGIN_API)