Changeset 87346 in webkit


Ignore:
Timestamp:
May 25, 2011 6:12:46 PM (13 years ago)
Author:
oliver@apple.com
Message:

2011-05-25 Oliver Hunt <​oliver@apple.com>

Reviewed by Geoffrey Garen.

Make RegExp GC allocated
​https://bugs.webkit.org/show_bug.cgi?id=61490

Make RegExp GC allocated. Basically mechanical change to replace
most use of [Pass]RefPtr<RegExp> with RegExp* or WriteBarrier<RegExp>
where actual ownership happens.

Made the RegExpCache use Strong<> references currently to avoid any
changes in behaviour.

  • JavaScriptCore.exp:
  • bytecode/CodeBlock.cpp: (JSC::CodeBlock::visitAggregate):
  • bytecode/CodeBlock.h: (JSC::CodeBlock::addRegExp):
  • bytecompiler/BytecodeGenerator.cpp: (JSC::BytecodeGenerator::addRegExp): (JSC::BytecodeGenerator::emitNewRegExp):
  • bytecompiler/BytecodeGenerator.h:
  • runtime/JSCell.h:
  • runtime/JSGlobalData.cpp: (JSC::JSGlobalData::JSGlobalData): (JSC::JSGlobalData::clearBuiltinStructures): (JSC::JSGlobalData::addRegExpToTrace):
  • runtime/JSGlobalData.h:
  • runtime/JSGlobalObject.cpp: (JSC::JSGlobalObject::reset):
  • runtime/RegExp.cpp: (JSC::RegExp::RegExp): (JSC::RegExp::create): (JSC::RegExp::invalidateCode):
  • runtime/RegExp.h: (JSC::RegExp::createStructure):
  • runtime/RegExpCache.cpp: (JSC::RegExpCache::lookupOrCreate): (JSC::RegExpCache::create):
  • runtime/RegExpCache.h:
  • runtime/RegExpConstructor.cpp: (JSC::constructRegExp):
  • runtime/RegExpObject.cpp: (JSC::RegExpObject::RegExpObject): (JSC::RegExpObject::visitChildren):
  • runtime/RegExpObject.h: (JSC::RegExpObject::setRegExp): (JSC::RegExpObject::RegExpObjectData::RegExpObjectData):
  • runtime/RegExpPrototype.cpp: (JSC::RegExpPrototype::RegExpPrototype): (JSC::regExpProtoFuncCompile):
  • runtime/RegExpPrototype.h:
  • runtime/StringPrototype.cpp: (JSC::stringProtoFuncMatch): (JSC::stringProtoFuncSearch):

2011-05-25 James Robinson <​jamesr@chromium.org>

Reviewed by Geoffrey Garen

CachedResource overhead size calculation ignores the actual size of the URL
​https://bugs.webkit.org/show_bug.cgi?id=61481

CachedResource::overheadSize is used to determine the size of an entry in the memory cache to know when to evict
it. When the resource is a large data: URL, for example representing image or audio data, the URL size itself
can be significant.

This patch uses an estimate of actual number of bytes used by the URL that is valid for ASCII urls and close for
other types of strings instead of a fixed number.

  • loader/cache/CachedResource.cpp: (WebCore::CachedResource::overheadSize):
