Changeset 84556 in webkit


Ignore:
Timestamp:
Apr 21, 2011 4:08:15 PM (13 years ago)
Author:
oliver@apple.com
Message:

2011-04-21 Oliver Hunt <​oliver@apple.com>

Reviewed by Geoffrey Garen.

Start moving to a general visitor pattern for GC traversal
​https://bugs.webkit.org/show_bug.cgi?id=59141

This is just a rename:

markChildren -> visitChildren
markAggregate -> visitAggregate
markStack -> visitor
MarkStack -> typedef'd to SlotVisitor

  • API/JSCallbackObject.h: (JSC::JSCallbackObjectData::visitChildren): (JSC::JSCallbackObjectData::JSPrivatePropertyMap::visitChildren): (JSC::JSCallbackObject::visitChildren):
  • JavaScriptCore.exp:
  • bytecode/CodeBlock.cpp: (JSC::CodeBlock::visitStructures): (JSC::EvalCodeCache::visitAggregate): (JSC::CodeBlock::visitAggregate):
  • bytecode/CodeBlock.h:
  • bytecode/EvalCodeCache.h:
  • bytecode/Instruction.h: (JSC::PolymorphicAccessStructureList::visitAggregate):
  • bytecode/StructureStubInfo.cpp: (JSC::StructureStubInfo::visitAggregate):
  • bytecode/StructureStubInfo.h:
  • debugger/DebuggerActivation.cpp: (JSC::DebuggerActivation::visitChildren):
  • debugger/DebuggerActivation.h:
  • heap/HandleHeap.cpp: (JSC::WeakHandleOwner::isReachableFromOpaqueRoots): (JSC::HandleHeap::markStrongHandles): (JSC::HandleHeap::markWeakHandles):
  • heap/HandleHeap.h:
  • heap/HandleStack.cpp: (JSC::HandleStack::mark):
  • heap/HandleStack.h:
  • heap/Heap.cpp: (JSC::Heap::markProtectedObjects): (JSC::Heap::markTempSortVectors): (JSC::Heap::markRoots):
  • heap/Heap.h:
  • heap/MarkStack.cpp: (JSC::MarkStack::visitChildren): (JSC::MarkStack::drain):
  • heap/MarkStack.h: (JSC::HeapRootVisitor::HeapRootVisitor): (JSC::HeapRootVisitor::mark): (JSC::HeapRootVisitor::visitor):
  • heap/MarkedSpace.h:
  • runtime/ArgList.cpp: (JSC::MarkedArgumentBuffer::markLists):
  • runtime/ArgList.h:
  • runtime/Arguments.cpp: (JSC::Arguments::visitChildren):
  • runtime/Arguments.h:
  • runtime/Executable.cpp: (JSC::EvalExecutable::visitChildren): (JSC::ProgramExecutable::visitChildren): (JSC::FunctionExecutable::visitChildren):
  • runtime/Executable.h:
  • runtime/GetterSetter.cpp: (JSC::GetterSetter::visitChildren):
  • runtime/GetterSetter.h: (JSC::GetterSetter::createStructure):
  • runtime/JSAPIValueWrapper.h: (JSC::JSAPIValueWrapper::createStructure):
  • runtime/JSActivation.cpp: (JSC::JSActivation::visitChildren):
  • runtime/JSActivation.h:
  • runtime/JSArray.cpp: (JSC::JSArray::visitChildren):
  • runtime/JSArray.h: (JSC::JSArray::visitDirect):
  • runtime/JSCell.h: (JSC::JSCell::JSCell::visitChildren):
  • runtime/JSFunction.cpp: (JSC::JSFunction::visitChildren):
  • runtime/JSFunction.h:
  • runtime/JSGlobalObject.cpp: (JSC::visitIfNeeded): (JSC::JSGlobalObject::visitChildren):
  • runtime/JSGlobalObject.h:
  • runtime/JSONObject.cpp:
  • runtime/JSObject.cpp: (JSC::JSObject::visitChildren):
  • runtime/JSObject.h: (JSC::JSObject::visitDirect):
  • runtime/JSPropertyNameIterator.cpp: (JSC::JSPropertyNameIterator::visitChildren):
  • runtime/JSPropertyNameIterator.h: (JSC::JSPropertyNameIterator::createStructure):
  • runtime/JSStaticScopeObject.cpp: (JSC::JSStaticScopeObject::visitChildren):
  • runtime/JSStaticScopeObject.h:
  • runtime/JSTypeInfo.h: (JSC::TypeInfo::TypeInfo): (JSC::TypeInfo::overridesVisitChildren):
  • runtime/JSWrapperObject.cpp: (JSC::JSWrapperObject::visitChildren):
  • runtime/JSWrapperObject.h:
  • runtime/JSZombie.h: (JSC::JSZombie::visitChildren):
  • runtime/NativeErrorConstructor.cpp: (JSC::NativeErrorConstructor::visitChildren):
  • runtime/NativeErrorConstructor.h:
  • runtime/RegExpObject.cpp: (JSC::RegExpObject::visitChildren):
  • runtime/RegExpObject.h:
  • runtime/ScopeChain.cpp: (JSC::ScopeChainNode::visitChildren):
  • runtime/ScopeChain.h:
  • runtime/SmallStrings.cpp: (JSC::SmallStrings::visitChildren):
  • runtime/SmallStrings.h:
  • runtime/Structure.cpp: (JSC::Structure::Structure): (JSC::Structure::visitChildren):
  • runtime/Structure.h:
  • runtime/StructureChain.cpp: (JSC::StructureChain::visitChildren):
  • runtime/StructureChain.h: (JSC::StructureChain::createStructure):

2011-04-21 Oliver Hunt <​oliver@apple.com>

Reviewed by Geoffrey Garen.

Start moving to a general visitor pattern for GC traversal
​https://bugs.webkit.org/show_bug.cgi?id=59141

This is just a rename:

markChildren -> visitChildren
markAggregate -> visitAggregate
markStack -> visitor
MarkStack -> typedef'd to SlotVisitor

  • UserObjectImp.cpp: (UserObjectImp::visitChildren):

2011-04-21 Oliver Hunt <​oliver@apple.com>

Reviewed by Geoffrey Garen.

Start moving to a general visitor pattern for GC traversal
​https://bugs.webkit.org/show_bug.cgi?id=59141

This is just a rename:

markChildren -> visitChildren
markAggregate -> visitAggregate
markStack -> visitor
MarkStack -> typedef'd to SlotVisitor

  • bindings/js/JSAttrCustom.cpp: (WebCore::JSAttr::visitChildren):
  • bindings/js/JSAudioConstructor.cpp: (WebCore::constructAudio):
  • bindings/js/JSCSSRuleCustom.cpp: (WebCore::JSCSSRule::visitChildren):
  • bindings/js/JSCSSStyleDeclarationCustom.cpp: (WebCore::JSCSSStyleDeclaration::visitChildren):
  • bindings/js/JSDOMBinding.cpp: (WebCore::visitActiveObjectsForContext): (WebCore::markDOMObjectWrapper):
  • bindings/js/JSDOMBinding.h:
  • bindings/js/JSDOMGlobalObject.cpp: (WebCore::JSDOMGlobalObject::visitChildren):
  • bindings/js/JSDOMGlobalObject.h:
  • bindings/js/JSDOMImplementationCustom.cpp: (WebCore::JSDOMImplementation::visitChildren):
  • bindings/js/JSDOMWindowCustom.cpp: (WebCore::JSDOMWindow::visitChildren):
  • bindings/js/JSDOMWindowShell.cpp: (WebCore::JSDOMWindowShell::visitChildren):
  • bindings/js/JSDOMWindowShell.h:
  • bindings/js/JSDocumentCustom.cpp: (WebCore::JSDocument::visitChildren):
  • bindings/js/JSElementCustom.cpp: (WebCore::JSElement::visitChildren):
  • bindings/js/JSEventListener.cpp: (WebCore::JSEventListener::markJSFunction):
  • bindings/js/JSEventListener.h:
  • bindings/js/JSHTMLCanvasElementCustom.cpp: (WebCore::JSHTMLCanvasElement::visitChildren):
  • bindings/js/JSHTMLLinkElementCustom.cpp: (WebCore::JSHTMLLinkElement::visitChildren):
  • bindings/js/JSHTMLStyleElementCustom.cpp: (WebCore::JSHTMLStyleElement::visitChildren):
  • bindings/js/JSImageConstructor.cpp: (WebCore::constructImage):
  • bindings/js/JSJavaScriptAudioNodeCustom.cpp: (WebCore::JSJavaScriptAudioNode::visitChildren):
  • bindings/js/JSMessageChannelCustom.cpp: (WebCore::JSMessageChannel::visitChildren):
  • bindings/js/JSMessagePortCustom.cpp: (WebCore::JSMessagePort::visitChildren):
  • bindings/js/JSNamedNodeMapCustom.cpp: (WebCore::JSNamedNodeMapOwner::isReachableFromOpaqueRoots): (WebCore::JSNamedNodeMap::visitChildren):
  • bindings/js/JSNavigatorCustom.cpp: (WebCore::JSNavigator::visitChildren):
  • bindings/js/JSNodeCustom.cpp: (WebCore::isObservable): (WebCore::isReachableFromDOM): (WebCore::JSNodeOwner::isReachableFromOpaqueRoots): (WebCore::JSNode::visitChildren):
  • bindings/js/JSNodeCustom.h:
  • bindings/js/JSNodeFilterCondition.cpp: (WebCore::JSNodeFilterCondition::WeakOwner::isReachableFromOpaqueRoots):
  • bindings/js/JSNodeFilterCondition.h:
  • bindings/js/JSNodeFilterCustom.cpp: (WebCore::JSNodeFilter::visitChildren):
  • bindings/js/JSNodeIteratorCustom.cpp: (WebCore::JSNodeIterator::visitChildren):
  • bindings/js/JSNodeListCustom.cpp: (WebCore::JSNodeListOwner::isReachableFromOpaqueRoots):
  • bindings/js/JSProcessingInstructionCustom.cpp: (WebCore::JSProcessingInstruction::visitChildren):
  • bindings/js/JSSVGElementInstanceCustom.cpp: (WebCore::JSSVGElementInstance::visitChildren):
  • bindings/js/JSSharedWorkerCustom.cpp: (WebCore::JSSharedWorker::visitChildren):
  • bindings/js/JSStyleSheetCustom.cpp: (WebCore::JSStyleSheet::visitChildren):
  • bindings/js/JSTreeWalkerCustom.cpp: (WebCore::JSTreeWalker::visitChildren):
  • bindings/js/JSWebGLRenderingContextCustom.cpp: (WebCore::JSWebGLRenderingContext::visitChildren):
  • bindings/js/JSWebKitAnimationListCustom.cpp: (WebCore::JSWebKitAnimationList::visitChildren):
  • bindings/js/JSWorkerContextCustom.cpp: (WebCore::JSWorkerContext::visitChildren):
  • bindings/js/JSXMLHttpRequestCustom.cpp: (WebCore::JSXMLHttpRequest::visitChildren):
  • bindings/js/JSXMLHttpRequestUploadCustom.cpp: (WebCore::JSXMLHttpRequestUpload::visitChildren):
  • bindings/scripts/CodeGeneratorJS.pm:
  • bridge/qt/qt_instance.cpp: (JSC::Bindings::QtRuntimeObject::visitChildren): (JSC::Bindings::QtInstance::markAggregate):
  • bridge/qt/qt_instance.h:
  • bridge/qt/qt_pixmapruntime.cpp:
  • bridge/qt/qt_runtime.cpp: (JSC::Bindings::QtRuntimeMetaMethod::visitChildren):
  • bridge/qt/qt_runtime.h:
  • dom/EventListener.h: (WebCore::EventListener::visitJSFunction):
  • dom/EventTarget.h: (WebCore::EventTarget::visitJSEventListeners):
  • dom/Node.h:
  • dom/NodeFilterCondition.h: (WebCore::NodeFilterCondition::visitAggregate):
  • page/DOMWindow.h:
  • workers/WorkerContext.h:
