Changeset 133270 in webkit


Ignore:
Timestamp:
Nov 2, 2012 12:22:59 AM (12 years ago)
Author:
commit-queue@webkit.org
Message:

Coordinated Graphics: Manage the lifecycle of shareable surfaces precisely.
​https://bugs.webkit.org/show_bug.cgi?id=100797

Patch by Huang Dongsung <​luxtella@company100.net> on 2012-11-02
Reviewed by Noam Rosenthal.

Internal Review by Gwang Yoon Hwang and Jae Hyun Park.

This patch makes UpdateAtlas manage the lifecycle of shareable surfaces
containing the updates in the way how CoordinatedTile manages the lifecycle of
tiles. Currently, UI Process creates the shareable surface when receiving an
UpdateTileForLayer message, but there is no exact point to remove the shareable
surface. Now, we introduce new two messages to handle the lifecycle:
CreateUpdateAtlas and RemoveUpdateAtlas.

This patch gives us two benefits.

  1. Reduce file and mmap operations. Web Process does not need to duplicate a

file handle every tile update. UI Process does not need to create a
ShareableSurface every UpdateTileForLayer message.

  1. Save memory. We can remove a ShareableSurface in UI Process when UpdateAtlas

in Web Process is removed.

  • Shared/SurfaceUpdateInfo.cpp:

(WebKit::SurfaceUpdateInfo::encode):
(WebKit::SurfaceUpdateInfo::decode):

  • Shared/SurfaceUpdateInfo.h:

(SurfaceUpdateInfo):

  • UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.cpp:

(WebKit::LayerTreeCoordinatorProxy::updateTileForLayer):
(WebKit::LayerTreeCoordinatorProxy::createUpdateAtlas):
(WebKit):
(WebKit::LayerTreeCoordinatorProxy::removeUpdateAtlas):
(WebKit::LayerTreeCoordinatorProxy::purgeBackingStores):

  • UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h:

(LayerTreeCoordinatorProxy):

  • UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.messages.in:
  • WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp:

(WebCore::CoordinatedGraphicsLayer::beginContentUpdate):

  • WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h:

(CoordinatedGraphicsLayerClient):
(CoordinatedGraphicsLayer):

  • WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.cpp:

(WebKit::CoordinatedTile::updateBackBuffer):

  • WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.h:

(CoordinatedTileClient):

  • WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp:

(WebKit::LayerTreeCoordinator::createUpdateAtlas):
(WebKit):
(WebKit::LayerTreeCoordinator::removeUpdateAtlas):
(WebKit::LayerTreeCoordinator::beginContentUpdate):

  • WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h:

(LayerTreeCoordinator):

  • WebProcess/WebPage/UpdateAtlas.cpp:

(WebKit::UpdateAtlas::UpdateAtlas):
(WebKit):
(WebKit::UpdateAtlas::~UpdateAtlas):
(WebKit::UpdateAtlas::beginPaintingOnAvailableBuffer):

  • WebProcess/WebPage/UpdateAtlas.h:

(UpdateAtlasClient):
(WebKit):
(UpdateAtlas):

