Changeset 124330 in webkit


Ignore:
Timestamp:
Aug 1, 2012 6:29:59 AM (12 years ago)
Author:
yurys@chromium.org
Message:

Web Inspector: add CSSStyleSheet memory instrumentation
https://bugs.webkit.org/show_bug.cgi?id=92748

Reviewed by Antti Koivisto.

Added MemoryInstrumentation for CSSStyleSheet, StyleSheetContents, StyleRule,
CSSSelectorList and StylePropertySet. The coverage is not complete as the
patch was growing too big.

  • css/CSSSelectorList.cpp:

(WebCore::CSSSelectorList::CSSSelectorList):
(WebCore::CSSSelectorList::length):
(WebCore):
(WebCore::CSSSelectorList::reportMemoryUsage):

  • css/CSSSelectorList.h:

(WebCore):
(CSSSelectorList):

  • css/CSSStyleSheet.cpp:

(WebCore::CSSStyleSheet::reportMemoryUsage):
(WebCore):

  • css/CSSStyleSheet.h:

(WebCore):
(CSSStyleSheet):

  • css/MediaList.cpp:

(WebCore):
(WebCore::MediaQuerySet::reportMemoryUsage):
(WebCore::MediaList::reportMemoryUsage):

  • css/MediaList.h:

(WebCore):
(MediaQuerySet):
(MediaList):

  • css/MediaQuery.cpp:

(WebCore::MediaQuery::reportMemoryUsage):
(WebCore):

  • css/MediaQuery.h:

(WebCore):
(MediaQuery):

  • css/MediaQueryExp.cpp:

(WebCore::MediaQueryExp::reportMemoryUsage):
(WebCore):

  • css/MediaQueryExp.h:

(WebCore):
(MediaQueryExp):

  • css/StylePropertySet.cpp:

(WebCore::StylePropertySet::reportMemoryUsage):
(WebCore):

  • css/StylePropertySet.h:

(WebCore):
(StylePropertySet):

  • css/StyleRule.cpp:

(WebCore::StyleRuleBase::reportMemoryUsage): We cannot make
reportMemoryUsage virtual as it would add vtable to StyleRuleBase
and its descendants and would blow its memory footprint. This
is why we have a switch over StyleRule type here.
(WebCore):
(WebCore::StyleRule::reportMemoryUsage):
(WebCore::StyleRulePage::reportMemoryUsage):
(WebCore::StyleRuleFontFace::reportMemoryUsage):
(WebCore::StyleRuleBlock::reportMemoryUsage):
(WebCore::StyleRuleMedia::reportMemoryUsage):
(WebCore::StyleRuleRegion::reportMemoryUsage):

  • css/StyleRule.h:

(WebCore):
(StyleRuleBase):
(StyleRule):
(StyleRuleFontFace):
(StyleRulePage):
(StyleRuleBlock):
(StyleRuleMedia):
(StyleRuleRegion):

  • css/StyleSheetContents.cpp:

(WebCore::StyleSheetContents::reportMemoryUsage):
(WebCore):

  • css/StyleSheetContents.h:

(WebCore):
(StyleSheetContents):

  • dom/Document.cpp:

(WebCore::Document::reportMemoryUsage):

  • dom/MemoryInstrumentation.h:

(WebCore::MemoryClassInfo::addInstrumentedVectorPtr):
(WebCore::MemoryClassInfo::addVectorPtr):

