Changeset 76611 in webkit for trunk/Source/JavaScriptCore/parser/JSParser.cpp

Timestamp:

Jan 25, 2011, 10:44:11 AM (14 years ago)

Author:

Antti Koivisto

Message:

REGRESSION: Leak in JSParser::Scope::copyCapturedVariablesToVector()
​https://bugs.webkit.org/show_bug.cgi?id=53061

Reviewed by Oliver Hunt.

Cache did not know about the subclass so failed to fully delete the items.
Got rid of the subclass and moved the classes to separate files.

• CMakeLists.txt:
• GNUmakefile.am:
• JavaScriptCore.exp:
• JavaScriptCore.gypi:
• JavaScriptCore.pro:
• JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
• JavaScriptCore.xcodeproj/project.pbxproj:
• parser/JSParser.cpp:

(JSC::JSParser::Scope::saveFunctionInfo):
(JSC::JSParser::Scope::restoreFunctionInfo):
(JSC::JSParser::findCachedFunctionInfo):
(JSC::JSParser::parseFunctionInfo):

• parser/SourceProvider.h:
• parser/SourceProviderCache.cpp: Added.

(JSC::SourceProviderCache::~SourceProviderCache):
(JSC::SourceProviderCache::byteSize):

• parser/SourceProviderCache.h: Added.

(JSC::SourceProviderCache::SourceProviderCache):
(JSC::SourceProviderCache::add):
(JSC::SourceProviderCache::get):

• parser/SourceProviderCacheItem.h: Added.

(JSC::SourceProviderCacheItem::SourceProviderCacheItem):
(JSC::SourceProviderCacheItem::approximateByteSize):
(JSC::SourceProviderCacheItem::closeBraceToken):

File:

• trunk/Source/JavaScriptCore/parser/JSParser.cpp (modified) (7 diffs)

trunk/Source/JavaScriptCore/parser/JSParser.cpp

@@ -35 +35 @@
 #include "ASTBuilder.h"
 #include "SourceProvider.h"
+#include "SourceProviderCacheItem.h"
 #include <wtf/HashFunctions.h>
 #include <wtf/WTFThreadData.h>
@@ -97 +98 @@
     };
     
-    struct CachedFunctionInfo : public SourceProviderCache::Item {
-        CachedFunctionInfo(int closeBraceLine, int closeBracePos)
-            : closeBraceLine(closeBraceLine) 
-            , closeBracePos(closeBracePos)
-        {
-        }
-        unsigned approximateByteSize() const
-        {
-            // The identifiers are uniqued strings so most likely there are few names that actually use any additional memory.
-            static const unsigned assummedAverageIdentifierSize = sizeof(RefPtr<StringImpl>) + 2;
-            unsigned size = sizeof(*this);
-            size += usedVariables.size() * assummedAverageIdentifierSize;
-            size += writtenVariables.size() * assummedAverageIdentifierSize;
-            return size;
-        }
-        JSToken closeBraceToken() const 
-        {
-            JSToken token;
-            token.m_type = CLOSEBRACE;
-            token.m_data.intValue = closeBracePos;
-            token.m_info.startOffset = closeBracePos;
-            token.m_info.endOffset = closeBracePos + 1;
-            token.m_info.line = closeBraceLine; 
-            return token;
-        }
-
-        int closeBraceLine;
-        int closeBracePos;
-        bool usesEval;
-        Vector<RefPtr<StringImpl> > usedVariables;
-        Vector<RefPtr<StringImpl> > writtenVariables;
-    };
-
     void next(Lexer::LexType lexType = Lexer::IdentifyReservedWords)
     {
@@ -464 +432 @@
         }
 
-        void saveFunctionInfo(CachedFunctionInfo* info)
+        void saveFunctionInfo(SourceProviderCacheItem* info)
         {
             ASSERT(m_isFunction);
@@ -472 +440 @@
         }
 
-        void restoreFunctionInfo(const CachedFunctionInfo* info)
+        void restoreFunctionInfo(const SourceProviderCacheItem* info)
         {
             ASSERT(m_isFunction);
@@ -610 +578 @@
     ScopeStack m_scopeStack;
 
-    const CachedFunctionInfo* findCachedFunctionInfo(int openBracePos) 
+    const SourceProviderCacheItem* findCachedFunctionInfo(int openBracePos) 
     {
-        return m_functionCache ? static_cast<const CachedFunctionInfo*>(m_functionCache->get(openBracePos)) : 0;
+        return m_functionCache ? m_functionCache->get(openBracePos) : 0;
     }
 
@@ -1319 +1287 @@
     bodyStartLine = tokenLine();
 
-    if (const CachedFunctionInfo* cachedInfo = TreeBuilder::CanUseFunctionCache ? findCachedFunctionInfo(openBracePos) : 0) {
+    if (const SourceProviderCacheItem* cachedInfo = TreeBuilder::CanUseFunctionCache ? findCachedFunctionInfo(openBracePos) : 0) {
         // If we know about this function already, we can use the cached info and skip the parser to the end of the function.
         body = context.createFunctionBody(strictMode());
@@ -1348 +1316 @@
     // Any future reparsing can then skip the function.
     static const int minimumFunctionLengthToCache = 64;
-    OwnPtr<CachedFunctionInfo> newInfo;
+    OwnPtr<SourceProviderCacheItem> newInfo;
     int functionLength = closeBracePos - openBracePos;
     if (TreeBuilder::CanUseFunctionCache && m_functionCache && functionLength > minimumFunctionLengthToCache) {
-        newInfo = adoptPtr(new CachedFunctionInfo(m_token.m_info.line, closeBracePos));
+        newInfo = adoptPtr(new SourceProviderCacheItem(m_token.m_info.line, closeBracePos));
         functionScope->saveFunctionInfo(newInfo.get());
     }