Changeset 102065 in webkit for trunk/Source/JavaScriptCore/API

Timestamp:

Dec 5, 2011, 4:17:34 PM (14 years ago)

Author:

Darin Adler

Message:

Convert JSClassRef to use HashMap<OwnPtr>
​https://bugs.webkit.org/show_bug.cgi?id=73780

Reviewed by Andreas Kling.

• API/JSCallbackObjectFunctions.h:

(JSC::JSCallbackObject::getOwnPropertyNames): Use get() on the hash map
entries because the hash map now has an OwnPtr instead of a raw pointer.

• API/JSClassRef.cpp:

(OpaqueJSClass::OpaqueJSClass): No need to initialize m_staticValues and
m_staticFunctions since they are now OwnPtr. Use adoptPtr when allocating.
Removed the code that gets and deletes existing entries, and just use set,
which now handles deletion automatically due to it being OwnPtr.
(OpaqueJSClass::~OpaqueJSClass): Replaced code to do all the deletion
with assertion-only NDEBUG-only code.
(OpaqueJSClassContextData::OpaqueJSClassContextData): Use adoptPtr when
allocating. Use OwnPtr when adding. Removed unneeded code to set
staticValues and staticFunctions to 0. Removed unneeded destructor.
(OpaqueJSClass::staticValues): Added get call. Also removed unneeded local.
(OpaqueJSClass::staticFunctions): Ditto.
(OpaqueJSClass::prototype): Added use of adoptPtr.

• API/JSClassRef.h: Made the static values and static functions tables

use OwnPtr for the entries. Also used OwnPtr for the pointers to the
tables themselves. Also removed ~OpaqueJSClassContextData(), letting
the compiler generate it.

Location:

trunk/Source/JavaScriptCore/API

Files:

• JSCallbackObjectFunctions.h (modified) (2 diffs)
• JSClassRef.cpp (modified) (6 diffs)
• JSClassRef.h (modified) (4 diffs)

trunk/Source/JavaScriptCore/API/JSCallbackObjectFunctions.h

