Changeset 138005 in webkit


Ignore:
Timestamp:
Dec 18, 2012 3:46:05 AM (11 years ago)
Author:
yurys@chromium.org
Message:

Web Inspector: show cached images under MemoryCache -> Images section
​https://bugs.webkit.org/show_bug.cgi?id=105261

Reviewed by Pavel Feldman.

Source/WebCore:

Provided class name and name for several objects related to CachedImage.
Changed native memory snapsho view so that MemoryCache.Image section can
be expanded into individual images.

  • inspector/front-end/NativeMemorySnapshotView.js:

(WebInspector.NativeMemorySnapshotView):
(WebInspector.NativeSnapshotNode.prototype._addChildrenFromGraph):
(WebInspector.NativeHeapGraphEdge):
(WebInspector.NativeHeapGraphEdge.prototype.type):
(WebInspector.NativeHeapGraphEdge.prototype.name):
(WebInspector.NativeHeapGraphEdge.prototype.target):
(WebInspector.NativeHeapGraphEdge.prototype._getStringField):
(WebInspector.NativeHeapGraphEdge.prototype.toString):
(WebInspector.NativeHeapGraphNode.prototype.size):
(WebInspector.NativeHeapGraphNode.prototype.referencedNodes):
(WebInspector.NativeHeapGraphNode.prototype.outgoingEdges):
(WebInspector.NativeHeapGraphNode.prototype.targetOfEdge):
(WebInspector.NativeHeapGraphNode.prototype.targetsOfAllEdges):
(WebInspector.NativeHeapGraphNode.prototype._firstEdgePoistion):
(WebInspector.NativeHeapGraphNode.prototype._afterLastEdgePosition):
(WebInspector.NativeHeapGraphNode.prototype._getStringField):
(WebInspector.NativeHeapGraphNode.prototype.toString):
(WebInspector.NativeHeapGraph):
(WebInspector.NativeHeapGraph.prototype.rootNodes):
(WebInspector.NativeHeapGraph.prototype._calculateNodeEdgeIndexes):
(WebInspector.NativeHeapGraph.prototype._addDummyNode):
(WebInspector.NativeMemoryProfileType.prototype.buttonClicked.didReceiveMemorySnapshot):
(WebInspector.NativeMemoryProfileType.prototype.buttonClicked):

  • loader/cache/CachedImage.cpp:

(WebCore::CachedImage::reportMemoryUsage):

  • loader/cache/CachedResource.cpp:

(WebCore::CachedResource::reportMemoryUsage):

  • loader/cache/MemoryCache.cpp:

(WebCore::MemoryCache::reportMemoryUsage):

  • platform/graphics/BitmapImage.cpp:

(WebCore::BitmapImage::reportMemoryUsage):
(WebCore::FrameData::reportMemoryUsage):

  • platform/graphics/Image.cpp:

(WebCore::Image::reportMemoryUsage):

  • platform/graphics/skia/MemoryInstrumentationSkia.cpp:

(reportMemoryUsage):

Source/WTF:

Use first provided name and class name. If one of the ancestors tries to overwrite
it just ignore the call.

  • wtf/MemoryObjectInfo.h:

(WTF::MemoryObjectInfo::setClassName):
(WTF::MemoryObjectInfo::setName):