Location:
trunk/Source/WebCore
Files:
25 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r124326 r124330  
     12012-07-31  Yury Semikhatsky  <yurys@chromium.org>
     2
     3        Web Inspector: add CSSStyleSheet memory instrumentation
     4        https://bugs.webkit.org/show_bug.cgi?id=92748
     5
     6        Reviewed by Antti Koivisto.
     7
     8        Added MemoryInstrumentation for CSSStyleSheet, StyleSheetContents, StyleRule,
     9        CSSSelectorList and StylePropertySet. The coverage is not complete as the
     10        patch was growing too big.
     11
     12        * css/CSSSelectorList.cpp:
     13        (WebCore::CSSSelectorList::CSSSelectorList):
     14        (WebCore::CSSSelectorList::length):
     15        (WebCore):
     16        (WebCore::CSSSelectorList::reportMemoryUsage):
     17        * css/CSSSelectorList.h:
     18        (WebCore):
     19        (CSSSelectorList):
     20        * css/CSSStyleSheet.cpp:
     21        (WebCore::CSSStyleSheet::reportMemoryUsage):
     22        (WebCore):
     23        * css/CSSStyleSheet.h:
     24        (WebCore):
     25        (CSSStyleSheet):
     26        * css/MediaList.cpp:
     27        (WebCore):
     28        (WebCore::MediaQuerySet::reportMemoryUsage):
     29        (WebCore::MediaList::reportMemoryUsage):
     30        * css/MediaList.h:
     31        (WebCore):
     32        (MediaQuerySet):
     33        (MediaList):
     34        * css/MediaQuery.cpp:
     35        (WebCore::MediaQuery::reportMemoryUsage):
     36        (WebCore):
     37        * css/MediaQuery.h:
     38        (WebCore):
     39        (MediaQuery):
     40        * css/MediaQueryExp.cpp:
     41        (WebCore::MediaQueryExp::reportMemoryUsage):
     42        (WebCore):
     43        * css/MediaQueryExp.h:
     44        (WebCore):
     45        (MediaQueryExp):
     46        * css/StylePropertySet.cpp:
     47        (WebCore::StylePropertySet::reportMemoryUsage):
     48        (WebCore):
     49        * css/StylePropertySet.h:
     50        (WebCore):
     51        (StylePropertySet):
     52        * css/StyleRule.cpp:
     53        (WebCore::StyleRuleBase::reportMemoryUsage): We cannot make
     54        reportMemoryUsage virtual as it would add vtable to StyleRuleBase
     55        and its descendants and would blow its memory footprint. This
     56        is why we have a switch over StyleRule type here.
     57        (WebCore):
     58        (WebCore::StyleRule::reportMemoryUsage):
     59        (WebCore::StyleRulePage::reportMemoryUsage):
     60        (WebCore::StyleRuleFontFace::reportMemoryUsage):
     61        (WebCore::StyleRuleBlock::reportMemoryUsage):
     62        (WebCore::StyleRuleMedia::reportMemoryUsage):
     63        (WebCore::StyleRuleRegion::reportMemoryUsage):
     64        * css/StyleRule.h:
     65        (WebCore):
     66        (StyleRuleBase):
     67        (StyleRule):
     68        (StyleRuleFontFace):
     69        (StyleRulePage):
     70        (StyleRuleBlock):
     71        (StyleRuleMedia):
     72        (StyleRuleRegion):
     73        * css/StyleSheetContents.cpp:
     74        (WebCore::StyleSheetContents::reportMemoryUsage):
     75        (WebCore):
     76        * css/StyleSheetContents.h:
     77        (WebCore):
     78        (StyleSheetContents):
     79        * dom/Document.cpp:
     80        (WebCore::Document::reportMemoryUsage):
     81        * dom/MemoryInstrumentation.h:
     82        (WebCore::MemoryClassInfo::addInstrumentedVectorPtr):
     83        (WebCore::MemoryClassInfo::addVectorPtr):
     84
    1852012-08-01  Keishi Hattori  <keishi@webkit.org>
    286
  • trunk/Source/WebCore/css/CSSSelectorList.cpp

    r115319 r124330  
    2929
    3030#include "CSSParserValues.h"
     31#include "MemoryInstrumentation.h"
    3132#include <wtf/text/StringBuilder.h>
    3233
     
    4041CSSSelectorList::CSSSelectorList(const CSSSelectorList& o)
    4142{
    42     CSSSelector* current = o.m_selectorArray;
    43     while (!current->isLastInSelectorList())
    44         ++current;
    45     unsigned length = (current - o.m_selectorArray) + 1;
     43    unsigned length = o.length();
    4644    if (length == 1) {
    4745        // Destructor expects a single selector to be allocated by new, multiple with fastMalloc.
     
    9694    m_selectorArray[arrayIndex - 1].setLastInSelectorList();
    9795    selectorVector.shrink(0);
     96}
     97
     98unsigned CSSSelectorList::length() const
     99{
     100    if (!m_selectorArray)
     101        return 0;
     102    CSSSelector* current = m_selectorArray;
     103    while (!current->isLastInSelectorList())
     104        ++current;
     105    return (current - m_selectorArray) + 1;
    98106}
    99107
     
    136144}
    137145
     146void CSSSelectorList::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     147{
     148    MemoryClassInfo<CSSSelectorList> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     149    info.addRawBuffer(m_selectorArray, length() * sizeof(CSSSelector));
     150}
     151
    138152template <typename Functor>
    139153static bool forEachTagSelector(Functor& functor, CSSSelector* selector)
  • trunk/Source/WebCore/css/CSSSelectorList.h

    r115115 r124330  
    3232
    3333class CSSParserSelector;
     34class MemoryObjectInfo;
    3435
    3536class CSSSelectorList {
     
    5354    String selectorsText() const;
    5455
     56    void reportMemoryUsage(MemoryObjectInfo*) const;
     57
    5558private:
     59    unsigned length() const;
    5660    void deleteSelectors();
    5761
  • trunk/Source/WebCore/css/CSSStyleSheet.cpp

    r118336 r124330  
    3333#include "HTMLNames.h"
    3434#include "MediaList.h"
     35#include "MemoryInstrumentation.h"
    3536#include "Node.h"
    3637#include "SVGNames.h"
     
    169170}
    170171
     172void CSSStyleSheet::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     173{
     174    MemoryClassInfo<CSSStyleSheet> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     175    info.addInstrumentedMember(m_contents);
     176    info.addString(m_title);
     177    info.addInstrumentedMember(m_mediaQueries);
     178    info.addInstrumentedMember(m_ownerNode);
     179    info.addInstrumentedMember(m_mediaCSSOMWrapper);
     180}
     181
    171182void CSSStyleSheet::setDisabled(bool disabled)
    172183{
  • trunk/Source/WebCore/css/CSSStyleSheet.h

    r118336 r124330  
    4040class Document;
    4141class MediaQuerySet;
     42class MemoryObjectInfo;
    4243class SecurityOrigin;
    4344class StyleSheetContents;
     
    106107    StyleSheetContents* contents() const { return m_contents.get(); }
    107108
     109    void reportMemoryUsage(MemoryObjectInfo*) const;
     110
    108111private:
    109112    CSSStyleSheet(PassRefPtr<StyleSheetContents>, CSSImportRule* ownerRule);
  • trunk/Source/WebCore/css/MediaList.cpp

    r116291 r124330  
    2727#include "MediaQuery.h"
    2828#include "MediaQueryExp.h"
     29#include "MemoryInstrumentation.h"
    2930
    3031namespace WebCore {
     
    210211    return text;
    211212}
     213
     214void MediaQuerySet::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     215{
     216    MemoryClassInfo<MediaQuerySet> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     217    info.addInstrumentedVector(m_queries);
     218}
    212219   
    213220MediaList::MediaList(MediaQuerySet* mediaQueries, CSSStyleSheet* parentSheet)
     
    283290}
    284291
    285 }
     292void MediaList::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     293{
     294    MemoryClassInfo<MediaList> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     295    info.addInstrumentedMember(m_mediaQueries);
     296}
     297
     298}
  • trunk/Source/WebCore/css/MediaList.h

    r116291 r124330  
    3535class MediaList;
    3636class MediaQuery;
     37class MemoryObjectInfo;
    3738
    3839class MediaQuerySet : public RefCounted<MediaQuerySet> {
     
    6667
    6768    PassRefPtr<MediaQuerySet> copy() const { return adoptRef(new MediaQuerySet(*this)); }
     69
     70    void reportMemoryUsage(MemoryObjectInfo*) const;
    6871
    6972private:
     
    107110    void reattach(MediaQuerySet*);
    108111
     112    void reportMemoryUsage(MemoryObjectInfo*) const;
     113
    109114private:
    110115    MediaList();
  • trunk/Source/WebCore/css/MediaQuery.cpp

    r118659 r124330  
    3131
    3232#include "MediaQueryExp.h"
     33#include "MemoryInstrumentation.h"
    3334#include <wtf/NonCopyingSort.h>
    3435#include <wtf/text/StringBuilder.h>
     
    134135}
    135136
     137void MediaQuery::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     138{
     139    MemoryClassInfo<MediaQuery> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     140    info.addString(m_mediaType);
     141    info.addInstrumentedVectorPtr(m_expressions);
     142    info.addString(m_serializationCache);
     143}
     144
    136145} //namespace
  • trunk/Source/WebCore/css/MediaQuery.h

    r118659 r124330  
    3737namespace WebCore {
    3838class MediaQueryExp;
     39class MemoryObjectInfo;
    3940
    4041class MediaQuery {
     
    5960    PassOwnPtr<MediaQuery> copy() const { return adoptPtr(new MediaQuery(*this)); }
    6061
     62    void reportMemoryUsage(MemoryObjectInfo*) const;
     63
    6164 private:
    6265    MediaQuery(const MediaQuery&);
  • trunk/Source/WebCore/css/MediaQueryExp.cpp

    r114676 r124330  
    3333#include "CSSPrimitiveValue.h"
    3434#include "CSSValueList.h"
     35#include "MemoryInstrumentation.h"
    3536#include <wtf/text/StringBuilder.h>
    3637
     
    109110}
    110111
     112void MediaQueryExp::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     113{
     114    MemoryClassInfo<MediaQueryExp> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     115    info.addString(m_mediaFeature);
     116    info.addString(m_serializationCache);
     117}
     118
    111119} // namespace
  • trunk/Source/WebCore/css/MediaQueryExp.h

    r115115 r124330  
    3838namespace WebCore {
    3939class CSSParserValueList;
     40class MemoryObjectInfo;
    4041
    4142class MediaQueryExp {
     
    7374    PassOwnPtr<MediaQueryExp> copy() const { return adoptPtr(new MediaQueryExp(*this)); }
    7475
     76    void reportMemoryUsage(MemoryObjectInfo*) const;
     77
    7578private:
    7679    MediaQueryExp(const AtomicString& mediaFeature, CSSParserValueList* values);
  • trunk/Source/WebCore/css/StylePropertySet.cpp

    r122600 r124330  
    10761076}
    10771077
     1078void StylePropertySet::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     1079{
     1080    MemoryClassInfo<StylePropertySet> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     1081    if (m_isMutable)
     1082        info.addVectorPtr(m_mutablePropertyVector);
     1083    else
     1084        info.addRawBuffer(m_properties, m_arraySize * sizeof(CSSProperty));
     1085}
     1086
    10781087// See the function above if you need to update this.
    10791088struct SameSizeAsStylePropertySet : public RefCounted<SameSizeAsStylePropertySet> {
  • trunk/Source/WebCore/css/StylePropertySet.h

    r123396 r124330  
    2626#include "CSSProperty.h"
    2727#include "CSSPropertyNames.h"
    28 #include "MemoryInstrumentation.h"
    2928#include <wtf/ListHashSet.h>
    3029#include <wtf/Vector.h>
     
    3635class CSSStyleDeclaration;
    3736class KURL;
     37class MemoryObjectInfo;
    3838class PropertySetCSSStyleDeclaration;
    3939class StyledElement;
     
    112112
    113113    static unsigned averageSizeInBytes();
     114    void reportMemoryUsage(MemoryObjectInfo*) const;
    114115
    115116#ifndef NDEBUG
     
    117118#endif
    118119   
    119     void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
    120     {
    121         MemoryClassInfo<StylePropertySet> info(memoryObjectInfo, this, MemoryInstrumentation::CSS, m_arraySize * sizeof(CSSProperty));
    122         if (m_isMutable)
    123             info.addMember(m_mutablePropertyVector);
    124     }
    125 
    126120private:
    127121    StylePropertySet(CSSParserMode);
  • trunk/Source/WebCore/css/StyleRule.cpp

    r121764 r124330  
    2929#include "CSSPageRule.h"
    3030#include "CSSStyleRule.h"
     31#include "MemoryInstrumentation.h"
    3132#include "StyleRuleImport.h"
    3233#include "WebKitCSSKeyframeRule.h"
     
    5051{
    5152    return createCSSOMWrapper(0, parentRule);
     53}
     54
     55void StyleRuleBase::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     56{
     57    switch (type()) {
     58    case Style:
     59        static_cast<const StyleRule*>(this)->reportMemoryUsage(memoryObjectInfo);
     60        return;
     61    case Page:
     62        static_cast<const StyleRulePage*>(this)->reportMemoryUsage(memoryObjectInfo);
     63        return;
     64    case FontFace:
     65        static_cast<const StyleRuleFontFace*>(this)->reportMemoryUsage(memoryObjectInfo);
     66        return;
     67    case Media:
     68        static_cast<const StyleRuleMedia*>(this)->reportMemoryUsage(memoryObjectInfo);
     69        return;
     70#if ENABLE(CSS_REGIONS)
     71    case Region:
     72        static_cast<const StyleRuleRegion*>(this)->reportMemoryUsage(memoryObjectInfo);
     73        return;
     74#endif
     75    case Import:
     76        static_cast<const StyleRuleImport*>(this)->reportMemoryUsage(memoryObjectInfo);
     77        return;
     78    case Keyframes:
     79        static_cast<const StyleRuleKeyframes*>(this)->reportMemoryUsage(memoryObjectInfo);
     80        return;
     81    case Unknown:
     82    case Charset:
     83    case Keyframe:
     84        MemoryClassInfo<StyleRuleBase> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     85        return;
     86    }
     87    ASSERT_NOT_REACHED();
    5288}
    5389
     
    171207}
    172208
     209void StyleRule::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     210{
     211    MemoryClassInfo<StyleRule> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     212    info.addInstrumentedMember(m_properties);
     213    info.addInstrumentedMember(m_selectorList);
     214}
     215
    173216StyleRule::StyleRule(int sourceLine)
    174217    : StyleRuleBase(Style, sourceLine)
     
    227270}
    228271
     272void StyleRulePage::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     273{
     274    MemoryClassInfo<StyleRulePage> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     275    info.addInstrumentedMember(m_properties);
     276    info.addInstrumentedMember(m_selectorList);
     277}
     278
    229279StyleRuleFontFace::StyleRuleFontFace()
    230280    : StyleRuleBase(FontFace, 0)
     
    254304}
    255305
     306void StyleRuleFontFace::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     307{
     308    MemoryClassInfo<StyleRuleFontFace> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     309    info.addInstrumentedMember(m_properties);
     310}
     311
     312
    256313StyleRuleBlock::StyleRuleBlock(Type type, Vector<RefPtr<StyleRuleBase> >& adoptRule)
    257314    : StyleRuleBase(type, 0)
     
    278335}
    279336
     337void StyleRuleBlock::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     338{
     339    MemoryClassInfo<StyleRuleBlock> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     340    info.addInstrumentedVector(m_childRules);
     341}
     342
    280343StyleRuleMedia::StyleRuleMedia(PassRefPtr<MediaQuerySet> media, Vector<RefPtr<StyleRuleBase> >& adoptRules)
    281344    : StyleRuleBlock(Media, adoptRules)
     
    291354}
    292355
     356void StyleRuleMedia::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     357{
     358    MemoryClassInfo<StyleRuleMedia> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     359    info.addInstrumentedMember(m_mediaQueries);
     360}
     361
    293362StyleRuleRegion::StyleRuleRegion(Vector<OwnPtr<CSSParserSelector> >* selectors, Vector<RefPtr<StyleRuleBase> >& adoptRules)
    294363    : StyleRuleBlock(Region, adoptRules)
     
    303372}
    304373
     374void StyleRuleRegion::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     375{
     376    MemoryClassInfo<StyleRuleRegion> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     377    info.addInstrumentedMember(m_selectorList);
     378}
     379
    305380} // namespace WebCore
  • trunk/Source/WebCore/css/StyleRule.h

    r120943 r124330  
    3232class CSSStyleRule;
    3333class CSSStyleSheet;
     34class MemoryObjectInfo;
    3435class StylePropertySet;
    3536
     
    7374    PassRefPtr<CSSRule> createCSSOMWrapper(CSSRule* parentRule) const;
    7475
     76    void reportMemoryUsage(MemoryObjectInfo*) const;
     77
    7578protected:
    7679    StyleRuleBase(Type type, signed sourceLine = 0) : m_type(type), m_sourceLine(sourceLine) { }
     
    105108
    106109    static unsigned averageSizeInBytes();
     110    void reportMemoryUsage(MemoryObjectInfo*) const;
    107111
    108112private:
     
    126130
    127131    PassRefPtr<StyleRuleFontFace> copy() const { return adoptRef(new StyleRuleFontFace(*this)); }
     132
     133    void reportMemoryUsage(MemoryObjectInfo*) const;
    128134
    129135private:
     
    150156    PassRefPtr<StyleRulePage> copy() const { return adoptRef(new StyleRulePage(*this)); }
    151157
     158    void reportMemoryUsage(MemoryObjectInfo*) const;
     159
    152160private:
    153161    StyleRulePage();
     
    164172    void wrapperInsertRule(unsigned, PassRefPtr<StyleRuleBase>);
    165173    void wrapperRemoveRule(unsigned);
     174
     175    void reportMemoryUsage(MemoryObjectInfo*) const;
    166176   
    167177protected:
     
    184194    PassRefPtr<StyleRuleMedia> copy() const { return adoptRef(new StyleRuleMedia(*this)); }
    185195
     196    void reportMemoryUsage(MemoryObjectInfo*) const;
     197
    186198private:
    187199    StyleRuleMedia(PassRefPtr<MediaQuerySet>, Vector<RefPtr<StyleRuleBase> >& adoptRules);
     
    202214    PassRefPtr<StyleRuleRegion> copy() const { return adoptRef(new StyleRuleRegion(*this)); }
    203215
     216    void reportMemoryUsage(MemoryObjectInfo*) const;
     217
    204218private:
    205219    StyleRuleRegion(Vector<OwnPtr<CSSParserSelector> >*, Vector<RefPtr<StyleRuleBase> >& adoptRules);
  • trunk/Source/WebCore/css/StyleRuleImport.cpp

    r118376 r124330  
    129129}
    130130
     131void StyleRuleImport::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     132{
     133    MemoryClassInfo<StyleRuleImport> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     134    info.addString(m_strHref);
     135    info.addInstrumentedMember(m_mediaQueries);
     136    info.addInstrumentedMember(m_styleSheet);
     137}
     138
    131139} // namespace WebCore
  • trunk/Source/WebCore/css/StyleRuleImport.h

    r118376 r124330  
    3131class CachedCSSStyleSheet;
    3232class MediaQuerySet;
     33class MemoryObjectInfo;
    3334class StyleSheetContents;
    3435
     
    5051
    5152    void requestStyleSheet();
     53
     54    void reportMemoryUsage(MemoryObjectInfo*) const;
    5255
    5356private:
  • trunk/Source/WebCore/css/StyleSheetContents.cpp

    r118963 r124330  
    2727#include "CachedCSSStyleSheet.h"
    2828#include "Document.h"
     29#include "MemoryInstrumentation.h"
    2930#include "Node.h"
    3031#include "SecurityOrigin.h"
     
    442443}
    443444
    444 }
     445void StyleSheetContents::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     446{
     447    MemoryClassInfo<StyleSheetContents> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     448    info.addString(m_originalURL);
     449    info.addString(m_encodingFromCharsetRule);
     450    info.addVector(m_importRules);
     451    info.addInstrumentedVector(m_childRules);
     452    info.addHashMap(m_namespaces);
     453    info.addVector(m_clients);
     454}
     455
     456}
  • trunk/Source/WebCore/css/StyleSheetContents.h

    r118963 r124330  
    3535class CachedCSSStyleSheet;
    3636class Document;
     37class MemoryObjectInfo;
    3738class Node;
    3839class SecurityOrigin;
     
    138139    void removedFromMemoryCache();
    139140
     141    void reportMemoryUsage(MemoryObjectInfo*) const;
     142
    140143private:
    141144    StyleSheetContents(StyleRuleImport* ownerRule, const String& originalURL, const KURL& baseURL, const CSSParserContext&);
  • trunk/Source/WebCore/css/WebKitCSSKeyframeRule.cpp

    r122976 r124330  
    2727#include "WebKitCSSKeyframeRule.h"
    2828
     29#include "MemoryInstrumentation.h"
    2930#include "PropertySetCSSStyleDeclaration.h"
    3031#include "StylePropertySet.h"
     
    8687}
    8788
     89void StyleKeyframe::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     90{
     91    MemoryClassInfo<StyleKeyframe> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     92    info.addInstrumentedMember(m_properties);
     93    info.addString(m_key);
     94}
     95
    8896WebKitCSSKeyframeRule::WebKitCSSKeyframeRule(StyleKeyframe* keyframe, WebKitCSSKeyframesRule* parent)
    8997    : CSSRule(0, CSSRule::WEBKIT_KEYFRAME_RULE)
  • trunk/Source/WebCore/css/WebKitCSSKeyframeRule.h

    r122976 r124330  
    3535namespace WebCore {
    3636
     37class MemoryInstrumentation;
    3738class StyleRuleCSSStyleDeclaration;
    3839class WebKitCSSKeyframesRule;
     
    5556   
    5657    String cssText() const;
     58
     59    void reportMemoryUsage(MemoryObjectInfo*) const;
    5760
    5861private:   
  • trunk/Source/WebCore/css/WebKitCSSKeyframesRule.cpp

    r118194 r124330  
    3030#include "CSSRuleList.h"
    3131#include "CSSStyleSheet.h"
     32#include "MemoryInstrumentation.h"
    3233#include "StylePropertySet.h"
    3334#include "StyleSheet.h"
     
    8788}
    8889
     90void StyleRuleKeyframes::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     91{
     92    MemoryClassInfo<StyleRuleKeyframes> info(memoryObjectInfo, this, MemoryInstrumentation::CSS);
     93    info.addInstrumentedVector(m_keyframes);
     94    info.addString(m_name);
     95}
     96
    8997WebKitCSSKeyframesRule::WebKitCSSKeyframesRule(StyleRuleKeyframes* keyframesRule, CSSStyleSheet* parent)
    9098    : CSSRule(parent, CSSRule::WEBKIT_KEYFRAMES_RULE)
  • trunk/Source/WebCore/css/WebKitCSSKeyframesRule.h

    r116291 r124330  
    3737
    3838class CSSRuleList;
     39class MemoryObjectInfo;
    3940class StyleKeyframe;
    4041class WebKitCSSKeyframeRule;
     
    5859
    5960    PassRefPtr<StyleRuleKeyframes> copy() const { return adoptRef(new StyleRuleKeyframes(*this)); }
     61
     62    void reportMemoryUsage(MemoryObjectInfo*) const;
    6063
    6164private:
  • trunk/Source/WebCore/dom/Document.cpp

    r124301 r124330  
    60996099    info.addString(m_documentURI);
    61006100    info.addString(m_baseTarget);
     6101    info.addInstrumentedMember(m_elemSheet);
     6102    info.addInstrumentedMember(m_pageUserSheet);
    61016103    if (m_pageGroupUserSheets)
    6102         info.addVector(*m_pageGroupUserSheets.get());
     6104        info.addInstrumentedVectorPtr(m_pageGroupUserSheets);
    61036105    if (m_userSheets)
    6104         info.addVector(*m_userSheets.get());
     6106        info.addInstrumentedVectorPtr(m_userSheets);
    61056107    info.addHashSet(m_nodeIterators);
    61066108    info.addHashSet(m_ranges);
  • trunk/Source/WebCore/dom/MemoryInstrumentation.h

    r124017 r124330  
    174174    template <typename HashSetType> void addInstrumentedHashSet(const HashSetType& set) { m_memoryInstrumentation->addInstrumentedCollection(set, m_objectType, true); }
    175175    template <typename VectorType> void addInstrumentedVector(const VectorType& vector) { m_memoryInstrumentation->addInstrumentedCollection(vector, m_objectType, true); }
     176    template <typename VectorType> void addInstrumentedVectorPtr(const OwnPtr<VectorType>& vector) { m_memoryInstrumentation->addInstrumentedCollection(*vector, m_objectType, false); }
     177    template <typename VectorType> void addInstrumentedVectorPtr(const VectorType* const& vector) { m_memoryInstrumentation->addInstrumentedCollection(*vector, m_objectType, false); }
    176178    template <typename ListHashSetType> void addListHashSet(const ListHashSetType& set) { m_memoryInstrumentation->addListHashSet(set, m_objectType, true); }
    177179    template <typename VectorType> void addVector(const VectorType& vector) { m_memoryInstrumentation->addVector(vector, m_objectType, true); }
     180    template <typename VectorType> void addVectorPtr(const VectorType* const vector) { m_memoryInstrumentation->addVector(*vector, m_objectType, false); }
    178181    void addRawBuffer(const void* const& buffer, size_t size) { m_memoryInstrumentation->addRawBuffer(buffer, m_objectType, size); }
    179182
Note: See TracChangeset for help on using the changeset viewer.