Changeset 122713 in webkit


Ignore:
Timestamp:
Jul 16, 2012 4:48:11 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

    r122707 r122713  
     12012-07-16  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-15  Carlos Garcia Campos  <cgarcia@igalia.com>
    273

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

    r122600 r122713  
    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

    r122600 r122713  
    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

    r122600 r122713  
    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

    r122600 r122713  
    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

    r122664 r122713  
    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

    r122600 r122713  
    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

    r122600 r122713  
    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

    r122600 r122713  
    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

    r122600 r122713  
    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

    r122637 r122713  
    60636063void Document::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    60646064{
    6065     memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    6066     ContainerNode::reportMemoryUsage(memoryObjectInfo);
    6067     memoryObjectInfo->reportVector(m_customFonts);
    6068     memoryObjectInfo->reportString(m_documentURI);
    6069     memoryObjectInfo->reportString(m_baseTarget);
     6065    MemoryClassInfo<Document> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     6066    info.visitBaseClass<ContainerNode>(this);
     6067    info.reportVector(m_customFonts);
     6068    info.reportString(m_documentURI);
     6069    info.reportString(m_baseTarget);
    60706070    if (m_pageGroupUserSheets)
    6071         memoryObjectInfo->reportVector(*m_pageGroupUserSheets.get());
     6071        info.reportVector(*m_pageGroupUserSheets.get());
    60726072    if (m_userSheets)
    6073         memoryObjectInfo->reportVector(*m_userSheets.get());
    6074     memoryObjectInfo->reportHashSet(m_nodeIterators);
    6075     memoryObjectInfo->reportHashSet(m_ranges);
    6076     memoryObjectInfo->reportListHashSet(m_styleSheetCandidateNodes);
    6077     memoryObjectInfo->reportString(m_preferredStylesheetSet);
    6078     memoryObjectInfo->reportString(m_selectedStylesheetSet);
    6079     memoryObjectInfo->reportString(m_title.string());
    6080     memoryObjectInfo->reportString(m_rawTitle.string());
    6081     memoryObjectInfo->reportString(m_xmlEncoding);
    6082     memoryObjectInfo->reportString(m_xmlVersion);
    6083     memoryObjectInfo->reportString(m_contentLanguage);
    6084     memoryObjectInfo->reportHashMap(m_documentNamedItemCollections);
    6085     memoryObjectInfo->reportHashMap(m_windowNamedItemCollections);
     6073        info.reportVector(*m_userSheets.get());
     6074    info.reportHashSet(m_nodeIterators);
     6075    info.reportHashSet(m_ranges);
     6076    info.reportListHashSet(m_styleSheetCandidateNodes);
     6077    info.reportString(m_preferredStylesheetSet);
     6078    info.reportString(m_selectedStylesheetSet);
     6079    info.reportString(m_title.string());
     6080    info.reportString(m_rawTitle.string());
     6081    info.reportString(m_xmlEncoding);
     6082    info.reportString(m_xmlVersion);
     6083    info.reportString(m_contentLanguage);
     6084    info.reportHashMap(m_documentNamedItemCollections);
     6085    info.reportHashMap(m_windowNamedItemCollections);
    60866086#if ENABLE(DASHBOARD_SUPPORT)
    6087     memoryObjectInfo->reportVector(m_dashboardRegions);
    6088 #endif
    6089     memoryObjectInfo->reportHashMap(m_cssCanvasElements);
    6090     memoryObjectInfo->reportVector(m_iconURLs);
    6091     memoryObjectInfo->reportHashSet(m_documentSuspensionCallbackElements);
    6092     memoryObjectInfo->reportHashSet(m_mediaVolumeCallbackElements);
    6093     memoryObjectInfo->reportHashSet(m_privateBrowsingStateChangedElements);
    6094     memoryObjectInfo->reportHashMap(m_elementsByAccessKey);
    6095     memoryObjectInfo->reportHashSet(m_mediaCanStartListeners);
    6096     memoryObjectInfo->reportVector(m_pendingTasks);
     6087    info.reportVector(m_dashboardRegions);
     6088#endif
     6089    info.reportHashMap(m_cssCanvasElements);
     6090    info.reportVector(m_iconURLs);
     6091    info.reportHashSet(m_documentSuspensionCallbackElements);
     6092    info.reportHashSet(m_mediaVolumeCallbackElements);
     6093    info.reportHashSet(m_privateBrowsingStateChangedElements);
     6094    info.reportHashMap(m_elementsByAccessKey);
     6095    info.reportHashSet(m_mediaCanStartListeners);
     6096    info.reportVector(m_pendingTasks);
    60976097}
    60986098

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

    r122600 r122713  
    430430    virtual void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    431431    {
    432         memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    433         ContainerNode::reportMemoryUsage(memoryObjectInfo);
    434         memoryObjectInfo->reportInstrumentedObject(m_tagName);
    435         memoryObjectInfo->reportInstrumentedPointer(m_attributeData.get());
     432        MemoryClassInfo<Element> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     433        info.visitBaseClass<ContainerNode>(this);
     434        info.reportInstrumentedObject(m_tagName);
     435        info.reportInstrumentedPointer(m_attributeData.get());
    436436    }
    437437

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

    r122600 r122713  
    103103    void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    104104    {
    105         memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    106         memoryObjectInfo->reportInstrumentedPointer(m_inlineStyleDecl.get());
    107         memoryObjectInfo->reportInstrumentedPointer(m_attributeStyle.get());
    108         memoryObjectInfo->reportObject(m_classNames);
    109         memoryObjectInfo->reportObject(m_idForStyleResolution);
    110         memoryObjectInfo->reportObject(m_attributes);
     105        MemoryClassInfo<ElementAttributeData> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     106        info.reportInstrumentedPointer(m_inlineStyleDecl.get());
     107        info.reportInstrumentedPointer(m_attributeStyle.get());
     108        info.reportObject(m_classNames);
     109        info.reportObject(m_idForStyleResolution);
     110        info.reportVector(m_attributes);
    111111    }
    112112

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

    r122600 r122713  
    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

    r122637 r122713  
    27692769void Node::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    27702770{
    2771     memoryObjectInfo->reportObjectInfo(this, MemoryInstrumentation::DOM);
    2772     TreeShared<Node, ContainerNode>::reportMemoryUsage(memoryObjectInfo);
    2773     ScriptWrappable::reportMemoryUsage(memoryObjectInfo);
    2774     memoryObjectInfo->reportPointer(m_document, MemoryInstrumentation::DOM);
    2775     memoryObjectInfo->reportInstrumentedPointer(m_next);
    2776     memoryObjectInfo->reportInstrumentedPointer(m_previous);
     2771    MemoryClassInfo<Node> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
     2772    info.visitBaseClass<TreeShared<Node, ContainerNode> >(this);
     2773    info.visitBaseClass<ScriptWrappable>(this);
     2774    info.reportInstrumentedPointer(m_document);
     2775    info.reportInstrumentedPointer(m_next);
     2776    info.reportInstrumentedPointer(m_previous);
    27772777}
    27782778

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

    r122600 r122713  
    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

    r122600 r122713  
    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.