Location:
trunk/Source
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r87345 r87346  
    1 2011-05-25  Oliver Hunt  <oliver@apple.com>
    2 
    3         Revert last change, something weird happened when I went to land.
    4 
    512011-05-25  Oliver Hunt  <oliver@apple.com>
    62

  • trunk/Source/JavaScriptCore/JavaScriptCore.exp

    r87345 r87346  
    138138__ZN3JSC12JSGlobalDataD1Ev
    139139__ZN3JSC12RegExpObject6s_infoE
    140 __ZN3JSC12RegExpObjectC1EPNS_14JSGlobalObjectEPNS_9StructureEN3WTF17NonNullPassRefPtrINS_6RegExpEEE
     140__ZN3JSC12RegExpObjectC1EPNS_14JSGlobalObjectEPNS_9StructureEPNS_6RegExpE
    141141__ZN3JSC12SamplingTool5setupEv
    142142__ZN3JSC12SmallStrings17createEmptyStringEPNS_12JSGlobalDataE

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def

    r87345 r87346  
    1919    ??0Mutex@WTF@@QAE@XZ
    2020    ??0RefCountedLeakCounter@WTF@@QAE@PBD@Z
    21     ??0RegExpObject@JSC@@QAE@PAVJSGlobalObject@1@PAVStructure@1@V?$NonNullPassRefPtr@VRegExp@JSC@@@WTF@@@Z
     21    ??0RegExpObject@JSC@@QAE@PAVJSGlobalObject@1@PAVStructure@1@PAVRegExp@1@JSC@@@WTF@@@Z
    2222    ??0SHA1@WTF@@QAE@XZ
    2323    ??0StringObject@JSC@@QAE@PAVExecState@1@PAVStructure@1@ABVUString@1@@Z

  • trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

    r87345 r87346  
    14711471    visitor.append(&m_globalObject);
    14721472    visitor.append(&m_ownerExecutable);
    1473     if (m_rareData)
     1473    if (m_rareData) {
    14741474        m_rareData->m_evalCodeCache.visitAggregate(visitor);
     1475        size_t regExpCount = m_rareData->m_regexps.size();
     1476        WriteBarrier<RegExp>* regexps = m_rareData->m_regexps.data();
     1477        for (size_t i = 0; i < regExpCount; i++)
     1478            visitor.append(regexps + i);
     1479    }
    14751480    visitor.appendValues(m_constantRegisters.data(), m_constantRegisters.size());
    14761481    for (size_t i = 0; i < m_functionExprs.size(); ++i)

  • trunk/Source/JavaScriptCore/bytecode/CodeBlock.h

    r87345 r87346  
    3737#include "JumpTable.h"
    3838#include "Nodes.h"
    39 #include "RegExp.h"
     39#include "RegExpObject.h"
    4040#include "UString.h"
    4141#include <wtf/FastAllocBase.h>
    … …  
    452452        FunctionExecutable* functionExpr(int index) { return m_functionExprs[index].get(); }
    453453
    454         unsigned addRegExp(PassRefPtr<RegExp> r) { createRareDataIfNecessary(); unsigned size = m_rareData->m_regexps.size(); m_rareData->m_regexps.append(r); return size; }
     454        unsigned addRegExp(RegExp* r)
     455        {
     456            createRareDataIfNecessary();
     457            unsigned size = m_rareData->m_regexps.size();
     458            m_rareData->m_regexps.append(WriteBarrier<RegExp>(*m_globalData, ownerExecutable(), r));
     459            return size;
     460        }
    455461        RegExp* regexp(int index) const { ASSERT(m_rareData); return m_rareData->m_regexps[index].get(); }
    456462
    … …  
    556562
    557563            // Rare Constants
    558             Vector<RefPtr<RegExp> > m_regexps;
     564            Vector<WriteBarrier<RegExp> > m_regexps;
    559565
    560566            // Jump Tables

  • trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp

    r87345 r87346  
    967967}
    968968
    969 unsigned BytecodeGenerator::addRegExp(PassRefPtr<RegExp> r)
     969unsigned BytecodeGenerator::addRegExp(RegExp* r)
    970970{
    971971    return m_codeBlock->addRegExp(r);
    … …  
    15931593}
    15941594
    1595 RegisterID* BytecodeGenerator::emitNewRegExp(RegisterID* dst, PassRefPtr<RegExp> regExp)
     1595RegisterID* BytecodeGenerator::emitNewRegExp(RegisterID* dst, RegExp* regExp)
    15961596{
    15971597    emitOpcode(op_new_regexp);

  • trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h

    r87345 r87346  
    292292        RegisterID* emitNewFunctionInternal(RegisterID* dst, unsigned index, bool shouldNullCheck);
    293293        RegisterID* emitNewFunctionExpression(RegisterID* dst, FuncExprNode* func);
    294         RegisterID* emitNewRegExp(RegisterID* dst, PassRefPtr<RegExp> regExp);
     294        RegisterID* emitNewRegExp(RegisterID* dst, RegExp*);
    295295
    296296        RegisterID* emitMove(RegisterID* dst, RegisterID* src);
    … …  
    476476        unsigned addConstant(const Identifier&);
    477477        RegisterID* addConstantValue(JSValue);
    478         unsigned addRegExp(PassRefPtr<RegExp>);
     478        unsigned addRegExp(RegExp*);
    479479
    480480        FunctionExecutable* makeFunction(ExecState* exec, FunctionBodyNode* body)

  • trunk/Source/JavaScriptCore/runtime/JSCell.h

    r87345 r87346  
    7272        friend class Structure;
    7373        friend class StructureChain;
     74        friend class RegExp;
    7475        enum CreatingEarlyCellTag { CreatingEarlyCell };
    7576

  • trunk/Source/JavaScriptCore/runtime/JSGlobalData.cpp

    r87345 r87346  
    5353#include "Parser.h"
    5454#include "RegExpCache.h"
     55#include "RegExpObject.h"
    5556#include "StrictEvalActivation.h"
    5657#include <wtf/WTFThreadData.h>
    … …  
    220221    functionExecutableStructure.set(*this, FunctionExecutable::createStructure(*this, jsNull()));
    221222    dummyMarkableCellStructure.set(*this, JSCell::createDummyStructure(*this));
     223    regExpStructure.set(*this, RegExp::createStructure(*this, jsNull()));
    222224    structureChainStructure.set(*this, StructureChain::createStructure(*this, jsNull()));
    223225
    … …  
    280282    functionExecutableStructure.clear();
    281283    dummyMarkableCellStructure.clear();
     284    regExpStructure.clear();
    282285    structureChainStructure.clear();
    283    
     286
    284287#if ENABLE(JSC_ZOMBIES)
    285288    zombieStructure.clear();
    … …  
    447450
    448451#if ENABLE(REGEXP_TRACING)
    449 void JSGlobalData::addRegExpToTrace(PassRefPtr<RegExp> regExp)
     452void JSGlobalData::addRegExpToTrace(RegExp* regExp)
    450453{
    451454    m_rtTraceList->add(regExp);

  • trunk/Source/JavaScriptCore/runtime/JSGlobalData.h

    r87345 r87346  
    175175        Strong<Structure> functionExecutableStructure;
    176176        Strong<Structure> dummyMarkableCellStructure;
     177        Strong<Structure> regExpStructure;
    177178        Strong<Structure> structureChainStructure;
    178179

  • trunk/Source/JavaScriptCore/runtime/JSGlobalObject.cpp

    r87345 r87346  
    223223    m_dateStructure.set(exec->globalData(), this, DateInstance::createStructure(exec->globalData(), m_datePrototype.get()));
    224224
    225     m_regExpPrototype.set(exec->globalData(), this, new (exec) RegExpPrototype(exec, this, RegExpPrototype::createStructure(exec->globalData(), m_objectPrototype.get())));
     225    RegExp* emptyRegex = RegExp::create(&exec->globalData(), "", NoFlags);
     226   
     227    m_regExpPrototype.set(exec->globalData(), this, new (exec) RegExpPrototype(exec, this, RegExpPrototype::createStructure(exec->globalData(), m_objectPrototype.get()), emptyRegex));
    226228    m_regExpStructure.set(exec->globalData(), this, RegExpObject::createStructure(exec->globalData(), m_regExpPrototype.get()));
    227229

  • trunk/Source/JavaScriptCore/runtime/RegExp.cpp

    r87345 r87346  
    3535namespace JSC {
    3636
     37const ClassInfo RegExp::s_info = { "RegExp", 0, 0, 0 };
     38
    3739RegExpFlags regExpFlags(const UString& string)
    3840{
    … …  
    7476};
    7577
    76 inline RegExp::RegExp(JSGlobalData*, const UString& patternString, RegExpFlags flags)
    77     : m_state(NotCompiled)
     78inline RegExp::RegExp(JSGlobalData* globalData, const UString& patternString, RegExpFlags flags)
     79    : JSCell(*globalData, globalData->regExpStructure.get())
     80    , m_state(NotCompiled)
    7881    , m_patternString(patternString)
    7982    , m_flags(flags)
    … …  
    9699}
    97100
    98 PassRefPtr<RegExp> RegExp::create(JSGlobalData* globalData, const UString& patternString, RegExpFlags flags)
    99 {
    100     RefPtr<RegExp> res = adoptRef(new RegExp(globalData, patternString, flags));
     101RegExp* RegExp::create(JSGlobalData* globalData, const UString& patternString, RegExpFlags flags)
     102{
     103    RegExp* res = new (globalData) RegExp(globalData, patternString, flags);
    101104#if ENABLE(REGEXP_TRACING)
    102105    globalData->addRegExpToTrace(res);
    103106#endif
    104     return res.release();
     107    return res;
    105108}
    106109
    … …  
    195198}
    196199
     200void RegExp::invalidateCode()
     201{
     202    m_representation.clear();
     203}
    197204
    198205#if ENABLE(YARR_JIT_DEBUG)

  • trunk/Source/JavaScriptCore/runtime/RegExp.h

    r87345 r87346  
    2525#include "UString.h"
    2626#include "ExecutableAllocator.h"
     27#include "Structure.h"
    2728#include "RegExpKey.h"
    2829#include <wtf/Forward.h>
    … …  
    3637    RegExpFlags regExpFlags(const UString&);
    3738
    38     class RegExp : public RefCounted<RegExp> {
     39    class RegExp : public JSCell {
    3940    public:
    40         static PassRefPtr<RegExp> create(JSGlobalData* globalData, const UString& pattern, RegExpFlags);
     41        static RegExp* create(JSGlobalData*, const UString& pattern, RegExpFlags);
    4142        ~RegExp();
    4243
    … …  
    5354        unsigned numSubpatterns() const { return m_numSubpatterns; }
    5455       
     56        void invalidateCode();
     57       
    5558#if ENABLE(REGEXP_TRACING)
    5659        void printTraceData();
    5760#endif
    5861
     62        static Structure* createStructure(JSGlobalData& globalData, JSValue prototype)
     63        {
     64            return Structure::create(globalData, prototype, TypeInfo(LeafType, 0), 0, &s_info);
     65        }
     66       
     67        static JS_EXPORTDATA const ClassInfo s_info;
     68       
    5969    private:
    6070        RegExp(JSGlobalData* globalData, const UString& pattern, RegExpFlags);

  • trunk/Source/JavaScriptCore/runtime/RegExpCache.cpp

    r87345 r87346  
    2929
    3030#include "RegExpCache.h"
     31#include "RegExpObject.h"
    3132
    3233namespace JSC {
    3334
    34 PassRefPtr<RegExp> RegExpCache::lookupOrCreate(const UString& patternString, RegExpFlags flags)
     35RegExp* RegExpCache::lookupOrCreate(const UString& patternString, RegExpFlags flags)
    3536{
    3637    if (patternString.length() < maxCacheablePatternLength) {
    37         pair<RegExpCacheMap::iterator, bool> result = m_cacheMap.add(RegExpKey(flags, patternString), 0);
     38        pair<RegExpCacheMap::iterator, bool> result = m_cacheMap.add(RegExpKey(flags, patternString), Strong<RegExp>());
    3839        if (!result.second)
    39             return result.first->second;
     40            return result.first->second.get();
    4041        else
    4142            return create(patternString, flags, result.first);
    … …  
    4445}
    4546
    46 PassRefPtr<RegExp> RegExpCache::create(const UString& patternString, RegExpFlags flags, RegExpCacheMap::iterator iterator)
     47RegExp* RegExpCache::create(const UString& patternString, RegExpFlags flags, RegExpCacheMap::iterator iterator)
    4748{
    48     RefPtr<RegExp> regExp = RegExp::create(m_globalData, patternString, flags);
    49 
     49    RegExp* regExp = RegExp::create(m_globalData, patternString, flags);
    5050    if (patternString.length() >= maxCacheablePatternLength)
    5151        return regExp;
    … …  
    5353    RegExpKey key = RegExpKey(flags, patternString);
    5454    iterator->first = key;
    55     iterator->second = regExp;
     55    iterator->second.set(*m_globalData, regExp);
    5656
    5757    ++m_nextKeyToEvict;

  • trunk/Source/JavaScriptCore/runtime/RegExpCache.h

    r87345 r87346  
    2828#include "RegExp.h"
    2929#include "RegExpKey.h"
     30#include "Strong.h"
    3031#include "UString.h"
    3132#include <wtf/FixedArray.h>
    … …  
    3940class RegExpCache {
    4041
    41 typedef HashMap<RegExpKey, RefPtr<RegExp> > RegExpCacheMap;
     42typedef HashMap<RegExpKey, Strong<RegExp> > RegExpCacheMap;
    4243
    4344public:
    44     PassRefPtr<RegExp> lookupOrCreate(const UString& patternString, RegExpFlags);
    45     PassRefPtr<RegExp> create(const UString& patternString, RegExpFlags, RegExpCacheMap::iterator);
     45    RegExp* lookupOrCreate(const UString& patternString, RegExpFlags);
     46    RegExp* create(const UString& patternString, RegExpFlags, RegExpCacheMap::iterator);
    4647    RegExpCache(JSGlobalData* globalData);
    4748

  • trunk/Source/JavaScriptCore/runtime/RegExpConstructor.cpp

    r87345 r87346  
    318318    }
    319319
    320     RefPtr<RegExp> regExp = exec->globalData().regExpCache()->lookupOrCreate(pattern, flags);
     320    RegExp* regExp = exec->globalData().regExpCache()->lookupOrCreate(pattern, flags);
    321321    if (!regExp->isValid())
    322322        return throwError(exec, createSyntaxError(exec, regExp->errorMessage()));
    323     return new (exec) RegExpObject(exec->lexicalGlobalObject(), globalObject->regExpStructure(), regExp.release());
     323    return new (exec) RegExpObject(exec->lexicalGlobalObject(), globalObject->regExpStructure(), regExp);
    324324}
    325325

  • trunk/Source/JavaScriptCore/runtime/RegExpObject.cpp

    r87345 r87346  
    6262*/
    6363
    64 RegExpObject::RegExpObject(JSGlobalObject* globalObject, Structure* structure, NonNullPassRefPtr<RegExp> regExp)
     64RegExpObject::RegExpObject(JSGlobalObject* globalObject, Structure* structure, RegExp* regExp)
    6565    : JSObjectWithGlobalObject(globalObject, structure)
    66     , d(adoptPtr(new RegExpObjectData(regExp)))
     66    , d(adoptPtr(new RegExpObjectData(globalObject->globalData(), this, regExp)))
    6767{
    6868    ASSERT(inherits(&s_info));
    … …  
    7979    ASSERT(structure()->typeInfo().overridesVisitChildren());
    8080    Base::visitChildren(visitor);
     81    if (d->regExp)
     82        visitor.append(&d->regExp);
    8183    if (UNLIKELY(!d->lastIndex.get().isInt32()))
    8284        visitor.append(&d->lastIndex);

  • trunk/Source/JavaScriptCore/runtime/RegExpObject.h

    r87345 r87346  
    2626
    2727namespace JSC {
    28 
     28   
    2929    class RegExpObject : public JSObjectWithGlobalObject {
    3030    public:
    3131        typedef JSObjectWithGlobalObject Base;
    3232
    33         RegExpObject(JSGlobalObject*, Structure*, NonNullPassRefPtr<RegExp>);
     33        RegExpObject(JSGlobalObject*, Structure*, RegExp*);
    3434        virtual ~RegExpObject();
    3535
    36         void setRegExp(PassRefPtr<RegExp> r) { d->regExp = r; }
     36        void setRegExp(JSGlobalData& globalData, RegExp* r) { d->regExp.set(globalData, this, r); }
    3737        RegExp* regExp() const { return d->regExp.get(); }
    3838
    … …  
    7575            WTF_MAKE_FAST_ALLOCATED;
    7676        public:
    77             RegExpObjectData(NonNullPassRefPtr<RegExp> regExp)
    78                 : regExp(regExp)
     77            RegExpObjectData(JSGlobalData& globalData, RegExpObject* owner, RegExp* regExp)
     78                : regExp(globalData, owner, regExp)
    7979            {
    8080                lastIndex.setWithoutWriteBarrier(jsNumber(0));
    8181            }
    8282
    83             RefPtr<RegExp> regExp;
     83            WriteBarrier<RegExp> regExp;
    8484            WriteBarrier<Unknown> lastIndex;
    8585        };

  • trunk/Source/JavaScriptCore/runtime/RegExpPrototype.cpp

    r87345 r87346  
    6363ASSERT_CLASS_FITS_IN_CELL(RegExpPrototype);
    6464
    65 RegExpPrototype::RegExpPrototype(ExecState* exec, JSGlobalObject* globalObject, Structure* structure)
    66     : RegExpObject(globalObject, structure, RegExp::create(&exec->globalData(), "", NoFlags))
     65RegExpPrototype::RegExpPrototype(ExecState*, JSGlobalObject* globalObject, Structure* structure, RegExp* regExp)
     66    : RegExpObject(globalObject, structure, regExp)
    6767{
    6868}
    … …  
    102102        return throwVMTypeError(exec);
    103103
    104     RefPtr<RegExp> regExp;
     104    RegExp* regExp;
    105105    JSValue arg0 = exec->argument(0);
    106106    JSValue arg1 = exec->argument(1);
    … …  
    129129        return throwVMError(exec, createSyntaxError(exec, regExp->errorMessage()));
    130130
    131     asRegExpObject(thisValue)->setRegExp(regExp.release());
     131    asRegExpObject(thisValue)->setRegExp(exec->globalData(), regExp);
    132132    asRegExpObject(thisValue)->setLastIndex(0);
    133133    return JSValue::encode(jsUndefined());

  • trunk/Source/JavaScriptCore/runtime/RegExpPrototype.h

    r87345 r87346  
    2929    class RegExpPrototype : public RegExpObject {
    3030    public:
    31         RegExpPrototype(ExecState*, JSGlobalObject*, Structure*);
     31        RegExpPrototype(ExecState*, JSGlobalObject*, Structure*, RegExp*);
    3232
    3333        static const ClassInfo s_info;

  • trunk/Source/JavaScriptCore/runtime/StringPrototype.cpp

    r87345 r87346  
    607607    JSValue a0 = exec->argument(0);
    608608
    609     RefPtr<RegExp> reg;
     609    RegExp* reg;
    610610    if (a0.inherits(&RegExpObject::s_info))
    611611        reg = asRegExpObject(a0)->regExp();
    … …  
    621621    int pos;
    622622    int matchLength = 0;
    623     regExpConstructor->performMatch(*globalData, reg.get(), s, 0, pos, matchLength);
     623    regExpConstructor->performMatch(*globalData, reg, s, 0, pos, matchLength);
    624624    if (!(reg->global())) {
    625625        // case without 'g' flag is handled like RegExp.prototype.exec
    … …  
    634634        list.append(jsSubstring(exec, s, pos, matchLength));
    635635        pos += matchLength == 0 ? 1 : matchLength;
    636         regExpConstructor->performMatch(*globalData, reg.get(), s, pos, pos, matchLength);
     636        regExpConstructor->performMatch(*globalData, reg, s, pos, pos, matchLength);
    637637    }
    638638    if (list.isEmpty()) {
    … …  
    656656    JSValue a0 = exec->argument(0);
    657657
    658     RefPtr<RegExp> reg;
     658    RegExp* reg;
    659659    if (a0.inherits(&RegExpObject::s_info))
    660660        reg = asRegExpObject(a0)->regExp();
    … …  
    670670    int pos;
    671671    int matchLength = 0;
    672     regExpConstructor->performMatch(*globalData, reg.get(), s, 0, pos, matchLength);
     672    regExpConstructor->performMatch(*globalData, reg, s, 0, pos, matchLength);
    673673    return JSValue::encode(jsNumber(pos));
    674674}

  • trunk/Source/WebCore/ChangeLog

    r87345 r87346  
    1 2011-05-25  Oliver Hunt  <oliver@apple.com>
    2 
    3         Revert last change, something weird happened when I went to land.
    4 
    5         * bindings/js/SerializedScriptValue.cpp:
    6         (WebCore::CloneDeserializer::readTerminal):
    7         * bridge/qt/qt_runtime.cpp:
    8         (JSC::Bindings::convertQVariantToValue):
    9 
    1012011-05-25  James Robinson  <jamesr@chromium.org>
    112

  • trunk/Source/WebCore/bindings/js/SerializedScriptValue.cpp

    r87345 r87346  
    11671167            RegExpFlags reFlags = regExpFlags(flags->ustring());
    11681168            ASSERT(reFlags != InvalidFlags);
    1169             RefPtr<RegExp> regExp = RegExp::create(&m_exec->globalData(), pattern->ustring(), reFlags);
     1169            RegExp* regExp = RegExp::create(&m_exec->globalData(), pattern->ustring(), reFlags);
    11701170            return new (m_exec) RegExpObject(m_exec->lexicalGlobalObject(), m_globalObject->regExpStructure(), regExp);
    11711171        }

  • trunk/Source/WebCore/bridge/qt/qt_runtime.cpp

    r87345 r87346  
    862862            RegExpFlags flags = (re.caseSensitivity() == Qt::CaseInsensitive) ? FlagIgnoreCase : NoFlags;
    863863
    864             RefPtr<JSC::RegExp> regExp = JSC::RegExp::create(&exec->globalData(), pattern, flags);
     864            JSC::RegExp* regExp = JSC::RegExp::create(&exec->globalData(), pattern, flags);
    865865            if (regExp->isValid())
    866                 return new (exec) RegExpObject(exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->regExpStructure(), regExp.release());
     866                return new (exec) RegExpObject(exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->regExpStructure(), regExp);
    867867            return jsNull();
    868868        }
Note: See TracChangeset for help on using the changeset viewer.