Location:
trunk/Source/WebKit2
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r133269 r133270  
     12012-11-02  Huang Dongsung  <luxtella@company100.net>
     2
     3        Coordinated Graphics: Manage the lifecycle of shareable surfaces precisely.
     4        https://bugs.webkit.org/show_bug.cgi?id=100797
     5
     6        Reviewed by Noam Rosenthal.
     7
     8        Internal Review by Gwang Yoon Hwang and Jae Hyun Park.
     9
     10        This patch makes UpdateAtlas manage the lifecycle of shareable surfaces
     11        containing the updates in the way how CoordinatedTile manages the lifecycle of
     12        tiles. Currently, UI Process creates the shareable surface when receiving an
     13        UpdateTileForLayer message, but there is no exact point to remove the shareable
     14        surface. Now, we introduce new two messages to handle the lifecycle:
     15        CreateUpdateAtlas and RemoveUpdateAtlas.
     16
     17        This patch gives us two benefits.
     18        1. Reduce file and mmap operations. Web Process does not need to duplicate a
     19        file handle every tile update. UI Process does not need to create a
     20        ShareableSurface every UpdateTileForLayer message.
     21        2. Save memory. We can remove a ShareableSurface in UI Process when UpdateAtlas
     22        in Web Process is removed.
     23
     24        * Shared/SurfaceUpdateInfo.cpp:
     25        (WebKit::SurfaceUpdateInfo::encode):
     26        (WebKit::SurfaceUpdateInfo::decode):
     27        * Shared/SurfaceUpdateInfo.h:
     28        (SurfaceUpdateInfo):
     29        * UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.cpp:
     30        (WebKit::LayerTreeCoordinatorProxy::updateTileForLayer):
     31        (WebKit::LayerTreeCoordinatorProxy::createUpdateAtlas):
     32        (WebKit):
     33        (WebKit::LayerTreeCoordinatorProxy::removeUpdateAtlas):
     34        (WebKit::LayerTreeCoordinatorProxy::purgeBackingStores):
     35        * UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h:
     36        (LayerTreeCoordinatorProxy):
     37        * UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.messages.in:
     38        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp:
     39        (WebCore::CoordinatedGraphicsLayer::beginContentUpdate):
     40        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h:
     41        (CoordinatedGraphicsLayerClient):
     42        (CoordinatedGraphicsLayer):
     43        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.cpp:
     44        (WebKit::CoordinatedTile::updateBackBuffer):
     45        * WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.h:
     46        (CoordinatedTileClient):
     47        * WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp:
     48        (WebKit::LayerTreeCoordinator::createUpdateAtlas):
     49        (WebKit):
     50        (WebKit::LayerTreeCoordinator::removeUpdateAtlas):
     51        (WebKit::LayerTreeCoordinator::beginContentUpdate):
     52        * WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h:
     53        (LayerTreeCoordinator):
     54        * WebProcess/WebPage/UpdateAtlas.cpp:
     55        (WebKit::UpdateAtlas::UpdateAtlas):
     56        (WebKit):
     57        (WebKit::UpdateAtlas::~UpdateAtlas):
     58        (WebKit::UpdateAtlas::beginPaintingOnAvailableBuffer):
     59        * WebProcess/WebPage/UpdateAtlas.h:
     60        (UpdateAtlasClient):
     61        (WebKit):
     62        (UpdateAtlas):
     63
    1642012-11-02  Jinwoo Song  <jinwoo7.song@samsung.com>
    265

  • trunk/Source/WebKit2/Shared/SurfaceUpdateInfo.cpp

    r132361 r133270  
    2929    encoder.encode(updateRect);
    3030    encoder.encode(scaleFactor);
    31     encoder.encode(surfaceHandle);
     31    encoder.encode(atlasID);
    3232    encoder.encode(surfaceOffset);
    3333}
    … …  
    3939    if (!decoder->decode(result.scaleFactor))
    4040        return false;
    41     if (!decoder->decode(result.surfaceHandle))
     41    if (!decoder->decode(result.atlasID))
    4242        return false;
    4343    if (!decoder->decode(result.surfaceOffset))

  • trunk/Source/WebKit2/Shared/SurfaceUpdateInfo.h

    r132361 r133270  
    2121#define SurfaceUpdateInfo_h
    2222
    23 #include "ShareableSurface.h"
    2423#include <WebCore/IntRect.h>
    2524#include <wtf/Noncopyable.h>
    … …  
    4746    float scaleFactor;
    4847
    49     // The handle of the shareable bitmap containing the updates. Will be null if there are no updates.
    50     ShareableSurface::Handle surfaceHandle;
     48    // The id of the update atlas including the shareable bitmap containing the updates.
     49    int atlasID;
    5150
    5251    // The offset in the bitmap where the rendered contents are.

  • trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.cpp

    r132861 r133270  
    6565void LayerTreeCoordinatorProxy::updateTileForLayer(int layerID, int tileID, const IntRect& targetRect, const WebKit::SurfaceUpdateInfo& updateInfo)
    6666{
    67     RefPtr<ShareableSurface> surface;
    68 #if USE(GRAPHICS_SURFACE)
    69     GraphicsSurfaceToken token = updateInfo.surfaceHandle.graphicsSurfaceToken();
    70     if (token.isValid()) {
    71         HashMap<GraphicsSurfaceToken::BufferHandle, RefPtr<ShareableSurface> >::iterator it = m_surfaces.find(token.frontBufferHandle);
    72         if (it == m_surfaces.end()) {
    73             surface = ShareableSurface::create(updateInfo.surfaceHandle);
    74             m_surfaces.add(token.frontBufferHandle, surface);
    75         } else
    76             surface = it->value;
    77     } else
    78         surface = ShareableSurface::create(updateInfo.surfaceHandle);
    79 #else
    80     surface = ShareableSurface::create(updateInfo.surfaceHandle);
    81 #endif
    82     dispatchUpdate(bind(&LayerTreeRenderer::updateTile, m_renderer.get(), layerID, tileID, LayerTreeRenderer::TileUpdate(updateInfo.updateRect, targetRect, surface, updateInfo.surfaceOffset)));
     67    SurfaceMap::iterator it = m_surfaces.find(updateInfo.atlasID);
     68    ASSERT(it != m_surfaces.end());
     69    dispatchUpdate(bind(&LayerTreeRenderer::updateTile, m_renderer.get(), layerID, tileID, LayerTreeRenderer::TileUpdate(updateInfo.updateRect, targetRect, it->value, updateInfo.surfaceOffset)));
    8370}
    8471
    … …  
    8673{
    8774    dispatchUpdate(bind(&LayerTreeRenderer::removeTile, m_renderer.get(), layerID, tileID));
     75}
     76
     77void LayerTreeCoordinatorProxy::createUpdateAtlas(int atlasID, const ShareableSurface::Handle& handle)
     78{
     79    ASSERT(!m_surfaces.contains(atlasID));
     80    m_surfaces.add(atlasID, ShareableSurface::create(handle));
     81}
     82
     83void LayerTreeCoordinatorProxy::removeUpdateAtlas(int atlasID)
     84{
     85    ASSERT(m_surfaces.contains(atlasID));
     86    m_surfaces.remove(atlasID);
    8887}
    8988
    … …  
    204203{
    205204    m_drawingAreaProxy->page()->process()->send(Messages::LayerTreeCoordinator::PurgeBackingStores(), m_drawingAreaProxy->page()->pageID());
    206 #if USE(GRAPHICS_SURFACE)
    207     m_surfaces.clear();
    208 #endif
    209205}
    210206

  • trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.h

    r133182 r133270  
    2727#include "DrawingAreaProxy.h"
    2828#include "Region.h"
     29#include "ShareableSurface.h"
    2930#include "SurfaceUpdateInfo.h"
    3031#include "WebLayerTreeInfo.h"
    … …  
    6566    void updateTileForLayer(int layerID, int tileID, const WebCore::IntRect&, const SurfaceUpdateInfo&);
    6667    void removeTileForLayer(int layerID, int tileID);
     68    void createUpdateAtlas(int atlasID, const ShareableSurface::Handle&);
     69    void removeUpdateAtlas(int atlasID);
    6770    void createDirectlyCompositedImage(int64_t, const WebKit::ShareableBitmap::Handle&);
    6871    void destroyDirectlyCompositedImage(int64_t);
    … …  
    9194    float m_lastSentScale;
    9295    WebCore::FloatPoint m_lastSentTrajectoryVector;
    93 #if USE(GRAPHICS_SURFACE)
    94     HashMap<WebCore::GraphicsSurfaceToken::BufferHandle, RefPtr<ShareableSurface> > m_surfaces;
    95 #endif
     96    typedef HashMap<int /* atlasID */, RefPtr<ShareableSurface> > SurfaceMap;
     97    SurfaceMap m_surfaces;
    9698};
    9799

  • trunk/Source/WebKit2/UIProcess/CoordinatedGraphics/LayerTreeCoordinatorProxy.messages.in

    r132742 r133270  
    3030    UpdateTileForLayer(uint32_t layerID, int tileID, WebCore::IntRect targetRect, WebKit::SurfaceUpdateInfo updateInfo)
    3131    RemoveTileForLayer(uint32_t layerID, int tileID)
     32    CreateUpdateAtlas(int atlasID, WebKit::ShareableSurface::Handle handle)
     33    RemoveUpdateAtlas(int atlasID)
    3234    CreateDirectlyCompositedImage(int64_t key, WebKit::ShareableBitmap::Handle handle)
    3335    DestroyDirectlyCompositedImage(int64_t key)

  • trunk/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.cpp

    r133182 r133270  
    638638}
    639639
    640 PassOwnPtr<WebCore::GraphicsContext> CoordinatedGraphicsLayer::beginContentUpdate(const WebCore::IntSize& size, ShareableSurface::Handle& handle, WebCore::IntPoint& offset)
    641 {
    642     return m_CoordinatedGraphicsLayerClient->beginContentUpdate(size, contentsOpaque() ? 0 : ShareableBitmap::SupportsAlpha, handle, offset);
     640PassOwnPtr<WebCore::GraphicsContext> CoordinatedGraphicsLayer::beginContentUpdate(const WebCore::IntSize& size, int& atlas, WebCore::IntPoint& offset)
     641{
     642    return m_CoordinatedGraphicsLayerClient->beginContentUpdate(size, contentsOpaque() ? 0 : ShareableBitmap::SupportsAlpha, atlas, offset);
    643643}
    644644

  • trunk/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedGraphicsLayer.h

    r133182 r133270  
    7373    virtual void detachLayer(WebCore::CoordinatedGraphicsLayer*) = 0;
    7474    virtual void syncFixedLayers() = 0;
    75     virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, ShareableBitmap::Flags, ShareableSurface::Handle&, WebCore::IntPoint&) = 0;
     75    virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, ShareableBitmap::Flags, int& atlasID, WebCore::IntPoint&) = 0;
    7676};
    7777}
    … …  
    148148    virtual void updateTile(int tileID, const WebKit::SurfaceUpdateInfo&, const IntRect&) OVERRIDE;
    149149    virtual void removeTile(int tileID) OVERRIDE;
    150     virtual PassOwnPtr<GraphicsContext> beginContentUpdate(const IntSize&, WebKit::ShareableSurface::Handle&, IntPoint&) OVERRIDE;
     150    virtual PassOwnPtr<GraphicsContext> beginContentUpdate(const IntSize&, int& atlasID, IntPoint&) OVERRIDE;
    151151
    152152    void setCoordinatedGraphicsLayerClient(WebKit::CoordinatedGraphicsLayerClient*);

  • trunk/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.cpp

    r131617 r133270  
    7474
    7575    SurfaceUpdateInfo updateInfo;
    76     OwnPtr<GraphicsContext> graphicsContext = m_client->beginContentUpdate(m_dirtyRect.size(), updateInfo.surfaceHandle, updateInfo.surfaceOffset);
     76    OwnPtr<GraphicsContext> graphicsContext = m_client->beginContentUpdate(m_dirtyRect.size(), updateInfo.atlasID, updateInfo.surfaceOffset);
    7777    if (!graphicsContext)
    7878        return Vector<IntRect>();

  • trunk/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/CoordinatedTile.h

    r124701 r133270  
    2929#if USE(TILED_BACKING_STORE)
    3030
    31 #include "ShareableSurface.h"
    3231#include "Tile.h"
    3332#include "TiledBackingStore.h"
    … …  
    8079    virtual void updateTile(int tileID, const SurfaceUpdateInfo&, const WebCore::IntRect&) = 0;
    8180    virtual void removeTile(int tileID) = 0;
    82     virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, ShareableSurface::Handle&, WebCore::IntPoint&) = 0;
     81    virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, int& atlasID, WebCore::IntPoint&) = 0;
    8382};
    8483

  • trunk/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.cpp

    r132883 r133270  
    617617}
    618618
     619void LayerTreeCoordinator::createUpdateAtlas(int atlasID, const ShareableSurface::Handle& handle)
     620{
     621    m_webPage->send(Messages::LayerTreeCoordinatorProxy::CreateUpdateAtlas(atlasID, handle));
     622}
     623
     624void LayerTreeCoordinator::removeUpdateAtlas(int atlasID)
     625{
     626    m_webPage->send(Messages::LayerTreeCoordinatorProxy::RemoveUpdateAtlas(atlasID));
     627}
     628
    619629WebCore::IntRect LayerTreeCoordinator::visibleContentsRect() const
    620630{
    … …  
    700710}
    701711
    702 PassOwnPtr<WebCore::GraphicsContext> LayerTreeCoordinator::beginContentUpdate(const WebCore::IntSize& size, ShareableBitmap::Flags flags, ShareableSurface::Handle& handle, WebCore::IntPoint& offset)
     712PassOwnPtr<WebCore::GraphicsContext> LayerTreeCoordinator::beginContentUpdate(const WebCore::IntSize& size, ShareableBitmap::Flags flags, int& atlasID, WebCore::IntPoint& offset)
    703713{
    704714    OwnPtr<WebCore::GraphicsContext> graphicsContext;
    … …  
    707717        if (atlas->flags() == flags) {
    708718            // This will return null if there is no available buffer space.
    709             graphicsContext = atlas->beginPaintingOnAvailableBuffer(handle, size, offset);
     719            graphicsContext = atlas->beginPaintingOnAvailableBuffer(atlasID, size, offset);
    710720            if (graphicsContext)
    711721                return graphicsContext.release();
    … …  
    714724
    715725    static const int ScratchBufferDimension = 1024; // Should be a power of two.
    716     m_updateAtlases.append(adoptPtr(new UpdateAtlas(ScratchBufferDimension, flags)));
     726    m_updateAtlases.append(adoptPtr(new UpdateAtlas(this, ScratchBufferDimension, flags)));
    717727    scheduleReleaseInactiveAtlases();
    718     return m_updateAtlases.last()->beginPaintingOnAvailableBuffer(handle, size, offset);
     728    return m_updateAtlases.last()->beginPaintingOnAvailableBuffer(atlasID, size, offset);
    719729}
    720730

  • trunk/Source/WebKit2/WebProcess/WebPage/CoordinatedGraphics/LayerTreeCoordinator.h

    r133182 r133270  
    3939
    4040class LayerTreeCoordinator : public LayerTreeHost, WebCore::GraphicsLayerClient
    41                            , public CoordinatedGraphicsLayerClient
    42                            , public WebCore::GraphicsLayerFactory {
     41    , public CoordinatedGraphicsLayerClient
     42    , public UpdateAtlasClient
     43    , public WebCore::GraphicsLayerFactory {
    4344public:
    4445    static PassRefPtr<LayerTreeCoordinator> create(WebPage*);
    … …  
    9495    virtual void syncFixedLayers();
    9596
    96     virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, ShareableBitmap::Flags, ShareableSurface::Handle&, WebCore::IntPoint&);
     97    virtual PassOwnPtr<WebCore::GraphicsContext> beginContentUpdate(const WebCore::IntSize&, ShareableBitmap::Flags, int& atlasID, WebCore::IntPoint&);
     98
     99    // UpdateAtlasClient
     100    virtual void createUpdateAtlas(int atlasID, const ShareableSurface::Handle&);
     101    virtual void removeUpdateAtlas(int atlasID);
    97102
    98103#if ENABLE(REQUEST_ANIMATION_FRAME)

  • trunk/Source/WebKit2/WebProcess/WebPage/UpdateAtlas.cpp

    r128473 r133270  
    3131namespace WebKit {
    3232
    33 UpdateAtlas::UpdateAtlas(int dimension, ShareableBitmap::Flags flags)
    34     : m_flags(flags)
     33UpdateAtlas::UpdateAtlas(UpdateAtlasClient* client, int dimension, ShareableBitmap::Flags flags)
     34    : m_client(client)
     35    , m_flags(flags)
    3536    , m_inactivityInSeconds(0)
     37    , m_isVaild(true)
    3638{
     39    static int nextID = 0;
     40    m_ID = ++nextID;
    3741    IntSize size = nextPowerOfTwo(IntSize(dimension, dimension));
    3842    m_surface = ShareableSurface::create(size, flags, ShareableSurface::SupportsGraphicsSurface);
     43
     44    if (!m_surface->createHandle(m_handle)) {
     45        m_isVaild = false;
     46        return;
     47    }
     48    m_client->createUpdateAtlas(m_ID, m_handle);
     49}
     50
     51UpdateAtlas::~UpdateAtlas()
     52{
     53    if (m_isVaild)
     54        m_client->removeUpdateAtlas(m_ID);
    3955}
    4056
    … …  
    5268}
    5369
    54 PassOwnPtr<GraphicsContext> UpdateAtlas::beginPaintingOnAvailableBuffer(ShareableSurface::Handle& handle, const WebCore::IntSize& size, IntPoint& offset)
     70PassOwnPtr<GraphicsContext> UpdateAtlas::beginPaintingOnAvailableBuffer(int& atlasID, const WebCore::IntSize& size, IntPoint& offset)
    5571{
    5672    m_inactivityInSeconds = 0;
    … …  
    6278        return PassOwnPtr<GraphicsContext>();
    6379
    64     if (!m_surface->createHandle(handle))
    65         return PassOwnPtr<WebCore::GraphicsContext>();
     80    if (!m_isVaild)
     81        return PassOwnPtr<GraphicsContext>();
     82
     83    atlasID = m_ID;
    6684
    6785    // FIXME: Use tri-state buffers, to allow faster updates.

  • trunk/Source/WebKit2/WebProcess/WebPage/UpdateAtlas.h

    r128473 r133270  
    3333namespace WebKit {
    3434
     35class UpdateAtlasClient {
     36public:
     37    virtual void createUpdateAtlas(int atlasID, const ShareableSurface::Handle&) = 0;
     38    virtual void removeUpdateAtlas(int atlasID) = 0;
     39};
     40
    3541class UpdateAtlas {
    3642    WTF_MAKE_NONCOPYABLE(UpdateAtlas);
    3743public:
    38     UpdateAtlas(int dimension, ShareableBitmap::Flags);
     44    UpdateAtlas(UpdateAtlasClient*, int dimension, ShareableBitmap::Flags);
     45    ~UpdateAtlas();
    3946
    4047    inline WebCore::IntSize size() const { return m_surface->size(); }
    4148
    4249    // Returns a null pointer of there is no available buffer.
    43     PassOwnPtr<WebCore::GraphicsContext> beginPaintingOnAvailableBuffer(ShareableSurface::Handle&, const WebCore::IntSize&, WebCore::IntPoint& offset);
     50    PassOwnPtr<WebCore::GraphicsContext> beginPaintingOnAvailableBuffer(int& atlasID, const WebCore::IntSize&, WebCore::IntPoint& offset);
    4451    void didSwapBuffers();
    4552    ShareableBitmap::Flags flags() const { return m_flags; }
    … …  
    6168
    6269private:
     70    UpdateAtlasClient* m_client;
    6371    OwnPtr<GeneralAreaAllocator> m_areaAllocator;
    6472    ShareableBitmap::Flags m_flags;
    6573    RefPtr<ShareableSurface> m_surface;
     74    ShareableSurface::Handle m_handle;
    6675    double m_inactivityInSeconds;
     76    int m_ID;
     77    bool m_isVaild;
    6778};
    6879
Note: See TracChangeset for help on using the changeset viewer.