/platform/external/webkit/WebCore/bindings/v8/npruntime.cpp
https://github.com/aharish/totoro-gb-opensource-update2 · C++ · 454 lines · 306 code · 74 blank · 74 comment · 66 complexity · ebc98f44ad37e545adb511e864d78796 MD5 · raw file
- /*
- * Copyright (C) 2004, 2006 Apple Computer, Inc. All rights reserved.
- * Copyright (C) 2007-2009 Google, Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
- #include "config.h"
- #include "NPV8Object.h"
- #include "npruntime_impl.h"
- #include "npruntime_priv.h"
- #include "V8NPObject.h"
- #include <wtf/HashMap.h>
- #include <wtf/HashSet.h>
- #include <wtf/Assertions.h>
- // FIXME: Consider removing locks if we're singlethreaded already.
- // The static initializer here should work okay, but we want to avoid
- // static initialization in general.
- namespace npruntime {
- // We use StringKey here as the key-type to avoid a string copy to
- // construct the map key and for faster comparisons than strcmp.
- class StringKey {
- public:
- explicit StringKey(const char* str) : m_string(str), m_length(strlen(str)) { }
- StringKey() : m_string(0), m_length(0) { }
- explicit StringKey(WTF::HashTableDeletedValueType) : m_string(hashTableDeletedValue()), m_length(0) { }
- StringKey& operator=(const StringKey& other)
- {
- this->m_string = other.m_string;
- this->m_length = other.m_length;
- return *this;
- }
- bool isHashTableDeletedValue() const
- {
- return m_string == hashTableDeletedValue();
- }
- const char* m_string;
- size_t m_length;
- private:
- const char* hashTableDeletedValue() const
- {
- return reinterpret_cast<const char*>(-1);
- }
- };
- inline bool operator==(const StringKey& x, const StringKey& y)
- {
- if (x.m_length != y.m_length)
- return false;
- if (x.m_string == y.m_string)
- return true;
- ASSERT(!x.isHashTableDeletedValue() && !y.isHashTableDeletedValue());
- return !memcmp(x.m_string, y.m_string, y.m_length);
- }
- // Implement WTF::DefaultHash<StringKey>::Hash interface.
- struct StringKeyHash {
- static unsigned hash(const StringKey& key)
- {
- // Compute string hash.
- unsigned hash = 0;
- size_t len = key.m_length;
- const char* str = key.m_string;
- for (size_t i = 0; i < len; i++) {
- char c = str[i];
- hash += c;
- hash += (hash << 10);
- hash ^= (hash >> 6);
- }
- hash += (hash << 3);
- hash ^= (hash >> 11);
- hash += (hash << 15);
- if (hash == 0)
- hash = 27;
- return hash;
- }
- static bool equal(const StringKey& x, const StringKey& y)
- {
- return x == y;
- }
- static const bool safeToCompareToEmptyOrDeleted = true;
- };
- } // namespace npruntime
- using npruntime::StringKey;
- using npruntime::StringKeyHash;
- // Implement HashTraits<StringKey>
- struct StringKeyHashTraits : WTF::GenericHashTraits<StringKey> {
- static void constructDeletedValue(StringKey& slot)
- {
- new (&slot) StringKey(WTF::HashTableDeletedValue);
- }
- static bool isDeletedValue(const StringKey& value)
- {
- return value.isHashTableDeletedValue();
- }
- };
- typedef WTF::HashMap<StringKey, PrivateIdentifier*, StringKeyHash, StringKeyHashTraits> StringIdentifierMap;
- static StringIdentifierMap* getStringIdentifierMap()
- {
- static StringIdentifierMap* stringIdentifierMap = 0;
- if (!stringIdentifierMap)
- stringIdentifierMap = new StringIdentifierMap();
- return stringIdentifierMap;
- }
- typedef WTF::HashMap<int, PrivateIdentifier*> IntIdentifierMap;
- static IntIdentifierMap* getIntIdentifierMap()
- {
- static IntIdentifierMap* intIdentifierMap = 0;
- if (!intIdentifierMap)
- intIdentifierMap = new IntIdentifierMap();
- return intIdentifierMap;
- }
- extern "C" {
- NPIdentifier _NPN_GetStringIdentifier(const NPUTF8* name)
- {
- ASSERT(name);
- if (name) {
- StringKey key(name);
- StringIdentifierMap* identMap = getStringIdentifierMap();
- StringIdentifierMap::iterator iter = identMap->find(key);
- if (iter != identMap->end())
- return static_cast<NPIdentifier>(iter->second);
- size_t nameLen = key.m_length;
- // We never release identifiers, so this dictionary will grow.
- PrivateIdentifier* identifier = static_cast<PrivateIdentifier*>(malloc(sizeof(PrivateIdentifier) + nameLen + 1));
- char* nameStorage = reinterpret_cast<char*>(identifier + 1);
- memcpy(nameStorage, name, nameLen + 1);
- identifier->isString = true;
- identifier->value.string = reinterpret_cast<NPUTF8*>(nameStorage);
- key.m_string = nameStorage;
- identMap->set(key, identifier);
- return (NPIdentifier)identifier;
- }
- return 0;
- }
- void _NPN_GetStringIdentifiers(const NPUTF8** names, int32_t nameCount, NPIdentifier* identifiers)
- {
- ASSERT(names);
- ASSERT(identifiers);
- if (names && identifiers) {
- for (int i = 0; i < nameCount; i++)
- identifiers[i] = _NPN_GetStringIdentifier(names[i]);
- }
- }
- NPIdentifier _NPN_GetIntIdentifier(int32_t intId)
- {
- // Special case for -1 and 0, both cannot be used as key in HashMap.
- if (!intId || intId == -1) {
- static PrivateIdentifier* minusOneOrZeroIds[2];
- PrivateIdentifier* id = minusOneOrZeroIds[intId + 1];
- if (!id) {
- id = reinterpret_cast<PrivateIdentifier*>(malloc(sizeof(PrivateIdentifier)));
- id->isString = false;
- id->value.number = intId;
- minusOneOrZeroIds[intId + 1] = id;
- }
- return (NPIdentifier) id;
- }
- IntIdentifierMap* identMap = getIntIdentifierMap();
- IntIdentifierMap::iterator iter = identMap->find(intId);
- if (iter != identMap->end())
- return static_cast<NPIdentifier>(iter->second);
- // We never release identifiers, so this dictionary will grow.
- PrivateIdentifier* identifier = reinterpret_cast<PrivateIdentifier*>(malloc(sizeof(PrivateIdentifier)));
- identifier->isString = false;
- identifier->value.number = intId;
- identMap->set(intId, identifier);
- return (NPIdentifier)identifier;
- }
- bool _NPN_IdentifierIsString(NPIdentifier identifier)
- {
- PrivateIdentifier* privateIdentifier = reinterpret_cast<PrivateIdentifier*>(identifier);
- return privateIdentifier->isString;
- }
- NPUTF8 *_NPN_UTF8FromIdentifier(NPIdentifier identifier)
- {
- PrivateIdentifier* privateIdentifier = reinterpret_cast<PrivateIdentifier*>(identifier);
- if (!privateIdentifier->isString || !privateIdentifier->value.string)
- return 0;
- return (NPUTF8*) strdup(privateIdentifier->value.string);
- }
- int32_t _NPN_IntFromIdentifier(NPIdentifier identifier)
- {
- PrivateIdentifier* privateIdentifier = reinterpret_cast<PrivateIdentifier*>(identifier);
- if (privateIdentifier->isString)
- return 0;
- return privateIdentifier->value.number;
- }
- void _NPN_ReleaseVariantValue(NPVariant* variant)
- {
- ASSERT(variant);
- if (variant->type == NPVariantType_Object) {
- _NPN_ReleaseObject(variant->value.objectValue);
- variant->value.objectValue = 0;
- } else if (variant->type == NPVariantType_String) {
- free((void*)variant->value.stringValue.UTF8Characters);
- variant->value.stringValue.UTF8Characters = 0;
- variant->value.stringValue.UTF8Length = 0;
- }
- variant->type = NPVariantType_Void;
- }
- NPObject *_NPN_CreateObject(NPP npp, NPClass* npClass)
- {
- ASSERT(npClass);
- if (npClass) {
- NPObject* npObject;
- if (npClass->allocate != 0)
- npObject = npClass->allocate(npp, npClass);
- else
- npObject = reinterpret_cast<NPObject*>(malloc(sizeof(NPObject)));
- npObject->_class = npClass;
- npObject->referenceCount = 1;
- return npObject;
- }
- return 0;
- }
- NPObject* _NPN_RetainObject(NPObject* npObject)
- {
- ASSERT(npObject);
- ASSERT(npObject->referenceCount > 0);
- if (npObject)
- npObject->referenceCount++;
- return npObject;
- }
- // _NPN_DeallocateObject actually deletes the object. Technically,
- // callers should use _NPN_ReleaseObject. Webkit exposes this function
- // to kill objects which plugins may not have properly released.
- void _NPN_DeallocateObject(NPObject* npObject)
- {
- ASSERT(npObject);
- ASSERT(npObject->referenceCount >= 0);
- if (npObject) {
- // NPObjects that remain in pure C++ may never have wrappers.
- // Hence, if it's not already alive, don't unregister it.
- // If it is alive, unregister it as the *last* thing we do
- // so that it can do as much cleanup as possible on its own.
- if (_NPN_IsAlive(npObject))
- _NPN_UnregisterObject(npObject);
- npObject->referenceCount = -1;
- if (npObject->_class->deallocate)
- npObject->_class->deallocate(npObject);
- else
- free(npObject);
- }
- }
- #if PLATFORM(ANDROID)
- // Android uses NPN_ReleaseObject (the 'public' version of _NPN_ReleaseObject)
- // in WebCoreFrameBridge.cpp. See http://trac.webkit.org/changeset/47021.
- // TODO: Upstream this to webkit.org.
- void NPN_ReleaseObject(NPObject *obj)
- {
- _NPN_ReleaseObject(obj);
- }
- #endif
- void _NPN_ReleaseObject(NPObject* npObject)
- {
- ASSERT(npObject);
- ASSERT(npObject->referenceCount >= 1);
- if (npObject && npObject->referenceCount >= 1) {
- if (!--npObject->referenceCount)
- _NPN_DeallocateObject(npObject);
- }
- }
- void _NPN_InitializeVariantWithStringCopy(NPVariant* variant, const NPString* value)
- {
- variant->type = NPVariantType_String;
- variant->value.stringValue.UTF8Length = value->UTF8Length;
- variant->value.stringValue.UTF8Characters = reinterpret_cast<NPUTF8*>(malloc(sizeof(NPUTF8) * value->UTF8Length));
- memcpy((void*)variant->value.stringValue.UTF8Characters, value->UTF8Characters, sizeof(NPUTF8) * value->UTF8Length);
- }
- // NPN_Registry
- //
- // The registry is designed for quick lookup of NPObjects.
- // JS needs to be able to quickly lookup a given NPObject to determine
- // if it is alive or not.
- // The browser needs to be able to quickly lookup all NPObjects which are
- // "owned" by an object.
- //
- // The liveObjectMap is a hash table of all live objects to their owner
- // objects. Presence in this table is used primarily to determine if
- // objects are live or not.
- //
- // The rootObjectMap is a hash table of root objects to a set of
- // objects that should be deactivated in sync with the root. A
- // root is defined as a top-level owner object. This is used on
- // Frame teardown to deactivate all objects associated
- // with a particular plugin.
- typedef WTF::HashSet<NPObject*> NPObjectSet;
- typedef WTF::HashMap<NPObject*, NPObject*> NPObjectMap;
- typedef WTF::HashMap<NPObject*, NPObjectSet*> NPRootObjectMap;
- // A map of live NPObjects with pointers to their Roots.
- NPObjectMap liveObjectMap;
- // A map of the root objects and the list of NPObjects
- // associated with that object.
- NPRootObjectMap rootObjectMap;
- void _NPN_RegisterObject(NPObject* npObject, NPObject* owner)
- {
- ASSERT(npObject);
- // Check if already registered.
- if (liveObjectMap.find(npObject) != liveObjectMap.end())
- return;
- if (!owner) {
- // Registering a new owner object.
- ASSERT(rootObjectMap.find(npObject) == rootObjectMap.end());
- rootObjectMap.set(npObject, new NPObjectSet());
- } else {
- // Always associate this object with it's top-most parent.
- // Since we always flatten, we only have to look up one level.
- NPObjectMap::iterator ownerEntry = liveObjectMap.find(owner);
- NPObject* parent = 0;
- if (liveObjectMap.end() != ownerEntry)
- parent = ownerEntry->second;
- if (parent)
- owner = parent;
- ASSERT(rootObjectMap.find(npObject) == rootObjectMap.end());
- if (rootObjectMap.find(owner) != rootObjectMap.end())
- rootObjectMap.get(owner)->add(npObject);
- }
- ASSERT(liveObjectMap.find(npObject) == liveObjectMap.end());
- liveObjectMap.set(npObject, owner);
- }
- void _NPN_UnregisterObject(NPObject* npObject)
- {
- ASSERT(npObject);
- ASSERT(liveObjectMap.find(npObject) != liveObjectMap.end());
- NPObject* owner = 0;
- if (liveObjectMap.find(npObject) != liveObjectMap.end())
- owner = liveObjectMap.find(npObject)->second;
- if (!owner) {
- // Unregistering a owner object; also unregister it's descendants.
- ASSERT(rootObjectMap.find(npObject) != rootObjectMap.end());
- NPObjectSet* set = rootObjectMap.get(npObject);
- while (set->size() > 0) {
- #ifndef NDEBUG
- int size = set->size();
- #endif
- NPObject* sub_object = *(set->begin());
- // The sub-object should not be a owner!
- ASSERT(rootObjectMap.find(sub_object) == rootObjectMap.end());
- // First, unregister the object.
- set->remove(sub_object);
- liveObjectMap.remove(sub_object);
- // Remove the JS references to the object.
- forgetV8ObjectForNPObject(sub_object);
- ASSERT(set->size() < size);
- }
- delete set;
- rootObjectMap.remove(npObject);
- } else {
- NPRootObjectMap::iterator ownerEntry = rootObjectMap.find(owner);
- if (ownerEntry != rootObjectMap.end()) {
- NPObjectSet* list = ownerEntry->second;
- ASSERT(list->find(npObject) != list->end());
- list->remove(npObject);
- }
- }
- liveObjectMap.remove(npObject);
- forgetV8ObjectForNPObject(npObject);
- }
- bool _NPN_IsAlive(NPObject* npObject)
- {
- return liveObjectMap.find(npObject) != liveObjectMap.end();
- }
- } // extern "C"