Changeset 122580 in webkit


Ignore:
Timestamp:
Jul 13, 2012 8:09:10 AM (12 years ago)
Author:
loislo@chromium.org
Message:

Web Inspector: native memory instrumentation: extract instrumentation methods into MemoryClassInfo
​https://bugs.webkit.org/show_bug.cgi?id=91227

Reviewed by Pavel Feldman.

void Node::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
{

MemoryClassInfo<Node> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
info.visitBaseClass<ScriptWrappable>(this);

info.addMember(m_notInstrumentedPointer); automatically detects poniter/reference
info.addInstrumentedMember(m_next);
info.addHashSet<MemoryInstrumentation::NonClass>(m_aHash); NonClass value_type (report only size of internal template structures)
info.addHashSet<MemoryInstrumentation::NotInstrumentedClass>(m_aHashSet); not instrumented value_type (use sizeof)
info.addHashSet<MemoryInstrumentation::InstrumentedClass>(m_aHashSet); instrumented value_type (call visit)

}

The change is covered by existing tests for native memory snapshot.

  • bindings/v8/DOMDataStore.cpp:

(WebCore::DOMDataStore::reportMemoryUsage):

  • bindings/v8/IntrusiveDOMWrapperMap.h:

(WebCore::ChunkedTable::reportMemoryUsage):

  • bindings/v8/ScriptWrappable.h:

(WebCore::ScriptWrappable::reportMemoryUsage):

  • bindings/v8/V8Binding.cpp:

(WebCore::V8BindingPerIsolateData::reportMemoryUsage):
(WebCore::StringCache::reportMemoryUsage):

  • bindings/v8/V8DOMMap.h:
  • css/StylePropertySet.h:

(WebCore::StylePropertySet::reportMemoryUsage):

  • dom/CharacterData.cpp:

(WebCore::CharacterData::reportMemoryUsage):

  • dom/ContainerNode.h:

(WebCore::ContainerNode::reportMemoryUsage):

  • dom/Document.cpp:

(WebCore::Document::reportMemoryUsage):

  • dom/Element.h:

(WebCore::Element::reportMemoryUsage):

  • dom/ElementAttributeData.h:

(WebCore::ElementAttributeData::reportMemoryUsage):

  • dom/MemoryInstrumentation.h:

(MemoryInstrumentation):
(WebCore::MemoryObjectInfo::objectType):
(WebCore::MemoryObjectInfo::objectSize):
(WebCore::MemoryObjectInfo::memoryInstrumentation):
(MemoryObjectInfo):
(WebCore::MemoryObjectInfo::reportObjectInfo):
(WebCore):
(MemoryClassInfo):
(WebCore::MemoryClassInfo::MemoryClassInfo):
(WebCore::MemoryClassInfo::visitBaseClass):
(WebCore::MemoryClassInfo::reportInstrumentedPointer):
(WebCore::MemoryClassInfo::reportInstrumentedObject):
(WebCore::MemoryClassInfo::reportPointer):
(WebCore::MemoryClassInfo::reportObject):
(WebCore::MemoryClassInfo::reportHashMap):
(WebCore::MemoryClassInfo::reportHashSet):
(WebCore::MemoryClassInfo::reportListHashSet):
(WebCore::MemoryClassInfo::reportVector):
(WebCore::MemoryClassInfo::reportString):

  • dom/Node.cpp:

(WebCore::Node::reportMemoryUsage):

  • dom/QualifiedName.h:

(WebCore::QualifiedName::QualifiedNameImpl::reportMemoryUsage):
(WebCore::QualifiedName::reportMemoryUsage):

  • platform/TreeShared.h:

(WebCore::TreeShared::reportMemoryUsage):