Location:
trunk/Source
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r137994 r138005  
     12012-12-18  Yury Semikhatsky  <yurys@chromium.org>
     2
     3        Web Inspector: show cached images under MemoryCache -> Images section
     4        https://bugs.webkit.org/show_bug.cgi?id=105261
     5
     6        Reviewed by Pavel Feldman.
     7
     8        Use first provided name and class name. If one of the ancestors tries to overwrite
     9        it just ignore the call.
     10
     11        * wtf/MemoryObjectInfo.h:
     12        (WTF::MemoryObjectInfo::setClassName):
     13        (WTF::MemoryObjectInfo::setName):
     14
    1152012-12-18  Uli Schlachter  <psychon@znc.in>
    216

  • trunk/Source/WTF/wtf/MemoryObjectInfo.h

    r137589 r138005  
    6262    void setCustomAllocation(bool customAllocation) { m_customAllocation = customAllocation; }
    6363
    64     void setClassName(const String& className) { m_className = className; }
     64    void setClassName(const String& className)
     65    {
     66        if (m_className.isEmpty())
     67            m_className = className;
     68    }
    6569    const String& className() const { return m_className; }
    66     void setName(const String& name) { m_name = name; }
     70    void setName(const String& name)
     71    {
     72        if (m_name.isEmpty())
     73            m_name = name;
     74    }
    6775    const String& name() const { return m_name; }
    6876

  • trunk/Source/WebCore/ChangeLog

    r138004 r138005  
     12012-12-18  Yury Semikhatsky  <yurys@chromium.org>
     2
     3        Web Inspector: show cached images under MemoryCache -> Images section
     4        https://bugs.webkit.org/show_bug.cgi?id=105261
     5
     6        Reviewed by Pavel Feldman.
     7
     8        Provided class name and name for several objects related to CachedImage.
     9        Changed native memory snapsho view so that MemoryCache.Image section can
     10        be expanded into individual images.
     11
     12        * inspector/front-end/NativeMemorySnapshotView.js:
     13        (WebInspector.NativeMemorySnapshotView):
     14        (WebInspector.NativeSnapshotNode.prototype._addChildrenFromGraph):
     15        (WebInspector.NativeHeapGraphEdge):
     16        (WebInspector.NativeHeapGraphEdge.prototype.type):
     17        (WebInspector.NativeHeapGraphEdge.prototype.name):
     18        (WebInspector.NativeHeapGraphEdge.prototype.target):
     19        (WebInspector.NativeHeapGraphEdge.prototype._getStringField):
     20        (WebInspector.NativeHeapGraphEdge.prototype.toString):
     21        (WebInspector.NativeHeapGraphNode.prototype.size):
     22        (WebInspector.NativeHeapGraphNode.prototype.referencedNodes):
     23        (WebInspector.NativeHeapGraphNode.prototype.outgoingEdges):
     24        (WebInspector.NativeHeapGraphNode.prototype.targetOfEdge):
     25        (WebInspector.NativeHeapGraphNode.prototype.targetsOfAllEdges):
     26        (WebInspector.NativeHeapGraphNode.prototype._firstEdgePoistion):
     27        (WebInspector.NativeHeapGraphNode.prototype._afterLastEdgePosition):
     28        (WebInspector.NativeHeapGraphNode.prototype._getStringField):
     29        (WebInspector.NativeHeapGraphNode.prototype.toString):
     30        (WebInspector.NativeHeapGraph):
     31        (WebInspector.NativeHeapGraph.prototype.rootNodes):
     32        (WebInspector.NativeHeapGraph.prototype._calculateNodeEdgeIndexes):
     33        (WebInspector.NativeHeapGraph.prototype._addDummyNode):
     34        (WebInspector.NativeMemoryProfileType.prototype.buttonClicked.didReceiveMemorySnapshot):
     35        (WebInspector.NativeMemoryProfileType.prototype.buttonClicked):
     36        * loader/cache/CachedImage.cpp:
     37        (WebCore::CachedImage::reportMemoryUsage):
     38        * loader/cache/CachedResource.cpp:
     39        (WebCore::CachedResource::reportMemoryUsage):
     40        * loader/cache/MemoryCache.cpp:
     41        (WebCore::MemoryCache::reportMemoryUsage):
     42        * platform/graphics/BitmapImage.cpp:
     43        (WebCore::BitmapImage::reportMemoryUsage):
     44        (WebCore::FrameData::reportMemoryUsage):
     45        * platform/graphics/Image.cpp:
     46        (WebCore::Image::reportMemoryUsage):
     47        * platform/graphics/skia/MemoryInstrumentationSkia.cpp:
     48        (reportMemoryUsage):
     49
    1502012-12-18  Eugene Klyuchnikov  <eustas@chromium.org>
    251

  • trunk/Source/WebCore/inspector/front-end/NativeMemorySnapshotView.js

    r137742 r138005  
    4040
    4141    this.element.addStyleClass("native-snapshot-view");
    42     this._containmentDataGrid = new WebInspector.NativeSnapshotDataGrid(profile._memoryBlock);
     42    this._containmentDataGrid = new WebInspector.NativeSnapshotDataGrid(profile);
    4343    this._containmentDataGrid.show(this.element);
    4444
    45     this._heapGraphDataGrid = new WebInspector.NativeHeapGraphDataGrid(new WebInspector.NativeHeapGraph(profile._graph));
     45    this._heapGraphDataGrid = new WebInspector.NativeHeapGraphDataGrid(profile._graph);
    4646
    4747    this._viewSelectElement = document.createElement("select");
    … …  
    9191 * @constructor
    9292 * @extends {WebInspector.DataGrid}
    93  * @param {MemoryAgent.MemoryBlock} profile
     93 * @param {WebInspector.NativeMemoryProfileHeader} profile
    9494 */
    9595WebInspector.NativeSnapshotDataGrid = function(profile)
    … …  
    100100    };
    101101    WebInspector.DataGrid.call(this, columns);
    102     this._totalNode = new WebInspector.NativeSnapshotNode(profile, profile);
     102    this._profile = profile;
     103    this._totalNode = new WebInspector.NativeSnapshotNode(profile._memoryBlock, profile._memoryBlock);
    103104    if (WebInspector.settings.showNativeSnapshotUninstrumentedSize.get()) {
    104105        this.setRootNode(new WebInspector.DataGridNode(null, true));
    … …  
    146147 * @extends {WebInspector.DataGridNode}
    147148 * @param {MemoryAgent.MemoryBlock} nodeData
    148  * @param {MemoryAgent.MemoryBlock} profile
    149  */
    150 WebInspector.NativeSnapshotNode = function(nodeData, profile)
     149 * @param {MemoryAgent.MemoryBlock} rootMemoryBlock
     150 */
     151WebInspector.NativeSnapshotNode = function(nodeData, rootMemoryBlock)
    151152{
    152153    this._nodeData = nodeData;
    153     this._profile = profile;
     154    this._rootMemoryBlock = rootMemoryBlock;
    154155    var viewProperties = WebInspector.MemoryBlockViewProperties._forMemoryBlock(nodeData);
    155156    var data = { name: viewProperties._description, size: this._nodeData.size };
    … …  
    224225
    225226        var sizeKB = this._nodeData.size / 1024;
    226         var totalSize = this._profile.size;
     227        var totalSize = this._rootMemoryBlock.size;
    227228        var percentage = this._nodeData.size / totalSize  * 100;
    228229
    … …  
    260261        this.removeEventListener("populate", this._populate, this);
    261262        this._nodeData.children.sort(this.dataGrid._sortingFunction.bind(this.dataGrid));
     263
    262264        for (var node in this._nodeData.children) {
    263265            var nodeData = this._nodeData.children[node];
     266            this._addChildrenFromGraph(nodeData);
    264267            if (WebInspector.settings.showNativeSnapshotUninstrumentedSize.get() || nodeData.name !== "Other")
    265                 this.appendChild(new WebInspector.NativeSnapshotNode(nodeData, this._profile));
    266         }
     268                this.appendChild(new WebInspector.NativeSnapshotNode(nodeData, this._rootMemoryBlock));
     269        }
     270    },
     271
     272    /**
     273     * @param {MemoryAgent.MemoryBlock} memoryBlock
     274     */
     275    _addChildrenFromGraph: function(memoryBlock)
     276    {
     277        if (memoryBlock.children)
     278            return;
     279        if (memoryBlock.name !== "Image" || this._nodeData.name !== "MemoryCache")
     280            return;
     281
     282        // Collect objects on the path MemoryCache -> CachedImage -m_image-> BitmapImage -m_frames-> FrameData -m_frame-> SkBitmap -> SkPixelRef
     283        var graph = this.dataGrid._profile._graph;
     284        var roots = graph.rootNodes();
     285        var memoryCache;
     286        for (var i = 0; i < roots.length; i++) {
     287            var root = roots[i];
     288            if (root.className() === "MemoryCache") {
     289                memoryCache = root;
     290                break;
     291            }
     292        }
     293        var edges = memoryCache.outgoingEdges();
     294        var cachedImages = [];
     295        for (var i = 0; i < edges.length; i++) {
     296            var target = edges[i].target();
     297            if (target.className() === "CachedImage") {
     298                var cachedImage = {
     299                    name: target.name(),
     300                    size: target.size(),
     301                    children: []
     302                };
     303                cachedImages.push(cachedImage);
     304                var image = target.targetOfEdge("m_image");
     305                if (image.className() === "BitmapImage") {
     306                    var frames = image.targetsOfAllEdges("m_frame");
     307                    for (var j = 0; j < frames.length; j++) {
     308                        var pixels = frames[j].targetOfEdge("pixels");
     309                        if (pixels) {
     310                            cachedImage.size += pixels.size();
     311                            cachedImage.children.push({
     312                                name: "Bitmap pixels",
     313                                size: pixels.size()
     314                            });
     315                        }
     316                    }
     317                }
     318            }
     319        }
     320        memoryBlock.children = cachedImages;
    267321    },
    268322
    … …  
    276330 * @param {number} position
    277331 */
    278 WebInspector.NativeHeapGraphNode = function(graph, position)
     332WebInspector.NativeHeapGraphEdge = function(graph, position)
    279333{
    280334    this._graph = graph;
    … …  
    282336}
    283337
     338WebInspector.NativeHeapGraphEdge.prototype = {
     339    type: function()
     340    {
     341        return this._getStringField(this._graph._edgeTypeOffset);
     342    },
     343
     344    name: function()
     345    {
     346        return this._getStringField(this._graph._edgeNameOffset);
     347    },
     348
     349    target: function()
     350    {
     351        var edges = this._graph._edges;
     352        var targetPosition = edges[this._position + this._graph._edgeTargetOffset] * this._graph._nodeFieldCount;
     353        return new WebInspector.NativeHeapGraphNode(this._graph, targetPosition);
     354    },
     355
     356    _getStringField: function(offset)
     357    {
     358        var typeIndex = this._graph._edges[this._position + offset];
     359        return this._graph._rawGraph.strings[typeIndex];
     360    },
     361
     362    toString: function()
     363    {
     364        return "Edge#" + this._position + " -" + this.name() + "-> " + this.target();
     365    }
     366
     367}
     368
     369
     370/**
     371 * @constructor
     372 * @param {WebInspector.NativeHeapGraph} graph
     373 * @param {number} position
     374 */
     375WebInspector.NativeHeapGraphNode = function(graph, position)
     376{
     377    this._graph = graph;
     378    this._position = position;
     379}
     380
    284381WebInspector.NativeHeapGraphNode.prototype = {
    285382    id: function()
    … …  
    295392    size: function()
    296393    {
    297         return this._graph._rawGraph.nodes[this._position + this._graph._nodeSizeOffset];
     394        return this._graph._nodes[this._position + this._graph._nodeSizeOffset];
    298395    },
    299396
    … …  
    315412    referencedNodes: function()
    316413    {
    317         var edges = this._graph._rawGraph.edges;
    318         var nodes = this._graph._rawGraph.nodes;
     414        var edges = this._graph._edges;
     415        var nodes = this._graph._nodes;
    319416        var edgeFieldCount = this._graph._edgeFieldCount;
    320417        var nodeFieldCount = this._graph._nodeFieldCount;
    … …  
    328425    },
    329426
     427    outgoingEdges: function()
     428    {
     429        var edges = this._graph._edges;
     430        var edgeFieldCount = this._graph._edgeFieldCount;
     431
     432        var firstEdgePosition = this._firstEdgePoistion();
     433        var afterLastEdgePosition = this._afterLastEdgePosition();
     434        var result = [];
     435        for (var i = firstEdgePosition; i < afterLastEdgePosition; i += edgeFieldCount)
     436            result.push(new WebInspector.NativeHeapGraphEdge(this._graph, i));
     437        return result;
     438    },
     439
     440    targetOfEdge: function(edgeName)
     441    {
     442        return this.targetsOfAllEdges(edgeName)[0];
     443    },
     444
     445    targetsOfAllEdges: function(edgeName)
     446    {
     447        var edges = this._graph._edges;
     448        var edgeFieldCount = this._graph._edgeFieldCount;
     449
     450        var firstEdgePosition = this._firstEdgePoistion();
     451        var afterLastEdgePosition = this._afterLastEdgePosition();
     452
     453        var edge = new WebInspector.NativeHeapGraphEdge(this._graph, firstEdgePosition)
     454        var result = [];
     455        for (var i = firstEdgePosition; i < afterLastEdgePosition; i += edgeFieldCount) {
     456            edge._position = i;
     457            if (edge.name() === edgeName)
     458                result.push(edge.target());
     459        }
     460        return result;
     461    },
     462
    330463    _firstEdgePoistion: function()
    331464    {
    332         return this._graph._rawGraph.nodes[this._position + this._graph._nodeFirstEdgeOffset] * this._graph._edgeFieldCount;
     465        return this._graph._nodes[this._position + this._graph._nodeFirstEdgeOffset] * this._graph._edgeFieldCount;
    333466    },
    334467
    335468    _afterLastEdgePosition: function()
    336469    {
    337         var edges = this._graph._rawGraph.edges;
    338         var nodes = this._graph._rawGraph.nodes;
    339         var afterLastEdgePosition = nodes[this._position + this._graph._nodeFieldCount + this._graph._nodeFirstEdgeOffset];
    340         if (afterLastEdgePosition)
    341             afterLastEdgePosition *= this._graph._edgeFieldCount;
    342         else
    343             afterLastEdgePosition = edges.length;
    344         return afterLastEdgePosition;
     470        return this._graph._nodes[this._position + this._graph._nodeFieldCount + this._graph._nodeFirstEdgeOffset] * this._graph._edgeFieldCount;
    345471    },
    346472
    347473    _getStringField: function(offset)
    348474    {
    349         var typeIndex = this._graph._rawGraph.nodes[this._position + offset];
     475        var typeIndex = this._graph._nodes[this._position + offset];
    350476        return this._graph._rawGraph.strings[typeIndex];
     477    },
     478
     479    toString: function()
     480    {
     481        return "Node#" + this.id() + " " + this.name() + "(" + this.className() + ")";
    351482    }
    352483}
    … …  
    373504    this._edgeNameOffset = 2;
    374505
     506    this._nodeCount = rawGraph.nodes.length / this._nodeFieldCount;
     507    this._nodes = rawGraph.nodes;
     508    this._edges = rawGraph.edges;
     509    this._strings = rawGraph.strings;
     510
    375511    this._calculateNodeEdgeIndexes();
    376512}
    … …  
    379515    rootNodes: function()
    380516    {
    381         var nodeHasIncomingEdges = new Uint8Array(this._rawGraph.nodes.length / this._nodeFieldCount);
    382         var edges = this._rawGraph.edges;
     517        var nodeHasIncomingEdges = new Uint8Array(this._nodeCount);
     518        var edges = this._edges;
    383519        var edgesLength = edges.length;
    384520        var edgeFieldCount = this._edgeFieldCount;
    … …  
    399535    _calculateNodeEdgeIndexes: function()
    400536    {
    401         var nodes = this._rawGraph.nodes;
     537        var nodes = this._nodes;
    402538        var nodeFieldCount = this._nodeFieldCount;
    403539        var nodeLength = nodes.length;
    … …  
    408544            firstEdgeIndex += count;
    409545        }
     546        this._addDummyNode();
     547    },
     548
     549    _addDummyNode: function()
     550    {
     551        var firstEdgePosition = this._nodes.length + this._nodeFirstEdgeOffset;
     552        for (var i = 0; i < this._nodeFieldCount; i++)
     553            this._nodes.push(0);
     554        this._nodes[firstEdgePosition] = this._edges.length;
    410555    }
    411556}
    … …  
    546691            }
    547692            profileHeader._memoryBlock = memoryBlock;
    548             profileHeader._graph = graph;
     693            profileHeader._graph = new WebInspector.NativeHeapGraph(graph);
    549694            profileHeader.isTemporary = false;
    550695            profileHeader.sidebarElement.subtitle = Number.bytesToString(/** @type{number} */(memoryBlock.size));

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

    r137981 r138005  
    4040#include "SubresourceLoader.h"
    4141#include <wtf/CurrentTime.h>
     42#include <wtf/MemoryObjectInfo.h>
    4243#include <wtf/StdLibExtras.h>
    4344#include <wtf/Vector.h>
    … …  
    483484{
    484485    MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::CachedResourceImage);
     486    memoryObjectInfo->setClassName("CachedImage");
    485487    CachedResource::reportMemoryUsage(memoryObjectInfo);
    486     info.addMember(m_image);
     488    info.addMember(m_image, "m_image");
    487489#if ENABLE(SVG)
    488490    info.addMember(m_svgImageCache);

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

    r137604 r138005  
    5252#include <wtf/MemoryInstrumentationHashCountedSet.h>
    5353#include <wtf/MemoryInstrumentationHashSet.h>
     54#include <wtf/MemoryObjectInfo.h>
    5455#include <wtf/RefCountedLeakCounter.h>
    5556#include <wtf/StdLibExtras.h>
    … …  
    889890{
    890891    MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::CachedResource);
     892    memoryObjectInfo->setName(url().string());
    891893    info.addMember(m_resourceRequest);
    892894    info.addMember(m_clients);

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

    r133469 r138005  
    4848#include <wtf/MemoryInstrumentationHashMap.h>
    4949#include <wtf/MemoryInstrumentationVector.h>
     50#include <wtf/MemoryObjectInfo.h>
    5051#include <wtf/TemporaryChange.h>
    5152#include <wtf/text/CString.h>
    … …  
    724725{
    725726    MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::MemoryCacheStructures);
     727    memoryObjectInfo->setClassName("MemoryCache");
    726728    info.addMember(m_resources);
    727729    info.addMember(m_allResources);

  • trunk/Source/WebCore/platform/graphics/BitmapImage.cpp

    r130289 r138005  
    3636#include <wtf/CurrentTime.h>
    3737#include <wtf/MemoryInstrumentationVector.h>
     38#include <wtf/MemoryObjectInfo.h>
    3839#include <wtf/Vector.h>
    3940#include <wtf/text/WTFString.h>
    … …  
    577578{
    578579    MemoryClassInfo info(memoryObjectInfo, this, PlatformMemoryTypes::Image);
     580    memoryObjectInfo->setClassName("BitmapImage");
    579581    Image::reportMemoryUsage(memoryObjectInfo);
    580     info.addMember(m_source);
     582    info.addMember(m_source, "m_source");
    581583    info.addMember(m_frameTimer);
    582     info.addMember(m_frames);
     584    info.addMember(m_frames, "m_frames");
    583585}
    584586
    … …  
    586588{
    587589    MemoryClassInfo info(memoryObjectInfo, this, PlatformMemoryTypes::Image);
     590    memoryObjectInfo->setClassName("FrameData");
    588591#if OS(WINCE) && !PLATFORM(QT)
    589592    info.addRawBuffer(m_frame.get(), m_frameBytes);
    590593#elif USE(SKIA)
    591     info.addMember(m_frame);
     594    info.addMember(m_frame, "m_frame");
    592595#else
    593     info.addRawBuffer(m_frame, m_frameBytes);
     596    info.addRawBuffer(m_frame, m_frameBytes, "m_frame");
    594597#endif
    595598}

  • trunk/Source/WebCore/platform/graphics/Image.cpp

    r137011 r138005  
    3939#include <math.h>
    4040#include <wtf/MainThread.h>
     41#include <wtf/MemoryObjectInfo.h>
    4142#include <wtf/StdLibExtras.h>
    4243
    … …  
    202203{
    203204    MemoryClassInfo info(memoryObjectInfo, this, PlatformMemoryTypes::Image);
    204     info.addMember(m_data);
     205    memoryObjectInfo->setClassName("Image");
     206    info.addMember(m_data, "m_data");
    205207    info.addWeakPointer(m_imageObserver);
    206208}

  • trunk/Source/WebCore/platform/graphics/skia/MemoryInstrumentationSkia.cpp

    r131017 r138005  
    3737#include "SkDevice.h"
    3838#include "SkPixelRef.h"
     39#include <wtf/MemoryObjectInfo.h>
    3940
    4041void reportMemoryUsage(const SkBitmap* const& image, WTF::MemoryObjectInfo* memoryObjectInfo)
    4142{
    4243    WTF::MemoryClassInfo info(memoryObjectInfo, image);
     44    memoryObjectInfo->setClassName("SkBitmap");
     45
    4346    SkPixelRef* pixelRef = image->pixelRef();
    4447    info.addMember(pixelRef);
    4548    if (pixelRef)
    46         info.addRawBuffer(pixelRef->pixels(), image->getSize());
     49        info.addRawBuffer(pixelRef->pixels(), image->getSize(), 0, "pixels");
    4750}
    4851
Note: See TracChangeset for help on using the changeset viewer.