Location:
trunk/Source
Files:
120 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/API/JSCallbackObject.h

    r84052 r84556  
    6969    }
    7070
    71     void markChildren(MarkStack& markStack)
     71    void visitChildren(SlotVisitor& visitor)
    7272    {
    7373        if (!m_privateProperties)
    7474            return;
    75         m_privateProperties->markChildren(markStack);
     75        m_privateProperties->visitChildren(visitor);
    7676    }
    7777
    … …  
    9898        }
    9999
    100         void markChildren(MarkStack& markStack)
     100        void visitChildren(SlotVisitor& visitor)
    101101        {
    102102            for (PrivatePropertyMap::iterator ptr = m_propertyMap.begin(); ptr != m_propertyMap.end(); ++ptr) {
    103103                if (ptr->second)
    104                     markStack.append(&ptr->second);
     104                    visitor.append(&ptr->second);
    105105            }
    106106        }
    … …  
    150150
    151151protected:
    152     static const unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesHasInstance | OverridesMarkChildren | OverridesGetPropertyNames | Base::StructureFlags;
     152    static const unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesHasInstance | OverridesVisitChildren | OverridesGetPropertyNames | Base::StructureFlags;
    153153
    154154private:
    … …  
    173173    virtual CallType getCallData(CallData&);
    174174
    175     virtual void markChildren(MarkStack& markStack)
    176     {
    177         Base::markChildren(markStack);
    178         m_callbackObjectData->markChildren(markStack);
     175    virtual void visitChildren(SlotVisitor& visitor)
     176    {
     177        Base::visitChildren(visitor);
     178        m_callbackObjectData->visitChildren(visitor);
    179179    }
    180180

  • trunk/Source/JavaScriptCore/ChangeLog

    r84550 r84556  
     12011-04-21  Oliver Hunt  <oliver@apple.com>
     2
     3        Reviewed by Geoffrey Garen.
     4
     5        Start moving to a general visitor pattern for GC traversal
     6        https://bugs.webkit.org/show_bug.cgi?id=59141
     7
     8        This is just a rename:
     9            markChildren -> visitChildren
     10            markAggregate -> visitAggregate
     11            markStack -> visitor
     12            MarkStack -> typedef'd to SlotVisitor
     13
     14        * API/JSCallbackObject.h:
     15        (JSC::JSCallbackObjectData::visitChildren):
     16        (JSC::JSCallbackObjectData::JSPrivatePropertyMap::visitChildren):
     17        (JSC::JSCallbackObject::visitChildren):
     18        * JavaScriptCore.exp:
     19        * bytecode/CodeBlock.cpp:
     20        (JSC::CodeBlock::visitStructures):
     21        (JSC::EvalCodeCache::visitAggregate):
     22        (JSC::CodeBlock::visitAggregate):
     23        * bytecode/CodeBlock.h:
     24        * bytecode/EvalCodeCache.h:
     25        * bytecode/Instruction.h:
     26        (JSC::PolymorphicAccessStructureList::visitAggregate):
     27        * bytecode/StructureStubInfo.cpp:
     28        (JSC::StructureStubInfo::visitAggregate):
     29        * bytecode/StructureStubInfo.h:
     30        * debugger/DebuggerActivation.cpp:
     31        (JSC::DebuggerActivation::visitChildren):
     32        * debugger/DebuggerActivation.h:
     33        * heap/HandleHeap.cpp:
     34        (JSC::WeakHandleOwner::isReachableFromOpaqueRoots):
     35        (JSC::HandleHeap::markStrongHandles):
     36        (JSC::HandleHeap::markWeakHandles):
     37        * heap/HandleHeap.h:
     38        * heap/HandleStack.cpp:
     39        (JSC::HandleStack::mark):
     40        * heap/HandleStack.h:
     41        * heap/Heap.cpp:
     42        (JSC::Heap::markProtectedObjects):
     43        (JSC::Heap::markTempSortVectors):
     44        (JSC::Heap::markRoots):
     45        * heap/Heap.h:
     46        * heap/MarkStack.cpp:
     47        (JSC::MarkStack::visitChildren):
     48        (JSC::MarkStack::drain):
     49        * heap/MarkStack.h:
     50        (JSC::HeapRootVisitor::HeapRootVisitor):
     51        (JSC::HeapRootVisitor::mark):
     52        (JSC::HeapRootVisitor::visitor):
     53        * heap/MarkedSpace.h:
     54        * runtime/ArgList.cpp:
     55        (JSC::MarkedArgumentBuffer::markLists):
     56        * runtime/ArgList.h:
     57        * runtime/Arguments.cpp:
     58        (JSC::Arguments::visitChildren):
     59        * runtime/Arguments.h:
     60        * runtime/Executable.cpp:
     61        (JSC::EvalExecutable::visitChildren):
     62        (JSC::ProgramExecutable::visitChildren):
     63        (JSC::FunctionExecutable::visitChildren):
     64        * runtime/Executable.h:
     65        * runtime/GetterSetter.cpp:
     66        (JSC::GetterSetter::visitChildren):
     67        * runtime/GetterSetter.h:
     68        (JSC::GetterSetter::createStructure):
     69        * runtime/JSAPIValueWrapper.h:
     70        (JSC::JSAPIValueWrapper::createStructure):
     71        * runtime/JSActivation.cpp:
     72        (JSC::JSActivation::visitChildren):
     73        * runtime/JSActivation.h:
     74        * runtime/JSArray.cpp:
     75        (JSC::JSArray::visitChildren):
     76        * runtime/JSArray.h:
     77        (JSC::JSArray::visitDirect):
     78        * runtime/JSCell.h:
     79        (JSC::JSCell::JSCell::visitChildren):
     80        * runtime/JSFunction.cpp:
     81        (JSC::JSFunction::visitChildren):
     82        * runtime/JSFunction.h:
     83        * runtime/JSGlobalObject.cpp:
     84        (JSC::visitIfNeeded):
     85        (JSC::JSGlobalObject::visitChildren):
     86        * runtime/JSGlobalObject.h:
     87        * runtime/JSONObject.cpp:
     88        * runtime/JSObject.cpp:
     89        (JSC::JSObject::visitChildren):
     90        * runtime/JSObject.h:
     91        (JSC::JSObject::visitDirect):
     92        * runtime/JSPropertyNameIterator.cpp:
     93        (JSC::JSPropertyNameIterator::visitChildren):
     94        * runtime/JSPropertyNameIterator.h:
     95        (JSC::JSPropertyNameIterator::createStructure):
     96        * runtime/JSStaticScopeObject.cpp:
     97        (JSC::JSStaticScopeObject::visitChildren):
     98        * runtime/JSStaticScopeObject.h:
     99        * runtime/JSTypeInfo.h:
     100        (JSC::TypeInfo::TypeInfo):
     101        (JSC::TypeInfo::overridesVisitChildren):
     102        * runtime/JSWrapperObject.cpp:
     103        (JSC::JSWrapperObject::visitChildren):
     104        * runtime/JSWrapperObject.h:
     105        * runtime/JSZombie.h:
     106        (JSC::JSZombie::visitChildren):
     107        * runtime/NativeErrorConstructor.cpp:
     108        (JSC::NativeErrorConstructor::visitChildren):
     109        * runtime/NativeErrorConstructor.h:
     110        * runtime/RegExpObject.cpp:
     111        (JSC::RegExpObject::visitChildren):
     112        * runtime/RegExpObject.h:
     113        * runtime/ScopeChain.cpp:
     114        (JSC::ScopeChainNode::visitChildren):
     115        * runtime/ScopeChain.h:
     116        * runtime/SmallStrings.cpp:
     117        (JSC::SmallStrings::visitChildren):
     118        * runtime/SmallStrings.h:
     119        * runtime/Structure.cpp:
     120        (JSC::Structure::Structure):
     121        (JSC::Structure::visitChildren):
     122        * runtime/Structure.h:
     123        * runtime/StructureChain.cpp:
     124        (JSC::StructureChain::visitChildren):
     125        * runtime/StructureChain.h:
     126        (JSC::StructureChain::createStructure):
     127
    11282011-04-21  Sheriff Bot  <webkit.review.bot@gmail.com>
    2129

  • trunk/Source/JavaScriptCore/JavaScriptCore.exp

    r84052 r84556  
    157157__ZN3JSC14JSGlobalObject12defineGetterEPNS_9ExecStateERKNS_10IdentifierEPNS_8JSObjectEj
    158158__ZN3JSC14JSGlobalObject12defineSetterEPNS_9ExecStateERKNS_10IdentifierEPNS_8JSObjectEj
    159 __ZN3JSC14JSGlobalObject12markChildrenERNS_9MarkStackE
     159__ZN3JSC14JSGlobalObject13visitChildrenERNS_9MarkStackE
    160160__ZN3JSC14JSGlobalObject17putWithAttributesEPNS_9ExecStateERKNS_10IdentifierENS_7JSValueEj
    161161__ZN3JSC14JSGlobalObject3putEPNS_9ExecStateERKNS_10IdentifierENS_7JSValueERNS_15PutPropertySlotE 
    … …  
    169169__ZN3JSC14TimeoutChecker5resetEv
    170170__ZN3JSC14throwTypeErrorEPNS_9ExecStateE
    171 __ZN3JSC15JSWrapperObject12markChildrenERNS_9MarkStackE
     171__ZN3JSC15JSWrapperObject13visitChildrenERNS_9MarkStackE
    172172__ZN3JSC15WeakHandleOwner26isReachableFromOpaqueRootsENS_6HandleINS_7UnknownEEEPvRNS_9MarkStackE
    173173__ZN3JSC15WeakHandleOwner8finalizeENS_6HandleINS_7UnknownEEEPv
    … …  
    253253__ZN3JSC6RegExp6createEPNS_12JSGlobalDataERKNS_7UStringENS_11RegExpFlagsE
    254254__ZN3JSC6RegExpD1Ev
    255 __ZN3JSC7JSArray12markChildrenERNS_9MarkStackE
     255__ZN3JSC7JSArray13visitChildrenERNS_9MarkStackE
    256256__ZN3JSC7JSArray15setSubclassDataEPv
    257257__ZN3JSC7JSArray18getOwnPropertySlotEPNS_9ExecStateEjRNS_12PropertySlotE
    … …  
    285285__ZN3JSC8JSObject12lookupGetterEPNS_9ExecStateERKNS_10IdentifierE
    286286__ZN3JSC8JSObject12lookupSetterEPNS_9ExecStateERKNS_10IdentifierE
    287 __ZN3JSC8JSObject12markChildrenERNS_9MarkStackE
     287__ZN3JSC8JSObject13visitChildrenERNS_9MarkStackE
    288288__ZN3JSC8JSObject14deletePropertyEPNS_9ExecStateERKNS_10IdentifierE
    289289__ZN3JSC8JSObject14deletePropertyEPNS_9ExecStateEj
    … …  
    307307__ZN3JSC8JSObject24getOwnPropertyDescriptorEPNS_9ExecStateERKNS_10IdentifierERNS_18PropertyDescriptorE
    308308__ZN3JSC8JSObject3putEPNS_9ExecStateERKNS_10IdentifierENS_7JSValueERNS_15PutPropertySlotE
    309 __ZN3JSC8JSObject3putEPNS_9ExecStateEjNS_7JSValueE 
     309__ZN3JSC8JSObject3putEPNS_9ExecStateEjNS_7JSValueE
    310310__ZN3JSC8JSObject6s_infoE
    311311__ZN3JSC8Profiler13stopProfilingEPNS_9ExecStateERKNS_7UStringE

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

    r84052 r84556  
    238238    ?lookupGetter@JSObject@JSC@@UAE?AVJSValue@2@PAVExecState@2@ABVIdentifier@2@@Z
    239239    ?lookupSetter@JSObject@JSC@@UAE?AVJSValue@2@PAVExecState@2@ABVIdentifier@2@@Z
    240     ?markChildren@JSGlobalObject@JSC@@UAEXAAVMarkStack@2@@Z
    241     ?markChildren@JSObject@JSC@@UAEXAAVMarkStack@2@@Z
    242     ?markChildren@JSWrapperObject@JSC@@EAEXAAVMarkStack@2@@Z
    243     ?markChildren@ScopeChainNode@JSC@@UAEXAAVMarkStack@2@@Z
     240    ?visitChildren@JSGlobalObject@JSC@@UAEXAAVMarkStack@2@@Z
     241    ?visitChildren@JSObject@JSC@@UAEXAAVMarkStack@2@@Z
     242    ?visitChildren@JSWrapperObject@JSC@@EAEXAAVMarkStack@2@@Z
     243    ?visitChildren@ScopeChainNode@JSC@@UAEXAAVMarkStack@2@@Z
    244244    ?materializePropertyMap@Structure@JSC@@AAEXAAVJSGlobalData@2@@Z
    245245    ?monthFromDayInYear@WTF@@YAHH_N@Z

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

    r84052 r84556  
    14011401}
    14021402
    1403 void CodeBlock::markStructures(MarkStack& markStack, Instruction* vPC) const
     1403void CodeBlock::visitStructures(SlotVisitor& visitor, Instruction* vPC) const
    14041404{
    14051405    Interpreter* interpreter = m_globalData->interpreter;
    14061406
    14071407    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_self) || vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_getter_self) || vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_custom_self)) {
    1408         markStack.append(&vPC[4].u.structure);
     1408        visitor.append(&vPC[4].u.structure);
    14091409        return;
    14101410    }
    14111411    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_proto) || vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_getter_proto) || vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_custom_proto)) {
    1412         markStack.append(&vPC[4].u.structure);
    1413         markStack.append(&vPC[5].u.structure);
     1412        visitor.append(&vPC[4].u.structure);
     1413        visitor.append(&vPC[5].u.structure);
    14141414        return;
    14151415    }
    14161416    if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_chain) || vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_getter_chain) || vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_custom_chain)) {
    1417         markStack.append(&vPC[4].u.structure);
    1418         markStack.append(&vPC[5].u.structureChain);
     1417        visitor.append(&vPC[4].u.structure);
     1418        visitor.append(&vPC[5].u.structureChain);
    14191419        return;
    14201420    }
    14211421    if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_transition)) {
    1422         markStack.append(&vPC[4].u.structure);
    1423         markStack.append(&vPC[5].u.structure);
    1424         markStack.append(&vPC[6].u.structureChain);
     1422        visitor.append(&vPC[4].u.structure);
     1423        visitor.append(&vPC[5].u.structure);
     1424        visitor.append(&vPC[6].u.structureChain);
    14251425        return;
    14261426    }
    14271427    if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_replace)) {
    1428         markStack.append(&vPC[4].u.structure);
     1428        visitor.append(&vPC[4].u.structure);
    14291429        return;
    14301430    }
    14311431    if (vPC[0].u.opcode == interpreter->getOpcode(op_resolve_global) || vPC[0].u.opcode == interpreter->getOpcode(op_resolve_global_dynamic)) {
    14321432        if (vPC[3].u.structure)
    1433             markStack.append(&vPC[3].u.structure);
     1433            visitor.append(&vPC[3].u.structure);
    14341434        return;
    14351435    }
    … …  
    14411441        || (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_custom_self_list))) {
    14421442        PolymorphicAccessStructureList* polymorphicStructures = vPC[4].u.polymorphicStructures;
    1443         polymorphicStructures->markAggregate(markStack, vPC[5].u.operand);
     1443        polymorphicStructures->visitAggregate(visitor, vPC[5].u.operand);
    14441444        delete polymorphicStructures;
    14451445        return;
    … …  
    14501450}
    14511451
    1452 void EvalCodeCache::markAggregate(MarkStack& markStack)
     1452void EvalCodeCache::visitAggregate(SlotVisitor& visitor)
    14531453{
    14541454    EvalCacheMap::iterator end = m_cacheMap.end();
    14551455    for (EvalCacheMap::iterator ptr = m_cacheMap.begin(); ptr != end; ++ptr)
    1456         markStack.append(&ptr->second);
    1457 }
    1458 
    1459 void CodeBlock::markAggregate(MarkStack& markStack)
    1460 {
    1461     markStack.append(&m_globalObject);
    1462     markStack.append(&m_ownerExecutable);
     1456        visitor.append(&ptr->second);
     1457}
     1458
     1459void CodeBlock::visitAggregate(SlotVisitor& visitor)
     1460{
     1461    visitor.append(&m_globalObject);
     1462    visitor.append(&m_ownerExecutable);
    14631463    if (m_rareData)
    1464         m_rareData->m_evalCodeCache.markAggregate(markStack);
    1465     markStack.appendValues(m_constantRegisters.data(), m_constantRegisters.size());
     1464        m_rareData->m_evalCodeCache.visitAggregate(visitor);
     1465    visitor.appendValues(m_constantRegisters.data(), m_constantRegisters.size());
    14661466    for (size_t i = 0; i < m_functionExprs.size(); ++i)
    1467         markStack.append(&m_functionExprs[i]);
     1467        visitor.append(&m_functionExprs[i]);
    14681468    for (size_t i = 0; i < m_functionDecls.size(); ++i)
    1469         markStack.append(&m_functionDecls[i]);
     1469        visitor.append(&m_functionDecls[i]);
    14701470#if ENABLE(JIT_OPTIMIZE_CALL)
    14711471    for (unsigned i = 0; i < numberOfCallLinkInfos(); ++i)
    14721472        if (callLinkInfo(i).isLinked())
    1473             markStack.append(&callLinkInfo(i).callee);
     1473            visitor.append(&callLinkInfo(i).callee);
    14741474#endif
    14751475#if ENABLE(INTERPRETER)
    14761476    for (size_t size = m_propertyAccessInstructions.size(), i = 0; i < size; ++i)
    1477         markStructures(markStack, &m_instructions[m_propertyAccessInstructions[i]]);
     1477        markStructures(visitor, &m_instructions[m_propertyAccessInstructions[i]]);
    14781478#endif
    14791479#if ENABLE(JIT)
    14801480    for (size_t size = m_globalResolveInfos.size(), i = 0; i < size; ++i) {
    14811481        if (m_globalResolveInfos[i].structure)
    1482             markStack.append(&m_globalResolveInfos[i].structure);
     1482            visitor.append(&m_globalResolveInfos[i].structure);
    14831483    }
    14841484
    14851485    for (size_t size = m_structureStubInfos.size(), i = 0; i < size; ++i)
    1486         m_structureStubInfos[i].markAggregate(markStack);
     1486        m_structureStubInfos[i].visitAggregate(visitor);
    14871487
    14881488    for (size_t size = m_methodCallLinkInfos.size(), i = 0; i < size; ++i) {
    14891489        if (m_methodCallLinkInfos[i].cachedStructure) {
    14901490            // Both members must be filled at the same time
    1491             markStack.append(&m_methodCallLinkInfos[i].cachedStructure);
     1491            visitor.append(&m_methodCallLinkInfos[i].cachedStructure);
    14921492            ASSERT(!!m_methodCallLinkInfos[i].cachedPrototypeStructure);
    1493             markStack.append(&m_methodCallLinkInfos[i].cachedPrototypeStructure);
     1493            visitor.append(&m_methodCallLinkInfos[i].cachedPrototypeStructure);
    14941494        }
    14951495    }

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

    r84052 r84556  
    212212        virtual ~CodeBlock();
    213213
    214         void markAggregate(MarkStack&);
     214        void visitAggregate(SlotVisitor&);
    215215
    216216        static void dumpStatistics();
    … …  
    482482        void printPutByIdOp(ExecState*, int location, Vector<Instruction>::const_iterator&, const char* op) const;
    483483#endif
    484         void markStructures(MarkStack&, Instruction* vPC) const;
     484        void visitStructures(SlotVisitor&, Instruction* vPC) const;
    485485
    486486        void createRareDataIfNecessary()

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

    r80598 r84556  
    4343
    4444    class MarkStack;
     45    typedef MarkStack SlotVisitor;
    4546
    4647    class EvalCodeCache {
    … …  
    6869        bool isEmpty() const { return m_cacheMap.isEmpty(); }
    6970
    70         void markAggregate(MarkStack&);
     71        void visitAggregate(SlotVisitor&);
    7172
    7273    private:

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

    r84052 r84556  
    108108        }
    109109
    110         void markAggregate(MarkStack& markStack, int count)
     110        void visitAggregate(SlotVisitor& visitor, int count)
    111111        {
    112112            for (int i = 0; i < count; ++i) {
    … …  
    114114                ASSERT(info.base);
    115115               
    116                 markStack.append(&info.base);
     116                visitor.append(&info.base);
    117117                if (info.u.proto && !info.isChain)
    118                     markStack.append(&info.u.proto);
     118                    visitor.append(&info.u.proto);
    119119                if (info.u.chain && info.isChain)
    120                     markStack.append(&info.u.chain);
     120                    visitor.append(&info.u.chain);
    121121            }
    122122        }

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

    r84052 r84556  
    6464}
    6565
    66 void StructureStubInfo::markAggregate(MarkStack& markStack)
     66void StructureStubInfo::visitAggregate(SlotVisitor& visitor)
    6767{
    6868    switch (accessType) {
    6969    case access_get_by_id_self:
    70         markStack.append(&u.getByIdSelf.baseObjectStructure);
     70        visitor.append(&u.getByIdSelf.baseObjectStructure);
    7171        return;
    7272    case access_get_by_id_proto:
    73         markStack.append(&u.getByIdProto.baseObjectStructure);
    74         markStack.append(&u.getByIdProto.prototypeStructure);
     73        visitor.append(&u.getByIdProto.baseObjectStructure);
     74        visitor.append(&u.getByIdProto.prototypeStructure);
    7575        return;
    7676    case access_get_by_id_chain:
    77         markStack.append(&u.getByIdChain.baseObjectStructure);
    78         markStack.append(&u.getByIdChain.chain);
     77        visitor.append(&u.getByIdChain.baseObjectStructure);
     78        visitor.append(&u.getByIdChain.chain);
    7979        return;
    8080    case access_get_by_id_self_list: {
    8181        PolymorphicAccessStructureList* polymorphicStructures = u.getByIdSelfList.structureList;
    82         polymorphicStructures->markAggregate(markStack, u.getByIdSelfList.listSize);
     82        polymorphicStructures->visitAggregate(visitor, u.getByIdSelfList.listSize);
    8383        return;
    8484    }
    8585    case access_get_by_id_proto_list: {
    8686        PolymorphicAccessStructureList* polymorphicStructures = u.getByIdProtoList.structureList;
    87         polymorphicStructures->markAggregate(markStack, u.getByIdProtoList.listSize);
     87        polymorphicStructures->visitAggregate(visitor, u.getByIdProtoList.listSize);
    8888        return;
    8989    }
    9090    case access_put_by_id_transition:
    91         markStack.append(&u.putByIdTransition.previousStructure);
    92         markStack.append(&u.putByIdTransition.structure);
    93         markStack.append(&u.putByIdTransition.chain);
     91        visitor.append(&u.putByIdTransition.previousStructure);
     92        visitor.append(&u.putByIdTransition.structure);
     93        visitor.append(&u.putByIdTransition.chain);
    9494        return;
    9595    case access_put_by_id_replace:
    96         markStack.append(&u.putByIdReplace.baseObjectStructure);
     96        visitor.append(&u.putByIdReplace.baseObjectStructure);
    9797        return;
    9898    case access_get_by_id:

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

    r84052 r84556  
    117117
    118118        void deref();
    119         void markAggregate(MarkStack&);
     119        void visitAggregate(SlotVisitor&);
    120120
    121121        bool seenOnce()

  • trunk/Source/JavaScriptCore/debugger/DebuggerActivation.cpp

    r84052 r84556  
    3939}
    4040
    41 void DebuggerActivation::markChildren(MarkStack& markStack)
     41void DebuggerActivation::visitChildren(SlotVisitor& visitor)
    4242{
    43     JSObject::markChildren(markStack);
     43    JSObject::visitChildren(visitor);
    4444
    4545    if (m_activation)
    46         markStack.append(&m_activation);
     46        visitor.append(&m_activation);
    4747}
    4848

  • trunk/Source/JavaScriptCore/debugger/DebuggerActivation.h

    r84052 r84556  
    3737        DebuggerActivation(JSGlobalData&, JSObject*);
    3838
    39         virtual void markChildren(MarkStack&);
     39        virtual void visitChildren(SlotVisitor&);
    4040        virtual UString className() const;
    4141        virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
    … …  
    5656
    5757    protected:
    58         static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesMarkChildren | JSObject::StructureFlags;
     58        static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesVisitChildren | JSObject::StructureFlags;
    5959
    6060    private:

  • trunk/Source/JavaScriptCore/heap/HandleHeap.cpp

    r83910 r84556  
    3535}
    3636
    37 bool WeakHandleOwner::isReachableFromOpaqueRoots(Handle<Unknown>, void*, MarkStack&)
     37bool WeakHandleOwner::isReachableFromOpaqueRoots(Handle<Unknown>, void*, SlotVisitor&)
    3838{
    3939    return false;
    … …  
    6161}
    6262
    63 void HandleHeap::markStrongHandles(HeapRootMarker& heapRootMarker)
     63void HandleHeap::markStrongHandles(HeapRootVisitor& heapRootMarker)
    6464{
    6565    Node* end = m_strongList.end();
    … …  
    6868}
    6969
    70 void HandleHeap::markWeakHandles(HeapRootMarker& heapRootMarker)
     70void HandleHeap::markWeakHandles(HeapRootVisitor& heapRootVisitor)
    7171{
    72     MarkStack& markStack = heapRootMarker.markStack();
     72    SlotVisitor& visitor = heapRootVisitor.visitor();
    7373
    7474    Node* end = m_weakList.end();
    … …  
    8383            continue;
    8484
    85         if (!weakOwner->isReachableFromOpaqueRoots(Handle<Unknown>::wrapSlot(node->slot()), node->weakOwnerContext(), markStack))
     85        if (!weakOwner->isReachableFromOpaqueRoots(Handle<Unknown>::wrapSlot(node->slot()), node->weakOwnerContext(), visitor))
    8686            continue;
    8787
    88         heapRootMarker.mark(node->slot());
     88        heapRootVisitor.mark(node->slot());
    8989    }
    9090}

  • trunk/Source/JavaScriptCore/heap/HandleHeap.h

    r83885 r84556  
    3535
    3636class HandleHeap;
    37 class HeapRootMarker;
     37class HeapRootVisitor;
    3838class JSGlobalData;
    3939class JSValue;
    4040class MarkStack;
    4141class TypeCounter;
     42typedef MarkStack SlotVisitor;
    4243
    4344class WeakHandleOwner {
    4445public:
    4546    virtual ~WeakHandleOwner();
    46     virtual bool isReachableFromOpaqueRoots(Handle<Unknown>, void* context, MarkStack&);
     47    virtual bool isReachableFromOpaqueRoots(Handle<Unknown>, void* context, SlotVisitor&);
    4748    virtual void finalize(Handle<Unknown>, void* context);
    4849};
    … …  
    6263    HandleSlot copyWeak(HandleSlot);
    6364
    64     void markStrongHandles(HeapRootMarker&);
    65     void markWeakHandles(HeapRootMarker&);
     65    void markStrongHandles(HeapRootVisitor&);
     66    void markWeakHandles(HeapRootVisitor&);
    6667    void finalizeWeakHandles();
    6768

  • trunk/Source/JavaScriptCore/heap/HandleStack.cpp

    r83385 r84556  
    4040}
    4141
    42 void HandleStack::mark(HeapRootMarker& heapRootMarker)
     42void HandleStack::mark(HeapRootVisitor& heapRootMarker)
    4343{
    4444    const Vector<HandleSlot>& blocks = m_blockStack.blocks();

  • trunk/Source/JavaScriptCore/heap/HandleStack.h

    r83385 r84556  
    3636
    3737class LocalScope;
    38 class HeapRootMarker;
     38class HeapRootVisitor;
    3939
    4040class HandleStack {
    … …  
    5353    HandleSlot push();
    5454
    55     void mark(HeapRootMarker&);
     55    void mark(HeapRootVisitor&);
    5656
    5757private:

  • trunk/Source/JavaScriptCore/heap/Heap.cpp

    r83910 r84556  
    152152}
    153153
    154 void Heap::markProtectedObjects(HeapRootMarker& heapRootMarker)
     154void Heap::markProtectedObjects(HeapRootVisitor& heapRootMarker)
    155155{
    156156    ProtectCountSet::iterator end = m_protectedValues.end();
    … …  
    170170}
    171171   
    172 void Heap::markTempSortVectors(HeapRootMarker& heapRootMarker)
     172void Heap::markTempSortVectors(HeapRootVisitor& heapRootMarker)
    173173{
    174174    typedef Vector<Vector<ValueStringPair>* > VectorOfValueStringVectors;
    … …  
    208208    m_operationInProgress = Collection;
    209209
    210     MarkStack& markStack = m_markStack;
    211     HeapRootMarker heapRootMarker(markStack);
     210    MarkStack& visitor = m_markStack;
     211    HeapRootVisitor heapRootMarker(visitor);
    212212   
    213213    // We gather conservative roots before clearing mark bits because
    … …  
    222222    m_markedSpace.clearMarks();
    223223
    224     markStack.append(machineThreadRoots);
    225     markStack.drain();
    226 
    227     markStack.append(registerFileRoots);
    228     markStack.drain();
     224    visitor.append(machineThreadRoots);
     225    visitor.drain();
     226
     227    visitor.append(registerFileRoots);
     228    visitor.drain();
    229229
    230230    markProtectedObjects(heapRootMarker);
    231     markStack.drain();
     231    visitor.drain();
    232232   
    233233    markTempSortVectors(heapRootMarker);
    234     markStack.drain();
     234    visitor.drain();
    235235
    236236    if (m_markListSet && m_markListSet->size())
    … …  
    238238    if (m_globalData->exception)
    239239        heapRootMarker.mark(&m_globalData->exception);
    240     markStack.drain();
     240    visitor.drain();
    241241
    242242    m_handleHeap.markStrongHandles(heapRootMarker);
    243     markStack.drain();
     243    visitor.drain();
    244244
    245245    m_handleStack.mark(heapRootMarker);
    246     markStack.drain();
     246    visitor.drain();
    247247
    248248    // Mark the small strings cache as late as possible, since it will clear
    249249    // itself if nothing else has marked it.
    250250    // FIXME: Change the small strings cache to use Weak<T>.
    251     m_globalData->smallStrings.markChildren(heapRootMarker);
    252     markStack.drain();
     251    m_globalData->smallStrings.visitChildren(heapRootMarker);
     252    visitor.drain();
    253253   
    254254    // Weak handles must be marked last, because their owners use the set of
    … …  
    256256    int lastOpaqueRootCount;
    257257    do {
    258         lastOpaqueRootCount = markStack.opaqueRootCount();
     258        lastOpaqueRootCount = visitor.opaqueRootCount();
    259259        m_handleHeap.markWeakHandles(heapRootMarker);
    260         markStack.drain();
     260        visitor.drain();
    261261    // If the set of opaque roots has grown, more weak handles may have become reachable.
    262     } while (lastOpaqueRootCount != markStack.opaqueRootCount());
    263 
    264     markStack.reset();
     262    } while (lastOpaqueRootCount != visitor.opaqueRootCount());
     263
     264    visitor.reset();
    265265
    266266    m_operationInProgress = NoOperation;

  • trunk/Source/JavaScriptCore/heap/Heap.h

    r83418 r84556  
    3535    class GCActivityCallback;
    3636    class GlobalCodeBlock;
    37     class HeapRootMarker;
     37    class HeapRootVisitor;
    3838    class JSCell;
    3939    class JSGlobalData;
    … …  
    4545    class UString;
    4646    class WeakGCHandlePool;
     47    typedef MarkStack SlotVisitor;
    4748
    4849    typedef std::pair<JSValue, UString> ValueStringPair;
    … …  
    115116
    116117        void markRoots();
    117         void markProtectedObjects(HeapRootMarker&);
    118         void markTempSortVectors(HeapRootMarker&);
     118        void markProtectedObjects(HeapRootVisitor&);
     119        void markTempSortVectors(HeapRootVisitor&);
    119120
    120121        enum SweepToggle { DoNotSweep, DoSweep };

  • trunk/Source/JavaScriptCore/heap/MarkStack.cpp

    r84052 r84556  
    5555}
    5656
    57 inline void MarkStack::markChildren(JSCell* cell)
     57inline void MarkStack::visitChildren(JSCell* cell)
    5858{
    5959    ASSERT(Heap::isMarked(cell));
    6060    if (cell->structure()->typeInfo().type() < CompoundType) {
    61         cell->JSCell::markChildren(*this);
     61        cell->JSCell::visitChildren(*this);
    6262        return;
    6363    }
    6464
    65     if (!cell->structure()->typeInfo().overridesMarkChildren()) {
     65    if (!cell->structure()->typeInfo().overridesVisitChildren()) {
    6666        ASSERT(cell->isObject());
    6767#ifdef NDEBUG
    68         asObject(cell)->markChildrenDirect(*this);
     68        asObject(cell)->visitChildrenDirect(*this);
    6969#else
    7070        ASSERT(!m_isCheckingForDefaultMarkViolation);
    7171        m_isCheckingForDefaultMarkViolation = true;
    72         cell->markChildren(*this);
     72        cell->visitChildren(*this);
    7373        ASSERT(m_isCheckingForDefaultMarkViolation);
    7474        m_isCheckingForDefaultMarkViolation = false;
    … …  
    7777    }
    7878    if (cell->vptr() == m_jsArrayVPtr) {
    79         asArray(cell)->markChildrenDirect(*this);
     79        asArray(cell)->visitChildrenDirect(*this);
    8080        return;
    8181    }
    82     cell->markChildren(*this);
     82    cell->visitChildren(*this);
    8383}
    8484
    … …  
    112112
    113113            if (cell->structure()->typeInfo().type() < CompoundType) {
    114                 cell->JSCell::markChildren(*this);
     114                cell->JSCell::visitChildren(*this);
    115115                if (current.m_values == end) {
    116116                    m_markSets.removeLast();
    … …  
    123123                m_markSets.removeLast();
    124124
    125             markChildren(cell);
     125            visitChildren(cell);
    126126        }
    127127        while (!m_values.isEmpty())
    128             markChildren(m_values.removeLast());
     128            visitChildren(m_values.removeLast());
    129129    }
    130130#if !ASSERT_DISABLED

  • trunk/Source/JavaScriptCore/heap/MarkStack.h

    r84301 r84556  
    8181
    8282    private:
    83         friend class HeapRootMarker; // Allowed to mark a JSValue* or JSCell** directly.
     83        friend class HeapRootVisitor; // Allowed to mark a JSValue* or JSCell** directly.
    8484        void append(JSValue*);
    8585        void append(JSValue*, size_t count);
    … …  
    8888        void internalAppend(JSCell*);
    8989        void internalAppend(JSValue);
    90         void markChildren(JSCell*);
     90        void visitChildren(JSCell*);
    9191
    9292        struct MarkSet {
    … …  
    203203    };
    204204
     205    typedef MarkStack SlotVisitor;
     206
    205207    inline void MarkStack::append(JSValue* slot, size_t count)
    206208    {
    … …  
    244246    // All other references should be wrapped in WriteBarriers and marked through
    245247    // the MarkStack.
    246     class HeapRootMarker {
     248    class HeapRootVisitor {
    247249    private:
    248250        friend class Heap;
    249         HeapRootMarker(MarkStack&);
     251        HeapRootVisitor(SlotVisitor&);
    250252       
    251253    public:
    … …  
    255257        void mark(JSCell**);
    256258       
    257         MarkStack& markStack();
     259        SlotVisitor& visitor();
    258260
    259261    private:
    260         MarkStack& m_markStack;
     262        SlotVisitor& m_visitor;
    261263    };
    262264
    263     inline HeapRootMarker::HeapRootMarker(MarkStack& markStack)
    264         : m_markStack(markStack)
    265     {
    266     }
    267 
    268     inline void HeapRootMarker::mark(JSValue* slot)
    269     {
    270         m_markStack.append(slot);
    271     }
    272 
    273     inline void HeapRootMarker::mark(JSValue* slot, size_t count)
    274     {
    275         m_markStack.append(slot, count);
    276     }
    277 
    278     inline void HeapRootMarker::mark(JSString** slot)
    279     {
    280         m_markStack.append(reinterpret_cast<JSCell**>(slot));
    281     }
    282 
    283     inline void HeapRootMarker::mark(JSCell** slot)
    284     {
    285         m_markStack.append(slot);
    286     }
    287 
    288     inline MarkStack& HeapRootMarker::markStack()
    289     {
    290         return m_markStack;
     265    inline HeapRootVisitor::HeapRootVisitor(SlotVisitor& visitor)
     266        : m_visitor(visitor)
     267    {
     268    }
     269
     270    inline void HeapRootVisitor::mark(JSValue* slot)
     271    {
     272        m_visitor.append(slot);
     273    }
     274
     275    inline void HeapRootVisitor::mark(JSValue* slot, size_t count)
     276    {
     277        m_visitor.append(slot, count);
     278    }
     279
     280    inline void HeapRootVisitor::mark(JSString** slot)
     281    {
     282        m_visitor.append(reinterpret_cast<JSCell**>(slot));
     283    }
     284
     285    inline void HeapRootVisitor::mark(JSCell** slot)
     286    {
     287        m_visitor.append(slot);
     288    }
     289
     290    inline SlotVisitor& HeapRootVisitor::visitor()
     291    {
     292        return m_visitor;
    291293    }
    292294

  • trunk/Source/JavaScriptCore/heap/MarkedSpace.h

    r83506 r84556  
    4343    class MarkStack;
    4444    class WeakGCHandle;
     45    typedef MarkStack SlotVisitor;
    4546
    4647    class MarkedSpace {

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

    r81193 r84556  
    4040}
    4141
    42 void MarkedArgumentBuffer::markLists(HeapRootMarker& heapRootMarker, ListSet& markSet)
     42void MarkedArgumentBuffer::markLists(HeapRootVisitor& heapRootMarker, ListSet& markSet)
    4343{
    4444    ListSet::iterator end = markSet.end();

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

    r81193 r84556  
    3131
    3232    class MarkStack;
     33    typedef MarkStack SlotVisitor;
    3334
    3435    class MarkedArgumentBuffer {
    … …  
    142143        const_iterator end() const { return m_buffer + m_size; }
    143144
    144         static void markLists(HeapRootMarker&, ListSet&);
     145        static void markLists(HeapRootVisitor&, ListSet&);
    145146
    146147    private:

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

    r80285 r84556  
    4444}
    4545
    46 void Arguments::markChildren(MarkStack& markStack)
    47 {
    48     JSObject::markChildren(markStack);
     46void Arguments::visitChildren(SlotVisitor& visitor)
     47{
     48    JSObject::visitChildren(visitor);
    4949
    5050    if (d->registerArray)
    51         markStack.appendValues(d->registerArray.get(), d->numParameters);
     51        visitor.appendValues(d->registerArray.get(), d->numParameters);
    5252
    5353    if (d->extraArguments) {
    5454        unsigned numExtraArguments = d->numArguments - d->numParameters;
    55         markStack.appendValues(d->extraArguments, numExtraArguments);
    56     }
    57 
    58     markStack.append(&d->callee);
     55        visitor.appendValues(d->extraArguments, numExtraArguments);
     56    }
     57
     58    visitor.append(&d->callee);
    5959
    6060    if (d->activation)
    61         markStack.append(&d->activation);
     61        visitor.append(&d->activation);
    6262}
    6363

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

    r84052 r84556  
    7272        static const ClassInfo s_info;
    7373
    74         virtual void markChildren(MarkStack&);
     74        virtual void visitChildren(SlotVisitor&);
    7575
    7676        void fillArgList(ExecState*, MarkedArgumentBuffer&);
    … …  
    9999
    100100    protected:
    101         static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesMarkChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
     101        static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesVisitChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
    102102
    103103    private:

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

    r84052 r84556  
    136136}
    137137
    138 void EvalExecutable::markChildren(MarkStack& markStack)
    139 {
    140     ScriptExecutable::markChildren(markStack);
     138void EvalExecutable::visitChildren(SlotVisitor& visitor)
     139{
     140    ScriptExecutable::visitChildren(visitor);
    141141    if (m_evalCodeBlock)
    142         m_evalCodeBlock->markAggregate(markStack);
     142        m_evalCodeBlock->visitAggregate(visitor);
    143143}
    144144
    … …  
    222222#endif
    223223
    224 void ProgramExecutable::markChildren(MarkStack& markStack)
    225 {
    226     ScriptExecutable::markChildren(markStack);
     224void ProgramExecutable::visitChildren(SlotVisitor& visitor)
     225{
     226    ScriptExecutable::visitChildren(visitor);
    227227    if (m_programCodeBlock)
    228         m_programCodeBlock->markAggregate(markStack);
     228        m_programCodeBlock->visitAggregate(visitor);
    229229}
    230230
    … …  
    322322}
    323323
    324 void FunctionExecutable::markChildren(MarkStack& markStack)
    325 {
    326     ScriptExecutable::markChildren(markStack);
     324void FunctionExecutable::visitChildren(SlotVisitor& visitor)
     325{
     326    ScriptExecutable::visitChildren(visitor);
    327327    if (m_codeBlockForCall)
    328         m_codeBlockForCall->markAggregate(markStack);
     328        m_codeBlockForCall->visitAggregate(visitor);
    329329    if (m_codeBlockForConstruct)
    330         m_codeBlockForConstruct->markAggregate(markStack);
     330        m_codeBlockForConstruct->visitAggregate(visitor);
    331331}
    332332

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

    r84052 r84556  
    236236
    237237    private:
    238         static const unsigned StructureFlags = OverridesMarkChildren | ScriptExecutable::StructureFlags;
     238        static const unsigned StructureFlags = OverridesVisitChildren | ScriptExecutable::StructureFlags;
    239239        static const ClassInfo s_info;
    240240        EvalExecutable(ExecState*, const SourceCode&, bool);
    241241
    242242        JSObject* compileInternal(ExecState*, ScopeChainNode*);
    243         virtual void markChildren(MarkStack&);
     243        virtual void visitChildren(SlotVisitor&);
    244244
    245245        OwnPtr<EvalCodeBlock> m_evalCodeBlock;
    … …  
    283283
    284284    private:
    285         static const unsigned StructureFlags = OverridesMarkChildren | ScriptExecutable::StructureFlags;
     285        static const unsigned StructureFlags = OverridesVisitChildren | ScriptExecutable::StructureFlags;
    286286        static const ClassInfo s_info;
    287287        ProgramExecutable(ExecState*, const SourceCode&);
    288288
    289289        JSObject* compileInternal(ExecState*, ScopeChainNode*);
    290         virtual void markChildren(MarkStack&);
     290        virtual void visitChildren(SlotVisitor&);
    291291
    292292        OwnPtr<ProgramCodeBlock> m_programCodeBlock;
    … …  
    371371
    372372        void discardCode();
    373         void markChildren(MarkStack&);
     373        void visitChildren(SlotVisitor&);
    374374        static FunctionExecutable* fromGlobalCode(const Identifier&, ExecState*, Debugger*, const SourceCode&, JSObject** exception);
    375375        static Structure* createStructure(JSGlobalData& globalData, JSValue proto) { return Structure::create(globalData, proto, TypeInfo(CompoundType, StructureFlags), AnonymousSlotCount, 0); }
    … …  
    382382        JSObject* compileForConstructInternal(ExecState*, ScopeChainNode*);
    383383       
    384         static const unsigned StructureFlags = OverridesMarkChildren | ScriptExecutable::StructureFlags;
     384        static const unsigned StructureFlags = OverridesVisitChildren | ScriptExecutable::StructureFlags;
    385385        static const ClassInfo s_info;
    386386        unsigned m_numCapturedVariables : 31;

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

    r77151 r84556  
    2929namespace JSC {
    3030
    31 void GetterSetter::markChildren(MarkStack& markStack)
     31void GetterSetter::visitChildren(SlotVisitor& visitor)
    3232{
    33     JSCell::markChildren(markStack);
     33    JSCell::visitChildren(visitor);
    3434
    3535    if (m_getter)
    36         markStack.append(&m_getter);
     36        visitor.append(&m_getter);
    3737    if (m_setter)
    38         markStack.append(&m_setter);
     38        visitor.append(&m_setter);
    3939}
    4040

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

    r84052 r84556  
    4343        }
    4444
    45         virtual void markChildren(MarkStack&);
     45        virtual void visitChildren(SlotVisitor&);
    4646
    4747        JSObject* getter() const { return m_getter.get(); }
    … …  
    5151        static Structure* createStructure(JSGlobalData& globalData, JSValue prototype)
    5252        {
    53             return Structure::create(globalData, prototype, TypeInfo(GetterSetterType, OverridesMarkChildren), AnonymousSlotCount, 0);
     53            return Structure::create(globalData, prototype, TypeInfo(GetterSetterType, OverridesVisitChildren), AnonymousSlotCount, 0);
    5454        }
    5555    private:

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

    r84052 r84556  
    3939        static Structure* createStructure(JSGlobalData& globalData, JSValue prototype)
    4040        {
    41             return Structure::create(globalData, prototype, TypeInfo(CompoundType, OverridesMarkChildren | OverridesGetPropertyNames), AnonymousSlotCount, 0);
     41            return Structure::create(globalData, prototype, TypeInfo(CompoundType, OverridesVisitChildren | OverridesGetPropertyNames), AnonymousSlotCount, 0);
    4242        }
    4343

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

    r84052 r84556  
    5959}
    6060
    61 void JSActivation::markChildren(MarkStack& markStack)
    62 {
    63     Base::markChildren(markStack);
     61void JSActivation::visitChildren(SlotVisitor& visitor)
     62{
     63    Base::visitChildren(visitor);
    6464
    6565    // No need to mark our registers if they're still in the RegisterFile.
    … …  
    6868        return;
    6969
    70     markStack.appendValues(registerArray, m_numParametersMinusThis);
     70    visitor.appendValues(registerArray, m_numParametersMinusThis);
    7171
    7272    // Skip the call frame, which sits between the parameters and vars.
    73     markStack.appendValues(registerArray + m_numParametersMinusThis + RegisterFile::CallFrameHeaderSize, m_numCapturedVars, MayContainNullValues);
     73    visitor.appendValues(registerArray + m_numParametersMinusThis + RegisterFile::CallFrameHeaderSize, m_numCapturedVars, MayContainNullValues);
    7474}
    7575

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

    r84052 r84556  
    4646        virtual ~JSActivation();
    4747
    48         virtual void markChildren(MarkStack&);
     48        virtual void visitChildren(SlotVisitor&);
    4949
    5050        virtual bool isDynamicScope(bool& requiresDynamicChecks) const;
    … …  
    7070
    7171    protected:
    72         static const unsigned StructureFlags = OverridesGetOwnPropertySlot | NeedsThisConversion | OverridesMarkChildren | OverridesGetPropertyNames | JSVariableObject::StructureFlags;
     72        static const unsigned StructureFlags = OverridesGetOwnPropertySlot | NeedsThisConversion | OverridesVisitChildren | OverridesGetPropertyNames | JSVariableObject::StructureFlags;
    7373
    7474    private:

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

    r84052 r84556  
    858858}
    859859
    860 void JSArray::markChildren(MarkStack& markStack)
    861 {
    862     markChildrenDirect(markStack);
     860void JSArray::visitChildren(SlotVisitor& visitor)
     861{
     862    visitChildrenDirect(visitor);
    863863}
    864864

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

    r84052 r84556  
    129129        }
    130130       
    131         inline void markChildrenDirect(MarkStack& markStack);
     131        inline void visitChildrenDirect(SlotVisitor&);
    132132
    133133        static ptrdiff_t storageOffset()
    … …  
    142142
    143143    protected:
    144         static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesMarkChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
     144        static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesVisitChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
    145145        virtual void put(ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
    146146        virtual bool deleteProperty(ExecState*, const Identifier& propertyName);
    147147        virtual bool deleteProperty(ExecState*, unsigned propertyName);
    148148        virtual void getOwnPropertyNames(ExecState*, PropertyNameArray&, EnumerationMode mode = ExcludeDontEnumProperties);
    149         virtual void markChildren(MarkStack&);
     149        virtual void visitChildren(SlotVisitor&);
    150150
    151151        void* subclassData() const;
    … …  
    186186    inline bool isJSArray(JSGlobalData* globalData, JSValue v) { return v.isCell() && isJSArray(globalData, v.asCell()); }
    187187
    188     inline void JSArray::markChildrenDirect(MarkStack& markStack)
    189     {
    190         JSObject::markChildrenDirect(markStack);
     188    inline void JSArray::visitChildrenDirect(SlotVisitor& visitor)
     189    {
     190        JSObject::visitChildrenDirect(visitor);
    191191       
    192192        ArrayStorage* storage = m_storage;
    193193
    194194        unsigned usedVectorLength = std::min(storage->m_length, m_vectorLength);
    195         markStack.appendValues(storage->m_vector, usedVectorLength, MayContainNullValues);
     195        visitor.appendValues(storage->m_vector, usedVectorLength, MayContainNullValues);
    196196
    197197        if (SparseArrayValueMap* map = storage->m_sparseValueMap) {
    198198            SparseArrayValueMap::iterator end = map->end();
    199199            for (SparseArrayValueMap::iterator it = map->begin(); it != end; ++it)
    200                 markStack.append(&it->second);
     200                visitor.append(&it->second);
    201201        }
    202202    }

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

    r84052 r84556  
    119119        void* operator new(size_t, void* placementNewDestination) { return placementNewDestination; }
    120120
    121         virtual void markChildren(MarkStack&);
     121        virtual void visitChildren(SlotVisitor&);
    122122#if ENABLE(JSC_ZOMBIES)
    123123        virtual bool isZombie() const { return false; }
    … …  
    179179    }
    180180
    181     inline void JSCell::markChildren(MarkStack& markStack)
    182     {
    183         markStack.append(&m_structure);
     181    inline void JSCell::visitChildren(SlotVisitor& visitor)
     182    {
     183        visitor.append(&m_structure);
    184184    }
    185185

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

    r84052 r84556  
    134134}
    135135
    136 void JSFunction::markChildren(MarkStack& markStack)
    137 {
    138     Base::markChildren(markStack);
    139 
    140     markStack.append(&m_scopeChain);
     136void JSFunction::visitChildren(SlotVisitor& visitor)
     137{
     138    Base::visitChildren(visitor);
     139
     140    visitor.append(&m_scopeChain);
    141141    if (m_executable) {
    142142        // Delightful race condition: m_executable may not have been initialised
    143143        // if this is a host function, as the executable isn't necessarily created
    144144        // until after the function has been allocated.
    145         markStack.append(&m_executable);
     145        visitor.append(&m_executable);
    146146    }
    147147}

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

    r84052 r84556  
    8585
    8686    protected:
    87         const static unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesMarkChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
     87        const static unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesVisitChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
    8888
    8989    private:
    … …  
    9898        virtual bool deleteProperty(ExecState*, const Identifier& propertyName);
    9999
    100         virtual void markChildren(MarkStack&);
     100        virtual void visitChildren(SlotVisitor&);
    101101
    102102        static JSValue argumentsGetter(ExecState*, JSValue, const Identifier&);

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

    r84052 r84556  
    7979static const int preferredScriptCheckTimeInterval = 1000;
    8080
    81 template <typename T> static inline void markIfNeeded(MarkStack& markStack, WriteBarrier<T>* v)
     81template <typename T> static inline void visitIfNeeded(SlotVisitor& visitor, WriteBarrier<T>* v)
    8282{
    8383    if (*v)
    84         markStack.append(v);
     84        visitor.append(v);
    8585}
    8686
    … …  
    308308}
    309309
    310 void JSGlobalObject::markChildren(MarkStack& markStack)
    311 {
    312     JSVariableObject::markChildren(markStack);
    313 
    314     markIfNeeded(markStack, &m_globalScopeChain);
    315     markIfNeeded(markStack, &m_methodCallDummy);
    316 
    317     markIfNeeded(markStack, &m_regExpConstructor);
    318     markIfNeeded(markStack, &m_errorConstructor);
    319     markIfNeeded(markStack, &m_evalErrorConstructor);
    320     markIfNeeded(markStack, &m_rangeErrorConstructor);
    321     markIfNeeded(markStack, &m_referenceErrorConstructor);
    322     markIfNeeded(markStack, &m_syntaxErrorConstructor);
    323     markIfNeeded(markStack, &m_typeErrorConstructor);
    324     markIfNeeded(markStack, &m_URIErrorConstructor);
    325 
    326     markIfNeeded(markStack, &m_evalFunction);
    327     markIfNeeded(markStack, &m_callFunction);
    328     markIfNeeded(markStack, &m_applyFunction);
    329 
    330     markIfNeeded(markStack, &m_objectPrototype);
    331     markIfNeeded(markStack, &m_functionPrototype);
    332     markIfNeeded(markStack, &m_arrayPrototype);
    333     markIfNeeded(markStack, &m_booleanPrototype);
    334     markIfNeeded(markStack, &m_stringPrototype);
    335     markIfNeeded(markStack, &m_numberPrototype);
    336     markIfNeeded(markStack, &m_datePrototype);
    337     markIfNeeded(markStack, &m_regExpPrototype);
    338 
    339     markIfNeeded(markStack, &m_argumentsStructure);
    340     markIfNeeded(markStack, &m_arrayStructure);
    341     markIfNeeded(markStack, &m_booleanObjectStructure);
    342     markIfNeeded(markStack, &m_callbackConstructorStructure);
    343     markIfNeeded(markStack, &m_callbackFunctionStructure);
    344     markIfNeeded(markStack, &m_callbackObjectStructure);
    345     markIfNeeded(markStack, &m_dateStructure);
    346     markIfNeeded(markStack, &m_emptyObjectStructure);
    347     markIfNeeded(markStack, &m_errorStructure);
    348     markIfNeeded(markStack, &m_functionStructure);
    349     markIfNeeded(markStack, &m_numberObjectStructure);
    350     markIfNeeded(markStack, &m_regExpMatchesArrayStructure);
    351     markIfNeeded(markStack, &m_regExpStructure);
    352     markIfNeeded(markStack, &m_stringObjectStructure);
    353     markIfNeeded(markStack, &m_internalFunctionStructure);
     310void JSGlobalObject::visitChildren(SlotVisitor& visitor)
     311{
     312    JSVariableObject::visitChildren(visitor);
     313
     314    visitIfNeeded(visitor, &m_globalScopeChain);
     315    visitIfNeeded(visitor, &m_methodCallDummy);
     316
     317    visitIfNeeded(visitor, &m_regExpConstructor);
     318    visitIfNeeded(visitor, &m_errorConstructor);
     319    visitIfNeeded(visitor, &m_evalErrorConstructor);
     320    visitIfNeeded(visitor, &m_rangeErrorConstructor);
     321    visitIfNeeded(visitor, &m_referenceErrorConstructor);
     322    visitIfNeeded(visitor, &m_syntaxErrorConstructor);
     323    visitIfNeeded(visitor, &m_typeErrorConstructor);
     324    visitIfNeeded(visitor, &m_URIErrorConstructor);
     325
     326    visitIfNeeded(visitor, &m_evalFunction);
     327    visitIfNeeded(visitor, &m_callFunction);
     328    visitIfNeeded(visitor, &m_applyFunction);
     329
     330    visitIfNeeded(visitor, &m_objectPrototype);
     331    visitIfNeeded(visitor, &m_functionPrototype);
     332    visitIfNeeded(visitor, &m_arrayPrototype);
     333    visitIfNeeded(visitor, &m_booleanPrototype);
     334    visitIfNeeded(visitor, &m_stringPrototype);
     335    visitIfNeeded(visitor, &m_numberPrototype);
     336    visitIfNeeded(visitor, &m_datePrototype);
     337    visitIfNeeded(visitor, &m_regExpPrototype);
     338
     339    visitIfNeeded(visitor, &m_argumentsStructure);
     340    visitIfNeeded(visitor, &m_arrayStructure);
     341    visitIfNeeded(visitor, &m_booleanObjectStructure);
     342    visitIfNeeded(visitor, &m_callbackConstructorStructure);
     343    visitIfNeeded(visitor, &m_callbackFunctionStructure);
     344    visitIfNeeded(visitor, &m_callbackObjectStructure);
     345    visitIfNeeded(visitor, &m_dateStructure);
     346    visitIfNeeded(visitor, &m_emptyObjectStructure);
     347    visitIfNeeded(visitor, &m_errorStructure);
     348    visitIfNeeded(visitor, &m_functionStructure);
     349    visitIfNeeded(visitor, &m_numberObjectStructure);
     350    visitIfNeeded(visitor, &m_regExpMatchesArrayStructure);
     351    visitIfNeeded(visitor, &m_regExpStructure);
     352    visitIfNeeded(visitor, &m_stringObjectStructure);
     353    visitIfNeeded(visitor, &m_internalFunctionStructure);
    354354
    355355    if (m_registerArray) {
    356356        // Outside the execution of global code, when our variables are torn off,
    357357        // we can mark the torn-off array.
    358         markStack.appendValues(m_registerArray.get(), m_registerArraySize);
     358        visitor.appendValues(m_registerArray.get(), m_registerArraySize);
    359359    } else if (m_registers) {
    360360        // During execution of global code, when our variables are in the register file,
    361361        // the symbol table tells us how many variables there are, and registers
    362362        // points to where they end, and the registers used for execution begin.
    363         markStack.appendValues(m_registers - symbolTable().size(), symbolTable().size());
     363        visitor.appendValues(m_registers - symbolTable().size(), symbolTable().size());
    364364    }
    365365}

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

    r84052 r84556  
    152152        virtual ~JSGlobalObject();
    153153
    154         virtual void markChildren(MarkStack&);
     154        virtual void visitChildren(SlotVisitor&);
    155155
    156156        virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
    … …  
    259259
    260260        static const unsigned AnonymousSlotCount = JSVariableObject::AnonymousSlotCount + 1;
    261         static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesMarkChildren | OverridesGetPropertyNames | JSVariableObject::StructureFlags;
     261        static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesVisitChildren | OverridesGetPropertyNames | JSVariableObject::StructureFlags;
    262262
    263263        struct GlobalPropertyInfo {

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

    r84052 r84556  
    8080    Local<Unknown> stringify(Handle<Unknown>);
    8181
    82     void markAggregate(MarkStack&);
     82    void visitAggregate(SlotVisitor&);
    8383
    8484private:

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

    r84052 r84556  
    6969}
    7070
    71 void JSObject::markChildren(MarkStack& markStack)
     71void JSObject::visitChildren(SlotVisitor& visitor)
    7272{
    7373#ifndef NDEBUG
    74     bool wasCheckingForDefaultMarkViolation = markStack.m_isCheckingForDefaultMarkViolation;
    75     markStack.m_isCheckingForDefaultMarkViolation = false;
     74    bool wasCheckingForDefaultMarkViolation = visitor.m_isCheckingForDefaultMarkViolation;
     75    visitor.m_isCheckingForDefaultMarkViolation = false;
    7676#endif
    7777
    78     markChildrenDirect(markStack);
     78    visitChildrenDirect(visitor);
    7979
    8080#ifndef NDEBUG
    81     markStack.m_isCheckingForDefaultMarkViolation = wasCheckingForDefaultMarkViolation;
     81    visitor.m_isCheckingForDefaultMarkViolation = wasCheckingForDefaultMarkViolation;
    8282#endif
    8383}

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

    r84052 r84556  
    8080
    8181    public:
    82         virtual void markChildren(MarkStack&);
    83         ALWAYS_INLINE void markChildrenDirect(MarkStack& markStack);
     82        virtual void visitChildren(SlotVisitor&);
     83        ALWAYS_INLINE void visitChildrenDirect(SlotVisitor&);
    8484
    8585        // The inline virtual destructor cannot be the first virtual function declared
    … …  
    821821}
    822822
    823 ALWAYS_INLINE void JSObject::markChildrenDirect(MarkStack& markStack)
    824 {
    825     JSCell::markChildren(markStack);
     823ALWAYS_INLINE void JSObject::visitChildrenDirect(SlotVisitor& visitor)
     824{
     825    JSCell::visitChildren(visitor);
    826826
    827827    PropertyStorage storage = propertyStorage();
    828828    size_t storageSize = m_structure->propertyStorageSize();
    829     markStack.appendValues(storage, storageSize);
     829    visitor.appendValues(storage, storageSize);
    830830    if (m_inheritorID)
    831         markStack.append(&m_inheritorID);
     831        visitor.append(&m_inheritorID);
    832832}
    833833

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

    r84052 r84556  
    9696}
    9797
    98 void JSPropertyNameIterator::markChildren(MarkStack& markStack)
     98void JSPropertyNameIterator::visitChildren(SlotVisitor& visitor)
    9999{
    100     markStack.appendValues(m_jsStrings.get(), m_jsStringsSize, MayContainNullValues);
     100    visitor.appendValues(m_jsStrings.get(), m_jsStringsSize, MayContainNullValues);
    101101    if (m_cachedPrototypeChain)
    102         markStack.append(&m_cachedPrototypeChain);
     102        visitor.append(&m_cachedPrototypeChain);
    103103}
    104104

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

    r84052 r84556  
    4848        static Structure* createStructure(JSGlobalData& globalData, JSValue prototype)
    4949        {
    50             return Structure::create(globalData, prototype, TypeInfo(CompoundType, OverridesMarkChildren), AnonymousSlotCount, &s_info);
     50            return Structure::create(globalData, prototype, TypeInfo(CompoundType, OverridesVisitChildren), AnonymousSlotCount, &s_info);
    5151        }
    5252
    5353        virtual bool isPropertyNameIterator() const { return true; }
    5454
    55         virtual void markChildren(MarkStack&);
     55        virtual void visitChildren(SlotVisitor&);
    5656
    5757        bool getOffset(size_t i, int& offset)

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

    r80742 r84556  
    3131ASSERT_CLASS_FITS_IN_CELL(JSStaticScopeObject);
    3232
    33 void JSStaticScopeObject::markChildren(MarkStack& markStack)
     33void JSStaticScopeObject::visitChildren(SlotVisitor& visitor)
    3434{
    35     JSVariableObject::markChildren(markStack);
    36     markStack.append(&m_registerStore);
     35    JSVariableObject::visitChildren(visitor);
     36    visitor.append(&m_registerStore);
    3737}
    3838

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

    r84052 r84556  
    4040        }
    4141
    42         virtual void markChildren(MarkStack&);
     42        virtual void visitChildren(SlotVisitor&);
    4343        bool isDynamicScope(bool& requiresDynamicChecks) const;
    4444        virtual JSObject* toThisObject(ExecState*) const;
    … …  
    5151
    5252    protected:
    53         static const unsigned StructureFlags = OverridesGetOwnPropertySlot | NeedsThisConversion | OverridesMarkChildren | OverridesGetPropertyNames | JSVariableObject::StructureFlags;
     53        static const unsigned StructureFlags = OverridesGetOwnPropertySlot | NeedsThisConversion | OverridesVisitChildren | OverridesGetPropertyNames | JSVariableObject::StructureFlags;
    5454
    5555    private:

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

    r84052 r84556  
    4242    static const unsigned NeedsThisConversion = 1 << 4;
    4343    static const unsigned OverridesGetOwnPropertySlot = 1 << 5;
    44     static const unsigned OverridesMarkChildren = 1 << 6;
     44    static const unsigned OverridesVisitChildren = 1 << 6;
    4545    static const unsigned OverridesGetPropertyNames = 1 << 7;
    4646    static const unsigned IsJSFinalObject = 1 << 8;
    … …  
    5555            ASSERT(flags <= 0x1FF);
    5656            ASSERT(type <= 0xFF);
    57             ASSERT(type >= CompoundType || !(flags & OverridesMarkChildren));
     57            ASSERT(type >= CompoundType || !(flags & OverridesVisitChildren));
    5858            // ImplementsDefaultHasInstance means (ImplementsHasInstance & !OverridesHasInstance)
    5959            if ((m_flags & (ImplementsHasInstance | OverridesHasInstance)) == ImplementsHasInstance)
    … …  
    6868        bool needsThisConversion() const { return m_flags & NeedsThisConversion; }
    6969        bool overridesGetOwnPropertySlot() const { return m_flags & OverridesGetOwnPropertySlot; }
    70         bool overridesMarkChildren() const { return m_flags & OverridesMarkChildren; }
     70        bool overridesVisitChildren() const { return m_flags & OverridesVisitChildren; }
    7171        bool overridesGetPropertyNames() const { return m_flags & OverridesGetPropertyNames; }
    7272        unsigned flags() const { return m_flags; }

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

    r77151 r84556  
    2727ASSERT_CLASS_FITS_IN_CELL(JSWrapperObject);
    2828
    29 void JSWrapperObject::markChildren(MarkStack& markStack)
     29void JSWrapperObject::visitChildren(SlotVisitor& visitor)
    3030{
    31     JSObject::markChildren(markStack);
     31    JSObject::visitChildren(visitor);
    3232    if (m_internalValue)
    33         markStack.append(&m_internalValue);
     33        visitor.append(&m_internalValue);
    3434}
    3535

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

    r84052 r84556  
    4343
    4444    protected:
    45         static const unsigned StructureFlags = OverridesMarkChildren | JSNonFinalObject::StructureFlags;
     45        static const unsigned StructureFlags = OverridesVisitChildren | JSNonFinalObject::StructureFlags;
    4646
    4747    private:
    48         virtual void markChildren(MarkStack&);
     48        virtual void visitChildren(SlotVisitor&);
    4949       
    5050        WriteBarrier<Unknown> m_internalValue;

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

    r84052 r84556  
    5656    virtual UString toString(ExecState*) const { ASSERT_NOT_REACHED(); return ""; }
    5757    virtual JSObject* toObject(ExecState*) const { ASSERT_NOT_REACHED(); return 0; }
    58     virtual void markChildren(MarkStack&) { ASSERT_NOT_REACHED(); }
     58    virtual void visitChildren(SlotVisitor&) { ASSERT_NOT_REACHED(); }
    5959    virtual void put(ExecState*, const Identifier&, JSValue, PutPropertySlot&) { ASSERT_NOT_REACHED(); }
    6060    virtual void put(ExecState*, unsigned, JSValue) { ASSERT_NOT_REACHED(); }

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

    r84052 r84556  
    4747}
    4848
    49 void NativeErrorConstructor::markChildren(MarkStack& markStack)
     49void NativeErrorConstructor::visitChildren(SlotVisitor& visitor)
    5050{
    51     InternalFunction::markChildren(markStack);
     51    InternalFunction::visitChildren(visitor);
    5252    if (m_errorStructure)
    53         markStack.append(&m_errorStructure);
     53        visitor.append(&m_errorStructure);
    5454}
    5555

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

    r84052 r84556  
    4444
    4545    private:
    46         static const unsigned StructureFlags = OverridesMarkChildren | InternalFunction::StructureFlags;
     46        static const unsigned StructureFlags = OverridesVisitChildren | InternalFunction::StructureFlags;
    4747        virtual ConstructType getConstructData(ConstructData&);
    4848        virtual CallType getCallData(CallData&);
    49         virtual void markChildren(MarkStack&);
     49        virtual void visitChildren(SlotVisitor&);
    5050
    5151        WriteBarrier<Structure> m_errorStructure;

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

    r84052 r84556  
    7373}
    7474
    75 void RegExpObject::markChildren(MarkStack& markStack)
     75void RegExpObject::visitChildren(SlotVisitor& visitor)
    7676{
    77     Base::markChildren(markStack);
     77    Base::visitChildren(visitor);
    7878    if (UNLIKELY(!d->lastIndex.get().isInt32()))
    79         markStack.append(&d->lastIndex);
     79        visitor.append(&d->lastIndex);
    8080}
    8181

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

    r84052 r84556  
    6565
    6666    protected:
    67         static const unsigned StructureFlags = OverridesMarkChildren | OverridesGetOwnPropertySlot | JSObjectWithGlobalObject::StructureFlags;
     67        static const unsigned StructureFlags = OverridesVisitChildren | OverridesGetOwnPropertySlot | JSObjectWithGlobalObject::StructureFlags;
    6868
    6969    private:
    70         virtual void markChildren(MarkStack&);
     70        virtual void visitChildren(SlotVisitor&);
    7171
    7272        bool match(ExecState*);

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

    r82971 r84556  
    6868}
    6969
    70 void ScopeChainNode::markChildren(MarkStack& markStack)
     70void ScopeChainNode::visitChildren(SlotVisitor& visitor)
    7171{
    7272    if (next)
    73         markStack.append(&next);
    74     markStack.append(&object);
    75     markStack.append(&globalObject);
    76     markStack.append(&globalThis);
     73        visitor.append(&next);
     74    visitor.append(&object);
     75    visitor.append(&globalObject);
     76    visitor.append(&globalThis);
    7777}
    7878

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

    r84052 r84556  
    3333    class MarkStack;
    3434    class ScopeChainIterator;
     35    typedef MarkStack SlotVisitor;
    3536   
    3637    class ScopeChainNode : public JSCell {
    … …  
    6768       
    6869        static Structure* createStructure(JSGlobalData& globalData, JSValue proto) { return Structure::create(globalData, proto, TypeInfo(CompoundType, StructureFlags), AnonymousSlotCount, &s_info); }
    69         virtual void markChildren(MarkStack&);
     70        virtual void visitChildren(SlotVisitor&);
    7071    private:
    71         static const unsigned StructureFlags = OverridesMarkChildren;
     72        static const unsigned StructureFlags = OverridesVisitChildren;
    7273        static const ClassInfo s_info;
    7374    };

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

    r81191 r84556  
    7575}
    7676
    77 void SmallStrings::markChildren(HeapRootMarker& heapRootMarker)
     77void SmallStrings::visitChildren(HeapRootVisitor& heapRootMarker)
    7878{
    7979    /*

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

    r81191 r84556  
    3434namespace JSC {
    3535
    36     class HeapRootMarker;
     36    class HeapRootVisitor;
    3737    class JSGlobalData;
    3838    class JSString;
    3939    class MarkStack;
    4040    class SmallStringsStorage;
     41    typedef MarkStack SlotVisitor;
    4142
    4243    static const unsigned maxSingleCharacterString = 0xFF;
    … …  
    6465        StringImpl* singleCharacterStringRep(unsigned char character);
    6566
    66         void markChildren(HeapRootMarker&);
     67        void visitChildren(HeapRootVisitor&);
    6768        void clear();
    6869

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

    r84121 r84556  
    199199Structure::Structure(JSGlobalData& globalData)
    200200    : JSCell(globalData, this)
    201     , m_typeInfo(CompoundType, OverridesMarkChildren)
     201    , m_typeInfo(CompoundType, OverridesVisitChildren)
    202202    , m_prototype(globalData, this, jsNull())
    203203    , m_classInfo(&s_info)
    … …  
    766766}
    767767
    768 void Structure::markChildren(MarkStack& markStack)
    769 {
    770     JSCell::markChildren(markStack);
     768void Structure::visitChildren(SlotVisitor& visitor)
     769{
     770    JSCell::visitChildren(visitor);
    771771    if (m_prototype)
    772         markStack.append(&m_prototype);
     772        visitor.append(&m_prototype);
    773773    if (m_cachedPrototypeChain)
    774         markStack.append(&m_cachedPrototypeChain);
     774        visitor.append(&m_cachedPrototypeChain);
    775775    if (m_previous)
    776         markStack.append(&m_previous);
     776        visitor.append(&m_previous);
    777777    if (m_specificValueInPrevious)
    778         markStack.append(&m_specificValueInPrevious);
     778        visitor.append(&m_specificValueInPrevious);
    779779    if (m_enumerationCache)
    780         markStack.append(&m_enumerationCache);
     780        visitor.append(&m_enumerationCache);
    781781    if (m_propertyTable) {
    782782        PropertyTable::iterator end = m_propertyTable->end();
    783783        for (PropertyTable::iterator ptr = m_propertyTable->begin(); ptr != end; ++ptr) {
    784784            if (ptr->specificValue)
    785                 markStack.append(&ptr->specificValue);
     785                visitor.append(&ptr->specificValue);
    786786        }
    787787    }

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

    r84121 r84556  
    4848    class PropertyNameArrayData;
    4949    class StructureChain;
     50    typedef MarkStack SlotVisitor;
    5051
    5152    struct ClassInfo;
    … …  
    100101        JSValue prototypeForLookup(ExecState*) const;
    101102        StructureChain* prototypeChain(ExecState*) const;
    102         void markChildren(MarkStack&);
     103        void visitChildren(SlotVisitor&);
    103104
    104105        Structure* previousID() const { return m_previous.get(); }

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

    r84052 r84556  
    5454}
    5555
    56 void StructureChain::markChildren(MarkStack& markStack)
     56void StructureChain::visitChildren(SlotVisitor& visitor)
    5757{
    5858    size_t i = 0;
    5959    while (m_vector[i])
    60         markStack.append(&m_vector[i++]);
     60        visitor.append(&m_vector[i++]);
    6161}
    6262

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

    r84052 r84556  
    4545        static StructureChain* create(JSGlobalData& globalData, Structure* head) { return new (&globalData) StructureChain(globalData, globalData.structureChainStructure.get(), head); }
    4646        WriteBarrier<Structure>* head() { return m_vector.get(); }
    47         void markChildren(MarkStack&);
     47        void visitChildren(SlotVisitor&);
    4848
    49         static Structure* createStructure(JSGlobalData& globalData, JSValue prototype) { return Structure::create(globalData, prototype, TypeInfo(CompoundType, OverridesMarkChildren), 0, &s_info); }
     49        static Structure* createStructure(JSGlobalData& globalData, JSValue prototype) { return Structure::create(globalData, prototype, TypeInfo(CompoundType, OverridesVisitChildren), 0, &s_info); }
    5050
    5151    private:

  • trunk/Source/JavaScriptGlue/ChangeLog

    r84290 r84556  
     12011-04-21  Oliver Hunt  <oliver@apple.com>
     2
     3        Reviewed by Geoffrey Garen.
     4
     5        Start moving to a general visitor pattern for GC traversal
     6        https://bugs.webkit.org/show_bug.cgi?id=59141
     7
     8        This is just a rename:
     9            markChildren -> visitChildren
     10            markAggregate -> visitAggregate
     11            markStack -> visitor
     12            MarkStack -> typedef'd to SlotVisitor
     13
     14        * UserObjectImp.cpp:
     15        (UserObjectImp::visitChildren):
     16
    1172011-04-19  Renata Hodovan  <reni@webkit.org>
    218

  • trunk/Source/JavaScriptGlue/UserObjectImp.cpp

    r84052 r84556  
    405405}
    406406
    407 void UserObjectImp::markChildren(MarkStack& markStack)
    408 {
    409     JSObject::markChildren(markStack);
     407void UserObjectImp::visitChildren(SlotVisitor& visitor)
     408{
     409    JSObject::visitChildren(visitor);
    410410    if (fJSUserObject)
    411411        fJSUserObject->Mark();

  • trunk/Source/JavaScriptGlue/UserObjectImp.h

    r84052 r84556  
    5555    virtual UString toString(ExecState *exec) const;
    5656
    57     virtual void markChildren(MarkStack&);
     57    virtual void visitChildren(SlotVisitor&);
    5858
    5959    JSUserObject *GetJSUserObject() const;
    … …  
    6161    static Structure* createStructure(JSGlobalData& globalData, JSValue prototype)
    6262    {
    63         return Structure::create(globalData, prototype, TypeInfo(ObjectType, OverridesGetOwnPropertySlot | OverridesMarkChildren | OverridesGetPropertyNames), AnonymousSlotCount, &s_info);
     63        return Structure::create(globalData, prototype, TypeInfo(ObjectType, OverridesGetOwnPropertySlot | OverridesVisitChildren | OverridesGetPropertyNames), AnonymousSlotCount, &s_info);
    6464    }
    6565

  • trunk/Source/WebCore/ChangeLog

    r84553 r84556  
     12011-04-21  Oliver Hunt  <oliver@apple.com>
     2
     3        Reviewed by Geoffrey Garen.
     4
     5        Start moving to a general visitor pattern for GC traversal
     6        https://bugs.webkit.org/show_bug.cgi?id=59141
     7
     8        This is just a rename:
     9            markChildren -> visitChildren
     10            markAggregate -> visitAggregate
     11            markStack -> visitor
     12            MarkStack -> typedef'd to SlotVisitor
     13
     14        * bindings/js/JSAttrCustom.cpp:
     15        (WebCore::JSAttr::visitChildren):
     16        * bindings/js/JSAudioConstructor.cpp:
     17        (WebCore::constructAudio):
     18        * bindings/js/JSCSSRuleCustom.cpp:
     19        (WebCore::JSCSSRule::visitChildren):
     20        * bindings/js/JSCSSStyleDeclarationCustom.cpp:
     21        (WebCore::JSCSSStyleDeclaration::visitChildren):
     22        * bindings/js/JSDOMBinding.cpp:
     23        (WebCore::visitActiveObjectsForContext):
     24        (WebCore::markDOMObjectWrapper):
     25        * bindings/js/JSDOMBinding.h:
     26        * bindings/js/JSDOMGlobalObject.cpp:
     27        (WebCore::JSDOMGlobalObject::visitChildren):
     28        * bindings/js/JSDOMGlobalObject.h:
     29        * bindings/js/JSDOMImplementationCustom.cpp:
     30        (WebCore::JSDOMImplementation::visitChildren):
     31        * bindings/js/JSDOMWindowCustom.cpp:
     32        (WebCore::JSDOMWindow::visitChildren):
     33        * bindings/js/JSDOMWindowShell.cpp:
     34        (WebCore::JSDOMWindowShell::visitChildren):
     35        * bindings/js/JSDOMWindowShell.h:
     36        * bindings/js/JSDocumentCustom.cpp:
     37        (WebCore::JSDocument::visitChildren):
     38        * bindings/js/JSElementCustom.cpp:
     39        (WebCore::JSElement::visitChildren):
     40        * bindings/js/JSEventListener.cpp:
     41        (WebCore::JSEventListener::markJSFunction):
     42        * bindings/js/JSEventListener.h:
     43        * bindings/js/JSHTMLCanvasElementCustom.cpp:
     44        (WebCore::JSHTMLCanvasElement::visitChildren):
     45        * bindings/js/JSHTMLLinkElementCustom.cpp:
     46        (WebCore::JSHTMLLinkElement::visitChildren):
     47        * bindings/js/JSHTMLStyleElementCustom.cpp:
     48        (WebCore::JSHTMLStyleElement::visitChildren):
     49        * bindings/js/JSImageConstructor.cpp:
     50        (WebCore::constructImage):
     51        * bindings/js/JSJavaScriptAudioNodeCustom.cpp:
     52        (WebCore::JSJavaScriptAudioNode::visitChildren):
     53        * bindings/js/JSMessageChannelCustom.cpp:
     54        (WebCore::JSMessageChannel::visitChildren):
     55        * bindings/js/JSMessagePortCustom.cpp:
     56        (WebCore::JSMessagePort::visitChildren):
     57        * bindings/js/JSNamedNodeMapCustom.cpp:
     58        (WebCore::JSNamedNodeMapOwner::isReachableFromOpaqueRoots):
     59        (WebCore::JSNamedNodeMap::visitChildren):
     60        * bindings/js/JSNavigatorCustom.cpp:
     61        (WebCore::JSNavigator::visitChildren):
     62        * bindings/js/JSNodeCustom.cpp:
     63        (WebCore::isObservable):
     64        (WebCore::isReachableFromDOM):
     65        (WebCore::JSNodeOwner::isReachableFromOpaqueRoots):
     66        (WebCore::JSNode::visitChildren):
     67        * bindings/js/JSNodeCustom.h:
     68        * bindings/js/JSNodeFilterCondition.cpp:
     69        (WebCore::JSNodeFilterCondition::WeakOwner::isReachableFromOpaqueRoots):
     70        * bindings/js/JSNodeFilterCondition.h:
     71        * bindings/js/JSNodeFilterCustom.cpp:
     72        (WebCore::JSNodeFilter::visitChildren):
     73        * bindings/js/JSNodeIteratorCustom.cpp:
     74        (WebCore::JSNodeIterator::visitChildren):
     75        * bindings/js/JSNodeListCustom.cpp:
     76        (WebCore::JSNodeListOwner::isReachableFromOpaqueRoots):
     77        * bindings/js/JSProcessingInstructionCustom.cpp:
     78        (WebCore::JSProcessingInstruction::visitChildren):
     79        * bindings/js/JSSVGElementInstanceCustom.cpp:
     80        (WebCore::JSSVGElementInstance::visitChildren):
     81        * bindings/js/JSSharedWorkerCustom.cpp:
     82        (WebCore::JSSharedWorker::visitChildren):
     83        * bindings/js/JSStyleSheetCustom.cpp:
     84        (WebCore::JSStyleSheet::visitChildren):
     85        * bindings/js/JSTreeWalkerCustom.cpp:
     86        (WebCore::JSTreeWalker::visitChildren):
     87        * bindings/js/JSWebGLRenderingContextCustom.cpp:
     88        (WebCore::JSWebGLRenderingContext::visitChildren):
     89        * bindings/js/JSWebKitAnimationListCustom.cpp:
     90        (WebCore::JSWebKitAnimationList::visitChildren):
     91        * bindings/js/JSWorkerContextCustom.cpp:
     92        (WebCore::JSWorkerContext::visitChildren):
     93        * bindings/js/JSXMLHttpRequestCustom.cpp:
     94        (WebCore::JSXMLHttpRequest::visitChildren):
     95        * bindings/js/JSXMLHttpRequestUploadCustom.cpp:
     96        (WebCore::JSXMLHttpRequestUpload::visitChildren):
     97        * bindings/scripts/CodeGeneratorJS.pm:
     98        * bridge/qt/qt_instance.cpp:
     99        (JSC::Bindings::QtRuntimeObject::visitChildren):
     100        (JSC::Bindings::QtInstance::markAggregate):
     101        * bridge/qt/qt_instance.h:
     102        * bridge/qt/qt_pixmapruntime.cpp:
     103        * bridge/qt/qt_runtime.cpp:
     104        (JSC::Bindings::QtRuntimeMetaMethod::visitChildren):
     105        * bridge/qt/qt_runtime.h:
     106        * dom/EventListener.h:
     107        (WebCore::EventListener::visitJSFunction):
     108        * dom/EventTarget.h:
     109        (WebCore::EventTarget::visitJSEventListeners):
     110        * dom/Node.h:
     111        * dom/NodeFilterCondition.h:
     112        (WebCore::NodeFilterCondition::visitAggregate):
     113        * page/DOMWindow.h:
     114        * workers/WorkerContext.h:
     115
    11162011-04-21  Beth Dakin  <bdakin@apple.com>
    2117

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

    r83938 r84556  
    4040using namespace HTMLNames;
    4141
    42 void JSAttr::markChildren(MarkStack& markStack)
     42void JSAttr::visitChildren(SlotVisitor& visitor)
    4343{
    44     Base::markChildren(markStack);
     44    Base::visitChildren(visitor);
    4545
    4646    Element* element = impl()->ownerElement();
    4747    if (!element)
    4848        return;
    49     markStack.addOpaqueRoot(root(element));
     49    visitor.addOpaqueRoot(root(element));
    5050}
    5151

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

    r81272 r84556  
    5757
    5858    // Calling toJS on the document causes the JS document wrapper to be
    59     // added to the window object. This is done to ensure that JSDocument::markChildren
     59    // added to the window object. This is done to ensure that JSDocument::visitChildren
    6060    // will be called, which will cause the audio element to be marked if necessary.
    6161    toJS(exec, jsConstructor->globalObject(), document);

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

    r84527 r84556  
    8080}
    8181
    82 void JSCSSRule::markChildren(MarkStack& markStack)
     82void JSCSSRule::visitChildren(SlotVisitor& visitor)
    8383{
    84     Base::markChildren(markStack);
    85     markStack.addOpaqueRoot(root(impl()));
     84    Base::visitChildren(visitor);
     85    visitor.addOpaqueRoot(root(impl()));
    8686}
    8787

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

    r84527 r84556  
    7474}
    7575
    76 void JSCSSStyleDeclaration::markChildren(MarkStack& markStack)
    77 {
    78     Base::markChildren(markStack);
    79     markStack.addOpaqueRoot(root(impl()));
     76void JSCSSStyleDeclaration::visitChildren(SlotVisitor& visitor)
     77{
     78    Base::visitChildren(visitor);
     79    visitor.addOpaqueRoot(root(impl()));
    8080}
    8181

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

    r84194 r84556  
    135135}
    136136
    137 void markActiveObjectsForContext(MarkStack& markStack, JSGlobalData& globalData, ScriptExecutionContext* scriptExecutionContext)
     137void visitActiveObjectsForContext(SlotVisitor& visitor, JSGlobalData& globalData, ScriptExecutionContext* scriptExecutionContext)
    138138{
    139139    // If an element has pending activity that may result in event listeners being called
    … …  
    146146            // Generally, an active object with pending activity must have a wrapper to mark its listeners.
    147147            // However, some ActiveDOMObjects don't have JS wrappers.
    148             markDOMObjectWrapper(markStack, globalData, iter->second);
     148            markDOMObjectWrapper(visitor, globalData, iter->second);
    149149        }
    150150    }
    … …  
    155155        // If the message port is remotely entangled, then always mark it as in-use because we can't determine reachability across threads.
    156156        if (!(*iter)->locallyEntangledPort() || (*iter)->hasPendingActivity())
    157             markDOMObjectWrapper(markStack, globalData, *iter);
    158     }
    159 }
    160 
    161 void markDOMObjectWrapper(MarkStack& markStack, JSGlobalData& globalData, void* object)
     157            markDOMObjectWrapper(visitor, globalData, *iter);
     158    }
     159}
     160
     161void markDOMObjectWrapper(SlotVisitor& visitor, JSGlobalData& globalData, void* object)
    162162{
    163163    // FIXME: This could be changed to only mark wrappers that are "observable"
    … …  
    169169    for (JSGlobalDataWorldIterator worldIter(&globalData); worldIter; ++worldIter) {
    170170        if (JSDOMWrapper* wrapper = worldIter->m_wrappers.get(object).get())
    171             markStack.deprecatedAppend(reinterpret_cast<JSCell**>(&wrapper));
     171            visitor.deprecatedAppend(reinterpret_cast<JSCell**>(&wrapper));
    172172    }
    173173}

  • trunk/Source/WebCore/bindings/js/JSDOMBinding.h

    r84194 r84556  
    9090
    9191    protected:
    92         static const unsigned StructureFlags = JSC::ImplementsHasInstance | JSC::OverridesMarkChildren | JSDOMWrapperWithGlobalPointer::StructureFlags;
     92        static const unsigned StructureFlags = JSC::ImplementsHasInstance | JSC::OverridesVisitChildren | JSDOMWrapperWithGlobalPointer::StructureFlags;
    9393        DOMConstructorObject(JSC::Structure* structure, JSDOMGlobalObject* globalObject)
    9494            : JSDOMWrapperWithGlobalPointer(structure, globalObject)
    … …  
    114114    };
    115115   
    116     void markActiveObjectsForContext(JSC::MarkStack&, JSC::JSGlobalData&, ScriptExecutionContext*);
    117     void markDOMObjectWrapper(JSC::MarkStack&, JSC::JSGlobalData& globalData, void* object);
     116    void visitActiveObjectsForContext(JSC::SlotVisitor&, JSC::JSGlobalData&, ScriptExecutionContext*);
     117    void markDOMObjectWrapper(JSC::SlotVisitor&, JSC::JSGlobalData&, void*);
    118118
    119119    JSC::Structure* getCachedDOMStructure(JSDOMGlobalObject*, const JSC::ClassInfo*);

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

    r84052 r84556  
    5151}
    5252
    53 void JSDOMGlobalObject::markChildren(MarkStack& markStack)
     53void JSDOMGlobalObject::visitChildren(SlotVisitor& visitor)
    5454{
    55     Base::markChildren(markStack);
     55    Base::visitChildren(visitor);
    5656
    5757    JSDOMStructureMap::iterator end = structures().end();
    5858    for (JSDOMStructureMap::iterator it = structures().begin(); it != end; ++it)
    59         markStack.append(&it->second);
     59        visitor.append(&it->second);
    6060
    6161    JSDOMConstructorMap::iterator end2 = constructors().end();
    6262    for (JSDOMConstructorMap::iterator it2 = constructors().begin(); it2 != end2; ++it2)
    63         markStack.append(&it2->second);
     63        visitor.append(&it2->second);
    6464
    6565    if (m_injectedScript)
    66         markStack.append(&m_injectedScript);
     66        visitor.append(&m_injectedScript);
    6767}
    6868

  • trunk/Source/WebCore/bindings/js/JSDOMGlobalObject.h

    r84052 r84556  
    6464        JSObject* injectedScript() const;
    6565
    66         virtual void markChildren(JSC::MarkStack&);
     66        virtual void visitChildren(JSC::SlotVisitor&);
    6767
    6868        DOMWrapperWorld* world() { return m_world.get(); }

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

    r83938 r84556  
    3030namespace WebCore {
    3131
    32 void JSDOMImplementation::markChildren(MarkStack& markStack)
     32void JSDOMImplementation::visitChildren(SlotVisitor& visitor)
    3333{
    34     Base::markChildren(markStack);
     34    Base::visitChildren(visitor);
    3535
    3636    Document* ownerDocument = impl()->ownerDocument();
    3737    if (!ownerDocument)
    3838        return;
    39     markStack.addOpaqueRoot(ownerDocument);
     39    visitor.addOpaqueRoot(ownerDocument);
    4040}
    4141

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

    r84194 r84556  
    7373namespace WebCore {
    7474
    75 void JSDOMWindow::markChildren(MarkStack& markStack)
    76 {
    77     Base::markChildren(markStack);
    78 
    79     impl()->markJSEventListeners(markStack);
     75void JSDOMWindow::visitChildren(SlotVisitor& visitor)
     76{
     77    Base::visitChildren(visitor);
     78
     79    impl()->visitJSEventListeners(visitor);
    8080
    8181    JSGlobalData& globalData = *Heap::heap(this)->globalData();
    8282
    83     markDOMObjectWrapper(markStack, globalData, impl()->optionalConsole());
    84     markDOMObjectWrapper(markStack, globalData, impl()->optionalHistory());
    85     markDOMObjectWrapper(markStack, globalData, impl()->optionalLocationbar());
    86     markDOMObjectWrapper(markStack, globalData, impl()->optionalMenubar());
    87     markDOMObjectWrapper(markStack, globalData, impl()->optionalNavigator());
    88     markDOMObjectWrapper(markStack, globalData, impl()->optionalPersonalbar());
    89     markDOMObjectWrapper(markStack, globalData, impl()->optionalScreen());
    90     markDOMObjectWrapper(markStack, globalData, impl()->optionalScrollbars());
    91     markDOMObjectWrapper(markStack, globalData, impl()->optionalSelection());
    92     markDOMObjectWrapper(markStack, globalData, impl()->optionalStatusbar());
    93     markDOMObjectWrapper(markStack, globalData, impl()->optionalToolbar());
    94     markDOMObjectWrapper(markStack, globalData, impl()->optionalLocation());
    95     markDOMObjectWrapper(markStack, globalData, impl()->optionalMedia());
     83    markDOMObjectWrapper(visitor, globalData, impl()->optionalConsole());
     84    markDOMObjectWrapper(visitor, globalData, impl()->optionalHistory());
     85    markDOMObjectWrapper(visitor, globalData, impl()->optionalLocationbar());
     86    markDOMObjectWrapper(visitor, globalData, impl()->optionalMenubar());
     87    markDOMObjectWrapper(visitor, globalData, impl()->optionalNavigator());
     88    markDOMObjectWrapper(visitor, globalData, impl()->optionalPersonalbar());
     89    markDOMObjectWrapper(visitor, globalData, impl()->optionalScreen());
     90    markDOMObjectWrapper(visitor, globalData, impl()->optionalScrollbars());
     91    markDOMObjectWrapper(visitor, globalData, impl()->optionalSelection());
     92    markDOMObjectWrapper(visitor, globalData, impl()->optionalStatusbar());
     93    markDOMObjectWrapper(visitor, globalData, impl()->optionalToolbar());
     94    markDOMObjectWrapper(visitor, globalData, impl()->optionalLocation());
     95    markDOMObjectWrapper(visitor, globalData, impl()->optionalMedia());
    9696#if ENABLE(DOM_STORAGE)
    97     markDOMObjectWrapper(markStack, globalData, impl()->optionalSessionStorage());
    98     markDOMObjectWrapper(markStack, globalData, impl()->optionalLocalStorage());
     97    markDOMObjectWrapper(visitor, globalData, impl()->optionalSessionStorage());
     98    markDOMObjectWrapper(visitor, globalData, impl()->optionalLocalStorage());
    9999#endif
    100100#if ENABLE(OFFLINE_WEB_APPLICATIONS)
    101     markDOMObjectWrapper(markStack, globalData, impl()->optionalApplicationCache());
     101    markDOMObjectWrapper(visitor, globalData, impl()->optionalApplicationCache());
    102102#endif
    103103}

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

    r84371 r84556  
    3333#include "JSDOMWindow.h"
    3434#include "DOMWindow.h"
     35#include "ScriptController.h"
    3536#include <runtime/JSObject.h>
    3637
    … …  
    7374// ----
    7475
    75 void JSDOMWindowShell::markChildren(MarkStack& markStack)
     76void JSDOMWindowShell::visitChildren(SlotVisitor& visitor)
    7677{
    77     Base::markChildren(markStack);
     78    Base::visitChildren(visitor);
    7879    if (m_window)
    79         markStack.append(&m_window);
     80        visitor.append(&m_window);
    8081}
    8182

  • trunk/Source/WebCore/bindings/js/JSDOMWindowShell.h

    r84052 r84556  
    6767
    6868    private:
    69         static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | JSC::OverridesMarkChildren | JSC::OverridesGetPropertyNames | Base::StructureFlags;
     69        static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | JSC::OverridesVisitChildren | JSC::OverridesGetPropertyNames | Base::StructureFlags;
    7070
    71         virtual void markChildren(JSC::MarkStack&);
     71        virtual void visitChildren(JSC::SlotVisitor&);
    7272        virtual JSC::UString className() const;
    7373        virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&);

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

    r84527 r84556  
    3535#include "JSTouchList.h"
    3636#include "Location.h"
     37#include "ScriptController.h"
    3738#include "TouchList.h"
    3839
    … …  
    4849namespace WebCore {
    4950
    50 void JSDocument::markChildren(MarkStack& markStack)
     51void JSDocument::visitChildren(SlotVisitor& visitor)
    5152{
    52     JSNode::markChildren(markStack);
     53    JSNode::visitChildren(visitor);
    5354
    5455    Document* document = impl();
    5556    JSGlobalData& globalData = *Heap::heap(this)->globalData();
    5657
    57     markActiveObjectsForContext(markStack, globalData, document);
    58     markDOMObjectWrapper(markStack, globalData, document->implementation());
     58    visitActiveObjectsForContext(visitor, globalData, document);
     59    markDOMObjectWrapper(visitor, globalData, document->implementation());
    5960}
    6061

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

    r84194 r84556  
    5252using namespace HTMLNames;
    5353
    54 void JSElement::markChildren(MarkStack& markStack)
     54void JSElement::visitChildren(SlotVisitor& visitor)
    5555{
    56     Base::markChildren(markStack);
     56    Base::visitChildren(visitor);
    5757
    5858    Element* element = impl();
    5959    JSGlobalData& globalData = *Heap::heap(this)->globalData();
    6060
    61     markDOMObjectWrapper(markStack, globalData, element->attributeMap());
    62     markDOMObjectWrapper(markStack, globalData, element->optionalClassList());
    63     markDOMObjectWrapper(markStack, globalData, element->optionalDataset());
     61    markDOMObjectWrapper(visitor, globalData, element->attributeMap());
     62    markDOMObjectWrapper(visitor, globalData, element->optionalClassList());
     63    markDOMObjectWrapper(visitor, globalData, element->optionalDataset());
    6464
    6565    if (element->isStyledElement())
    66         markDOMObjectWrapper(markStack, globalData, static_cast<StyledElement*>(element)->inlineStyleDecl());
     66        markDOMObjectWrapper(visitor, globalData, static_cast<StyledElement*>(element)->inlineStyleDecl());
    6767}
    6868

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

    r84052 r84556  
    5757}
    5858
    59 void JSEventListener::markJSFunction(MarkStack& markStack)
     59void JSEventListener::markJSFunction(SlotVisitor& visitor)
    6060{
    6161    if (m_jsFunction)
    62         markStack.append(&m_jsFunction);
     62        visitor.append(&m_jsFunction);
    6363}
    6464

  • trunk/Source/WebCore/bindings/js/JSEventListener.h

    r83385 r84556  
    5858    private:
    5959        virtual JSC::JSObject* initializeJSFunction(ScriptExecutionContext*) const;
    60         virtual void markJSFunction(JSC::MarkStack&);
     60        virtual void markJSFunction(JSC::SlotVisitor&);
    6161        virtual bool virtualisAttribute() const;
    6262

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

    r81899 r84556  
    4141namespace WebCore {
    4242
    43 void JSHTMLCanvasElement::markChildren(MarkStack& markStack)
     43void JSHTMLCanvasElement::visitChildren(SlotVisitor& visitor)
    4444{
    45     Base::markChildren(markStack);
     45    Base::visitChildren(visitor);
    4646
    4747    HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(impl());
    4848    JSGlobalData& globalData = *Heap::heap(this)->globalData();
    4949
    50     markDOMObjectWrapper(markStack, globalData, canvas->renderingContext());
     50    markDOMObjectWrapper(visitor, globalData, canvas->renderingContext());
    5151}
    5252

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

    r72344 r84556  
    3333namespace WebCore {
    3434
    35 void JSHTMLLinkElement::markChildren(MarkStack& markStack)
     35void JSHTMLLinkElement::visitChildren(SlotVisitor& visitor)
    3636{
    37     Base::markChildren(markStack);
     37    Base::visitChildren(visitor);
    3838
    3939    if (StyleSheet* sheet = static_cast<HTMLLinkElement*>(impl())->sheet())
    40         markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), sheet);
     40        markDOMObjectWrapper(visitor, *Heap::heap(this)->globalData(), sheet);
    4141}
    4242

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

    r72344 r84556  
    3333namespace WebCore {
    3434
    35 void JSHTMLStyleElement::markChildren(MarkStack& markStack)
     35void JSHTMLStyleElement::visitChildren(SlotVisitor& visitor)
    3636{
    37     Base::markChildren(markStack);
     37    Base::visitChildren(visitor);
    3838
    3939    if (StyleSheet* sheet = static_cast<HTMLStyleElement*>(impl())->sheet())
    40         markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), sheet);
     40        markDOMObjectWrapper(visitor, *Heap::heap(this)->globalData(), sheet);
    4141}
    4242

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

    r81272 r84556  
    5050
    5151    // Calling toJS on the document causes the JS document wrapper to be
    52     // added to the window object. This is done to ensure that JSDocument::markChildren
     52    // added to the window object. This is done to ensure that JSDocument::visit
    5353    // will be called, which will cause the image element to be marked if necessary.
    5454    toJS(exec, jsConstructor->globalObject(), document);

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

    r72838 r84556  
    3535namespace WebCore {
    3636
    37 void JSJavaScriptAudioNode::markChildren(MarkStack& markStack)
     37void JSJavaScriptAudioNode::visitChildren(SlotVisitor& visitor)
    3838{
    39     Base::markChildren(markStack);
    40     static_cast<JavaScriptAudioNode*>(impl())->markJSEventListeners(markStack);
     39    Base::visitChildren(visitor);
     40    static_cast<JavaScriptAudioNode*>(impl())->markJSEventListeners(visitor);
    4141}
    4242

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

    r61136 r84556  
    3434namespace WebCore {
    3535   
    36 void JSMessageChannel::markChildren(MarkStack& markStack)
     36void JSMessageChannel::visitChildren(SlotVisitor& visitor)
    3737{
    38     Base::markChildren(markStack);
     38    Base::visitChildren(visitor);
    3939
    4040    if (MessagePort* port = m_impl->port1())
    41         markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), port);
     41        markDOMObjectWrapper(visitor, *Heap::heap(this)->globalData(), port);
    4242
    4343    if (MessagePort* port = m_impl->port2())
    44         markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), port);
     44        markDOMObjectWrapper(visitor, *Heap::heap(this)->globalData(), port);
    4545}
    4646

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

    r65077 r84556  
    4242namespace WebCore {
    4343
    44 void JSMessagePort::markChildren(MarkStack& markStack)
     44void JSMessagePort::visitChildren(SlotVisitor& visitor)
    4545{
    46     Base::markChildren(markStack);
     46    Base::visitChildren(visitor);
    4747
    4848    // If we have a locally entangled port, we can directly mark it as reachable. Ports that are remotely entangled are marked in-use by markActiveObjectsForContext().
    4949    if (MessagePort* entangledPort = m_impl->locallyEntangledPort())
    50         markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), entangledPort);
     50        markDOMObjectWrapper(visitor, *Heap::heap(this)->globalData(), entangledPort);
    5151
    52     m_impl->markJSEventListeners(markStack);
     52    m_impl->visitJSEventListeners(visitor);
    5353}
    5454

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

    r84309 r84556  
    2828
    2929#include "JSNode.h"
     30
    3031#include "Element.h"
    3132#include "NamedNodeMap.h"
    … …  
    3637
    3738class JSNamedNodeMapOwner : public JSC::WeakHandleOwner {
    38     virtual bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::MarkStack&);
     39    virtual bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::SlotVisitor&);
    3940    virtual void finalize(JSC::Handle<JSC::Unknown>, void* context);
    4041};
    4142
    42 bool JSNamedNodeMapOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, MarkStack& markStack)
     43bool JSNamedNodeMapOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
    4344{
    4445    JSNamedNodeMap* jsNamedNodeMap = static_cast<JSNamedNodeMap*>(handle.get().asCell());
    … …  
    4849    if (!element)
    4950        return false;
    50     return markStack.containsOpaqueRoot(root(element));
     51    return visitor.containsOpaqueRoot(root(element));
    5152}
    5253
    … …  
    8081}
    8182
    82 void JSNamedNodeMap::markChildren(MarkStack& markStack)
     83void JSNamedNodeMap::visitChildren(SlotVisitor& visitor)
    8384{
    84     Base::markChildren(markStack);
     85    Base::visitChildren(visitor);
    8586
    8687    // We need to keep the wrapper for our underlying NamedNodeMap's element
    … …  
    9192    if (!element)
    9293        return;
    93     markStack.addOpaqueRoot(root(element));
     94    visitor.addOpaqueRoot(root(element));
    9495}
    9596

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

    r83287 r84556  
    3333using namespace JSC;
    3434
    35 void JSNavigator::markChildren(MarkStack& markStack)
     35void JSNavigator::visitChildren(SlotVisitor& visitor)
    3636{
    37     Base::markChildren(markStack);
     37    Base::visitChildren(visitor);
    3838
    3939    JSGlobalData& globalData = *Heap::heap(this)->globalData();
    4040
    41     markDOMObjectWrapper(markStack, globalData, impl()->optionalGeolocation());
     41    markDOMObjectWrapper(visitor, globalData, impl()->optionalGeolocation());
    4242}
    4343

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

    r84520 r84556  
    109109    // those objects through the DOM must reflect those properties.
    110110    // FIXME: It would be better if this logic could be in the node next to
    111     // the custom markChildren functions rather than here.
     111    // the custom visit functions rather than here.
    112112    // Note that for some compound objects like stylesheets and CSSStyleDeclarations,
    113113    // we don't descend to check children for custom properties, and just conservatively
    … …  
    148148}
    149149
    150 static inline bool isReachableFromDOM(JSNode* jsNode, Node* node, DOMWrapperWorld* world, MarkStack& markStack)
     150static inline bool isReachableFromDOM(JSNode* jsNode, Node* node, DOMWrapperWorld* world, SlotVisitor& visitor)
    151151{
    152152    if (!node->inDocument()) {
    … …  
    171171    }
    172172
    173     return isObservable(jsNode, node, world) && markStack.containsOpaqueRoot(root(node));
    174 }
    175 
    176 bool JSNodeOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, MarkStack& markStack)
     173    return isObservable(jsNode, node, world) && visitor.containsOpaqueRoot(root(node));
     174}
     175
     176bool JSNodeOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, SlotVisitor& visitor)
    177177{
    178178    JSNode* jsNode = static_cast<JSNode*>(handle.get().asCell());
    179179    DOMWrapperWorld* world = static_cast<DOMWrapperWorld*>(context);
    180     return isReachableFromDOM(jsNode, jsNode->impl(), world, markStack);
     180    return isReachableFromDOM(jsNode, jsNode->impl(), world, visitor);
    181181}
    182182
    … …  
    237237}
    238238
    239 void JSNode::markChildren(MarkStack& markStack)
    240 {
    241     Base::markChildren(markStack);
     239void JSNode::visitChildren(SlotVisitor& visitor)
     240{
     241    Base::visitChildren(visitor);
    242242
    243243    Node* node = m_impl.get();
    244     node->markJSEventListeners(markStack);
    245 
    246     markStack.addOpaqueRoot(root(node));
     244    node->visitJSEventListeners(visitor);
     245
     246    visitor.addOpaqueRoot(root(node));
    247247}
    248248

  • trunk/Source/WebCore/bindings/js/JSNodeCustom.h

    r84527 r84556  
    3636
    3737class JSNodeOwner : public JSC::WeakHandleOwner {
    38     virtual bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::MarkStack&);
     38    virtual bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::SlotVisitor&);
    3939    virtual void finalize(JSC::Handle<JSC::Unknown>, void* context);
    4040};

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

    r84024 r84556  
    8484}
    8585
    86 bool JSNodeFilterCondition::WeakOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, MarkStack& markStack)
     86bool JSNodeFilterCondition::WeakOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, SlotVisitor& visitor)
    8787{
    88     return markStack.containsOpaqueRoot(context);
     88    return visitor.containsOpaqueRoot(context);
    8989}
    9090

  • trunk/Source/WebCore/bindings/js/JSNodeFilterCondition.h

    r84021 r84556  
    4444
    4545        class WeakOwner : public JSC::WeakHandleOwner {
    46             virtual bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::MarkStack&);
     46            virtual bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::SlotVisitor&);
    4747        };
    4848        WeakOwner m_weakOwner;

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

    r84021 r84556  
    3737namespace WebCore {
    3838
    39 void JSNodeFilter::markChildren(MarkStack& markStack)
     39void JSNodeFilter::visitChildren(SlotVisitor& visitor)
    4040{
    41     Base::markChildren(markStack);
    42     markStack.addOpaqueRoot(impl());
     41    Base::visitChildren(visitor);
     42    visitor.addOpaqueRoot(impl());
    4343}
    4444

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

    r84021 r84556  
    3030namespace WebCore {
    3131
    32 void JSNodeIterator::markChildren(MarkStack& markStack)
     32void JSNodeIterator::visitChildren(SlotVisitor& visitor)
    3333{
    34     Base::markChildren(markStack);
     34    Base::visitChildren(visitor);
    3535
    3636    if (NodeFilter* filter = m_impl->filter())
    37         markStack.addOpaqueRoot(filter);
     37        visitor.addOpaqueRoot(filter);
    3838}
    3939

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

    r84309 r84556  
    3838
    3939class JSNodeListOwner : public JSC::WeakHandleOwner {
    40     virtual bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::MarkStack&);
     40    virtual bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::SlotVisitor&);
    4141    virtual void finalize(JSC::Handle<JSC::Unknown>, void* context);
    4242};
    4343
    44 bool JSNodeListOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, MarkStack& markStack)
     44bool JSNodeListOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
    4545{
    4646    JSNodeList* jsNodeList = static_cast<JSNodeList*>(handle.get().asCell());
    … …  
    4949    if (!jsNodeList->impl()->isDynamicNodeList())
    5050        return false;
    51     return markStack.containsOpaqueRoot(root(static_cast<DynamicNodeList*>(jsNodeList->impl())->rootNode()));
     51    return visitor.containsOpaqueRoot(root(static_cast<DynamicNodeList*>(jsNodeList->impl())->rootNode()));
    5252}
    5353

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

    r72344 r84556  
    3333namespace WebCore {
    3434
    35 void JSProcessingInstruction::markChildren(MarkStack& markStack)
     35void JSProcessingInstruction::visitChildren(SlotVisitor& visitor)
    3636{
    37     Base::markChildren(markStack);
     37    Base::visitChildren(visitor);
    3838
    3939    if (StyleSheet* sheet = static_cast<ProcessingInstruction*>(impl())->sheet())
    40         markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), sheet);
     40        markDOMObjectWrapper(visitor, *Heap::heap(this)->globalData(), sheet);
    4141}
    4242

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

    r83938 r84556  
    3434namespace WebCore {
    3535
    36 void JSSVGElementInstance::markChildren(JSC::MarkStack& markStack)
     36void JSSVGElementInstance::visitChildren(JSC::SlotVisitor& visitor)
    3737{
    38     Base::markChildren(markStack);
    39     markStack.addOpaqueRoot(root(impl()->correspondingElement()));
     38    Base::visitChildren(visitor);
     39    visitor.addOpaqueRoot(root(impl()->correspondingElement()));
    4040}
    4141

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

    r62845 r84556  
    4444namespace WebCore {
    4545
    46 void JSSharedWorker::markChildren(MarkStack& markStack)
     46void JSSharedWorker::visitChildren(SlotVisitor& visitor)
    4747{
    48     Base::markChildren(markStack);
     48    Base::visitChildren(visitor);
    4949
    5050    if (MessagePort* port = impl()->port())
    51         markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), port);
     51        markDOMObjectWrapper(visitor, *Heap::heap(this)->globalData(), port);
    5252}
    5353

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

    r84527 r84556  
    6767}
    6868
    69 void JSStyleSheet::markChildren(MarkStack& markStack)
     69void JSStyleSheet::visitChildren(SlotVisitor& visitor)
    7070{
    71     Base::markChildren(markStack);
    72     markStack.addOpaqueRoot(root(impl()));
     71    Base::visitChildren(visitor);
     72    visitor.addOpaqueRoot(root(impl()));
    7373}
    7474

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

    r84021 r84556  
    3030namespace WebCore {
    3131   
    32 void JSTreeWalker::markChildren(MarkStack& markStack)
     32void JSTreeWalker::visitChildren(SlotVisitor& visitor)
    3333{
    34     Base::markChildren(markStack);
     34    Base::visitChildren(visitor);
    3535
    3636    if (NodeFilter* filter = m_impl->filter())
    37         markStack.addOpaqueRoot(filter);
     37        visitor.addOpaqueRoot(filter);
    3838}
    3939

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

    r79011 r84556  
    193193}
    194194
    195 void JSWebGLRenderingContext::markChildren(MarkStack& markStack)
    196 {
    197     Base::markChildren(markStack);
     195void JSWebGLRenderingContext::visitChildren(SlotVisitor& visitor)
     196{
     197    Base::visitChildren(visitor);
    198198
    199199    WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(impl());
    200200    for (int i = 0; i < context->getNumberOfExtensions(); ++i)
    201         markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), context->getExtensionNumber(i));
     201        markDOMObjectWrapper(visitor, *Heap::heap(this)->globalData(), context->getExtensionNumber(i));
    202202}
    203203

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

    r80846 r84556  
    3333namespace WebCore {
    3434
    35 void JSWebKitAnimationList::markChildren(MarkStack& markStack)
     35void JSWebKitAnimationList::visitChildren(SlotVisitor& visitor)
    3636{
    37     Base::markChildren(markStack);
     37    Base::visitChildren(visitor);
    3838
    3939    WebKitAnimationList* list = impl();
    … …  
    4242    unsigned length = list->length();
    4343    for (unsigned i = 0; i < length; ++i)
    44         markDOMObjectWrapper(markStack, globalData, list->item(i));
     44        markDOMObjectWrapper(visitor, globalData, list->item(i));
    4545}
    4646

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

    r84073 r84556  
    5454namespace WebCore {
    5555
    56 void JSWorkerContext::markChildren(MarkStack& markStack)
     56void JSWorkerContext::visitChildren(SlotVisitor& visitor)
    5757{
    58     Base::markChildren(markStack);
     58    Base::visitChildren(visitor);
    5959
    6060    JSGlobalData& globalData = this->globalData();
    6161
    62     markActiveObjectsForContext(markStack, globalData, scriptExecutionContext());
     62    visitActiveObjectsForContext(visitor, globalData, scriptExecutionContext());
    6363
    64     markDOMObjectWrapper(markStack, globalData, impl()->optionalLocation());
    65     markDOMObjectWrapper(markStack, globalData, impl()->optionalNavigator());
     64    markDOMObjectWrapper(visitor, globalData, impl()->optionalLocation());
     65    markDOMObjectWrapper(visitor, globalData, impl()->optionalNavigator());
    6666
    67     impl()->markJSEventListeners(markStack);
     67    impl()->visitJSEventListeners(visitor);
    6868}
    6969

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

    r83532 r84556  
    5555namespace WebCore {
    5656
    57 void JSXMLHttpRequest::markChildren(MarkStack& markStack)
    58 {
    59     Base::markChildren(markStack);
     57void JSXMLHttpRequest::visitChildren(SlotVisitor& visitor)
     58{
     59    Base::visitChildren(visitor);
    6060
    6161    if (XMLHttpRequestUpload* upload = m_impl->optionalUpload())
    62         markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), upload);
     62        markDOMObjectWrapper(visitor, *Heap::heap(this)->globalData(), upload);
    6363
    6464    if (Document* responseDocument = m_impl->optionalResponseXML())
    65         markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), responseDocument);
     65        markDOMObjectWrapper(visitor, *Heap::heap(this)->globalData(), responseDocument);
    6666
    6767    if (ArrayBuffer* responseArrayBuffer = m_impl->optionalResponseArrayBuffer())
    68         markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), responseArrayBuffer);
     68        markDOMObjectWrapper(visitor, *Heap::heap(this)->globalData(), responseArrayBuffer);
    6969
    7070#if ENABLE(XHR_RESPONSE_BLOB)
    7171    if (Blob* responseBlob = m_impl->optionalResponseBlob())
    72         markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), responseBlob);
     72        markDOMObjectWrapper(visitor, *Heap::heap(this)->globalData(), responseBlob);
    7373#endif
    7474
    75     m_impl->markJSEventListeners(markStack);
     75    m_impl->visitJSEventListeners(visitor);
    7676}
    7777

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

    r58330 r84556  
    4242namespace WebCore {
    4343
    44 void JSXMLHttpRequestUpload::markChildren(MarkStack& markStack)
     44void JSXMLHttpRequestUpload::visitChildren(SlotVisitor& visitor)
    4545{
    46     Base::markChildren(markStack);
     46    Base::visitChildren(visitor);
    4747
    4848    if (XMLHttpRequest* xmlHttpRequest = m_impl->associatedXMLHttpRequest())
    49         markDOMObjectWrapper(markStack, *Heap::heap(this)->globalData(), xmlHttpRequest);
     49        markDOMObjectWrapper(visitor, *Heap::heap(this)->globalData(), xmlHttpRequest);
    5050
    51     m_impl->markJSEventListeners(markStack);
     51    m_impl->visitJSEventListeners(visitor);
    5252}
    5353

  • trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm

    r84194 r84556  
    752752        "    }\n\n");
    753753
    754     # markChildren function
     754    # visit function
    755755    if ($needsMarkChildren) {
    756         push(@headerContent, "    virtual void markChildren(JSC::MarkStack&);\n\n");
    757         $structureFlags{"JSC::OverridesMarkChildren"} = 1;
     756        push(@headerContent, "    virtual void visitChildren(JSC::SlotVisitor&);\n\n");
     757        $structureFlags{"JSC::OverridesVisitChildren"} = 1;
    758758    }
    759759
    … …  
    956956    }
    957957    if ($dataNode->extendedAttributes->{"CustomMarkFunction"} or $needsMarkChildren) {
    958         $structureFlags{"JSC::OverridesMarkChildren"} = 1;
     958        $structureFlags{"JSC::OverridesVisitChildren"} = 1;
    959959    }
    960960    push(@headerContent,
    … …  
    14321432
    14331433    if ($needsMarkChildren && !$dataNode->extendedAttributes->{"CustomMarkFunction"}) {
    1434         push(@implContent, "void ${className}::markChildren(MarkStack& markStack)\n");
     1434        push(@implContent, "void ${className}::visitChildren(SlotVisitor& visitor)\n");
    14351435        push(@implContent, "{\n");
    1436         push(@implContent, "    Base::markChildren(markStack);\n");
    1437         push(@implContent, "    impl()->markJSEventListeners(markStack);\n");
     1436        push(@implContent, "    Base::visitChildren(visitor);\n");
     1437        push(@implContent, "    impl()->visitJSEventListeners(visitor);\n");
    14381438        push(@implContent, "}\n\n");
    14391439    }

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

    r84286 r84556  
    5252    static const ClassInfo s_info;
    5353
    54     virtual void markChildren(MarkStack& markStack)
     54    virtual void visitChildren(SlotVisitor& visitor)
    5555    {
    56         RuntimeObject::markChildren(markStack);
     56        RuntimeObject::visitChildren(visitor);
    5757        QtInstance* instance = static_cast<QtInstance*>(getInternalInstance());
    5858        if (instance)
    59             instance->markAggregate(markStack);
     59            instance->visitAggregate(visitor);
    6060    }
    6161
    … …  
    6666
    6767protected:
    68     static const unsigned StructureFlags = RuntimeObject::StructureFlags | OverridesMarkChildren;
     68    static const unsigned StructureFlags = RuntimeObject::StructureFlags | OverridesVisitChildren;
    6969};
    7070
    … …  
    186186}
    187187
    188 void QtInstance::markAggregate(MarkStack& markStack)
     188void QtInstance::visitAggregate(SlotVisitor& visitor)
    189189{
    190190    if (m_defaultMethod)
    191         markStack.append(&m_defaultMethod);
     191        visitor.append(&m_defaultMethod);
    192192    for (QHash<QByteArray, WriteBarrier<JSObject> >::Iterator it = m_methods.begin(), end = m_methods.end(); it != end; ++it)
    193         markStack.append(&it.value());
     193        visitor.append(&it.value());
    194194}
    195195

  • trunk/Source/WebCore/bridge/qt/qt_instance.h

    r84286 r84556  
    4949    virtual JSValue defaultValue(ExecState*, PreferredPrimitiveType) const;
    5050
    51     void markAggregate(MarkStack&);
     51    void visitAggregate(SlotVisitor&);
    5252
    5353    virtual JSValue getMethod(ExecState* exec, const Identifier& propertyName);

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

    r84052 r84556  
    157157
    158158protected:
    159     static const unsigned StructureFlags = RuntimeObject::StructureFlags | OverridesMarkChildren;
     159    static const unsigned StructureFlags = RuntimeObject::StructureFlags | OverridesVisitChildren;
    160160};
    161161

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

    r82173 r84556  
    14011401}
    14021402
    1403 void QtRuntimeMetaMethod::markChildren(MarkStack& markStack)
    1404 {
    1405     QtRuntimeMethod::markChildren(markStack);
     1403void QtRuntimeMetaMethod::visitChildren(SlotVisitor& visitor)
     1404{
     1405    QtRuntimeMethod::visitChildren(visitor);
    14061406    QW_D(QtRuntimeMetaMethod);
    14071407    if (d->m_connect)
    1408         markStack.append(&d->m_connect);
     1408        visitor.append(&d->m_connect);
    14091409    if (d->m_disconnect)
    1410         markStack.append(&d->m_disconnect);
     1410        visitor.append(&d->m_disconnect);
    14111411}
    14121412

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

    r84052 r84556  
    160160
    161161protected:
    162     static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesGetPropertyNames | InternalFunction::StructureFlags | OverridesMarkChildren;
     162    static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesGetPropertyNames | InternalFunction::StructureFlags | OverridesVisitChildren;
    163163
    164164    QtRuntimeMethodData *d_func() const {return d_ptr;}
    … …  
    176176    virtual void getOwnPropertyNames(ExecState*, PropertyNameArray&, EnumerationMode mode = ExcludeDontEnumProperties);
    177177
    178     virtual void markChildren(MarkStack& markStack);
     178    virtual void visitChildren(SlotVisitor&);
    179179
    180180protected:

  • trunk/Source/WebCore/dom/EventListener.h

    r78634 r84556  
    2727    class JSObject;
    2828    class MarkStack;
     29    typedef MarkStack SlotVisitor;
    2930}
    3031
    … …  
    5455
    5556#if USE(JSC)
    56         virtual void markJSFunction(JSC::MarkStack&) { }
     57        virtual void visitJSFunction(JSC::SlotVisitor&) { }
    5758#endif
    5859

  • trunk/Source/WebCore/dom/EventTarget.h

    r83261 r84556  
    171171
    172172#if USE(JSC)
    173         void markJSEventListeners(JSC::MarkStack&);
     173        void visitJSEventListeners(JSC::SlotVisitor&);
    174174        void invalidateJSEventListeners(JSC::JSObject*);
    175175#endif
    … …  
    224224
    225225#if USE(JSC)
    226     inline void EventTarget::markJSEventListeners(JSC::MarkStack& markStack)
     226    inline void EventTarget::visitJSEventListeners(JSC::SlotVisitor& visitor)
    227227    {
    228228        EventTargetData* d = eventTargetData();
    … …  
    234234            EventListenerVector& entry = *it->second;
    235235            for (size_t i = 0; i < entry.size(); ++i)
    236                 entry[i].listener->markJSFunction(markStack);
     236                entry[i].listener->visitJSFunction(visitor);
    237237        }
    238238    }

  • trunk/Source/WebCore/dom/Node.h

    r84520 r84556  
    3838    class JSGlobalData;
    3939    class MarkStack;
     40    typedef MarkStack SlotVisitor;
    4041}
    4142#endif

  • trunk/Source/WebCore/dom/NodeFilterCondition.h

    r47022 r84556  
    3131namespace JSC {
    3232    class MarkStack;
     33    typedef MarkStack SlotVisitor;
    3334}
    3435
    … …  
    4142        virtual ~NodeFilterCondition() { }
    4243        virtual short acceptNode(ScriptState*, Node*) const = 0;
    43         virtual void markAggregate(JSC::MarkStack&) { }
     44        virtual void visitAggregate(JSC::SlotVisitor&) { }
    4445    };
    4546

  • trunk/Source/WebCore/page/DOMWindow.h

    r84224 r84556  
    341341        void finishedLoading();
    342342
    343         // These functions are used for GC marking. See JSDOMWindow::markChildren(MarkStack&) in JSDOMWindowCustom.cpp.
     343        // These functions are used for GC marking. See JSDOMWindow::visitChildren(SlotVisitor&) in JSDOMWindowCustom.cpp.
    344344        Screen* optionalScreen() const { return m_screen.get(); }
    345345        DOMSelection* optionalSelection() const { return m_selection.get(); }

  • trunk/Source/WebCore/workers/WorkerContext.h

    r84224 r84556  
    142142        WorkerInspectorController* workerInspectorController() { return m_workerInspectorController.get(); }
    143143#endif
    144         // These methods are used for GC marking. See JSWorkerContext::markChildren(MarkStack&) in
     144        // These methods are used for GC marking. See JSWorkerContext::visitChildren(SlotVisitor&) in
    145145        // JSWorkerContextCustom.cpp.
    146146        WorkerNavigator* optionalNavigator() const { return m_navigator.get(); }
Note: See TracChangeset for help on using the changeset viewer.