Changeset 73907 in webkit


Ignore:
Timestamp:
Dec 13, 2010 5:34:00 AM (13 years ago)
Author:
antonm@chromium.org
Message:

2010-12-13 Anton Muhin <​antonm@chromium.org>

Reviewed by Pavel Feldman.

[v8] More CSS wrappers GC work: keep document's style sheets, style sheet and css rule lists' items in proper object groups
​https://bugs.webkit.org/show_bug.cgi?id=50828

  • bindings/v8/DOMData.h: (WebCore::DOMData::WrapperMapObjectRemover::visitDOMWrapper): (WebCore::DOMData::removeObjectsFromWrapperMap):
  • bindings/v8/DOMDataStore.h: (WebCore::ChunkedTable::visit): (WebCore::ChunkedTable::visitEntries): (WebCore::DOMDataStore::IntrusiveDOMWrapperMap::visit): (WebCore::DOMDataStore::IntrusiveDOMWrapperMap::ChunkedTableTraits::visit):
  • bindings/v8/V8DOMMap.cpp: (WebCore::removeAllDOMObjectsInCurrentThread): (WebCore::visitDOMNodesInCurrentThread): (WebCore::visitDOMObjectsInCurrentThread): (WebCore::visitActiveDOMObjectsInCurrentThread): (WebCore::visitDOMSVGElementInstancesInCurrentThread):
  • bindings/v8/V8DOMMap.h: (WebCore::WeakReferenceMap::visit):
  • bindings/v8/V8GCController.cpp: (WebCore::DOMObjectVisitor::visitDOMWrapper): (WebCore::EnsureWeakDOMNodeVisitor::visitDOMWrapper): (WebCore::GCPrologueVisitor::visitDOMWrapper): (WebCore::NodeGrouperVisitor::visitDOMWrapper): (WebCore::NodeGrouperVisitor::applyGrouping): (WebCore::DOMObjectGrouperVisitor::visitDOMWrapper): (WebCore::GCEpilogueVisitor::visitDOMWrapper):
