1ec5e06b75d7de78d4ba9abb8d4a0585f7dd92ea
[WebKit-https.git] / WebCore / bindings / v8 / NPV8Object.cpp
1 /*
2  * Copyright (C) 2004, 2006 Apple Computer, Inc.  All rights reserved.
3  * Copyright (C) 2007, 2008, 2009 Google, Inc.  All rights reserved.
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 #include "config.h"
28
29 #include "NPV8Object.h"
30
31 #include "PlatformBridge.h"
32 #include "DOMWindow.h"
33 #include "Frame.h"
34 #include "OwnArrayPtr.h"
35 #include "PlatformString.h"
36 #include "ScriptController.h"
37 #include "V8GCController.h"
38 #include "V8Helpers.h"
39 #include "V8NPUtils.h"
40 #include "V8Proxy.h"
41 #include "WrapperTypeInfo.h"
42 #include "npruntime_impl.h"
43 #include "npruntime_priv.h"
44
45 #if PLATFORM(CHROMIUM)
46 #include <bindings/npruntime.h>
47 #else
48 #include "npruntime.h"
49 #endif
50
51 #include <stdio.h>
52 #include <wtf/StringExtras.h>
53
54 using namespace WebCore;
55
56 namespace WebCore {
57
58 WrapperTypeInfo* npObjectTypeInfo()
59 {
60     static WrapperTypeInfo typeInfo = { 0, 0, 0 };
61     return &typeInfo;
62 }
63
64 // FIXME: Comments on why use malloc and free.
65 static NPObject* allocV8NPObject(NPP, NPClass*)
66 {
67     return static_cast<NPObject*>(malloc(sizeof(V8NPObject)));
68 }
69
70 static void freeV8NPObject(NPObject* npObject)
71 {
72     V8NPObject* v8NpObject = reinterpret_cast<V8NPObject*>(npObject);
73 #ifndef NDEBUG
74     V8GCController::unregisterGlobalHandle(v8NpObject, v8NpObject->v8Object);
75 #endif
76     v8NpObject->v8Object.Dispose();
77     free(v8NpObject);
78 }
79
80 static v8::Handle<v8::Value>* createValueListFromVariantArgs(const NPVariant* arguments, uint32_t argumentCount, NPObject* owner)
81 {
82     v8::Handle<v8::Value>* argv = new v8::Handle<v8::Value>[argumentCount];
83     for (uint32_t index = 0; index < argumentCount; index++) {
84         const NPVariant* arg = &arguments[index];
85         argv[index] = convertNPVariantToV8Object(arg, owner);
86     }
87     return argv;
88 }
89
90 // Create an identifier (null terminated utf8 char*) from the NPIdentifier.
91 static v8::Local<v8::String> npIdentifierToV8Identifier(NPIdentifier name)
92 {
93     PrivateIdentifier* identifier = static_cast<PrivateIdentifier*>(name);
94     if (identifier->isString)
95         return v8::String::New(static_cast<const char*>(identifier->value.string));
96
97     char buffer[32];
98     snprintf(buffer, sizeof(buffer), "%d", identifier->value.number);
99     return v8::String::New(buffer);
100 }
101
102 NPObject* v8ObjectToNPObject(v8::Handle<v8::Object> object)
103 {
104     return reinterpret_cast<NPObject*>(object->GetPointerFromInternalField(v8DOMWrapperObjectIndex)); 
105 }
106
107 static NPClass V8NPObjectClass = { NP_CLASS_STRUCT_VERSION,
108                                    allocV8NPObject,
109                                    freeV8NPObject,
110                                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
111
112 // NPAPI's npruntime functions.
113 NPClass* npScriptObjectClass = &V8NPObjectClass;
114
115 NPObject* npCreateV8ScriptObject(NPP npp, v8::Handle<v8::Object> object, DOMWindow* root)
116 {
117     // Check to see if this object is already wrapped.
118     if (object->InternalFieldCount() == npObjectInternalFieldCount) {
119         WrapperTypeInfo* typeInfo = static_cast<WrapperTypeInfo*>(object->GetPointerFromInternalField(v8DOMWrapperTypeIndex));
120         if (typeInfo == npObjectTypeInfo()) {
121
122             NPObject* returnValue = v8ObjectToNPObject(object);
123             _NPN_RetainObject(returnValue);
124             return returnValue;
125         }
126     }
127
128     V8NPObject* v8npObject = reinterpret_cast<V8NPObject*>(_NPN_CreateObject(npp, &V8NPObjectClass));
129     v8npObject->v8Object = v8::Persistent<v8::Object>::New(object);
130 #ifndef NDEBUG
131     V8GCController::registerGlobalHandle(NPOBJECT, v8npObject, v8npObject->v8Object);
132 #endif
133     v8npObject->rootObject = root;
134     return reinterpret_cast<NPObject*>(v8npObject);
135 }
136
137 } // namespace WebCore
138
139 bool _NPN_Invoke(NPP npp, NPObject* npObject, NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
140 {
141     if (!npObject)
142         return false;
143
144     if (npObject->_class != npScriptObjectClass) {
145         if (npObject->_class->invoke)
146             return npObject->_class->invoke(npObject, methodName, arguments, argumentCount, result);
147
148         VOID_TO_NPVARIANT(*result);
149         return true;
150     }
151
152     V8NPObject* v8NpObject = reinterpret_cast<V8NPObject*>(npObject);
153
154     PrivateIdentifier* identifier = static_cast<PrivateIdentifier*>(methodName);
155     if (!identifier->isString)
156         return false;
157
158     if (!strcmp(identifier->value.string, "eval")) {
159         if (argumentCount != 1)
160             return false;
161         if (arguments[0].type != NPVariantType_String)
162             return false;
163         return _NPN_Evaluate(npp, npObject, const_cast<NPString*>(&arguments[0].value.stringValue), result);
164     }
165
166     v8::HandleScope handleScope;
167     // FIXME: should use the plugin's owner frame as the security context.
168     v8::Handle<v8::Context> context = toV8Context(npp, npObject);
169     if (context.IsEmpty())
170         return false;
171
172     v8::Context::Scope scope(context);
173     ExceptionCatcher exceptionCatcher;
174
175     v8::Handle<v8::Value> functionObject = v8NpObject->v8Object->Get(v8::String::New(identifier->value.string));
176     if (functionObject.IsEmpty() || functionObject->IsNull()) {
177         NULL_TO_NPVARIANT(*result);
178         return false;
179     }
180     if (functionObject->IsUndefined()) {
181         VOID_TO_NPVARIANT(*result);
182         return false;
183     }
184
185     V8Proxy* proxy = toV8Proxy(npObject);
186     ASSERT(proxy);
187
188     // Call the function object.
189     v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(functionObject);
190     OwnArrayPtr<v8::Handle<v8::Value> > argv(createValueListFromVariantArgs(arguments, argumentCount, npObject));
191     v8::Local<v8::Value> resultObject = proxy->callFunction(function, v8NpObject->v8Object, argumentCount, argv.get());
192
193     // If we had an error, return false.  The spec is a little unclear here, but says "Returns true if the method was
194     // successfully invoked".  If we get an error return value, was that successfully invoked?
195     if (resultObject.IsEmpty())
196         return false;
197
198     convertV8ObjectToNPVariant(resultObject, npObject, result);
199     return true;
200 }
201
202 // FIXME: Fix it same as _NPN_Invoke (HandleScope and such).
203 bool _NPN_InvokeDefault(NPP npp, NPObject* npObject, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
204 {
205     if (!npObject)
206         return false;
207
208     if (npObject->_class != npScriptObjectClass) {
209         if (npObject->_class->invokeDefault)
210             return npObject->_class->invokeDefault(npObject, arguments, argumentCount, result);
211
212         VOID_TO_NPVARIANT(*result);
213         return true;
214     }
215
216     V8NPObject* v8NpObject = reinterpret_cast<V8NPObject*>(npObject);
217
218     VOID_TO_NPVARIANT(*result);
219
220     v8::HandleScope handleScope;
221     v8::Handle<v8::Context> context = toV8Context(npp, npObject);
222     if (context.IsEmpty())
223         return false;
224
225     v8::Context::Scope scope(context);
226     ExceptionCatcher exceptionCatcher;
227
228     // Lookup the function object and call it.
229     v8::Handle<v8::Object> functionObject(v8NpObject->v8Object);
230     if (!functionObject->IsFunction())
231         return false;
232
233     v8::Local<v8::Value> resultObject;
234     v8::Handle<v8::Function> function(v8::Function::Cast(*functionObject));
235     if (!function->IsNull()) {
236         V8Proxy* proxy = toV8Proxy(npObject);
237         ASSERT(proxy);
238
239         OwnArrayPtr<v8::Handle<v8::Value> > argv(createValueListFromVariantArgs(arguments, argumentCount, npObject));
240         resultObject = proxy->callFunction(function, functionObject, argumentCount, argv.get());
241     }
242     // If we had an error, return false.  The spec is a little unclear here, but says "Returns true if the method was
243     // successfully invoked".  If we get an error return value, was that successfully invoked?
244     if (resultObject.IsEmpty())
245         return false;
246
247     convertV8ObjectToNPVariant(resultObject, npObject, result);
248     return true;
249 }
250
251 bool _NPN_Evaluate(NPP npp, NPObject* npObject, NPString* npScript, NPVariant* result)
252 {
253     bool popupsAllowed = PlatformBridge::popupsAllowed(npp);
254     return _NPN_EvaluateHelper(npp, popupsAllowed, npObject, npScript, result);
255 }
256
257 bool _NPN_EvaluateHelper(NPP npp, bool popupsAllowed, NPObject* npObject, NPString* npScript, NPVariant* result)
258 {
259     VOID_TO_NPVARIANT(*result);
260     if (!npObject)
261         return false;
262
263     if (npObject->_class != npScriptObjectClass)
264         return false;
265
266     v8::HandleScope handleScope;
267     v8::Handle<v8::Context> context = toV8Context(npp, npObject);
268     if (context.IsEmpty())
269         return false;
270
271     V8Proxy* proxy = toV8Proxy(npObject);
272     ASSERT(proxy);
273
274     v8::Context::Scope scope(context);
275     ExceptionCatcher exceptionCatcher;
276
277     String filename;
278     if (!popupsAllowed)
279         filename = "npscript";
280
281     String script = String::fromUTF8(npScript->UTF8Characters, npScript->UTF8Length);
282     v8::Local<v8::Value> v8result = proxy->evaluate(ScriptSourceCode(script, KURL(ParsedURLString, filename)), 0);
283
284     if (v8result.IsEmpty())
285         return false;
286
287     convertV8ObjectToNPVariant(v8result, npObject, result);
288     return true;
289 }
290
291 bool _NPN_GetProperty(NPP npp, NPObject* npObject, NPIdentifier propertyName, NPVariant* result)
292 {
293     if (!npObject)
294         return false;
295
296     if (npObject->_class == npScriptObjectClass) {
297         V8NPObject* object = reinterpret_cast<V8NPObject*>(npObject);
298
299         v8::HandleScope handleScope;
300         v8::Handle<v8::Context> context = toV8Context(npp, npObject);
301         if (context.IsEmpty())
302             return false;
303
304         v8::Context::Scope scope(context);
305         ExceptionCatcher exceptionCatcher;
306
307         v8::Handle<v8::Object> obj(object->v8Object);
308         v8::Local<v8::Value> v8result = obj->Get(npIdentifierToV8Identifier(propertyName));
309         
310         if (v8result.IsEmpty())
311             return false;
312
313         convertV8ObjectToNPVariant(v8result, npObject, result);
314         return true;
315     }
316
317     if (npObject->_class->hasProperty && npObject->_class->getProperty) {
318         if (npObject->_class->hasProperty(npObject, propertyName))
319             return npObject->_class->getProperty(npObject, propertyName, result);
320     }
321
322     VOID_TO_NPVARIANT(*result);
323     return false;
324 }
325
326 bool _NPN_SetProperty(NPP npp, NPObject* npObject, NPIdentifier propertyName, const NPVariant* value)
327 {
328     if (!npObject)
329         return false;
330
331     if (npObject->_class == npScriptObjectClass) {
332         V8NPObject* object = reinterpret_cast<V8NPObject*>(npObject);
333
334         v8::HandleScope handleScope;
335         v8::Handle<v8::Context> context = toV8Context(npp, npObject);
336         if (context.IsEmpty())
337             return false;
338
339         v8::Context::Scope scope(context);
340         ExceptionCatcher exceptionCatcher;
341
342         v8::Handle<v8::Object> obj(object->v8Object);
343         obj->Set(npIdentifierToV8Identifier(propertyName),
344                  convertNPVariantToV8Object(value, object->rootObject->frame()->script()->windowScriptNPObject()));
345         return true;
346     }
347
348     if (npObject->_class->setProperty)
349         return npObject->_class->setProperty(npObject, propertyName, value);
350
351     return false;
352 }
353
354 bool _NPN_RemoveProperty(NPP npp, NPObject* npObject, NPIdentifier propertyName)
355 {
356     if (!npObject)
357         return false;
358     if (npObject->_class != npScriptObjectClass)
359         return false;
360
361     V8NPObject* object = reinterpret_cast<V8NPObject*>(npObject);
362
363     v8::HandleScope handleScope;
364     v8::Handle<v8::Context> context = toV8Context(npp, npObject);
365     if (context.IsEmpty())
366         return false;
367     v8::Context::Scope scope(context);
368     ExceptionCatcher exceptionCatcher;
369
370     v8::Handle<v8::Object> obj(object->v8Object);
371     // FIXME: Verify that setting to undefined is right.
372     obj->Set(npIdentifierToV8Identifier(propertyName), v8::Undefined());
373     return true;
374 }
375
376 bool _NPN_HasProperty(NPP npp, NPObject* npObject, NPIdentifier propertyName)
377 {
378     if (!npObject)
379         return false;
380
381     if (npObject->_class == npScriptObjectClass) {
382         V8NPObject* object = reinterpret_cast<V8NPObject*>(npObject);
383
384         v8::HandleScope handleScope;
385         v8::Handle<v8::Context> context = toV8Context(npp, npObject);
386         if (context.IsEmpty())
387             return false;
388         v8::Context::Scope scope(context);
389         ExceptionCatcher exceptionCatcher;
390
391         v8::Handle<v8::Object> obj(object->v8Object);
392         return obj->Has(npIdentifierToV8Identifier(propertyName));
393     }
394
395     if (npObject->_class->hasProperty)
396         return npObject->_class->hasProperty(npObject, propertyName);
397     return false;
398 }
399
400 bool _NPN_HasMethod(NPP npp, NPObject* npObject, NPIdentifier methodName)
401 {
402     if (!npObject)
403         return false;
404
405     if (npObject->_class == npScriptObjectClass) {
406         V8NPObject* object = reinterpret_cast<V8NPObject*>(npObject);
407
408         v8::HandleScope handleScope;
409         v8::Handle<v8::Context> context = toV8Context(npp, npObject);
410         if (context.IsEmpty())
411             return false;
412         v8::Context::Scope scope(context);
413         ExceptionCatcher exceptionCatcher;
414
415         v8::Handle<v8::Object> obj(object->v8Object);
416         v8::Handle<v8::Value> prop = obj->Get(npIdentifierToV8Identifier(methodName));
417         return prop->IsFunction();
418     }
419
420     if (npObject->_class->hasMethod)
421         return npObject->_class->hasMethod(npObject, methodName);
422     return false;
423 }
424
425 void _NPN_SetException(NPObject* npObject, const NPUTF8 *message)
426 {
427     if (!npObject || npObject->_class != npScriptObjectClass) {
428         // We won't be able to find a proper scope for this exception, so just throw it.
429         // This is consistent with JSC, which throws a global exception all the time.
430         V8Proxy::throwError(V8Proxy::GeneralError, message);
431         return;
432     }
433     v8::HandleScope handleScope;
434     v8::Handle<v8::Context> context = toV8Context(0, npObject);
435     if (context.IsEmpty())
436         return;
437
438     v8::Context::Scope scope(context);
439     ExceptionCatcher exceptionCatcher;
440
441     V8Proxy::throwError(V8Proxy::GeneralError, message);
442 }
443
444 bool _NPN_Enumerate(NPP npp, NPObject* npObject, NPIdentifier** identifier, uint32_t* count)
445 {
446     if (!npObject)
447         return false;
448
449     if (npObject->_class == npScriptObjectClass) {
450         V8NPObject* object = reinterpret_cast<V8NPObject*>(npObject);
451
452         v8::HandleScope handleScope;
453         v8::Handle<v8::Context> context = toV8Context(npp, npObject);
454         if (context.IsEmpty())
455             return false;
456         v8::Context::Scope scope(context);
457         ExceptionCatcher exceptionCatcher;
458
459         v8::Handle<v8::Object> obj(object->v8Object);
460
461         // FIXME: http://b/issue?id=1210340: Use a v8::Object::Keys() method when it exists, instead of evaluating javascript.
462
463         // FIXME: Figure out how to cache this helper function.  Run a helper function that collects the properties
464         // on the object into an array.
465         const char enumeratorCode[] =
466             "(function (obj) {"
467             "  var props = [];"
468             "  for (var prop in obj) {"
469             "    props[props.length] = prop;"
470             "  }"
471             "  return props;"
472             "});";
473         v8::Handle<v8::String> source = v8::String::New(enumeratorCode);
474         v8::Handle<v8::Script> script = v8::Script::Compile(source, 0);
475         v8::Handle<v8::Value> enumeratorObj = script->Run();
476         v8::Handle<v8::Function> enumerator = v8::Handle<v8::Function>::Cast(enumeratorObj);
477         v8::Handle<v8::Value> argv[] = { obj };
478         v8::Local<v8::Value> propsObj = enumerator->Call(v8::Handle<v8::Object>::Cast(enumeratorObj), ARRAYSIZE_UNSAFE(argv), argv);
479         if (propsObj.IsEmpty())
480             return false;
481
482         // Convert the results into an array of NPIdentifiers.
483         v8::Handle<v8::Array> props = v8::Handle<v8::Array>::Cast(propsObj);
484         *count = props->Length();
485         *identifier = static_cast<NPIdentifier*>(malloc(sizeof(NPIdentifier*) * *count));
486         for (uint32_t i = 0; i < *count; ++i) {
487             v8::Local<v8::Value> name = props->Get(v8::Integer::New(i));
488             (*identifier)[i] = getStringIdentifier(v8::Local<v8::String>::Cast(name));
489         }
490         return true;
491     }
492
493     if (NP_CLASS_STRUCT_VERSION_HAS_ENUM(npObject->_class) && npObject->_class->enumerate)
494        return npObject->_class->enumerate(npObject, identifier, count);
495
496     return false;
497 }
498
499 bool _NPN_Construct(NPP npp, NPObject* npObject, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
500 {
501     if (!npObject)
502         return false;
503
504     if (npObject->_class == npScriptObjectClass) {
505         V8NPObject* object = reinterpret_cast<V8NPObject*>(npObject);
506
507         v8::HandleScope handleScope;
508         v8::Handle<v8::Context> context = toV8Context(npp, npObject);
509         if (context.IsEmpty())
510             return false;
511         v8::Context::Scope scope(context);
512         ExceptionCatcher exceptionCatcher;
513
514         // Lookup the constructor function.
515         v8::Handle<v8::Object> ctorObj(object->v8Object);
516         if (!ctorObj->IsFunction())
517             return false;
518
519         // Call the constructor.
520         v8::Local<v8::Value> resultObject;
521         v8::Handle<v8::Function> ctor(v8::Function::Cast(*ctorObj));
522         if (!ctor->IsNull()) {
523             V8Proxy* proxy = toV8Proxy(npObject);
524             ASSERT(proxy);
525
526             OwnArrayPtr<v8::Handle<v8::Value> > argv(createValueListFromVariantArgs(arguments, argumentCount, npObject));
527             resultObject = proxy->newInstance(ctor, argumentCount, argv.get());
528         }
529
530         if (resultObject.IsEmpty())
531             return false;
532
533         convertV8ObjectToNPVariant(resultObject, npObject, result);
534         return true;
535     }
536
537     if (NP_CLASS_STRUCT_VERSION_HAS_CTOR(npObject->_class) && npObject->_class->construct)
538         return npObject->_class->construct(npObject, arguments, argumentCount, result);
539
540     return false;
541 }