Move WebCore into Source
[WebKit-https.git] / Source / WebCore / bridge / NP_jsobject.cpp
1 /*
2  * Copyright (C) 2004, 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 "NP_jsobject.h"
31
32 #include "PlatformString.h"
33 #include "PluginView.h"
34 #include "StringSourceProvider.h"
35 #include "c_utility.h"
36 #include "c_instance.h"
37 #include "IdentifierRep.h"
38 #include "JSDOMBinding.h"
39 #include "npruntime_impl.h"
40 #include "npruntime_priv.h"
41 #include "runtime_root.h"
42 #include <runtime/Error.h>
43 #include <runtime/JSGlobalObject.h>
44 #include <runtime/JSLock.h>
45 #include <runtime/PropertyNameArray.h>
46 #include <parser/SourceCode.h>
47 #include <runtime/Completion.h>
48 #include <runtime/Completion.h>
49
50 using namespace JSC;
51 using namespace JSC::Bindings;
52 using namespace WebCore;
53
54 class ObjectMap {
55 public:
56     NPObject* get(RootObject* rootObject, JSObject* jsObject)
57     {
58         return m_map.get(rootObject).get(jsObject);
59     }
60
61     void add(RootObject* rootObject, JSObject* jsObject, NPObject* npObject)
62     {
63         HashMap<RootObject*, JSToNPObjectMap>::iterator iter = m_map.find(rootObject);
64         if (iter == m_map.end()) {
65             rootObject->addInvalidationCallback(&m_invalidationCallback);
66             iter = m_map.add(rootObject, JSToNPObjectMap()).first;
67         }
68
69         ASSERT(iter->second.find(jsObject) == iter->second.end());
70         iter->second.add(jsObject, npObject);
71     }
72
73     void remove(RootObject* rootObject)
74     {
75         HashMap<RootObject*, JSToNPObjectMap>::iterator iter = m_map.find(rootObject);
76         ASSERT(iter != m_map.end());
77         m_map.remove(iter);
78     }
79
80     void remove(RootObject* rootObject, JSObject* jsObject)
81     {
82         HashMap<RootObject*, JSToNPObjectMap>::iterator iter = m_map.find(rootObject);
83         ASSERT(iter != m_map.end());
84         ASSERT(iter->second.find(jsObject) != iter->second.end());
85
86         iter->second.remove(jsObject);
87     }
88
89 private:
90     struct RootObjectInvalidationCallback : public RootObject::InvalidationCallback {
91         virtual void operator()(RootObject*);
92     };
93     RootObjectInvalidationCallback m_invalidationCallback;
94
95     // JSObjects are protected by RootObject.
96     typedef HashMap<JSObject*, NPObject*> JSToNPObjectMap;
97     HashMap<RootObject*, JSToNPObjectMap> m_map;
98 };
99
100
101 static ObjectMap& objectMap()
102 {
103     DEFINE_STATIC_LOCAL(ObjectMap, map, ());
104     return map;
105 }
106
107 void ObjectMap::RootObjectInvalidationCallback::operator()(RootObject* rootObject)
108 {
109     objectMap().remove(rootObject);
110 }
111
112 static void getListFromVariantArgs(ExecState* exec, const NPVariant* args, unsigned argCount, RootObject* rootObject, MarkedArgumentBuffer& aList)
113 {
114     for (unsigned i = 0; i < argCount; ++i)
115         aList.append(convertNPVariantToValue(exec, &args[i], rootObject));
116 }
117
118 static NPObject* jsAllocate(NPP, NPClass*)
119 {
120     return static_cast<NPObject*>(malloc(sizeof(JavaScriptObject)));
121 }
122
123 static void jsDeallocate(NPObject* npObj)
124 {
125     JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(npObj);
126
127     if (obj->rootObject && obj->rootObject->isValid()) {
128         objectMap().remove(obj->rootObject, obj->imp);
129         obj->rootObject->gcUnprotect(obj->imp);
130     }
131
132     if (obj->rootObject)
133         obj->rootObject->deref();
134
135     free(obj);
136 }
137
138 static NPClass javascriptClass = { 1, jsAllocate, jsDeallocate, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
139 static NPClass noScriptClass = { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
140
141 NPClass* NPScriptObjectClass = &javascriptClass;
142 static NPClass* NPNoScriptObjectClass = &noScriptClass;
143
144 NPObject* _NPN_CreateScriptObject(NPP npp, JSObject* imp, PassRefPtr<RootObject> rootObject)
145 {
146     if (NPObject* object = objectMap().get(rootObject.get(), imp))
147         return _NPN_RetainObject(object);
148
149     JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(_NPN_CreateObject(npp, NPScriptObjectClass));
150
151     obj->rootObject = rootObject.releaseRef();
152
153     if (obj->rootObject) {
154         obj->rootObject->gcProtect(imp);
155         objectMap().add(obj->rootObject, imp, reinterpret_cast<NPObject*>(obj));
156     }
157
158     obj->imp = imp;
159
160     return reinterpret_cast<NPObject*>(obj);
161 }
162
163 NPObject* _NPN_CreateNoScriptObject(void)
164 {
165     return _NPN_CreateObject(0, NPNoScriptObjectClass);
166 }
167
168 bool _NPN_InvokeDefault(NPP, NPObject* o, const NPVariant* args, uint32_t argCount, NPVariant* result)
169 {
170     if (o->_class == NPScriptObjectClass) {
171         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o); 
172         
173         VOID_TO_NPVARIANT(*result);
174         
175         // Lookup the function object.
176         RootObject* rootObject = obj->rootObject;
177         if (!rootObject || !rootObject->isValid())
178             return false;
179         
180         ExecState* exec = rootObject->globalObject()->globalExec();
181         JSLock lock(SilenceAssertionsOnly);
182         
183         // Call the function object.
184         JSValue function = obj->imp;
185         CallData callData;
186         CallType callType = getCallData(function, callData);
187         if (callType == CallTypeNone)
188             return false;
189         
190         MarkedArgumentBuffer argList;
191         getListFromVariantArgs(exec, args, argCount, rootObject, argList);
192         ProtectedPtr<JSGlobalObject> globalObject = rootObject->globalObject();
193         globalObject->globalData().timeoutChecker.start();
194         JSValue resultV = JSC::call(exec, function, callType, callData, function, argList);
195         globalObject->globalData().timeoutChecker.stop();
196
197         // Convert and return the result of the function call.
198         convertValueToNPVariant(exec, resultV, result);
199         exec->clearException();
200         return true;        
201     }
202
203     if (o->_class->invokeDefault)
204         return o->_class->invokeDefault(o, args, argCount, result);    
205     VOID_TO_NPVARIANT(*result);
206     return true;
207 }
208
209 bool _NPN_Invoke(NPP npp, NPObject* o, NPIdentifier methodName, const NPVariant* args, uint32_t argCount, NPVariant* result)
210 {
211     if (o->_class == NPScriptObjectClass) {
212         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o); 
213
214         IdentifierRep* i = static_cast<IdentifierRep*>(methodName);
215         if (!i->isString())
216             return false;
217
218         // Special case the "eval" method.
219         if (methodName == _NPN_GetStringIdentifier("eval")) {
220             if (argCount != 1)
221                 return false;
222             if (args[0].type != NPVariantType_String)
223                 return false;
224             return _NPN_Evaluate(npp, o, const_cast<NPString*>(&args[0].value.stringValue), result);
225         }
226
227         // Look up the function object.
228         RootObject* rootObject = obj->rootObject;
229         if (!rootObject || !rootObject->isValid())
230             return false;
231         ExecState* exec = rootObject->globalObject()->globalExec();
232         JSLock lock(SilenceAssertionsOnly);
233         JSValue function = obj->imp->get(exec, identifierFromNPIdentifier(exec, i->string()));
234         CallData callData;
235         CallType callType = getCallData(function, callData);
236         if (callType == CallTypeNone)
237             return false;
238
239         // Call the function object.
240         MarkedArgumentBuffer argList;
241         getListFromVariantArgs(exec, args, argCount, rootObject, argList);
242         ProtectedPtr<JSGlobalObject> globalObject = rootObject->globalObject();
243         globalObject->globalData().timeoutChecker.start();
244         JSValue resultV = JSC::call(exec, function, callType, callData, obj->imp, argList);
245         globalObject->globalData().timeoutChecker.stop();
246
247         // Convert and return the result of the function call.
248         convertValueToNPVariant(exec, resultV, result);
249         exec->clearException();
250         return true;
251     }
252
253     if (o->_class->invoke)
254         return o->_class->invoke(o, methodName, args, argCount, result);
255     
256     VOID_TO_NPVARIANT(*result);
257     return true;
258 }
259
260 bool _NPN_Evaluate(NPP instance, NPObject* o, NPString* s, NPVariant* variant)
261 {
262     if (o->_class == NPScriptObjectClass) {
263         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o); 
264
265         RootObject* rootObject = obj->rootObject;
266         if (!rootObject || !rootObject->isValid())
267             return false;
268
269         // There is a crash in Flash when evaluating a script that destroys the
270         // PluginView, so we destroy it asynchronously.
271         PluginView::keepAlive(instance);
272
273         ExecState* exec = rootObject->globalObject()->globalExec();
274         JSLock lock(SilenceAssertionsOnly);
275         String scriptString = convertNPStringToUTF16(s);
276         ProtectedPtr<JSGlobalObject> globalObject = rootObject->globalObject();
277         globalObject->globalData().timeoutChecker.start();
278         Completion completion = JSC::evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(scriptString), JSC::JSValue());
279         globalObject->globalData().timeoutChecker.stop();
280         ComplType type = completion.complType();
281         
282         JSValue result;
283         if (type == Normal) {
284             result = completion.value();
285             if (!result)
286                 result = jsUndefined();
287         } else
288             result = jsUndefined();
289
290         convertValueToNPVariant(exec, result, variant);
291         exec->clearException();
292         return true;
293     }
294
295     VOID_TO_NPVARIANT(*variant);
296     return false;
297 }
298
299 bool _NPN_GetProperty(NPP, NPObject* o, NPIdentifier propertyName, NPVariant* variant)
300 {
301     if (o->_class == NPScriptObjectClass) {
302         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o); 
303
304         RootObject* rootObject = obj->rootObject;
305         if (!rootObject || !rootObject->isValid())
306             return false;
307
308         ExecState* exec = rootObject->globalObject()->globalExec();
309         IdentifierRep* i = static_cast<IdentifierRep*>(propertyName);
310         
311         JSLock lock(SilenceAssertionsOnly);
312         JSValue result;
313         if (i->isString())
314             result = obj->imp->get(exec, identifierFromNPIdentifier(exec, i->string()));
315         else
316             result = obj->imp->get(exec, i->number());
317
318         convertValueToNPVariant(exec, result, variant);
319         exec->clearException();
320         return true;
321     }
322
323     if (o->_class->hasProperty && o->_class->getProperty) {
324         if (o->_class->hasProperty(o, propertyName))
325             return o->_class->getProperty(o, propertyName, variant);
326         return false;
327     }
328
329     VOID_TO_NPVARIANT(*variant);
330     return false;
331 }
332
333 bool _NPN_SetProperty(NPP, NPObject* o, NPIdentifier propertyName, const NPVariant* variant)
334 {
335     if (o->_class == NPScriptObjectClass) {
336         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o); 
337
338         RootObject* rootObject = obj->rootObject;
339         if (!rootObject || !rootObject->isValid())
340             return false;
341
342         ExecState* exec = rootObject->globalObject()->globalExec();
343         JSLock lock(SilenceAssertionsOnly);
344         IdentifierRep* i = static_cast<IdentifierRep*>(propertyName);
345
346         if (i->isString()) {
347             PutPropertySlot slot;
348             obj->imp->put(exec, identifierFromNPIdentifier(exec, i->string()), convertNPVariantToValue(exec, variant, rootObject), slot);
349         } else
350             obj->imp->put(exec, i->number(), convertNPVariantToValue(exec, variant, rootObject));
351         exec->clearException();
352         return true;
353     }
354
355     if (o->_class->setProperty)
356         return o->_class->setProperty(o, propertyName, variant);
357
358     return false;
359 }
360
361 bool _NPN_RemoveProperty(NPP, NPObject* o, NPIdentifier propertyName)
362 {
363     if (o->_class == NPScriptObjectClass) {
364         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o); 
365
366         RootObject* rootObject = obj->rootObject;
367         if (!rootObject || !rootObject->isValid())
368             return false;
369
370         ExecState* exec = rootObject->globalObject()->globalExec();
371         IdentifierRep* i = static_cast<IdentifierRep*>(propertyName);
372         if (i->isString()) {
373             if (!obj->imp->hasProperty(exec, identifierFromNPIdentifier(exec, i->string()))) {
374                 exec->clearException();
375                 return false;
376             }
377         } else {
378             if (!obj->imp->hasProperty(exec, i->number())) {
379                 exec->clearException();
380                 return false;
381             }
382         }
383
384         JSLock lock(SilenceAssertionsOnly);
385         if (i->isString())
386             obj->imp->deleteProperty(exec, identifierFromNPIdentifier(exec, i->string()));
387         else
388             obj->imp->deleteProperty(exec, i->number());
389
390         exec->clearException();
391         return true;
392     }
393     return false;
394 }
395
396 bool _NPN_HasProperty(NPP, NPObject* o, NPIdentifier propertyName)
397 {
398     if (o->_class == NPScriptObjectClass) {
399         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o); 
400
401         RootObject* rootObject = obj->rootObject;
402         if (!rootObject || !rootObject->isValid())
403             return false;
404
405         ExecState* exec = rootObject->globalObject()->globalExec();
406         IdentifierRep* i = static_cast<IdentifierRep*>(propertyName);
407         JSLock lock(SilenceAssertionsOnly);
408         if (i->isString()) {
409             bool result = obj->imp->hasProperty(exec, identifierFromNPIdentifier(exec, i->string()));
410             exec->clearException();
411             return result;
412         }
413
414         bool result = obj->imp->hasProperty(exec, i->number());
415         exec->clearException();
416         return result;
417     }
418
419     if (o->_class->hasProperty)
420         return o->_class->hasProperty(o, propertyName);
421
422     return false;
423 }
424
425 bool _NPN_HasMethod(NPP, NPObject* o, NPIdentifier methodName)
426 {
427     if (o->_class == NPScriptObjectClass) {
428         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o); 
429
430         IdentifierRep* i = static_cast<IdentifierRep*>(methodName);
431         if (!i->isString())
432             return false;
433
434         RootObject* rootObject = obj->rootObject;
435         if (!rootObject || !rootObject->isValid())
436             return false;
437
438         ExecState* exec = rootObject->globalObject()->globalExec();
439         JSLock lock(SilenceAssertionsOnly);
440         JSValue func = obj->imp->get(exec, identifierFromNPIdentifier(exec, i->string()));
441         exec->clearException();
442         return !func.isUndefined();
443     }
444     
445     if (o->_class->hasMethod)
446         return o->_class->hasMethod(o, methodName);
447     
448     return false;
449 }
450
451 void _NPN_SetException(NPObject*, const NPUTF8* message)
452 {
453     // Ignoring the NPObject param is consistent with the Mozilla implementation.
454     UString exception(message);
455     CInstance::setGlobalException(exception);
456 }
457
458 bool _NPN_Enumerate(NPP, NPObject* o, NPIdentifier** identifier, uint32_t* count)
459 {
460     if (o->_class == NPScriptObjectClass) {
461         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o); 
462         
463         RootObject* rootObject = obj->rootObject;
464         if (!rootObject || !rootObject->isValid())
465             return false;
466         
467         ExecState* exec = rootObject->globalObject()->globalExec();
468         JSLock lock(SilenceAssertionsOnly);
469         PropertyNameArray propertyNames(exec);
470
471         obj->imp->getPropertyNames(exec, propertyNames);
472         unsigned size = static_cast<unsigned>(propertyNames.size());
473         // FIXME: This should really call NPN_MemAlloc but that's in WebKit
474         NPIdentifier* identifiers = static_cast<NPIdentifier*>(malloc(sizeof(NPIdentifier) * size));
475         
476         for (unsigned i = 0; i < size; ++i)
477             identifiers[i] = _NPN_GetStringIdentifier(propertyNames[i].ustring().utf8().data());
478
479         *identifier = identifiers;
480         *count = size;
481
482         exec->clearException();
483         return true;
484     }
485     
486     if (NP_CLASS_STRUCT_VERSION_HAS_ENUM(o->_class) && o->_class->enumerate)
487         return o->_class->enumerate(o, identifier, count);
488     
489     return false;
490 }
491
492 bool _NPN_Construct(NPP, NPObject* o, const NPVariant* args, uint32_t argCount, NPVariant* result)
493 {
494     if (o->_class == NPScriptObjectClass) {
495         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
496         
497         VOID_TO_NPVARIANT(*result);
498         
499         // Lookup the constructor object.
500         RootObject* rootObject = obj->rootObject;
501         if (!rootObject || !rootObject->isValid())
502             return false;
503         
504         ExecState* exec = rootObject->globalObject()->globalExec();
505         JSLock lock(SilenceAssertionsOnly);
506         
507         // Call the constructor object.
508         JSValue constructor = obj->imp;
509         ConstructData constructData;
510         ConstructType constructType = getConstructData(constructor, constructData);
511         if (constructType == ConstructTypeNone)
512             return false;
513         
514         MarkedArgumentBuffer argList;
515         getListFromVariantArgs(exec, args, argCount, rootObject, argList);
516         ProtectedPtr<JSGlobalObject> globalObject = rootObject->globalObject();
517         globalObject->globalData().timeoutChecker.start();
518         JSValue resultV = JSC::construct(exec, constructor, constructType, constructData, argList);
519         globalObject->globalData().timeoutChecker.stop();
520         
521         // Convert and return the result.
522         convertValueToNPVariant(exec, resultV, result);
523         exec->clearException();
524         return true;
525     }
526     
527     if (NP_CLASS_STRUCT_VERSION_HAS_CTOR(o->_class) && o->_class->construct)
528         return o->_class->construct(o, args, argCount, result);
529     
530     return false;
531 }
532
533 #endif // ENABLE(NETSCAPE_PLUGIN_API)