Changeset 124744 in webkit


Ignore:
Timestamp:
Aug 6, 2012 2:12:01 AM (12 years ago)
Author:
loislo@chromium.org
Message:

Web Inspector: native memory instrumentation: cover MemoryCache with MemoryInstrumentation
​https://bugs.webkit.org/show_bug.cgi?id=91734

Reviewed by Yury Semikhatsky.

Old version of native memory instrumentation doesn't mark the memory cache objects as visited.
As a result MI could count the same objects multiple times.
The new version just traverses through MemoryCache the same way as through DOM.
Also not all the cached resource types were counted.

  • dom/Document.cpp:

(WebCore::Document::reportMemoryUsage):

  • dom/MemoryInstrumentation.h:
  • inspector/InspectorMemoryAgent.cpp:

(MemoryBlockName):
(WebCore):
(WebCore::collectDomTreeInfo):
(WebCore::InspectorMemoryAgent::getProcessMemoryDistribution):

  • loader/cache/CachedCSSStyleSheet.cpp:

(WebCore::CachedCSSStyleSheet::reportMemoryUsage):
(WebCore):

  • loader/cache/CachedCSSStyleSheet.h:

(WebCore):
(CachedCSSStyleSheet):

  • loader/cache/CachedFont.cpp:

(WebCore::CachedFont::reportMemoryUsage):
(WebCore):

  • loader/cache/CachedFont.h:

(CachedFont):

  • loader/cache/CachedImage.cpp:

(WebCore::CachedImage::reportMemoryUsage):
(WebCore):

  • loader/cache/CachedImage.h:

(CachedImage):

  • loader/cache/CachedRawResource.cpp:

(WebCore::CachedRawResource::reportMemoryUsage):
(WebCore):

  • loader/cache/CachedRawResource.h:

(WebCore):
(CachedRawResource):

  • loader/cache/CachedResource.cpp:

(WebCore::CachedResource::reportMemoryUsage):
(WebCore):

  • loader/cache/CachedResource.h:

(WebCore):
(CachedResource):

  • loader/cache/CachedResourceHandle.cpp:

(WebCore::CachedResourceHandleBase::reportMemoryUsage):
(WebCore):

  • loader/cache/CachedResourceHandle.h:

(WebCore):
(CachedResourceHandleBase):

  • loader/cache/CachedResourceLoader.cpp:

(WebCore):
(WebCore::CachedResourceLoader::reportMemoryUsage):

  • loader/cache/CachedResourceLoader.h:

(WebCore):
(CachedResourceLoader):

  • loader/cache/CachedSVGDocument.cpp:

(WebCore::CachedSVGDocument::reportMemoryUsage):
(WebCore):

  • loader/cache/CachedSVGDocument.h:

(CachedSVGDocument):

  • loader/cache/CachedScript.cpp:

(WebCore::CachedScript::reportMemoryUsage):
(WebCore):

  • loader/cache/CachedScript.h:

(WebCore):
(CachedScript):

  • loader/cache/CachedShader.cpp:

(WebCore::CachedShader::reportMemoryUsage):
(WebCore):

  • loader/cache/CachedShader.h:

(WebCore):
(CachedShader):

  • loader/cache/CachedXSLStyleSheet.cpp:

(WebCore::CachedXSLStyleSheet::reportMemoryUsage):
(WebCore):

  • loader/cache/CachedXSLStyleSheet.h:

(WebCore):
(CachedXSLStyleSheet):

  • loader/cache/MemoryCache.cpp:

(WebCore::MemoryCache::reportMemoryUsage):
(WebCore):

  • loader/cache/MemoryCache.h:

(WebCore):
(MemoryCache):

  • platform/PurgeableBuffer.h:

(WebCore):
(PurgeableBuffer):