Location:
trunk/Source/WebCore
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r122578 r122580  
     12012-07-13  Ilya Tikhonovsky  <loislo@chromium.org>
     2
     3        Web Inspector: native memory instrumentation: extract instrumentation methods into MemoryClassInfo
     4        https://bugs.webkit.org/show_bug.cgi?id=91227
     5
     6        Reviewed by Pavel Feldman.
     7
     8        void Node::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     9        {
     10            MemoryClassInfo<Node> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     11            info.visitBaseClass<ScriptWrappable>(this);
     12
     13            info.addMember(m_notInstrumentedPointer); // automatically detects poniter/reference
     14            info.addInstrumentedMember(m_next);
     15            info.addHashSet<MemoryInstrumentation::NonClass>(m_aHash);                // NonClass value_type (report only size of internal template structures)
     16            info.addHashSet<MemoryInstrumentation::NotInstrumentedClass>(m_aHashSet); // not instrumented value_type (use sizeof)
     17            info.addHashSet<MemoryInstrumentation::InstrumentedClass>(m_aHashSet);    // instrumented value_type (call visit)
     18        }
     19
     20        The change is covered by existing tests for native memory snapshot.
     21
     22        * bindings/v8/DOMDataStore.cpp:
     23        (WebCore::DOMDataStore::reportMemoryUsage):
     24        * bindings/v8/IntrusiveDOMWrapperMap.h:
     25        (WebCore::ChunkedTable::reportMemoryUsage):
     26        * bindings/v8/ScriptWrappable.h:
     27        (WebCore::ScriptWrappable::reportMemoryUsage):
     28        * bindings/v8/V8Binding.cpp:
     29        (WebCore::V8BindingPerIsolateData::reportMemoryUsage):
     30        (WebCore::StringCache::reportMemoryUsage):
     31        * bindings/v8/V8DOMMap.h:
     32        * css/StylePropertySet.h:
     33        (WebCore::StylePropertySet::reportMemoryUsage):
     34        * dom/CharacterData.cpp:
     35        (WebCore::CharacterData::reportMemoryUsage):
     36        * dom/ContainerNode.h:
     37        (WebCore::ContainerNode::reportMemoryUsage):
     38        * dom/Document.cpp:
     39        (WebCore::Document::reportMemoryUsage):
     40        * dom/Element.h:
     41        (WebCore::Element::reportMemoryUsage):
     42        * dom/ElementAttributeData.h:
     43        (WebCore::ElementAttributeData::reportMemoryUsage):
     44        * dom/MemoryInstrumentation.h:
     45        (MemoryInstrumentation):
     46        (WebCore::MemoryObjectInfo::objectType):
     47        (WebCore::MemoryObjectInfo::objectSize):
     48        (WebCore::MemoryObjectInfo::memoryInstrumentation):
     49        (MemoryObjectInfo):
     50        (WebCore::MemoryObjectInfo::reportObjectInfo):
     51        (WebCore):
     52        (MemoryClassInfo):
     53        (WebCore::MemoryClassInfo::MemoryClassInfo):
     54        (WebCore::MemoryClassInfo::visitBaseClass):
     55        (WebCore::MemoryClassInfo::reportInstrumentedPointer):
     56        (WebCore::MemoryClassInfo::reportInstrumentedObject):
     57        (WebCore::MemoryClassInfo::reportPointer):
     58        (WebCore::MemoryClassInfo::reportObject):
     59        (WebCore::MemoryClassInfo::reportHashMap):
     60        (WebCore::MemoryClassInfo::reportHashSet):
     61        (WebCore::MemoryClassInfo::reportListHashSet):
     62        (WebCore::MemoryClassInfo::reportVector):
     63        (WebCore::MemoryClassInfo::reportString):
     64        * dom/Node.cpp:
     65        (WebCore::Node::reportMemoryUsage):
     66        * dom/QualifiedName.h:
     67        (WebCore::QualifiedName::QualifiedNameImpl::reportMemoryUsage):
     68        (WebCore::QualifiedName::reportMemoryUsage):
     69        * platform/TreeShared.h:
     70        (WebCore::TreeShared::reportMemoryUsage):
     71
    1722012-07-13  Pavel Feldman  <pfeldman@chromium.org>
    273

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

    r121022 r122580  
    5757    void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    5858    {
    59         memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    60         memoryObjectInfo->reportObject(m_wrapper);
     59        MemoryClassInfo<ScriptWrappable> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     60        info.reportObject(m_wrapper);
    6161    }
    6262

  • trunk/Source/WebCore/bindings/v8/DOMDataStore.cpp

    r122466 r122580  
    122122void DOMDataStore::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    123123{
    124     memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::Binding);
    125     memoryObjectInfo->reportInstrumentedPointer(m_domNodeMap);
    126     memoryObjectInfo->reportInstrumentedPointer(m_activeDomNodeMap);
    127     memoryObjectInfo->reportInstrumentedPointer(m_domObjectMap);
    128     memoryObjectInfo->reportInstrumentedPointer(m_activeDomObjectMap);
     124    MemoryClassInfo<DOMDataStore> info(memoryObjectInfo, this, MemoryInstrumentation::Binding);
     125    info.reportInstrumentedPointer(m_domNodeMap);
     126    info.reportInstrumentedPointer(m_activeDomNodeMap);
     127    info.reportInstrumentedPointer(m_domObjectMap);
     128    info.reportInstrumentedPointer(m_activeDomObjectMap);
    129129}
    130130

  • trunk/Source/WebCore/bindings/v8/IntrusiveDOMWrapperMap.h

    r122466 r122580  
    105105    void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    106106    {
    107         memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::Binding);
     107        MemoryClassInfo<ChunkedTable> info(memoryObjectInfo, this, MemoryInstrumentation::Binding);
    108108        for (Chunk* chunk = m_chunks; chunk; chunk = chunk->m_previous)
    109             memoryObjectInfo->reportPointer(chunk, MemoryInstrumentation::Binding);
     109            info.reportPointer(chunk);
    110110    }
    111111
    … …  
    187187    virtual void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const OVERRIDE
    188188    {
    189         memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::Binding);
    190         memoryObjectInfo->reportInstrumentedObject(m_table);
     189        MemoryClassInfo<IntrusiveDOMWrapperMap> info(memoryObjectInfo, this, MemoryInstrumentation::Binding);
     190        info.reportInstrumentedObject(m_table);
    191191    }
    192192

  • trunk/Source/WebCore/bindings/v8/ScriptWrappable.h

    r121022 r122580  
    5555    void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    5656    {
    57         memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    58         memoryObjectInfo->reportPointer(m_wrapper, MemoryInstrumentation::DOM);
     57        MemoryClassInfo<ScriptWrappable> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     58        info.reportPointer(m_wrapper);
    5959    }
    6060

  • trunk/Source/WebCore/bindings/v8/V8Binding.cpp

    r122466 r122580  
    9393void V8BindingPerIsolateData::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    9494{
    95     memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::Binding);
    96     memoryObjectInfo->reportHashMap(m_rawTemplates);
    97     memoryObjectInfo->reportHashMap(m_templates);
    98     memoryObjectInfo->reportInstrumentedObject(m_stringCache);
    99     memoryObjectInfo->reportVector(m_domDataList);
     95    MemoryClassInfo<V8BindingPerIsolateData> info(memoryObjectInfo, this, MemoryInstrumentation::Binding);
     96    info.reportHashMap(m_rawTemplates);
     97    info.reportHashMap(m_templates);
     98    info.reportInstrumentedObject(m_stringCache);
     99    info.reportVector(m_domDataList);
    100100
    101101    for (size_t i = 0; i < m_domDataList.size(); i++)
    102         memoryObjectInfo->reportInstrumentedPointer(m_domDataList[i]);
     102        info.reportInstrumentedPointer(m_domDataList[i]);
    103103}
    104104
    … …  
    591591void StringCache::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    592592{
    593     memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::Binding);
    594     memoryObjectInfo->reportHashMap(m_stringCache);
     593    MemoryClassInfo<StringCache> info(memoryObjectInfo, this, MemoryInstrumentation::Binding);
     594    info.reportHashMap(m_stringCache);
    595595}
    596596   

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

    r122466 r122580  
    137137        virtual void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const OVERRIDE
    138138        {
    139             memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::Binding);
    140             memoryObjectInfo->reportHashMap(m_map);
     139            MemoryClassInfo<WeakReferenceMap<KeyType, ValueType> > info(memoryObjectInfo, this, MemoryInstrumentation::Binding);
     140            info.reportHashMap(m_map);
    141141        }
    142142

  • trunk/Source/WebCore/css/StylePropertySet.h

    r122450 r122580  
    119119    void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    120120    {
    121         memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::CSS);
     121        MemoryClassInfo<StylePropertySet> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
    122122        if (m_isMutable)
    123             memoryObjectInfo->reportPointer(m_mutablePropertyVector, MemoryInstrumentation::CSS);
     123            info.reportPointer(m_mutablePropertyVector);
    124124    }
    125125

  • trunk/Source/WebCore/dom/CharacterData.cpp

    r122159 r122580  
    9595void CharacterData::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    9696{
    97     memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    98     Node::reportMemoryUsage(memoryObjectInfo);
    99     memoryObjectInfo->reportString(m_data);
     97    MemoryClassInfo<CharacterData> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     98    info.visitBaseClass<Node>(this);
     99    info.reportString(m_data);
    100100}
    101101

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

    r121022 r122580  
    102102    virtual void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    103103    {
    104         memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    105         Node::reportMemoryUsage(memoryObjectInfo);
    106         memoryObjectInfo->reportInstrumentedPointer(m_firstChild);
    107         memoryObjectInfo->reportInstrumentedPointer(m_lastChild);
     104        MemoryClassInfo<ContainerNode> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     105        info.visitBaseClass<Node>(this);
     106        info.reportInstrumentedPointer(m_firstChild);
     107        info.reportInstrumentedPointer(m_lastChild);
    108108    }
    109109

  • trunk/Source/WebCore/dom/Document.cpp

    r122556 r122580  
    60766076void Document::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    60776077{
    6078     memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    6079     ContainerNode::reportMemoryUsage(memoryObjectInfo);
    6080     memoryObjectInfo->reportVector(m_customFonts);
    6081     memoryObjectInfo->reportString(m_documentURI);
    6082     memoryObjectInfo->reportString(m_baseTarget);
     6078    MemoryClassInfo<Document> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     6079    info.visitBaseClass<ContainerNode>(this);
     6080    info.reportVector(m_customFonts);
     6081    info.reportString(m_documentURI);
     6082    info.reportString(m_baseTarget);
    60836083    if (m_pageGroupUserSheets)
    6084         memoryObjectInfo->reportVector(*m_pageGroupUserSheets.get());
     6084        info.reportVector(*m_pageGroupUserSheets.get());
    60856085    if (m_userSheets)
    6086         memoryObjectInfo->reportVector(*m_userSheets.get());
    6087     memoryObjectInfo->reportHashSet(m_nodeIterators);
    6088     memoryObjectInfo->reportHashSet(m_ranges);
    6089     memoryObjectInfo->reportListHashSet(m_styleSheetCandidateNodes);
    6090     memoryObjectInfo->reportString(m_preferredStylesheetSet);
    6091     memoryObjectInfo->reportString(m_selectedStylesheetSet);
    6092     memoryObjectInfo->reportString(m_title.string());
    6093     memoryObjectInfo->reportString(m_rawTitle.string());
    6094     memoryObjectInfo->reportString(m_xmlEncoding);
    6095     memoryObjectInfo->reportString(m_xmlVersion);
    6096     memoryObjectInfo->reportString(m_contentLanguage);
    6097     memoryObjectInfo->reportHashMap(m_documentNamedItemCollections);
    6098     memoryObjectInfo->reportHashMap(m_windowNamedItemCollections);
     6086        info.reportVector(*m_userSheets.get());
     6087    info.reportHashSet(m_nodeIterators);
     6088    info.reportHashSet(m_ranges);
     6089    info.reportListHashSet(m_styleSheetCandidateNodes);
     6090    info.reportString(m_preferredStylesheetSet);
     6091    info.reportString(m_selectedStylesheetSet);
     6092    info.reportString(m_title.string());
     6093    info.reportString(m_rawTitle.string());
     6094    info.reportString(m_xmlEncoding);
     6095    info.reportString(m_xmlVersion);
     6096    info.reportString(m_contentLanguage);
     6097    info.reportHashMap(m_documentNamedItemCollections);
     6098    info.reportHashMap(m_windowNamedItemCollections);
    60996099#if ENABLE(DASHBOARD_SUPPORT)
    6100     memoryObjectInfo->reportVector(m_dashboardRegions);
    6101 #endif
    6102     memoryObjectInfo->reportHashMap(m_cssCanvasElements);
    6103     memoryObjectInfo->reportVector(m_iconURLs);
    6104     memoryObjectInfo->reportHashSet(m_documentSuspensionCallbackElements);
    6105     memoryObjectInfo->reportHashSet(m_mediaVolumeCallbackElements);
    6106     memoryObjectInfo->reportHashSet(m_privateBrowsingStateChangedElements);
    6107     memoryObjectInfo->reportHashMap(m_elementsByAccessKey);
    6108     memoryObjectInfo->reportHashSet(m_mediaCanStartListeners);
    6109     memoryObjectInfo->reportVector(m_pendingTasks);
     6100    info.reportVector(m_dashboardRegions);
     6101#endif
     6102    info.reportHashMap(m_cssCanvasElements);
     6103    info.reportVector(m_iconURLs);
     6104    info.reportHashSet(m_documentSuspensionCallbackElements);
     6105    info.reportHashSet(m_mediaVolumeCallbackElements);
     6106    info.reportHashSet(m_privateBrowsingStateChangedElements);
     6107    info.reportHashMap(m_elementsByAccessKey);
     6108    info.reportHashSet(m_mediaCanStartListeners);
     6109    info.reportVector(m_pendingTasks);
    61106110}
    61116111

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

    r122550 r122580  
    431431    virtual void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    432432    {
    433         memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    434         ContainerNode::reportMemoryUsage(memoryObjectInfo);
    435         memoryObjectInfo->reportInstrumentedObject(m_tagName);
    436         memoryObjectInfo->reportInstrumentedPointer(m_attributeData.get());
     433        MemoryClassInfo<Element> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     434        info.visitBaseClass<ContainerNode>(this);
     435        info.reportInstrumentedObject(m_tagName);
     436        info.reportInstrumentedPointer(m_attributeData.get());
    437437    }
    438438

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

    r122450 r122580  
    105105    void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    106106    {
    107         memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    108         memoryObjectInfo->reportInstrumentedPointer(m_inlineStyleDecl.get());
    109         memoryObjectInfo->reportInstrumentedPointer(m_attributeStyle.get());
    110         memoryObjectInfo->reportObject(m_classNames);
    111         memoryObjectInfo->reportObject(m_idForStyleResolution);
     107        MemoryClassInfo<ElementAttributeData> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     108        info.reportInstrumentedPointer(m_inlineStyleDecl.get());
     109        info.reportInstrumentedPointer(m_attributeStyle.get());
     110        info.reportObject(m_classNames);
     111        info.reportObject(m_idForStyleResolution);
    112112        if (m_isMutable)
    113             memoryObjectInfo->reportPointer(m_mutableAttributeVector, MemoryInstrumentation::DOM);
     113            info.reportPointer(m_mutableAttributeVector);
    114114    }
    115115

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

    r122243 r122580  
    8282
    8383private:
    84     friend class MemoryObjectInfo;
    85 
     84    template <typename T> friend class MemoryClassInfo;
    8685    template <typename T>
    8786    class InstrumentedPointer : public InstrumentedPointerBase {
    … …  
    109108     { }
    110109
    111     template <typename P>
    112     void reportInstrumentedPointer(const P* memberPointer)
    113     {
    114         m_memoryInstrumentation->reportInstrumentedPointer(memberPointer);
    115     }
    116 
    117     template <typename P>
    118     void reportPointer(const P* pointer, MemoryInstrumentation::ObjectType objectType)
    119     {
    120         m_memoryInstrumentation->reportPointer(pointer, objectType);
    121     }
    122 
    123     template <typename T>
    124     void reportInstrumentedObject(const T& memberObject)
    125     {
    126         m_memoryInstrumentation->reportInstrumentedObject(memberObject);
    127     }
    128 
    129     template <typename T>
    130     void reportObject(const T& object) { m_memoryInstrumentation->reportObject(object); }
    131 
    132     template <typename T>
    133     void reportObjectInfo(const T*, MemoryInstrumentation::ObjectType objectType)
     110    MemoryInstrumentation::ObjectType objectType() const { return m_objectType; }
     111    size_t objectSize() const { return m_objectSize; }
     112
     113    MemoryInstrumentation* memoryInstrumentation() { return m_memoryInstrumentation; }
     114
     115private:
     116    template <typename T> friend class MemoryClassInfo;
     117
     118    template <typename T> void reportObjectInfo(const T*, MemoryInstrumentation::ObjectType objectType)
    134119    {
    135120        if (m_objectType != MemoryInstrumentation::Other)
    … …  
    139124    }
    140125
    141     template <typename HashMapType>
    142     void reportHashMap(const HashMapType& map)
    143     {
    144         m_memoryInstrumentation->reportHashMap(map, objectType(), true);
    145     }
    146 
    147     template <typename HashSetType>
    148     void reportHashSet(const HashSetType& set)
    149     {
    150         m_memoryInstrumentation->reportHashSet(set, objectType(), true);
    151     }
    152 
    153     template <typename ListHashSetType>
    154     void reportListHashSet(const ListHashSetType& set)
    155     {
    156         m_memoryInstrumentation->reportListHashSet(set, objectType(), true);
    157     }
    158 
    159     template <typename VectorType>
    160     void reportVector(const VectorType& vector)
    161     {
    162         m_memoryInstrumentation->reportVector(vector, objectType(), true);
    163     }
    164 
    165     void reportString(const String& string)
    166     {
    167         m_memoryInstrumentation->reportString(objectType(), string);
    168     }
    169 
    170     MemoryInstrumentation::ObjectType objectType() const { return m_objectType; }
    171     size_t objectSize() const { return m_objectSize; }
    172 
    173     MemoryInstrumentation* memoryInstrumentation() { return m_memoryInstrumentation; }
    174 
    175  private:
    176126    MemoryInstrumentation* m_memoryInstrumentation;
    177127    MemoryInstrumentation::ObjectType m_objectType;
    … …  
    180130
    181131template <typename T>
     132class MemoryClassInfo {
     133public:
     134    MemoryClassInfo(MemoryObjectInfo* memoryObjectInfo, const T* ptr, MemoryInstrumentation::ObjectType objectType)
     135        : m_memoryObjectInfo(memoryObjectInfo)
     136        , m_memoryInstrumentation(memoryObjectInfo->memoryInstrumentation())
     137    {
     138        m_memoryObjectInfo->reportObjectInfo(ptr, objectType);
     139        m_objectType = memoryObjectInfo->objectType();
     140    }
     141
     142    template <typename P> void visitBaseClass(const P* ptr) { ptr->P::reportMemoryUsage(m_memoryObjectInfo); }
     143
     144    template <typename P> void reportInstrumentedPointer(const P* memberPointer) { m_memoryInstrumentation->reportInstrumentedPointer(memberPointer); }
     145    template <typename O> void reportInstrumentedObject(const O& memberObject) { m_memoryInstrumentation->reportInstrumentedObject(memberObject); }
     146
     147    template <typename P> void reportPointer(const P* pointer) { m_memoryInstrumentation->reportPointer(pointer, m_objectType); }
     148    template <typename O> void reportObject(const O& object) { m_memoryInstrumentation->reportObject(object); }
     149
     150    template <typename HashMapType> void reportHashMap(const HashMapType& map) { m_memoryInstrumentation->reportHashMap(map, m_objectType, true); }
     151    template <typename HashSetType> void reportHashSet(const HashSetType& set) { m_memoryInstrumentation->reportHashSet(set, m_objectType, true); }
     152    template <typename ListHashSetType> void reportListHashSet(const ListHashSetType& set) { m_memoryInstrumentation->reportListHashSet(set, m_objectType, true); }
     153    template <typename VectorType> void reportVector(const VectorType& vector) { m_memoryInstrumentation->reportVector(vector, m_objectType, true); }
     154
     155    void reportString(const String& string) { m_memoryInstrumentation->reportString(m_objectType, string); }
     156
     157private:
     158    MemoryObjectInfo* m_memoryObjectInfo;
     159    MemoryInstrumentation* m_memoryInstrumentation;
     160    MemoryInstrumentation::ObjectType m_objectType;
     161};
     162
     163template <typename T>
    182164void MemoryInstrumentation::reportInstrumentedPointer(const T* const object)
    183165{

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

    r122550 r122580  
    28022802void Node::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    28032803{
    2804     memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    2805     TreeShared<Node, ContainerNode>::reportMemoryUsage(memoryObjectInfo);
    2806     ScriptWrappable::reportMemoryUsage(memoryObjectInfo);
    2807     memoryObjectInfo->reportPointer(m_document, MemoryInstrumentation::DOM);
    2808     memoryObjectInfo->reportInstrumentedPointer(m_next);
    2809     memoryObjectInfo->reportInstrumentedPointer(m_previous);
     2804    MemoryClassInfo<Node> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     2805    info.visitBaseClass<TreeShared<Node, ContainerNode> >(this);
     2806    info.visitBaseClass<ScriptWrappable>(this);
     2807    info.reportInstrumentedPointer(m_document);
     2808    info.reportInstrumentedPointer(m_next);
     2809    info.reportInstrumentedPointer(m_previous);
    28102810}
    28112811

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

    r121022 r122580  
    5353        void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    5454        {
    55             memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    56             memoryObjectInfo->reportObject(m_prefix);
    57             memoryObjectInfo->reportObject(m_localName);
    58             memoryObjectInfo->reportObject(m_namespace);
    59             memoryObjectInfo->reportObject(m_localNameUpper);
     55            MemoryClassInfo<QualifiedNameImpl> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     56            info.reportObject(m_prefix);
     57            info.reportObject(m_localName);
     58            info.reportObject(m_namespace);
     59            info.reportObject(m_localNameUpper);
    6060        }
    6161    private:
    … …  
    105105    void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    106106    {
    107         memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    108         memoryObjectInfo->reportInstrumentedPointer(m_impl);
     107        MemoryClassInfo<QualifiedName> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     108        info.reportInstrumentedPointer(m_impl);
    109109    }
    110110private:

  • trunk/Source/WebCore/platform/TreeShared.h

    r121022 r122580  
    114114    void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    115115    {
    116         memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    117         memoryObjectInfo->reportInstrumentedPointer(m_parent);
     116        MemoryClassInfo<TreeShared<NodeType, ParentNodeType> > info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     117        info.reportInstrumentedPointer(m_parent);
    118118    }
    119119
Note: See TracChangeset for help on using the changeset viewer.