Fix issue 11264...

webkit/port/bindings/v8/npruntime.cpp

 /*
  * 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
@@ skipping 30 matching lines @@
 // Commenting out the locks to avoid dependencies on chrome for now.
 // Need a platform abstraction which we can use.
 // static Lock StringIdentifierMapLock;
 
 namespace {
 
 // 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) : _string(str), _length(strlen(str)) {}
-    StringKey() : _string(0), _length(0) {}
+    explicit StringKey(const char* str)
+        : m_string(str), m_length(strlen(str)) {}
+    StringKey() : m_string(0), m_length(0) {}
     explicit StringKey(WTF::HashTableDeletedValueType)
-        : _string(hashTableDeletedValue()), _length(0) { }
+        : m_string(hashTableDeletedValue()), m_length(0) { }
 
     StringKey& operator=(const StringKey& other) {
-        this->_string = other._string;
-        this->_length = other._length;
+        this->m_string = other.m_string;
+        this->m_length = other.m_length;
         return *this;
     }
 
     bool isHashTableDeletedValue() const {
-        return _string == hashTableDeletedValue();
+        return m_string == hashTableDeletedValue();
     }
 
-    const char* _string;
-    size_t _length;
+    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._length != y._length) {
+    if (x.m_length != y.m_length) {
         return false;
-    } else if (x._string == y._string) {
+    } else if (x.m_string == y.m_string) {
         return true;
     } else {
         ASSERT(!x.isHashTableDeletedValue() && !y.isHashTableDeletedValue());
-        return memcmp(x._string, y._string, y._length) == 0;
+        return memcmp(x.m_string, y.m_string, y.m_length) == 0;
     }
 }
 
 // Implement WTF::DefaultHash<StringKey>::Hash interface.
 struct StringKeyHash {
     static unsigned hash(const StringKey& key) {
-        // Use the same string hash function as in V8.
+        // Compute string hash.
         unsigned hash = 0;
-        size_t len = key._length;
-        const char* str = key._string;
+        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) {
@@ skipping 50 matching lines @@
 
     if (name) {
         // AutoLock safeLock(StringIdentifierMapLock);
 
         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._length;
+        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._string = 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) {
     // AutoLock safeLock(IntIdentifierMapLock);
+    // Special case for -1 and 0, both cannot be used as key in HashMap.
+    if (intid == 0 || 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;
@@ skipping 213 matching lines @@
     ForgetV8ObjectForNPObject(obj);
 
     g_live_objects.remove(obj);
 }
 
 bool _NPN_IsAlive(NPObject* obj) {
     return g_live_objects.find(obj) != g_live_objects.end();
 }
 
 }  // extern "C"