Location:
trunk/Source/WebCore
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r124739 r124744  
     12012-08-06  Ilya Tikhonovsky  <loislo@chromium.org>
     2
     3        Web Inspector: native memory instrumentation: cover MemoryCache with MemoryInstrumentation
     4        https://bugs.webkit.org/show_bug.cgi?id=91734
     5
     6        Reviewed by Yury Semikhatsky.
     7
     8        Old version of native memory instrumentation doesn't mark the memory cache objects as visited.
     9        As a result MI could count the same objects multiple times.
     10        The new version just traverses through MemoryCache the same way as through DOM.
     11        Also not all the cached resource types were counted.
     12
     13        * dom/Document.cpp:
     14        (WebCore::Document::reportMemoryUsage):
     15        * dom/MemoryInstrumentation.h:
     16        * inspector/InspectorMemoryAgent.cpp:
     17        (MemoryBlockName):
     18        (WebCore):
     19        (WebCore::collectDomTreeInfo):
     20        (WebCore::InspectorMemoryAgent::getProcessMemoryDistribution):
     21        * loader/cache/CachedCSSStyleSheet.cpp:
     22        (WebCore::CachedCSSStyleSheet::reportMemoryUsage):
     23        (WebCore):
     24        * loader/cache/CachedCSSStyleSheet.h:
     25        (WebCore):
     26        (CachedCSSStyleSheet):
     27        * loader/cache/CachedFont.cpp:
     28        (WebCore::CachedFont::reportMemoryUsage):
     29        (WebCore):
     30        * loader/cache/CachedFont.h:
     31        (CachedFont):
     32        * loader/cache/CachedImage.cpp:
     33        (WebCore::CachedImage::reportMemoryUsage):
     34        (WebCore):
     35        * loader/cache/CachedImage.h:
     36        (CachedImage):
     37        * loader/cache/CachedRawResource.cpp:
     38        (WebCore::CachedRawResource::reportMemoryUsage):
     39        (WebCore):
     40        * loader/cache/CachedRawResource.h:
     41        (WebCore):
     42        (CachedRawResource):
     43        * loader/cache/CachedResource.cpp:
     44        (WebCore::CachedResource::reportMemoryUsage):
     45        (WebCore):
     46        * loader/cache/CachedResource.h:
     47        (WebCore):
     48        (CachedResource):
     49        * loader/cache/CachedResourceHandle.cpp:
     50        (WebCore::CachedResourceHandleBase::reportMemoryUsage):
     51        (WebCore):
     52        * loader/cache/CachedResourceHandle.h:
     53        (WebCore):
     54        (CachedResourceHandleBase):
     55        * loader/cache/CachedResourceLoader.cpp:
     56        (WebCore):
     57        (WebCore::CachedResourceLoader::reportMemoryUsage):
     58        * loader/cache/CachedResourceLoader.h:
     59        (WebCore):
     60        (CachedResourceLoader):
     61        * loader/cache/CachedSVGDocument.cpp:
     62        (WebCore::CachedSVGDocument::reportMemoryUsage):
     63        (WebCore):
     64        * loader/cache/CachedSVGDocument.h:
     65        (CachedSVGDocument):
     66        * loader/cache/CachedScript.cpp:
     67        (WebCore::CachedScript::reportMemoryUsage):
     68        (WebCore):
     69        * loader/cache/CachedScript.h:
     70        (WebCore):
     71        (CachedScript):
     72        * loader/cache/CachedShader.cpp:
     73        (WebCore::CachedShader::reportMemoryUsage):
     74        (WebCore):
     75        * loader/cache/CachedShader.h:
     76        (WebCore):
     77        (CachedShader):
     78        * loader/cache/CachedXSLStyleSheet.cpp:
     79        (WebCore::CachedXSLStyleSheet::reportMemoryUsage):
     80        (WebCore):
     81        * loader/cache/CachedXSLStyleSheet.h:
     82        (WebCore):
     83        (CachedXSLStyleSheet):
     84        * loader/cache/MemoryCache.cpp:
     85        (WebCore::MemoryCache::reportMemoryUsage):
     86        (WebCore):
     87        * loader/cache/MemoryCache.h:
     88        (WebCore):
     89        (MemoryCache):
     90        * platform/PurgeableBuffer.h:
     91        (WebCore):
     92        (PurgeableBuffer):
     93
    1942012-08-06  Douglas Stockwell  <dstockwell@chromium.org>
    295

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

    r124736 r124744  
    60966096    info.addMember(m_documentURI);
    60976097    info.addMember(m_baseTarget);
     6098    info.addInstrumentedMember(m_frame);
     6099    info.addInstrumentedMember(m_cachedResourceLoader);
    60986100    info.addInstrumentedMember(m_elemSheet);
    60996101    info.addInstrumentedMember(m_pageUserSheet);

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

    r124736 r124744  
     1
    12/*
    23 * Copyright (C) 2012 Google Inc. All rights reserved.
    … …  
    5354        Binding,
    5455        Loader,
     56        MemoryCacheStructures,
     57        CachedResource,
     58        CachedResourceCSS,
     59        CachedResourceFont,
     60        CachedResourceImage,
     61        CachedResourceScript,
     62        CachedResourceSVG,
     63        CachedResourceShader,
     64        CachedResourceXSLT,
    5565        LastTypeEntry
    5666    };

  • trunk/Source/WebCore/inspector/InspectorMemoryAgent.cpp

    r124412 r124744  
    8282static const char inspectorDOMData[] = "InspectorDOMData";
    8383static const char inspectorJSHeapData[] = "InspectorJSHeapData";
     84static const char processPrivateMemory[] = "ProcessPrivateMemory";
     85
    8486static const char memoryCache[] = "MemoryCache";
    85 static const char processPrivateMemory[] = "ProcessPrivateMemory";
    86 
    87 static const char cachedImages[] = "CachedImages";
    88 static const char cachedCssStyleSheets[] = "CachedCssStyleSheets";
    89 static const char cachedScripts[] = "CachedScripts";
    90 static const char cachedXslStyleSheets[] = "CachedXslStyleSheets";
    91 static const char cachedFonts[] = "CachedFonts";
     87static const char memoryCacheStructures[] = "MemoryCacheStructures";
     88static const char cachedResource[] = "CachedResource";
     89static const char cachedResourceImage[] = "CachedImages";
     90static const char cachedResourceCSS[] = "CachedCssStyleSheets";
     91static const char cachedResourceScript[] = "CachedScripts";
     92static const char cachedResourceXSL[] = "CachedXslStyleSheets";
     93static const char cachedResourceFont[] = "CachedFonts";
     94static const char cachedResourceSVG[] = "CachedSVGGraphics";
     95static const char cachedResourceShader[] = "CachedShaders";
     96static const char cachedResourceXSLT[] = "CachedShadersXSLT";
     97
    9298static const char renderTreeUsed[] = "RenderTreeUsed";
    9399static const char renderTreeAllocated[] = "RenderTreeAllocated";
    … …  
    470476    }
    471477
    472     PassRefPtr<InspectorMemoryBlock> dumpStatistics(InspectorDataCounter* inspectorData)
    473     {
    474         inspectorData->addComponent(MemoryBlockName::inspectorDOMData, m_domMemoryUsage.selfSize());
    475 
     478    void visitMemoryCache()
     479    {
     480        m_domMemoryUsage.addRootObject(memoryCache());
     481    }
     482
     483    PassRefPtr<InspectorMemoryBlock> buildObjectForMemoryCache() const
     484    {
    476485        size_t totalSize = 0;
    477         for (int i = MemoryInstrumentation::Other; i < MemoryInstrumentation::LastTypeEntry; ++i)
     486
     487        COMPILE_ASSERT(MemoryInstrumentation::LastTypeEntry == MemoryInstrumentation::CachedResourceXSLT + 1, object_type_enum_was_changed_please_fix_the_implementation);
     488        for (int i = MemoryInstrumentation::MemoryCacheStructures; i < MemoryInstrumentation::LastTypeEntry; ++i)
     489            totalSize += m_domMemoryUsage.totalSize(static_cast<MemoryInstrumentation::ObjectType>(i));
     490
     491        RefPtr<TypeBuilder::Array<InspectorMemoryBlock> > children = TypeBuilder::Array<InspectorMemoryBlock>::create();
     492        addMemoryBlockFor(children.get(), m_domMemoryUsage.totalSize(MemoryInstrumentation::MemoryCacheStructures), MemoryBlockName::memoryCacheStructures);
     493        addMemoryBlockFor(children.get(), m_domMemoryUsage.totalSize(MemoryInstrumentation::CachedResource), MemoryBlockName::cachedResource);
     494        addMemoryBlockFor(children.get(), m_domMemoryUsage.totalSize(MemoryInstrumentation::CachedResourceCSS), MemoryBlockName::cachedResourceCSS);
     495        addMemoryBlockFor(children.get(), m_domMemoryUsage.totalSize(MemoryInstrumentation::CachedResourceFont), MemoryBlockName::cachedResourceFont);
     496        addMemoryBlockFor(children.get(), m_domMemoryUsage.totalSize(MemoryInstrumentation::CachedResourceImage), MemoryBlockName::cachedResourceImage);
     497        addMemoryBlockFor(children.get(), m_domMemoryUsage.totalSize(MemoryInstrumentation::CachedResourceScript), MemoryBlockName::cachedResourceScript);
     498        addMemoryBlockFor(children.get(), m_domMemoryUsage.totalSize(MemoryInstrumentation::CachedResourceSVG), MemoryBlockName::cachedResourceSVG);
     499        addMemoryBlockFor(children.get(), m_domMemoryUsage.totalSize(MemoryInstrumentation::CachedResourceShader), MemoryBlockName::cachedResourceShader);
     500        addMemoryBlockFor(children.get(), m_domMemoryUsage.totalSize(MemoryInstrumentation::CachedResourceXSLT), MemoryBlockName::cachedResourceXSLT);
     501
     502        RefPtr<InspectorMemoryBlock> block = InspectorMemoryBlock::create().setName(MemoryBlockName::memoryCache);
     503        block->setSize(totalSize);
     504        block->setChildren(children.release());
     505        return block.release();
     506    }
     507
     508    PassRefPtr<InspectorMemoryBlock> buildObjectForDOM() const
     509    {
     510        size_t totalSize = 0;
     511        for (int i = MemoryInstrumentation::Other; i < MemoryInstrumentation::MemoryCacheStructures; ++i)
    478512            totalSize += m_domMemoryUsage.totalSize(static_cast<MemoryInstrumentation::ObjectType>(i));
    479513
    … …  
    491525    }
    492526
     527    void dumpStatistics(TypeBuilder::Array<InspectorMemoryBlock>* children, InspectorDataCounter* inspectorData)
     528    {
     529        children->addItem(buildObjectForMemoryCache());
     530        children->addItem(buildObjectForDOM());
     531        inspectorData->addComponent(MemoryBlockName::inspectorDOMData, m_domMemoryUsage.selfSize());
     532    }
     533
    493534private:
    494535    Page* m_page;
    … …  
    498539}
    499540
    500 static PassRefPtr<InspectorMemoryBlock> domTreeInfo(Page* page, VisitedObjects& visitedObjects, InspectorDataCounter* inspectorData)
     541static void collectDomTreeInfo(Page* page, VisitedObjects& visitedObjects, TypeBuilder::Array<InspectorMemoryBlock>* children, InspectorDataCounter* inspectorData)
    501542{
    502543    DOMTreesIterator domTreesIterator(page, visitedObjects);
     544
    503545    ScriptProfiler::visitNodeWrappers(&domTreesIterator);
    504546
    … …  
    512554
    513555    domTreesIterator.visitBindings();
    514 
    515     return domTreesIterator.dumpStatistics(inspectorData);
     556    domTreesIterator.visitMemoryCache();
     557
     558    domTreesIterator.dumpStatistics(children, inspectorData);
    516559}
    517560
    … …  
    527570}
    528571
    529 static PassRefPtr<InspectorMemoryBlock> memoryCacheInfo()
    530 {
    531     MemoryCache::Statistics stats = memoryCache()->getStatistics();
    532     int totalSize = stats.images.size +
    533                     stats.cssStyleSheets.size +
    534                     stats.scripts.size +
    535                     stats.xslStyleSheets.size +
    536                     stats.fonts.size;
    537     RefPtr<InspectorMemoryBlock> memoryCacheStats = InspectorMemoryBlock::create().setName(MemoryBlockName::memoryCache);
    538     memoryCacheStats->setSize(totalSize);
    539 
    540     RefPtr<TypeBuilder::Array<InspectorMemoryBlock> > children = TypeBuilder::Array<InspectorMemoryBlock>::create();
    541     addMemoryBlockFor(children.get(), stats.images.size, MemoryBlockName::cachedImages);
    542     addMemoryBlockFor(children.get(), stats.cssStyleSheets.size, MemoryBlockName::cachedCssStyleSheets);
    543     addMemoryBlockFor(children.get(), stats.scripts.size, MemoryBlockName::cachedScripts);
    544     addMemoryBlockFor(children.get(), stats.xslStyleSheets.size, MemoryBlockName::cachedXslStyleSheets);
    545     addMemoryBlockFor(children.get(), stats.fonts.size, MemoryBlockName::cachedFonts);
    546     memoryCacheStats->setChildren(children.get());
    547     return memoryCacheStats.release();
    548 }
    549 
    550572static PassRefPtr<InspectorMemoryBlock> jsExternalResourcesInfo(VisitedObjects& visitedObjects)
    551573{
    … …  
    586608    RefPtr<TypeBuilder::Array<InspectorMemoryBlock> > children = TypeBuilder::Array<InspectorMemoryBlock>::create();
    587609    children->addItem(jsHeapInfo());
    588     children->addItem(memoryCacheInfo());
    589610    children->addItem(renderTreeInfo(m_page)); // FIXME: collect for all pages?
    590     children->addItem(domTreeInfo(m_page, visitedObjects, &inspectorData)); // FIXME: collect for all pages?
    591611    children->addItem(jsExternalResourcesInfo(visitedObjects));
     612    collectDomTreeInfo(m_page, visitedObjects, children.get(), &inspectorData); // FIXME: collect for all pages?
    592613    children->addItem(inspectorData.dumpStatistics());
    593614    children->addItem(dumpDOMStorageCache(m_domStorageAgent->memoryBytesUsedByStorageCache()));

  • trunk/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp

    r124720 r124744  
    3333#include "HTTPParsers.h"
    3434#include "MemoryCache.h"
     35#include "MemoryInstrumentation.h"
    3536#include "SharedBuffer.h"
    3637#include "StyleSheetContents.h"
    … …  
    199200}
    200201
    201 }
     202void CachedCSSStyleSheet::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     203{
     204    MemoryClassInfo<CachedCSSStyleSheet> info(memoryObjectInfo, this, MemoryInstrumentation::CachedResourceCSS);
     205    CachedResource::reportMemoryUsage(memoryObjectInfo);
     206    info.addMember(m_decoder);
     207    info.addInstrumentedMember(m_parsedStyleSheetCache);
     208    info.addMember(m_decodedSheetText);
     209}
     210
     211}

  • trunk/Source/WebCore/loader/cache/CachedCSSStyleSheet.h

    r123848 r124744  
    3333
    3434    class CachedResourceClient;
     35    class MemoryObjectInfo;
    3536    class SharedBuffer;
    3637    class StyleSheetContents;
    … …  
    5960        void saveParsedStyleSheet(PassRefPtr<StyleSheetContents>);
    6061   
     62        virtual void reportMemoryUsage(MemoryObjectInfo*) const OVERRIDE;
     63
    6164    private:
    6265        bool canUseSheet(bool enforceMIMEType, bool* hasValidMIMEType) const;

  • trunk/Source/WebCore/loader/cache/CachedFont.cpp

    r119918 r124744  
    3737#include "FontPlatformData.h"
    3838#include "MemoryCache.h"
     39#include "MemoryInstrumentation.h"
    3940#include "SharedBuffer.h"
    4041#include "TextResourceDecoder.h"
    … …  
    207208}
    208209
    209 }
     210void CachedFont::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     211{
     212    MemoryClassInfo<CachedFont> info(memoryObjectInfo, this, MemoryInstrumentation::CachedResourceFont);
     213    CachedResource::reportMemoryUsage(memoryObjectInfo);
     214#if ENABLE(SVG_FONTS)
     215    info.addInstrumentedMember(m_externalSVGDocument);
     216#endif
     217#ifdef STORE_FONT_CUSTOM_PLATFORM_DATA
     218    info.addMember(m_fontData);
     219#endif
     220}
     221
     222}

  • trunk/Source/WebCore/loader/cache/CachedFont.h

    r120000 r124744  
    7171#endif
    7272
     73    virtual void reportMemoryUsage(MemoryObjectInfo*) const OVERRIDE;
     74
    7375private:
    7476    FontCustomPlatformData* m_fontData;

  • trunk/Source/WebCore/loader/cache/CachedImage.cpp

    r123848 r124744  
    468468}
    469469
     470void CachedImage::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     471{
     472    MemoryClassInfo<CachedImage> info(memoryObjectInfo, this, MemoryInstrumentation::CachedResourceImage);
     473    CachedResource::reportMemoryUsage(memoryObjectInfo);
     474    info.addMember(m_image);
     475#if ENABLE(SVG)
     476    info.addMember(m_svgImageCache);
     477#endif
     478}
     479
    470480} // namespace WebCore

  • trunk/Source/WebCore/loader/cache/CachedImage.h

    r123848 r124744  
    9494    virtual void changedInRect(const Image*, const IntRect&);
    9595
     96    virtual void reportMemoryUsage(MemoryObjectInfo*) const OVERRIDE;
     97
    9698private:
    9799    Image* lookupOrCreateImageForRenderer(const RenderObject*);

  • trunk/Source/WebCore/loader/cache/CachedRawResource.cpp

    r119918 r124744  
    3030#include "CachedResourceClientWalker.h"
    3131#include "CachedResourceLoader.h"
     32#include "MemoryInstrumentation.h"
    3233#include "SharedBuffer.h"
    3334#include "SubresourceLoader.h"
    … …  
    160161}
    161162
     163void CachedRawResource::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     164{
     165    MemoryClassInfo<CachedRawResource> info(memoryObjectInfo, this, MemoryInstrumentation::CachedResource);
     166    CachedResource::reportMemoryUsage(memoryObjectInfo);
     167}
     168
     169
    162170} // namespace WebCore

  • trunk/Source/WebCore/loader/cache/CachedRawResource.h

    r120000 r124744  
    3030class CachedRawResourceCallback;
    3131class CachedRawResourceClient;
     32class MemoryObjectInfo;
    3233
    3334class CachedRawResource : public CachedResource {
    … …  
    4445
    4546    bool canReuse(const ResourceRequest&) const;
     47
     48    virtual void reportMemoryUsage(MemoryObjectInfo*) const OVERRIDE;
    4649
    4750private:

  • trunk/Source/WebCore/loader/cache/CachedResource.cpp

    r124032 r124744  
    3838#include "KURL.h"
    3939#include "Logging.h"
     40#include "MemoryInstrumentation.h"
    4041#include "PurgeableBuffer.h"
    4142#include "ResourceHandle.h"
    … …  
    801802}
    802803
    803 }
     804void CachedResource::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     805{
     806    MemoryClassInfo<CachedResource> info(memoryObjectInfo, this, MemoryInstrumentation::CachedResource);
     807    info.addMember(m_resourceRequest);
     808    info.addHashSet(m_clients);
     809    info.addMember(m_accept);
     810    info.addInstrumentedMember(m_loader);
     811    info.addMember(m_response);
     812    info.addInstrumentedMember(m_data);
     813    info.addMember(m_cachedMetadata.get());
     814    info.addInstrumentedMember(m_nextInAllResourcesList);
     815    info.addInstrumentedMember(m_prevInAllResourcesList);
     816    info.addInstrumentedMember(m_nextInLiveResourcesList);
     817    info.addInstrumentedMember(m_prevInLiveResourcesList);
     818    info.addInstrumentedMember(m_owningCachedResourceLoader);
     819    info.addInstrumentedMember(m_resourceToRevalidate);
     820    info.addInstrumentedMember(m_proxyResource);
     821    info.addInstrumentedHashSet(m_handlesToRevalidate);
     822
     823    if (m_purgeableData && !m_purgeableData->wasPurged())
     824        info.addRawBuffer(m_purgeableData.get(), m_purgeableData->size());
     825}
     826
     827}

  • trunk/Source/WebCore/loader/cache/CachedResource.h

    r124720 r124744  
    4848class Frame;
    4949class InspectorResource;
     50class MemoryObjectInfo;
    5051class PurgeableBuffer;
    5152class SecurityOrigin;
    … …  
    251252    double loadFinishTime() const { return m_loadFinishTime; }
    252253
     254    virtual void reportMemoryUsage(MemoryObjectInfo*) const;
     255
    253256protected:
    254257    void checkNotify();

  • trunk/Source/WebCore/loader/cache/CachedResourceHandle.cpp

    r95901 r124744  
    2727#include "CachedResourceHandle.h"
    2828
     29#include "MemoryInstrumentation.h"
     30
    2931namespace WebCore {
    3032
    … …  
    4042}
    4143
     44void CachedResourceHandleBase::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     45{
     46    MemoryClassInfo<CachedResourceHandleBase> info(memoryObjectInfo, this, MemoryInstrumentation::CachedResource);
     47    info.addInstrumentedMember(m_resource);
    4248}
     49
     50
     51}

  • trunk/Source/WebCore/loader/cache/CachedResourceHandle.h

    r116719 r124744  
    3131namespace WebCore {
    3232
     33class MemoryObjectInfo;
     34
    3335    class CachedResourceHandleBase {
    3436    public:
    … …  
    4143        typedef CachedResource* CachedResourceHandleBase::*UnspecifiedBoolType;
    4244        operator UnspecifiedBoolType() const { return m_resource ? &CachedResourceHandleBase::m_resource : 0; }
     45
     46        void reportMemoryUsage(MemoryObjectInfo*) const;
    4347
    4448    protected:

  • trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp

    r124032 r124744  
    878878}
    879879#endif
    880    
    881 }
     880
     881void CachedResourceLoader::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     882{
     883    MemoryClassInfo<CachedResourceLoader> info(memoryObjectInfo, this, MemoryInstrumentation::Loader);
     884    info.addHashMap(m_documentResources);
     885    for (DocumentResourceMap::const_iterator i = m_documentResources.begin(); i != m_documentResources.end(); ++i) {
     886        info.addMember(i->first);
     887        info.addInstrumentedMember(i->second);
     888    }
     889    info.addHashSet(m_validatedURLs);
     890    info.addListHashSet(*m_preloads);
     891    info.addMember(m_pendingPreloads);
     892}
     893
     894}

  • trunk/Source/WebCore/loader/cache/CachedResourceLoader.h

    r124032 r124744  
    5353class ImageLoader;
    5454class KURL;
     55class MemoryObjectInfo;
    5556
    5657// The CachedResourceLoader manages the loading of scripts/images/stylesheets for a single document.
    … …  
    120121    bool canRequest(CachedResource::Type, const KURL&, bool forPreload = false);
    121122   
     123    void reportMemoryUsage(MemoryObjectInfo*) const;
     124
    122125private:
    123126    CachedResourceHandle<CachedResource> requestResource(CachedResource::Type, ResourceRequest&, const String& charset, const ResourceLoaderOptions&, ResourceLoadPriority = ResourceLoadPriorityUnresolved, bool isPreload = false);

  • trunk/Source/WebCore/loader/cache/CachedSVGDocument.cpp

    r121566 r124744  
    7272}
    7373
     74void CachedSVGDocument::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     75{
     76    MemoryClassInfo<CachedSVGDocument> info(memoryObjectInfo, this, MemoryInstrumentation::CachedResourceSVG);
     77    CachedResource::reportMemoryUsage(memoryObjectInfo);
     78    info.addInstrumentedMember(m_document);
     79    info.addMember(m_decoder);
     80}
     81
    7482}
    7583

  • trunk/Source/WebCore/loader/cache/CachedSVGDocument.h

    r121566 r124744  
    4444    virtual void data(PassRefPtr<SharedBuffer> data, bool allDataReceived);
    4545
     46    virtual void reportMemoryUsage(MemoryObjectInfo*) const OVERRIDE;
     47
    4648protected:
    4749    RefPtr<SVGDocument> m_document;

  • trunk/Source/WebCore/loader/cache/CachedScript.cpp

    r124679 r124744  
    3131#include "CachedResourceClient.h"
    3232#include "CachedResourceClientWalker.h"
     33#include "MemoryInstrumentation.h"
    3334#include "SharedBuffer.h"
    3435#include "TextResourceDecoder.h"
    … …  
    127128#endif
    128129
     130void CachedScript::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     131{
     132    MemoryClassInfo<CachedScript> info(memoryObjectInfo, this, MemoryInstrumentation::CachedResourceScript);
     133    CachedResource::reportMemoryUsage(memoryObjectInfo);
     134    info.addMember(m_script);
     135    info.addMember(m_decoder);
     136#if USE(JSC)
     137    info.addMember(m_sourceProviderCache);
     138#endif
     139}
     140
    129141} // namespace WebCore

  • trunk/Source/WebCore/loader/cache/CachedScript.h

    r123848 r124744  
    3838
    3939    class CachedResourceLoader;
     40    class MemoryObjectInfo;
    4041    class TextResourceDecoder;
    4142
    … …  
    5859        void sourceProviderCacheSizeChanged(int delta);
    5960#endif
     61
     62        virtual void reportMemoryUsage(MemoryObjectInfo*) const OVERRIDE;
     63
    6064    private:
    6165        virtual PurgePriority purgePriority() const { return PurgeLast; }

  • trunk/Source/WebCore/loader/cache/CachedShader.cpp

    r108952 r124744  
    3333
    3434#include "CachedShader.h"
     35#include "MemoryInstrumentation.h"
    3536#include "SharedBuffer.h"
    3637#include "TextResourceDecoder.h"
    … …  
    6869}
    6970
     71void CachedShader::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     72{
     73    MemoryClassInfo<CachedShader> info(memoryObjectInfo, this, MemoryInstrumentation::CachedResourceShader);
     74    CachedResource::reportMemoryUsage(memoryObjectInfo);
     75    info.addMember(m_decoder);
     76    info.addMember(m_shaderString);
     77}
     78
    7079} // namespace WebCore
    7180

  • trunk/Source/WebCore/loader/cache/CachedShader.h

    r108952 r124744  
    3737namespace WebCore {
    3838
     39class MemoryObjectInfo;
    3940class TextResourceDecoder;
    4041
    … …  
    4748    void data(PassRefPtr<SharedBuffer>, bool allDataReceived);
    4849   
     50    virtual void reportMemoryUsage(MemoryObjectInfo*) const OVERRIDE;
     51
    4952private:
    5053    RefPtr<TextResourceDecoder> m_decoder;

  • trunk/Source/WebCore/loader/cache/CachedXSLStyleSheet.cpp

    r112245 r124744  
    3030#include "CachedResourceClientWalker.h"
    3131#include "CachedStyleSheetClient.h"
     32#include "MemoryInstrumentation.h"
    3233#include "SharedBuffer.h"
    3334#include "TextResourceDecoder.h"
    … …  
    9798}
    9899
     100void CachedXSLStyleSheet::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     101{
     102    MemoryClassInfo<CachedXSLStyleSheet> info(memoryObjectInfo, this, MemoryInstrumentation::CachedResourceXSLT);
     103    CachedResource::reportMemoryUsage(memoryObjectInfo);
     104    info.addMember(m_sheet);
     105    info.addMember(m_decoder);
     106}
     107
    99108#endif
    100109

  • trunk/Source/WebCore/loader/cache/CachedXSLStyleSheet.h

    r112245 r124744  
    3333
    3434    class CachedResourceLoader;
     35    class MemoryObjectInfo;
    3536    class TextResourceDecoder;
    3637
    … …  
    5152        void checkNotify();
    5253       
     54        virtual void reportMemoryUsage(MemoryObjectInfo*) const OVERRIDE;
     55
    5356    protected:
    5457        String m_sheet;

  • trunk/Source/WebCore/loader/cache/MemoryCache.cpp

    r124032 r124744  
    3737#include "Image.h"
    3838#include "Logging.h"
     39#include "MemoryInstrumentation.h"
    3940#include "ResourceHandle.h"
    4041#include "SecurityOrigin.h"
    … …  
    715716}
    716717
     718void MemoryCache::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     719{
     720    MemoryClassInfo<MemoryCache> info(memoryObjectInfo, this, MemoryInstrumentation::MemoryCacheStructures);
     721    info.addHashMap(m_resources);
     722    CachedResourceMap::const_iterator e = m_resources.end();
     723    for (CachedResourceMap::const_iterator i = m_resources.begin(); i != e; ++i) {
     724        info.addMember(i->first);
     725        info.addInstrumentedMember(i->second);
     726    }
     727    info.addVector(m_allResources);
     728    info.addMember(m_liveDecodedResources);
     729}
     730
    717731void MemoryCache::setDisabled(bool disabled)
    718732{

  • trunk/Source/WebCore/loader/cache/MemoryCache.h

    r118292 r124744  
    4040class CachedResourceLoader;
    4141class KURL;
     42class MemoryObjectInfo;
    4243class ScriptExecutionContext;
    4344class SecurityOrigin;
    … …  
    169170    unsigned deadSize() const { return m_deadSize; }
    170171
     172    void reportMemoryUsage(MemoryObjectInfo*) const;
     173
    171174private:
    172175    MemoryCache();

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

    r95901 r124744  
    3232
    3333namespace WebCore {
    34    
     34
    3535    class PurgeableBuffer {
    3636        WTF_MAKE_NONCOPYABLE(PurgeableBuffer);
    … …  
    5151
    5252        bool makePurgeable(bool purgeable);
    53        
     53
    5454    private:
    5555        PurgeableBuffer(char* data, size_t);
Note: See TracChangeset for help on using the changeset viewer.