Location:
trunk/WebCore
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r73904 r73907  
     12010-12-13  Anton Muhin  <antonm@chromium.org>
     2
     3        Reviewed by Pavel Feldman.
     4
     5        [v8] More CSS wrappers GC work: keep document's style sheets, style sheet and css rule lists' items in proper object groups
     6        https://bugs.webkit.org/show_bug.cgi?id=50828
     7
     8        * bindings/v8/DOMData.h:
     9        (WebCore::DOMData::WrapperMapObjectRemover::visitDOMWrapper):
     10        (WebCore::DOMData::removeObjectsFromWrapperMap):
     11        * bindings/v8/DOMDataStore.h:
     12        (WebCore::ChunkedTable::visit):
     13        (WebCore::ChunkedTable::visitEntries):
     14        (WebCore::DOMDataStore::IntrusiveDOMWrapperMap::visit):
     15        (WebCore::DOMDataStore::IntrusiveDOMWrapperMap::ChunkedTableTraits::visit):
     16        * bindings/v8/V8DOMMap.cpp:
     17        (WebCore::removeAllDOMObjectsInCurrentThread):
     18        (WebCore::visitDOMNodesInCurrentThread):
     19        (WebCore::visitDOMObjectsInCurrentThread):
     20        (WebCore::visitActiveDOMObjectsInCurrentThread):
     21        (WebCore::visitDOMSVGElementInstancesInCurrentThread):
     22        * bindings/v8/V8DOMMap.h:
     23        (WebCore::WeakReferenceMap::visit):
     24        * bindings/v8/V8GCController.cpp:
     25        (WebCore::DOMObjectVisitor::visitDOMWrapper):
     26        (WebCore::EnsureWeakDOMNodeVisitor::visitDOMWrapper):
     27        (WebCore::GCPrologueVisitor::visitDOMWrapper):
     28        (WebCore::NodeGrouperVisitor::visitDOMWrapper):
     29        (WebCore::NodeGrouperVisitor::applyGrouping):
     30        (WebCore::DOMObjectGrouperVisitor::visitDOMWrapper):
     31        (WebCore::GCEpilogueVisitor::visitDOMWrapper):
     32
    1332010-12-13  Zoltan Herczeg  <zherczeg@webkit.org>
    234

  • trunk/WebCore/bindings/v8/DOMData.h

    r63751 r73907  
    5656
    5757        template<typename T>
    58         static void removeObjectsFromWrapperMap(AbstractWeakReferenceMap<T, v8::Object>& domMap);
     58        static void removeObjectsFromWrapperMap(DOMDataStore* store, AbstractWeakReferenceMap<T, v8::Object>& domMap);
    5959
    6060        ThreadIdentifier owningThread() const { return m_owningThread; }
    … …  
    6666        class WrapperMapObjectRemover : public WeakReferenceMap<T, v8::Object>::Visitor {
    6767        public:
    68             virtual void visitDOMWrapper(T* domObject, v8::Persistent<v8::Object> v8Object)
     68            virtual void visitDOMWrapper(DOMDataStore* store, T* domObject, v8::Persistent<v8::Object> v8Object)
    6969            {
    7070                WrapperTypeInfo* type = V8DOMWrapper::domWrapperType(v8Object);
    … …  
    103103
    104104    template<typename T>
    105     void DOMData::removeObjectsFromWrapperMap(AbstractWeakReferenceMap<T, v8::Object>& domMap)
     105    void DOMData::removeObjectsFromWrapperMap(DOMDataStore* store, AbstractWeakReferenceMap<T, v8::Object>& domMap)
    106106    {
    107107        WrapperMapObjectRemover<T> remover;
    108         domMap.visit(&remover);
     108        domMap.visit(store, &remover);
    109109        domMap.clear();
    110110    }

  • trunk/WebCore/bindings/v8/DOMDataStore.h

    r72390 r73907  
    107107        }
    108108
    109         void visit(typename Traits::Visitor* visitor)
     109        void visit(DOMDataStore* store, typename Traits::Visitor* visitor)
    110110        {
    111111            if (!m_chunks)
    112112                return;
    113113
    114             visitEntries(m_chunks->m_entries, m_current, visitor);
     114            visitEntries(store, m_chunks->m_entries, m_current, visitor);
    115115            for (Chunk* chunk = m_chunks->m_previous; chunk; chunk = chunk->m_previous)
    116                 visitEntries(chunk->m_entries, chunk->m_entries + CHUNK_SIZE, visitor);
     116                visitEntries(store, chunk->m_entries, chunk->m_entries + CHUNK_SIZE, visitor);
    117117        }
    118118
    … …  
    130130        }
    131131
    132         static void visitEntries(T* first, T* last, typename Traits::Visitor* visitor)
     132        static void visitEntries(DOMDataStore* store, T* first, T* last, typename Traits::Visitor* visitor)
    133133        {
    134134            for (T* entry = first; entry < last; entry++)
    135                 Traits::visit(entry, visitor);
     135                Traits::visit(store, entry, visitor);
    136136        }
    137137
    … …  
    186186            }
    187187
    188             virtual void visit(Visitor* visitor)
    189             {
    190                 m_table.visit(visitor);
     188            virtual void visit(DOMDataStore* store, Visitor* visitor)
     189            {
     190                m_table.visit(store, visitor);
    191191            }
    192192
    … …  
    221221                }
    222222
    223                 static void visit(v8::Persistent<v8::Object>* entry, Visitor* visitor)
     223                static void visit(DOMDataStore* store, v8::Persistent<v8::Object>* entry, Visitor* visitor)
    224224                {
    225225                    Node* node = V8Node::toNative(*entry);
    226226                    ASSERT(node->wrapper() == entry);
    227227
    228                     visitor->visitDOMWrapper(node, *entry);
     228                    visitor->visitDOMWrapper(store, node, *entry);
    229229                }
    230230            };

  • trunk/WebCore/bindings/v8/V8DOMMap.cpp

    r72390 r73907  
    9191void removeAllDOMObjectsInCurrentThread()
    9292{
     93    DOMDataStore& store = getDOMDataStore();
     94
    9395    v8::HandleScope scope;
    9496
    … …  
    9698    if (WTF::isMainThread()) {
    9799        // Remove all DOM nodes.
    98         DOMData::removeObjectsFromWrapperMap<Node>(getDOMNodeMap());
     100        DOMData::removeObjectsFromWrapperMap<Node>(&store, store.domNodeMap());
    99101
    100102#if ENABLE(SVG)
    101103        // Remove all SVG element instances in the wrapper map.
    102         DOMData::removeObjectsFromWrapperMap<SVGElementInstance>(getDOMSVGElementInstanceMap());
     104        DOMData::removeObjectsFromWrapperMap<SVGElementInstance>(&store, store.domSvgElementInstanceMap());
    103105#endif
    104106    }
    105107
    106108    // Remove all DOM objects in the wrapper map.
    107     DOMData::removeObjectsFromWrapperMap<void>(getDOMObjectMap());
     109    DOMData::removeObjectsFromWrapperMap<void>(&store, store.domObjectMap());
    108110
    109111    // Remove all active DOM objects in the wrapper map.
    110     DOMData::removeObjectsFromWrapperMap<void>(getActiveDOMObjectMap());
     112    DOMData::removeObjectsFromWrapperMap<void>(&store, store.activeDomObjectMap());
    111113}
    112114
    … …  
    122124            continue;
    123125
    124         store->domNodeMap().visit(visitor);
     126        store->domNodeMap().visit(store, visitor);
    125127    }
    126128}
    … …  
    137139            continue;
    138140
    139         store->domObjectMap().visit(visitor);
     141        store->domObjectMap().visit(store, visitor);
    140142    }
    141143}
    … …  
    152154            continue;
    153155
    154         store->activeDomObjectMap().visit(visitor);
     156        store->activeDomObjectMap().visit(store, visitor);
    155157    }
    156158}
    … …  
    169171            continue;
    170172
    171         store->domSvgElementInstanceMap().visit(visitor);
     173        store->domSvgElementInstanceMap().visit(store, visitor);
    172174    }
    173175}

  • trunk/WebCore/bindings/v8/V8DOMMap.h

    r73491 r73907  
    3737
    3838namespace WebCore {
     39    class DOMDataStore;
    3940    class Node;
    4041#if ENABLE(SVG)
    … …  
    5152            virtual void startMap() { }
    5253            virtual void endMap() { }
    53             virtual void visitDOMWrapper(KeyType* key, v8::Persistent<ValueType> object) = 0;
     54            virtual void visitDOMWrapper(DOMDataStore* store, KeyType* key, v8::Persistent<ValueType> object) = 0;
    5455        protected:
    5556            virtual ~Visitor() { }
    … …  
    5960        virtual void set(KeyType* obj, v8::Persistent<ValueType> wrapper) = 0;
    6061        virtual bool contains(KeyType* obj) = 0;
    61         virtual void visit(Visitor* visitor) = 0;
     62        virtual void visit(DOMDataStore* store, Visitor* visitor) = 0;
    6263        virtual bool removeIfPresent(KeyType* key, v8::Persistent<v8::Data> value) = 0;
    6364        virtual void clear() = 0;
    … …  
    123124        bool contains(KeyType* obj) { return m_map.contains(obj); }
    124125
    125         virtual void visit(typename Parent::Visitor* visitor)
     126        virtual void visit(DOMDataStore* store, typename Parent::Visitor* visitor)
    126127        {
    127128            visitor->startMap();
    128129            typename HashMap<KeyType*, ValueType*>::iterator it = m_map.begin();
    129130            for (; it != m_map.end(); ++it)
    130                 visitor->visitDOMWrapper(it->first, v8::Persistent<ValueType>(it->second));
     131                visitor->visitDOMWrapper(store, it->first, v8::Persistent<ValueType>(it->second));
    131132            visitor->endMap();
    132133        }

  • trunk/WebCore/bindings/v8/V8GCController.cpp

    r73491 r73907  
    4646#include "V8CSSImportRule.h"
    4747#include "V8CSSMediaRule.h"
     48#include "V8CSSRuleList.h"
    4849#include "V8CSSStyleRule.h"
    4950#include "V8CSSStyleSheet.h"
    … …  
    5152#include "V8MessagePort.h"
    5253#include "V8Proxy.h"
     54#include "V8StyleSheetList.h"
    5355#include "WrapperTypeInfo.h"
    5456
    … …  
    136138class DOMObjectVisitor : public DOMWrapperMap<void>::Visitor {
    137139public:
    138     void visitDOMWrapper(void* object, v8::Persistent<v8::Object> wrapper)
     140    void visitDOMWrapper(DOMDataStore* store, void* object, v8::Persistent<v8::Object> wrapper)
    139141    {
    140142        WrapperTypeInfo* type = V8DOMWrapper::domWrapperType(wrapper);
    … …  
    146148class EnsureWeakDOMNodeVisitor : public DOMWrapperMap<Node>::Visitor {
    147149public:
    148     void visitDOMWrapper(Node* object, v8::Persistent<v8::Object> wrapper)
     150    void visitDOMWrapper(DOMDataStore* store, Node* object, v8::Persistent<v8::Object> wrapper)
    149151    {
    150152        UNUSED_PARAM(object);
    … …  
    194196class GCPrologueVisitor : public DOMWrapperMap<void>::Visitor {
    195197public:
    196     void visitDOMWrapper(void* object, v8::Persistent<v8::Object> wrapper)
     198    void visitDOMWrapper(DOMDataStore* store, void* object, v8::Persistent<v8::Object> wrapper)
    197199    {
    198200        WrapperTypeInfo* typeInfo = V8DOMWrapper::domWrapperType(wrapper); 
    … …  
    288290    }
    289291
    290     void visitDOMWrapper(Node* node, v8::Persistent<v8::Object> wrapper)
     292    void visitDOMWrapper(DOMDataStore* store, Node* node, v8::Persistent<v8::Object> wrapper)
    291293    {
    292294        // If the node is in document, put it in the ownerDocument's object group.
    … …  
    321323        }
    322324        m_grouper.append(GrouperItem(groupId, wrapper));
    323     }
    324 
    325     void applyGrouping()
    326     {
    327         /* FIXME: Re-enabled this code to avoid GCing these wrappers!
    328                       Currently this depends on looking up the wrapper
    329                       during a GC, but we don't know which isolated world
    330                       we're in, so it's unclear which map to look in...
    331325
    332326        // If the node is styled and there is a wrapper for the inline
    … …  
    334328        // wrapper alive as well, so we add it to the object group.
    335329        if (node->isStyledElement()) {
    336           StyledElement* element = reinterpret_cast<StyledElement*>(node);
    337           CSSStyleDeclaration* style = element->inlineStyleDecl();
    338           if (style != NULL) {
    339             wrapper = getDOMObjectMap().get(style);
     330            StyledElement* element = reinterpret_cast<StyledElement*>(node);
     331            CSSStyleDeclaration* style = element->inlineStyleDecl();
     332            if (style) {
     333                wrapper = store->domObjectMap().get(style);
     334                if (!wrapper.IsEmpty())
     335                    m_grouper.append(GrouperItem(groupId, wrapper));
     336            }
     337        }
     338
     339        if (node->isDocumentNode()) {
     340            Document* document = reinterpret_cast<Document*>(node);
     341            wrapper = store->domObjectMap().get(document->styleSheets());
    340342            if (!wrapper.IsEmpty())
    341               group.append(wrapper);
    342           }
    343         }
    344         */
     343                m_grouper.append(GrouperItem(groupId, wrapper));
     344        }
     345    }
     346
     347    void applyGrouping()
     348    {
    345349        makeV8ObjectGroups(m_grouper);
    346350    }
    … …  
    366370    }
    367371
    368     void visitDOMWrapper(void* object, v8::Persistent<v8::Object> wrapper)
     372    void visitDOMWrapper(DOMDataStore* store, void* object, v8::Persistent<v8::Object> wrapper)
    369373    {
    370374        WrapperTypeInfo* typeInfo = V8DOMWrapper::domWrapperType(wrapper);
    371         // FIXME: extend WrapperTypeInfo with isStyle to simplify the check below.
     375        // FIXME: extend WrapperTypeInfo with isStyle to simplify the check below or consider
     376        // adding a virtual method to WrapperTypeInfo which would know how to group objects.
    372377        // FIXME: check if there are other StyleBase wrappers we should care of.
    373         if (!V8CSSStyleSheet::info.equals(typeInfo)
    374             && !V8CSSCharsetRule::info.equals(typeInfo)
    375             && !V8CSSFontFaceRule::info.equals(typeInfo)
    376             && !V8CSSStyleRule::info.equals(typeInfo)
    377             && !V8CSSImportRule::info.equals(typeInfo)
    378             && !V8CSSMediaRule::info.equals(typeInfo)) {
    379             return;
    380         }
    381         StyleBase* styleBase = static_cast<StyleBase*>(object);
    382 
    383         // We put the whole tree of style elements into a single object group.
    384         // To achieve that we group elements by the roots of their trees.
    385         StyleBase* root = styleBase;
    386         ASSERT(root);
    387         while (true) {
    388           StyleBase* parent = root->parent();
    389           if (!parent)
    390               break;
    391           root = parent;
    392         }
    393         // Group id is an address of the root.
    394         uintptr_t groupId = reinterpret_cast<uintptr_t>(root);
    395         m_grouper.append(GrouperItem(groupId, wrapper));
     378        if (V8CSSStyleSheet::info.equals(typeInfo)
     379            || V8CSSCharsetRule::info.equals(typeInfo)
     380            || V8CSSFontFaceRule::info.equals(typeInfo)
     381            || V8CSSStyleRule::info.equals(typeInfo)
     382            || V8CSSImportRule::info.equals(typeInfo)
     383            || V8CSSMediaRule::info.equals(typeInfo)) {
     384            StyleBase* styleBase = static_cast<StyleBase*>(object);
     385
     386            // We put the whole tree of style elements into a single object group.
     387            // To achieve that we group elements by the roots of their trees.
     388            StyleBase* root = styleBase;
     389            ASSERT(root);
     390            while (true) {
     391                StyleBase* parent = root->parent();
     392                if (!parent)
     393                    break;
     394                root = parent;
     395            }
     396            // Group id is an address of the root.
     397            uintptr_t groupId = reinterpret_cast<uintptr_t>(root);
     398            m_grouper.append(GrouperItem(groupId, wrapper));
     399        } else if (V8StyleSheetList::info.equals(typeInfo)) {
     400            StyleSheetList* styleSheetList = static_cast<StyleSheetList*>(object);
     401            uintptr_t groupId = reinterpret_cast<uintptr_t>(styleSheetList);
     402            m_grouper.append(GrouperItem(groupId, wrapper));
     403            for (unsigned i = 0; i < styleSheetList->length(); i++) {
     404                StyleSheet* styleSheet = styleSheetList->item(i);
     405                wrapper = store->domObjectMap().get(styleSheet);
     406                if (!wrapper.IsEmpty())
     407                    m_grouper.append(GrouperItem(groupId, wrapper));
     408            }
     409        } else if (V8CSSRuleList::info.equals(typeInfo)) {
     410            CSSRuleList* cssRuleList = static_cast<CSSRuleList*>(object);
     411            uintptr_t groupId = reinterpret_cast<uintptr_t>(cssRuleList);
     412            m_grouper.append(GrouperItem(groupId, wrapper));
     413            for (unsigned i = 0; i < cssRuleList->length(); i++) {
     414                CSSRule* cssRule = cssRuleList->item(i);
     415                wrapper = store->domObjectMap().get(cssRule);
     416                if (!wrapper.IsEmpty())
     417                    m_grouper.append(GrouperItem(groupId, wrapper));
     418            }
     419        }
    396420    }
    397421
    … …  
    430454class GCEpilogueVisitor : public DOMWrapperMap<void>::Visitor {
    431455public:
    432     void visitDOMWrapper(void* object, v8::Persistent<v8::Object> wrapper)
     456    void visitDOMWrapper(DOMDataStore* store, void* object, v8::Persistent<v8::Object> wrapper)
    433457    {
    434458        WrapperTypeInfo* typeInfo = V8DOMWrapper::domWrapperType(wrapper);
Note: See TracChangeset for help on using the changeset viewer.