1 /*

     2  * Copyright (C) 2004, 2006 Apple Computer, Inc.  All rights reserved.

     3  * Copyright (C) 2007-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 #include "npruntime_impl.h"

    31 #include "npruntime_priv.h"

    32 #include "V8NPObject.h"

    33 

    34 #include <wtf/HashMap.h>

    35 #include <wtf/HashSet.h>

    36 #include <wtf/Assertions.h>

    37 

    38 using namespace WebCore;

    39 

    40 // FIXME: Consider removing locks if we're singlethreaded already.

    41 // The static initializer here should work okay, but we want to avoid

    42 // static initialization in general.

    43 

    44 namespace npruntime {

    45 

    46 // We use StringKey here as the key-type to avoid a string copy to

    47 // construct the map key and for faster comparisons than strcmp.

    48 class StringKey {

    49 public:

    50     explicit StringKey(const char* str) : m_string(str), m_length(strlen(str)) { }

    51     StringKey() : m_string(0), m_length(0) { }

    52     explicit StringKey(WTF::HashTableDeletedValueType) : m_string(hashTableDeletedValue()), m_length(0) { }

    53 

    54     StringKey& operator=(const StringKey& other)

    55     {

    56         this->m_string = other.m_string;

    57         this->m_length = other.m_length;

    58         return *this;

    59     }

    60 

    61     bool isHashTableDeletedValue() const

    62     {

    63         return m_string == hashTableDeletedValue();

    64     }

    65 

    66     const char* m_string;

    67     size_t m_length;

    68 

    69 private:

    70     const char* hashTableDeletedValue() const

    71     {

    72         return reinterpret_cast<const char*>(-1);

    73     }

    74 };

    75 

    76 inline bool operator==(const StringKey& x, const StringKey& y)

    77 {

    78     if (x.m_length != y.m_length)

    79         return false;

    80     if (x.m_string == y.m_string)

    81         return true;

    82 

    83     ASSERT(!x.isHashTableDeletedValue() && !y.isHashTableDeletedValue());

    84     return !memcmp(x.m_string, y.m_string, y.m_length);

    85 }

    86 

    87 // Implement WTF::DefaultHash<StringKey>::Hash interface.

    88 struct StringKeyHash {

    89     static unsigned hash(const StringKey& key)

    90     {

    91         // Compute string hash.

    92         unsigned hash = 0;

    93         size_t len = key.m_length;

    94         const char* str = key.m_string;

    95         for (size_t i = 0; i < len; i++) {

    96             char c = str[i];

    97             hash += c;

    98             hash += (hash << 10);

    99             hash ^= (hash >> 6);

   100         }

   101         hash += (hash << 3);

   102         hash ^= (hash >> 11);

   103         hash += (hash << 15);

   104         if (hash == 0)

   105             hash = 27;

   106         return hash;

   107     }

   108 

   109     static bool equal(const StringKey& x, const StringKey& y)

   110     {

   111         return x == y;

   112     }

   113 

   114     static const bool safeToCompareToEmptyOrDeleted = true;

   115 };

   116 

   117 }  // namespace npruntime

   118 

   119 using npruntime::StringKey;

   120 using npruntime::StringKeyHash;

   121 

   122 // Implement HashTraits<StringKey>

   123 struct StringKeyHashTraits : WTF::GenericHashTraits<StringKey> {

   124     static void constructDeletedValue(StringKey& slot)

   125     {

   126         new (&slot) StringKey(WTF::HashTableDeletedValue);

   127     }

   128 

   129     static bool isDeletedValue(const StringKey& value)

   130     {

   131         return value.isHashTableDeletedValue();

   132     }

   133 };

   134 

   135 typedef WTF::HashMap<StringKey, PrivateIdentifier*, StringKeyHash, StringKeyHashTraits> StringIdentifierMap;

   136 

   137 static StringIdentifierMap* getStringIdentifierMap()

   138 {

   139     static StringIdentifierMap* stringIdentifierMap = 0;

   140     if (!stringIdentifierMap)

   141         stringIdentifierMap = new StringIdentifierMap();

   142     return stringIdentifierMap;

   143 }

   144 

   145 typedef WTF::HashMap<int, PrivateIdentifier*> IntIdentifierMap;

   146 

   147 static IntIdentifierMap* getIntIdentifierMap()

   148 {

   149     static IntIdentifierMap* intIdentifierMap = 0;

   150     if (!intIdentifierMap)

   151         intIdentifierMap = new IntIdentifierMap();

   152     return intIdentifierMap;

   153 }

   154 

   155 extern "C" {

   156 

   157 NPIdentifier _NPN_GetStringIdentifier(const NPUTF8* name)

   158 {

   159     ASSERT(name);

   160 

   161     if (name) {

   162 

   163         StringKey key(name);

   164         StringIdentifierMap* identMap = getStringIdentifierMap();

   165         StringIdentifierMap::iterator iter = identMap->find(key);

   166         if (iter != identMap->end())

   167             return static_cast<NPIdentifier>(iter->second);

   168 

   169         size_t nameLen = key.m_length;

   170 

   171         // We never release identifiers, so this dictionary will grow.

   172         PrivateIdentifier* identifier = static_cast<PrivateIdentifier*>(malloc(sizeof(PrivateIdentifier) + nameLen + 1));

   173         char* nameStorage = reinterpret_cast<char*>(identifier + 1);

   174         memcpy(nameStorage, name, nameLen + 1);

   175         identifier->isString = true;

   176         identifier->value.string = reinterpret_cast<NPUTF8*>(nameStorage);

   177         key.m_string = nameStorage;

   178         identMap->set(key, identifier);

   179         return (NPIdentifier)identifier;

   180     }

   181 

   182     return 0;

   183 }

   184 

   185 void _NPN_GetStringIdentifiers(const NPUTF8** names, int32_t nameCount, NPIdentifier* identifiers)

   186 {

   187     ASSERT(names);

   188     ASSERT(identifiers);

   189 

   190     if (names && identifiers) {

   191         for (int i = 0; i < nameCount; i++)

   192             identifiers[i] = _NPN_GetStringIdentifier(names[i]);

   193     }

   194 }

   195 

   196 NPIdentifier _NPN_GetIntIdentifier(int32_t intId)

   197 {

   198     // Special case for -1 and 0, both cannot be used as key in HashMap.

   199     if (!intId || intId == -1) {

   200         static PrivateIdentifier* minusOneOrZeroIds[2];

   201         PrivateIdentifier* id = minusOneOrZeroIds[intId + 1];

   202         if (!id) {

   203             id = reinterpret_cast<PrivateIdentifier*>(malloc(sizeof(PrivateIdentifier)));

   204             id->isString = false;

   205             id->value.number = intId;

   206             minusOneOrZeroIds[intId + 1] = id;

   207         }

   208         return (NPIdentifier) id;

   209     }

   210 

   211     IntIdentifierMap* identMap = getIntIdentifierMap();

   212     IntIdentifierMap::iterator iter = identMap->find(intId);

   213     if (iter != identMap->end())

   214         return static_cast<NPIdentifier>(iter->second);

   215 

   216     // We never release identifiers, so this dictionary will grow.

   217     PrivateIdentifier* identifier = reinterpret_cast<PrivateIdentifier*>(malloc(sizeof(PrivateIdentifier)));

   218     identifier->isString = false;

   219     identifier->value.number = intId;

   220     identMap->set(intId, identifier);

   221     return (NPIdentifier)identifier;

   222 }

   223 

   224 bool _NPN_IdentifierIsString(NPIdentifier identifier)

   225 {

   226     PrivateIdentifier* privateIdentifier = reinterpret_cast<PrivateIdentifier*>(identifier);

   227     return privateIdentifier->isString;

   228 }

   229 

   230 NPUTF8 *_NPN_UTF8FromIdentifier(NPIdentifier identifier)

   231 {

   232     PrivateIdentifier* privateIdentifier = reinterpret_cast<PrivateIdentifier*>(identifier);

   233     if (!privateIdentifier->isString || !privateIdentifier->value.string)

   234         return 0;

   235 

   236     return (NPUTF8*) strdup(privateIdentifier->value.string);

   237 }

   238 

   239 int32_t _NPN_IntFromIdentifier(NPIdentifier identifier)

   240 {

   241     PrivateIdentifier* privateIdentifier = reinterpret_cast<PrivateIdentifier*>(identifier);

   242     if (privateIdentifier->isString)

   243         return 0;

   244     return privateIdentifier->value.number;

   245 }

   246 

   247 void _NPN_ReleaseVariantValue(NPVariant* variant)

   248 {

   249     ASSERT(variant);

   250 

   251     if (variant->type == NPVariantType_Object) {

   252         _NPN_ReleaseObject(variant->value.objectValue);

   253         variant->value.objectValue = 0;

   254     } else if (variant->type == NPVariantType_String) {

   255         free((void*)variant->value.stringValue.UTF8Characters);

   256         variant->value.stringValue.UTF8Characters = 0;

   257         variant->value.stringValue.UTF8Length = 0;

   258     }

   259 

   260     variant->type = NPVariantType_Void;

   261 }

   262 

   263 NPObject *_NPN_CreateObject(NPP npp, NPClass* npClass)

   264 {

   265     ASSERT(npClass);

   266 

   267     if (npClass) {

   268         NPObject* npObject;

   269         if (npClass->allocate != 0)

   270             npObject = npClass->allocate(npp, npClass);

   271         else

   272             npObject = reinterpret_cast<NPObject*>(malloc(sizeof(NPObject)));

   273 

   274         npObject->_class = npClass;

   275         npObject->referenceCount = 1;

   276         return npObject;

   277     }

   278 

   279     return 0;

   280 }

   281 

   282 NPObject* _NPN_RetainObject(NPObject* npObject)

   283 {

   284     ASSERT(npObject);

   285     ASSERT(npObject->referenceCount > 0);

   286 

   287     if (npObject)

   288         npObject->referenceCount++;

   289 

   290     return npObject;

   291 }

   292 

   293 // _NPN_DeallocateObject actually deletes the object.  Technically,

   294 // callers should use _NPN_ReleaseObject.  Webkit exposes this function

   295 // to kill objects which plugins may not have properly released.

   296 void _NPN_DeallocateObject(NPObject* npObject)

   297 {

   298     ASSERT(npObject);

   299 

   300     if (npObject) {

   301         // NPObjects that remain in pure C++ may never have wrappers.

   302         // Hence, if it's not already alive, don't unregister it.

   303         // If it is alive, unregister it as the *last* thing we do

   304         // so that it can do as much cleanup as possible on its own.

   305         if (_NPN_IsAlive(npObject))

   306             _NPN_UnregisterObject(npObject);

   307 

   308         npObject->referenceCount = -1;

   309         if (npObject->_class->deallocate)

   310             npObject->_class->deallocate(npObject);

   311         else

   312             free(npObject);

   313     }

   314 }

   315 

   316 void _NPN_ReleaseObject(NPObject* npObject)

   317 {

   318     ASSERT(npObject);

   319     ASSERT(npObject->referenceCount >= 1);

   320 

   321     if (npObject && npObject->referenceCount >= 1) {

   322         if (!--npObject->referenceCount)

   323             _NPN_DeallocateObject(npObject);

   324     }

   325 }

   326 

   327 void _NPN_InitializeVariantWithStringCopy(NPVariant* variant, const NPString* value)

   328 {

   329     variant->type = NPVariantType_String;

   330     variant->value.stringValue.UTF8Length = value->UTF8Length;

   331     variant->value.stringValue.UTF8Characters = reinterpret_cast<NPUTF8*>(malloc(sizeof(NPUTF8) * value->UTF8Length));

   332     memcpy((void*)variant->value.stringValue.UTF8Characters, value->UTF8Characters, sizeof(NPUTF8) * value->UTF8Length);

   333 }

   334 

   335 

   336 // NPN_Registry

   337 //

   338 // The registry is designed for quick lookup of NPObjects.

   339 // JS needs to be able to quickly lookup a given NPObject to determine

   340 // if it is alive or not.

   341 // The browser needs to be able to quickly lookup all NPObjects which are

   342 // "owned" by an object.

   343 //

   344 // The liveObjectMap is a hash table of all live objects to their owner

   345 // objects.  Presence in this table is used primarily to determine if

   346 // objects are live or not.

   347 //

   348 // The rootObjectMap is a hash table of root objects to a set of

   349 // objects that should be deactivated in sync with the root.  A

   350 // root is defined as a top-level owner object.  This is used on

   351 // Frame teardown to deactivate all objects associated

   352 // with a particular plugin.

   353 

   354 typedef WTF::HashSet<NPObject*> NPObjectSet;

   355 typedef WTF::HashMap<NPObject*, NPObject*> NPObjectMap;

   356 typedef WTF::HashMap<NPObject*, NPObjectSet*> NPRootObjectMap;

   357 

   358 // A map of live NPObjects with pointers to their Roots.

   359 NPObjectMap liveObjectMap;

   360 

   361 // A map of the root objects and the list of NPObjects

   362 // associated with that object.

   363 NPRootObjectMap rootObjectMap;

   364 

   365 void _NPN_RegisterObject(NPObject* npObject, NPObject* owner)

   366 {

   367     ASSERT(npObject);

   368 

   369     // Check if already registered.

   370     if (liveObjectMap.find(npObject) != liveObjectMap.end())

   371         return;

   372 

   373     if (!owner) {

   374         // Registering a new owner object.

   375         ASSERT(rootObjectMap.find(npObject) == rootObjectMap.end());

   376         rootObjectMap.set(npObject, new NPObjectSet());

   377     } else {

   378         // Always associate this object with it's top-most parent.

   379         // Since we always flatten, we only have to look up one level.

   380         NPObjectMap::iterator ownerEntry = liveObjectMap.find(owner);

   381         NPObject* parent = 0;

   382         if (liveObjectMap.end() != ownerEntry)

   383             parent = ownerEntry->second;

   384 

   385         if (parent)

   386             owner = parent;

   387         ASSERT(rootObjectMap.find(npObject) == rootObjectMap.end());

   388         if (rootObjectMap.find(owner) != rootObjectMap.end())

   389             rootObjectMap.get(owner)->add(npObject);

   390     }

   391 

   392     ASSERT(liveObjectMap.find(npObject) == liveObjectMap.end());

   393     liveObjectMap.set(npObject, owner);

   394 }

   395 

   396 void _NPN_UnregisterObject(NPObject* npObject)

   397 {

   398     ASSERT(npObject);

   399     ASSERT(liveObjectMap.find(npObject) != liveObjectMap.end());

   400 

   401     NPObject* owner = 0;

   402     if (liveObjectMap.find(npObject) != liveObjectMap.end())

   403         owner = liveObjectMap.find(npObject)->second;

   404 

   405     if (!owner) {

   406         // Unregistering a owner object; also unregister it's descendants.

   407         ASSERT(rootObjectMap.find(npObject) != rootObjectMap.end());

   408         NPObjectSet* set = rootObjectMap.get(npObject);

   409         while (set->size() > 0) {

   410 #ifndef NDEBUG

   411             int size = set->size();

   412 #endif

   413             NPObject* sub_object = *(set->begin());

   414             // The sub-object should not be a owner!

   415             ASSERT(rootObjectMap.find(sub_object) == rootObjectMap.end());

   416 

   417             // First, unregister the object.

   418             set->remove(sub_object);

   419             liveObjectMap.remove(sub_object);

   420 

   421             // Remove the JS references to the object.

   422             forgetV8ObjectForNPObject(sub_object);

   423 

   424             ASSERT(set->size() < size);

   425         }

   426         delete set;

   427         rootObjectMap.remove(npObject);

   428     } else {

   429         NPRootObjectMap::iterator ownerEntry = rootObjectMap.find(owner);

   430         if (ownerEntry != rootObjectMap.end()) {

   431             NPObjectSet* list = ownerEntry->second;

   432             ASSERT(list->find(npObject) != list->end());

   433             list->remove(npObject);

   434         }

   435     }

   436 

   437     liveObjectMap.remove(npObject);

   438     forgetV8ObjectForNPObject(npObject);

   439 }

   440 

   441 bool _NPN_IsAlive(NPObject* npObject)

   442 {

   443     return liveObjectMap.find(npObject) != liveObjectMap.end();

   444 }

   445 

   446 }  // extern "C"