@@ -440 +440 @@
             for (iterator it = staticValues->begin(); it != end; ++it) {
                 StringImpl* name = it->first.get();
-                StaticValueEntry* entry = it->second;
+                StaticValueEntry* entry = it->second.get();
                 if (entry->getProperty && (!(entry->attributes & kJSPropertyAttributeDontEnum) || (mode == IncludeDontEnumProperties)))
                     propertyNames.add(Identifier(exec, name));
@@ -451 +451 @@
             for (iterator it = staticFunctions->begin(); it != end; ++it) {
                 StringImpl* name = it->first.get();
-                StaticFunctionEntry* entry = it->second;
+                StaticFunctionEntry* entry = it->second.get();
                 if (!(entry->attributes & kJSPropertyAttributeDontEnum) || (mode == IncludeDontEnumProperties))
                     propertyNames.add(Identifier(exec, name));

trunk/Source/JavaScriptCore/API/JSClassRef.cpp

@@ -72 +72 @@
     , convertToType(definition->convertToType)
     , m_className(tryCreateStringFromUTF8(definition->className))
-    , m_staticValues(0)
-    , m_staticFunctions(0)
 {
     initializeThreading();
 
     if (const JSStaticValue* staticValue = definition->staticValues) {
-        m_staticValues = new OpaqueJSClassStaticValuesTable();
+        m_staticValues = adoptPtr(new OpaqueJSClassStaticValuesTable);
         while (staticValue->name) {
             UString valueName = tryCreateStringFromUTF8(staticValue->name);
             if (!valueName.isNull()) {
                 // Use a local variable here to sidestep an RVCT compiler bug.
-                StaticValueEntry* entry = new StaticValueEntry(staticValue->getProperty, staticValue->setProperty, staticValue->attributes);
-                StringImpl* impl = valueName.impl();
-                StaticValueEntry* existingEntry = m_staticValues->get(impl);
-                m_staticValues->set(impl, entry);
-                delete existingEntry;
+                OwnPtr<StaticValueEntry> entry = adoptPtr(new StaticValueEntry(staticValue->getProperty, staticValue->setProperty, staticValue->attributes));
+                m_staticValues->set(valueName.impl(), entry.release());
             }
             ++staticValue;
@@ -94 +89 @@
 
     if (const JSStaticFunction* staticFunction = definition->staticFunctions) {
-        m_staticFunctions = new OpaqueJSClassStaticFunctionsTable();
+        m_staticFunctions = adoptPtr(new OpaqueJSClassStaticFunctionsTable);
         while (staticFunction->name) {
             UString functionName = tryCreateStringFromUTF8(staticFunction->name);
             if (!functionName.isNull()) {
                 // Use a local variable here to sidestep an RVCT compiler bug.
-                StaticFunctionEntry* entry = new StaticFunctionEntry(staticFunction->callAsFunction, staticFunction->attributes);
-                StringImpl* impl = functionName.impl();
-                StaticFunctionEntry* existingEntry = m_staticFunctions->get(impl);
-                m_staticFunctions->set(impl, entry);
-                delete existingEntry;
+                OwnPtr<StaticFunctionEntry> entry = adoptPtr(new StaticFunctionEntry(staticFunction->callAsFunction, staticFunction->attributes));
+                m_staticFunctions->set(functionName.impl(), entry.release());
             }
             ++staticFunction;
@@ -118 +110 @@
     ASSERT(!m_className.length() || !m_className.impl()->isIdentifier());
 
+#ifndef NDEBUG
     if (m_staticValues) {
         OpaqueJSClassStaticValuesTable::const_iterator end = m_staticValues->end();
-        for (OpaqueJSClassStaticValuesTable::const_iterator it = m_staticValues->begin(); it != end; ++it) {
-            ASSERT(!it->first->isIdentifier());
-            delete it->second;
-        }
-        delete m_staticValues;
+        for (OpaqueJSClassStaticValuesTable::const_iterator it = m_staticValues->begin(); it != end; ++it)
+            ASSERT(!it->first->isIdentifier());
     }
 
     if (m_staticFunctions) {
         OpaqueJSClassStaticFunctionsTable::const_iterator end = m_staticFunctions->end();
-        for (OpaqueJSClassStaticFunctionsTable::const_iterator it = m_staticFunctions->begin(); it != end; ++it) {
-            ASSERT(!it->first->isIdentifier());
-            delete it->second;
-        }
-        delete m_staticFunctions;
-    }
+        for (OpaqueJSClassStaticFunctionsTable::const_iterator it = m_staticFunctions->begin(); it != end; ++it)
+            ASSERT(!it->first->isIdentifier());
+    }
+#endif
     
     if (prototypeClass)
@@ -163 +151 @@
 {
     if (jsClass->m_staticValues) {
-        staticValues = new OpaqueJSClassStaticValuesTable;
+        staticValues = adoptPtr(new OpaqueJSClassStaticValuesTable);
         OpaqueJSClassStaticValuesTable::const_iterator end = jsClass->m_staticValues->end();
         for (OpaqueJSClassStaticValuesTable::const_iterator it = jsClass->m_staticValues->begin(); it != end; ++it) {
             ASSERT(!it->first->isIdentifier());
             // Use a local variable here to sidestep an RVCT compiler bug.
-            StaticValueEntry* entry = new StaticValueEntry(it->second->getProperty, it->second->setProperty, it->second->attributes);
-            staticValues->add(StringImpl::create(it->first->characters(), it->first->length()), entry);
-        }
-    } else
-        staticValues = 0;
+            OwnPtr<StaticValueEntry> entry = adoptPtr(new StaticValueEntry(it->second->getProperty, it->second->setProperty, it->second->attributes));
+            staticValues->add(StringImpl::create(it->first->characters(), it->first->length()), entry.release());
+        }
+    }
 
     if (jsClass->m_staticFunctions) {
-        staticFunctions = new OpaqueJSClassStaticFunctionsTable;
+        staticFunctions = adoptPtr(new OpaqueJSClassStaticFunctionsTable);
         OpaqueJSClassStaticFunctionsTable::const_iterator end = jsClass->m_staticFunctions->end();
         for (OpaqueJSClassStaticFunctionsTable::const_iterator it = jsClass->m_staticFunctions->begin(); it != end; ++it) {
             ASSERT(!it->first->isIdentifier());
             // Use a local variable here to sidestep an RVCT compiler bug.
-            StaticFunctionEntry* entry = new StaticFunctionEntry(it->second->callAsFunction, it->second->attributes);
-            staticFunctions->add(StringImpl::create(it->first->characters(), it->first->length()), entry);
-        }
-            
-    } else
-        staticFunctions = 0;
-}
-
-OpaqueJSClassContextData::~OpaqueJSClassContextData()
-{
-    if (staticValues) {
-        deleteAllValues(*staticValues);
-        delete staticValues;
-    }
-
-    if (staticFunctions) {
-        deleteAllValues(*staticFunctions);
-        delete staticFunctions;
+            OwnPtr<StaticFunctionEntry> entry = adoptPtr(new StaticFunctionEntry(it->second->callAsFunction, it->second->attributes));
+            staticFunctions->add(StringImpl::create(it->first->characters(), it->first->length()), entry.release());
+        }
     }
 }
@@ -217 +189 @@
 OpaqueJSClassStaticValuesTable* OpaqueJSClass::staticValues(JSC::ExecState* exec)
 {
-    OpaqueJSClassContextData& jsClassData = contextData(exec);
-    return jsClassData.staticValues;
+    return contextData(exec).staticValues.get();
 }
 
 OpaqueJSClassStaticFunctionsTable* OpaqueJSClass::staticFunctions(JSC::ExecState* exec)
 {
-    OpaqueJSClassContextData& jsClassData = contextData(exec);
-    return jsClassData.staticFunctions;
+    return contextData(exec).staticFunctions.get();
 }
 
@@ -249 +219 @@
             prototypeClass = OpaqueJSClass::create(&kJSClassDefinitionEmpty).leakRef();
         if (!prototypeClass->m_staticFunctions)
-            prototypeClass->m_staticFunctions = new OpaqueJSClassStaticFunctionsTable;
+            prototypeClass->m_staticFunctions = adoptPtr(new OpaqueJSClassStaticFunctionsTable);
         const Identifier& toString = exec->propertyNames().toString;
         const Identifier& valueOf = exec->propertyNames().valueOf;
-        prototypeClass->m_staticFunctions->add(StringImpl::create(toString.characters(), toString.length()), new StaticFunctionEntry(&JSCallbackFunction::toStringCallback, 0));
-        prototypeClass->m_staticFunctions->add(StringImpl::create(valueOf.characters(), valueOf.length()), new StaticFunctionEntry(&JSCallbackFunction::valueOfCallback, 0));
+        prototypeClass->m_staticFunctions->add(StringImpl::create(toString.characters(), toString.length()), adoptPtr(new StaticFunctionEntry(&JSCallbackFunction::toStringCallback, 0)));
+        prototypeClass->m_staticFunctions->add(StringImpl::create(valueOf.characters(), valueOf.length()), adoptPtr(new StaticFunctionEntry(&JSCallbackFunction::valueOfCallback, 0)));
     }
 

trunk/Source/JavaScriptCore/API/JSClassRef.h

@@ -60 +60 @@
 };
 
-typedef HashMap<RefPtr<StringImpl>, StaticValueEntry*> OpaqueJSClassStaticValuesTable;
-typedef HashMap<RefPtr<StringImpl>, StaticFunctionEntry*> OpaqueJSClassStaticFunctionsTable;
+typedef HashMap<RefPtr<StringImpl>, OwnPtr<StaticValueEntry> > OpaqueJSClassStaticValuesTable;
+typedef HashMap<RefPtr<StringImpl>, OwnPtr<StaticFunctionEntry> > OpaqueJSClassStaticFunctionsTable;
 
 struct OpaqueJSClass;
@@ -71 +71 @@
 public:
     OpaqueJSClassContextData(JSC::JSGlobalData&, OpaqueJSClass*);
-    ~OpaqueJSClassContextData();
 
     // It is necessary to keep OpaqueJSClass alive because of the following rare scenario:
@@ -81 +80 @@
     RefPtr<OpaqueJSClass> m_class;
 
-    OpaqueJSClassStaticValuesTable* staticValues;
-    OpaqueJSClassStaticFunctionsTable* staticFunctions;
+    OwnPtr<OpaqueJSClassStaticValuesTable> staticValues;
+    OwnPtr<OpaqueJSClassStaticFunctionsTable> staticFunctions;
     JSC::Weak<JSC::JSObject> cachedPrototype;
 };
@@ -122 +121 @@
     // UStrings in these data members should not be put into any IdentifierTable.
     JSC::UString m_className;
-    OpaqueJSClassStaticValuesTable* m_staticValues;
-    OpaqueJSClassStaticFunctionsTable* m_staticFunctions;
+    OwnPtr<OpaqueJSClassStaticValuesTable> m_staticValues;
+    OwnPtr<OpaqueJSClassStaticFunctionsTable> m_staticFunctions;
 };