code.vuplus.com Git - vuplus_webkit/blob - 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         RefPtr<JSGlobalData> globalData(&exec->globalData());
 193         globalData->timeoutChecker.start();
 194         JSValue resultV = JSC::call(exec, function, callType, callData, function, argList);
 195         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         RefPtr<JSGlobalData> globalData(&exec->globalData());
 243         globalData->timeoutChecker.start();
 244         JSValue resultV = JSC::call(exec, function, callType, callData, obj->imp->toThisObject(exec), argList);
 245         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         RefPtr<JSGlobalData> globalData(&exec->globalData());
 277
 278         globalData->timeoutChecker.start();
 279         JSValue returnValue = JSC::evaluate(rootObject->globalObject()->globalExec(), rootObject->globalObject()->globalScopeChain(), makeSource(scriptString), JSC::JSValue());
 280         globalData->timeoutChecker.stop();
 281
 282         convertValueToNPVariant(exec, returnValue, variant);
 283         exec->clearException();
 284         return true;
 285     }
 286
 287     VOID_TO_NPVARIANT(*variant);
 288     return false;
 289 }
 290
 291 bool _NPN_GetProperty(NPP, NPObject* o, NPIdentifier propertyName, NPVariant* variant)
 292 {
 293     if (o->_class == NPScriptObjectClass) {
 294         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
 295
 296         RootObject* rootObject = obj->rootObject;
 297         if (!rootObject || !rootObject->isValid())
 298             return false;
 299
 300         ExecState* exec = rootObject->globalObject()->globalExec();
 301         IdentifierRep* i = static_cast<IdentifierRep*>(propertyName);
 302
 303         JSLock lock(SilenceAssertionsOnly);
 304         JSValue result;
 305         if (i->isString())
 306             result = obj->imp->get(exec, identifierFromNPIdentifier(exec, i->string()));
 307         else
 308             result = obj->imp->get(exec, i->number());
 309
 310         convertValueToNPVariant(exec, result, variant);
 311         exec->clearException();
 312         return true;
 313     }
 314
 315     if (o->_class->hasProperty && o->_class->getProperty) {
 316         if (o->_class->hasProperty(o, propertyName))
 317             return o->_class->getProperty(o, propertyName, variant);
 318         return false;
 319     }
 320
 321     VOID_TO_NPVARIANT(*variant);
 322     return false;
 323 }
 324
 325 bool _NPN_SetProperty(NPP, NPObject* o, NPIdentifier propertyName, const NPVariant* variant)
 326 {
 327     if (o->_class == NPScriptObjectClass) {
 328         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
 329
 330         RootObject* rootObject = obj->rootObject;
 331         if (!rootObject || !rootObject->isValid())
 332             return false;
 333
 334         ExecState* exec = rootObject->globalObject()->globalExec();
 335         JSLock lock(SilenceAssertionsOnly);
 336         IdentifierRep* i = static_cast<IdentifierRep*>(propertyName);
 337
 338         if (i->isString()) {
 339             PutPropertySlot slot;
 340             obj->imp->put(exec, identifierFromNPIdentifier(exec, i->string()), convertNPVariantToValue(exec, variant, rootObject), slot);
 341         } else
 342             obj->imp->put(exec, i->number(), convertNPVariantToValue(exec, variant, rootObject));
 343         exec->clearException();
 344         return true;
 345     }
 346
 347     if (o->_class->setProperty)
 348         return o->_class->setProperty(o, propertyName, variant);
 349
 350     return false;
 351 }
 352
 353 bool _NPN_RemoveProperty(NPP, NPObject* o, NPIdentifier propertyName)
 354 {
 355     if (o->_class == NPScriptObjectClass) {
 356         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
 357
 358         RootObject* rootObject = obj->rootObject;
 359         if (!rootObject || !rootObject->isValid())
 360             return false;
 361
 362         ExecState* exec = rootObject->globalObject()->globalExec();
 363         IdentifierRep* i = static_cast<IdentifierRep*>(propertyName);
 364         if (i->isString()) {
 365             if (!obj->imp->hasProperty(exec, identifierFromNPIdentifier(exec, i->string()))) {
 366                 exec->clearException();
 367                 return false;
 368             }
 369         } else {
 370             if (!obj->imp->hasProperty(exec, i->number())) {
 371                 exec->clearException();
 372                 return false;
 373             }
 374         }
 375
 376         JSLock lock(SilenceAssertionsOnly);
 377         if (i->isString())
 378             obj->imp->deleteProperty(exec, identifierFromNPIdentifier(exec, i->string()));
 379         else
 380             obj->imp->deleteProperty(exec, i->number());
 381
 382         exec->clearException();
 383         return true;
 384     }
 385     return false;
 386 }
 387
 388 bool _NPN_HasProperty(NPP, NPObject* o, NPIdentifier propertyName)
 389 {
 390     if (o->_class == NPScriptObjectClass) {
 391         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
 392
 393         RootObject* rootObject = obj->rootObject;
 394         if (!rootObject || !rootObject->isValid())
 395             return false;
 396
 397         ExecState* exec = rootObject->globalObject()->globalExec();
 398         IdentifierRep* i = static_cast<IdentifierRep*>(propertyName);
 399         JSLock lock(SilenceAssertionsOnly);
 400         if (i->isString()) {
 401             bool result = obj->imp->hasProperty(exec, identifierFromNPIdentifier(exec, i->string()));
 402             exec->clearException();
 403             return result;
 404         }
 405
 406         bool result = obj->imp->hasProperty(exec, i->number());
 407         exec->clearException();
 408         return result;
 409     }
 410
 411     if (o->_class->hasProperty)
 412         return o->_class->hasProperty(o, propertyName);
 413
 414     return false;
 415 }
 416
 417 bool _NPN_HasMethod(NPP, NPObject* o, NPIdentifier methodName)
 418 {
 419     if (o->_class == NPScriptObjectClass) {
 420         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
 421
 422         IdentifierRep* i = static_cast<IdentifierRep*>(methodName);
 423         if (!i->isString())
 424             return false;
 425
 426         RootObject* rootObject = obj->rootObject;
 427         if (!rootObject || !rootObject->isValid())
 428             return false;
 429
 430         ExecState* exec = rootObject->globalObject()->globalExec();
 431         JSLock lock(SilenceAssertionsOnly);
 432         JSValue func = obj->imp->get(exec, identifierFromNPIdentifier(exec, i->string()));
 433         exec->clearException();
 434         return !func.isUndefined();
 435     }
 436
 437     if (o->_class->hasMethod)
 438         return o->_class->hasMethod(o, methodName);
 439
 440     return false;
 441 }
 442
 443 void _NPN_SetException(NPObject*, const NPUTF8* message)
 444 {
 445     // Ignoring the NPObject param is consistent with the Mozilla implementation.
 446     UString exception(message);
 447     CInstance::setGlobalException(exception);
 448 }
 449
 450 bool _NPN_Enumerate(NPP, NPObject* o, NPIdentifier** identifier, uint32_t* count)
 451 {
 452     if (o->_class == NPScriptObjectClass) {
 453         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
 454
 455         RootObject* rootObject = obj->rootObject;
 456         if (!rootObject || !rootObject->isValid())
 457             return false;
 458
 459         ExecState* exec = rootObject->globalObject()->globalExec();
 460         JSLock lock(SilenceAssertionsOnly);
 461         PropertyNameArray propertyNames(exec);
 462
 463         obj->imp->getPropertyNames(exec, propertyNames);
 464         unsigned size = static_cast<unsigned>(propertyNames.size());
 465         // FIXME: This should really call NPN_MemAlloc but that's in WebKit
 466         NPIdentifier* identifiers = static_cast<NPIdentifier*>(malloc(sizeof(NPIdentifier) * size));
 467
 468         for (unsigned i = 0; i < size; ++i)
 469             identifiers[i] = _NPN_GetStringIdentifier(propertyNames[i].ustring().utf8().data());
 470
 471         *identifier = identifiers;
 472         *count = size;
 473
 474         exec->clearException();
 475         return true;
 476     }
 477
 478     if (NP_CLASS_STRUCT_VERSION_HAS_ENUM(o->_class) && o->_class->enumerate)
 479         return o->_class->enumerate(o, identifier, count);
 480
 481     return false;
 482 }
 483
 484 bool _NPN_Construct(NPP, NPObject* o, const NPVariant* args, uint32_t argCount, NPVariant* result)
 485 {
 486     if (o->_class == NPScriptObjectClass) {
 487         JavaScriptObject* obj = reinterpret_cast<JavaScriptObject*>(o);
 488
 489         VOID_TO_NPVARIANT(*result);
 490
 491         // Lookup the constructor object.
 492         RootObject* rootObject = obj->rootObject;
 493         if (!rootObject || !rootObject->isValid())
 494             return false;
 495
 496         ExecState* exec = rootObject->globalObject()->globalExec();
 497         JSLock lock(SilenceAssertionsOnly);
 498
 499         // Call the constructor object.
 500         JSValue constructor = obj->imp;
 501         ConstructData constructData;
 502         ConstructType constructType = getConstructData(constructor, constructData);
 503         if (constructType == ConstructTypeNone)
 504             return false;
 505
 506         MarkedArgumentBuffer argList;
 507         getListFromVariantArgs(exec, args, argCount, rootObject, argList);
 508         RefPtr<JSGlobalData> globalData(&exec->globalData());
 509         globalData->timeoutChecker.start();
 510         JSValue resultV = JSC::construct(exec, constructor, constructType, constructData, argList);
 511         globalData->timeoutChecker.stop();
 512
 513         // Convert and return the result.
 514         convertValueToNPVariant(exec, resultV, result);
 515         exec->clearException();
 516         return true;
 517     }
 518
 519     if (NP_CLASS_STRUCT_VERSION_HAS_CTOR(o->_class) && o->_class->construct)
 520         return o->_class->construct(o, args, argCount, result);
 521
 522     return false;
 523 }
 524
 525 #endif // ENABLE(NETSCAPE_PLUGIN_API)