Changeset 142037 in webkit


Ignore:
Timestamp:
Feb 6, 2013 2:46:42 PM (11 years ago)
Author:
jpetsovits@rim.com
Message:

[BlackBerry] Refactor renderContents() for cleaner code.
https://bugs.webkit.org/show_bug.cgi?id=109059
RIM PR 280374

Reviewed by Rob Buis.
Internally reviewed by Arvid Nilsson.

The fact that we've got two renderContents() implementations
in BackingStore.cpp, one of which was tailored to just
being called from drawContents(), is a major annoyance.

With this patch, the regular renderContents() is modified
in a way so that drawContents() can make use of it as well.
This includes an API change for both functions which makes
it more flexible and enables further cleanups and improvements
to accuracy. The second, unloved renderContents() is removed.

The user-visible changes are improved (float) accuracy for
render offsets, clipping to exactly the dstRect that has
been specified, and the changed public drawContents() API.

  • Api/BackingStore.cpp:

(BlackBerry::WebKit::BackingStorePrivate::renderDirectToWindow):
(BlackBerry::WebKit::BackingStorePrivate::render):
(BlackBerry::WebKit::BackingStorePrivate::renderContents):
(BlackBerry::WebKit::BackingStore::drawContents):

  • Api/BackingStore.h:

(Platform):
(Graphics):

  • Api/BackingStore_p.h:

(WebCore):
(BackingStorePrivate):

  • WebKitSupport/SurfacePool.cpp:

(BlackBerry::WebKit::SurfacePool::SurfacePool):
(BlackBerry::WebKit::SurfacePool::initialize):
(BlackBerry::WebKit::SurfacePool::destroyPlatformGraphicsContext):

  • WebKitSupport/SurfacePool.h:

(SurfacePool):

Location:
trunk/Source/WebKit/blackberry
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebKit/blackberry/Api/BackingStore.cpp

    r141903 r142037  
    11/*
    2  * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved.
     2 * Copyright (C) 2009, 2010, 2011, 2012, 2013 Research In Motion Limited. All rights reserved.
    33 *
    44 * This library is free software; you can redistribute it and/or
     
    991991        return Platform::IntRect();
    992992
    993     Platform::IntRect screenRect = m_client->mapFromTransformedContentsToTransformedViewport(dirtyRect);
     993    Platform::ViewportAccessor* viewportAccessor = m_webPage->webkitThreadViewportAccessor();
     994    Platform::IntRect screenRect = viewportAccessor->pixelViewportFromContents(dirtyRect);
    994995    windowFrontBufferState()->clearBlittedRegion(screenRect);
    995996
    996     paintDefaultBackground(dirtyRect, m_webPage->webkitThreadViewportAccessor(), true /*flush*/);
    997 
    998     const Platform::IntPoint origin = unclippedVisibleContentsRect().location();
    999     // We don't need a buffer since we're direct rendering to window.
    1000     renderContents(0, origin, dirtyRect);
     997    paintDefaultBackground(dirtyRect, viewportAccessor, true /*flush*/);
     998
     999    if (!renderContents(buffer(), screenRect, viewportAccessor->scale(), viewportAccessor->documentFromPixelContents(dirtyRect.location())))
     1000        return Platform::IntRect();
     1001
    10011002    windowBackBufferState()->addBlittedRegion(screenRect);
    10021003
     
    10471048    if (tileIndexList.isEmpty())
    10481049        return tileIndexList;
     1050
     1051    Platform::ViewportAccessor* viewportAccessor = m_webPage->webkitThreadViewportAccessor();
    10491052
    10501053    BackingStoreGeometry* geometry = frontState();
     
    10611064
    10621065    for (size_t i = 0; i < tileIndexList.size(); ++i) {
    1063         TileIndex index = tileIndexList[i];
    1064         Platform::IntRect dirtyRect(newGeometry->originOfTile(index), tileSize());
    1065 
    10661066        if (!SurfacePool::globalSurfacePool()->numberOfAvailableBackBuffers()) {
    10671067            newGeometry->setTileMap(newTileMap);
     
    10791079        }
    10801080
     1081        TileIndex index = tileIndexList[i];
     1082        Platform::IntPoint tileOrigin = newGeometry->originOfTile(index);
     1083        Platform::IntRect dirtyRect(tileOrigin, tileSize());
     1084
    10811085        // Paint default background if contents rect is empty.
    10821086        if (!expandedContentsRect().isEmpty()) {
     
    11061110            backBuffer->paintBackground();
    11071111
    1108         Platform::IntPoint tileOrigin = geometry->originOfTile(index);
    11091112        backBuffer->setLastRenderScale(currentScale);
    11101113        backBuffer->setLastRenderOrigin(tileOrigin);
     
    11201123            SurfacePool::globalSurfacePool()->waitForBuffer(backBuffer);
    11211124
    1122         // FIXME: modify render to take a Vector<IntRect> parameter so we're not recreating
    1123         // GraphicsContext on the stack each time.
    1124         renderContents(nativeBuffer, tileOrigin, dirtyRect);
     1125        const Platform::FloatPoint documentDirtyRectOrigin = viewportAccessor->toDocumentContents(dirtyRect.location(), currentScale);
     1126        const Platform::IntRect dstRect(dirtyRect.location() - tileOrigin, dirtyRect.size());
     1127
     1128        if (!renderContents(nativeBuffer, dstRect, currentScale, documentDirtyRectOrigin))
     1129            continue;
    11251130
    11261131        // Add the newly rendered region to the tile so it can keep track for blits.
     
    18941899}
    18951900
    1896 void BackingStorePrivate::renderContents(Platform::Graphics::Drawable* drawable,
    1897                                          const Platform::IntRect& contentsRect,
    1898                                          const Platform::IntSize& destinationSize) const
    1899 {
    1900     if (!drawable || contentsRect.isEmpty())
    1901         return;
    1902 
    1903     requestLayoutIfNeeded();
    1904 
    1905     PlatformGraphicsContext* platformGraphicsContext = SurfacePool::globalSurfacePool()->createPlatformGraphicsContext(drawable);
    1906     GraphicsContext graphicsContext(platformGraphicsContext);
    1907 
    1908     graphicsContext.translate(-contentsRect.x(), -contentsRect.y());
    1909 
    1910     WebCore::IntRect transformedContentsRect(contentsRect.x(), contentsRect.y(), contentsRect.width(), contentsRect.height());
    1911 
    1912     float widthScale = static_cast<float>(destinationSize.width()) / contentsRect.width();
    1913     float heightScale = static_cast<float>(destinationSize.height()) / contentsRect.height();
    1914 
    1915     // Don't scale the transformed content rect when the content is smaller than the destination
    1916     if (widthScale < 1.0 && heightScale < 1.0) {
    1917         TransformationMatrix matrix;
    1918         matrix.scaleNonUniform(1.0 / widthScale, 1.0 / heightScale);
    1919         transformedContentsRect = matrix.mapRect(transformedContentsRect);
    1920         // We extract from the contentsRect but draw a slightly larger region than
    1921         // we were told to, in order to avoid pixels being rendered only partially.
    1922         const int atLeastOneDevicePixel = static_cast<int>(ceilf(std::max(1.0 / widthScale, 1.0 / heightScale)));
    1923         transformedContentsRect.inflate(atLeastOneDevicePixel);
    1924     }
    1925 
    1926     if (widthScale != 1.0 && heightScale != 1.0)
    1927         graphicsContext.scale(FloatSize(widthScale, heightScale));
    1928 
    1929     graphicsContext.clip(transformedContentsRect);
    1930     m_client->frame()->view()->paintContents(&graphicsContext, transformedContentsRect);
    1931 
    1932     delete platformGraphicsContext;
    1933 }
    1934 
    1935 void BackingStorePrivate::renderContents(BlackBerry::Platform::Graphics::Buffer* tileBuffer,
    1936                                          const Platform::IntPoint& surfaceOffset,
    1937                                          const Platform::IntRect& contentsRect) const
    1938 {
    1939     // If tileBuffer == 0, we render directly to the window.
    1940     if (!m_webPage->isVisible() && tileBuffer)
    1941         return;
    1942 
     1901bool BackingStorePrivate::renderContents(BlackBerry::Platform::Graphics::Buffer* targetBuffer, const Platform::IntRect& dstRect, double scale, const Platform::FloatPoint& documentRenderOrigin) const
     1902{
    19431903#if DEBUG_BACKINGSTORE
    19441904    Platform::logAlways(Platform::LogLevelCritical,
    1945         "BackingStorePrivate::renderContents tileBuffer=0x%p surfaceOffset=%s contentsRect=%s",
    1946         tileBuffer, surfaceOffset.toString().c_str(), contentsRect.toString().c_str());
     1905        "BackingStorePrivate::renderContents targetBuffer=0x%p dstRect=%s scale=%f documentRenderOrigin=%s",
     1906        targetBuffer, dstRect.toString().c_str(), scale, documentRenderOrigin.toString().c_str());
    19471907#endif
    19481908
    19491909    // It is up to callers of this method to perform layout themselves!
    19501910    ASSERT(!m_webPage->d->mainFrame()->view()->needsLayout());
    1951 
    1952     Platform::IntSize contentsSize = m_client->contentsSize();
     1911    ASSERT(targetBuffer);
     1912
     1913    Platform::ViewportAccessor* viewportAccessor = m_webPage->webkitThreadViewportAccessor();
     1914    WebCore::FloatRect renderedFloatRect(documentRenderOrigin, viewportAccessor->toDocumentContents(dstRect.size(), scale));
     1915    WebCore::IntRect contentsRect(WebCore::IntPoint::zero(), m_client->contentsSize());
    19531916    Color backgroundColor(m_webPage->settings()->backgroundColor());
    19541917
    1955     BlackBerry::Platform::Graphics::Buffer* targetBuffer = tileBuffer
    1956         ? tileBuffer
    1957         : buffer();
    1958 
    1959     if (contentsSize.isEmpty()
    1960         || !Platform::IntRect(Platform::IntPoint(0, 0), m_client->transformedContentsSize()).contains(contentsRect)
    1961         || backgroundColor.hasAlpha()) {
     1918    if (contentsRect.isEmpty()
     1919        || backgroundColor.hasAlpha()
     1920        || !WebCore::FloatRect(contentsRect).contains(renderedFloatRect)) {
    19621921        // Clear the area if it's not fully covered by (opaque) contents.
    1963         BlackBerry::Platform::IntRect clearRect = BlackBerry::Platform::IntRect(
    1964             contentsRect.x() - surfaceOffset.x(), contentsRect.y() - surfaceOffset.y(),
    1965             contentsRect.width(), contentsRect.height());
    1966 
    1967         BlackBerry::Platform::Graphics::clearBuffer(targetBuffer, clearRect,
     1922        BlackBerry::Platform::Graphics::clearBuffer(targetBuffer, dstRect,
    19681923            backgroundColor.red(), backgroundColor.green(),
    19691924            backgroundColor.blue(), backgroundColor.alpha());
    19701925    }
    19711926
    1972     if (contentsSize.isEmpty())
    1973         return;
    1974 
    1975     BlackBerry::Platform::Graphics::Drawable* bufferDrawable =
    1976         BlackBerry::Platform::Graphics::lockBufferDrawable(targetBuffer);
    1977 
    1978     PlatformGraphicsContext* bufferPlatformGraphicsContext = bufferDrawable
    1979         ? SurfacePool::globalSurfacePool()->createPlatformGraphicsContext(bufferDrawable)
    1980         : 0;
    1981     PlatformGraphicsContext* targetPlatformGraphicsContext = bufferPlatformGraphicsContext
    1982         ? bufferPlatformGraphicsContext
    1983         : SurfacePool::globalSurfacePool()->lockTileRenderingSurface();
    1984 
    1985     ASSERT(targetPlatformGraphicsContext);
     1927    if (contentsRect.isEmpty())
     1928        return true;
     1929
     1930    Platform::Graphics::Drawable* bufferDrawable = Platform::Graphics::lockBufferDrawable(targetBuffer);
     1931    Platform::Graphics::Buffer* drawingBuffer = 0;
     1932
     1933    if (bufferDrawable)
     1934        drawingBuffer = targetBuffer;
     1935    else {
     1936        BBLOG(Platform::LogLevelWarn, "Using temporary buffer to paint contents, look into avoiding this.");
     1937
     1938        drawingBuffer = Platform::Graphics::createBuffer(dstRect.size(), Platform::Graphics::BackedWhenNecessary);
     1939        if (!drawingBuffer) {
     1940            Platform::logAlways(Platform::LogLevelWarn, "Could not create temporary buffer, expect bad things to happen.");
     1941            return false;
     1942        }
     1943        bufferDrawable = Platform::Graphics::lockBufferDrawable(drawingBuffer);
     1944        if (!bufferDrawable) {
     1945            Platform::logAlways(Platform::LogLevelWarn, "Could not lock temporary buffer drawable, expect bad things to happen.");
     1946            Platform::Graphics::destroyBuffer(drawingBuffer);
     1947            return false;
     1948        }
     1949    }
     1950
     1951    PlatformGraphicsContext* platformGraphicsContext = SurfacePool::globalSurfacePool()->createPlatformGraphicsContext(bufferDrawable);
     1952    ASSERT(platformGraphicsContext);
    19861953
    19871954    {
    1988         GraphicsContext graphicsContext(targetPlatformGraphicsContext);
    1989 
    1990         // Believe it or not this is important since the WebKit Skia backend
    1991         // doesn't store the original state unless you call save first :P
     1955        GraphicsContext graphicsContext(platformGraphicsContext);
     1956
     1957        // Clip the output to the destination pixels.
    19921958        graphicsContext.save();
     1959        graphicsContext.clip(dstRect);
    19931960
    19941961        // Translate context according to offset.
    1995         graphicsContext.translate(-surfaceOffset.x(), -surfaceOffset.y());
     1962        if (targetBuffer == drawingBuffer)
     1963            graphicsContext.translate(-dstRect.x(), -dstRect.y());
    19961964
    19971965        // Add our transformation matrix as the global transform.
    1998         AffineTransform affineTransform(
    1999             m_webPage->d->transformationMatrix()->a(),
    2000             m_webPage->d->transformationMatrix()->b(),
    2001             m_webPage->d->transformationMatrix()->c(),
    2002             m_webPage->d->transformationMatrix()->d(),
    2003             m_webPage->d->transformationMatrix()->e(),
    2004             m_webPage->d->transformationMatrix()->f());
    2005         graphicsContext.concatCTM(affineTransform);
    2006 
    2007         // Now that the matrix is applied we need untranformed contents coordinates.
    2008         Platform::IntRect untransformedContentsRect = m_webPage->d->mapFromTransformed(contentsRect);
    2009 
    2010         // We extract from the contentsRect but draw a slightly larger region than
    2011         // we were told to, in order to avoid pixels being rendered only partially.
    2012         const int atLeastOneDevicePixel =
    2013             static_cast<int>(ceilf(1.0 / m_webPage->d->transformationMatrix()->a()));
    2014         untransformedContentsRect.inflate(atLeastOneDevicePixel, atLeastOneDevicePixel);
    2015 
    2016         // Make sure the untransformed rectangle for the (slightly larger than
    2017         // initially requested) repainted region is within the bounds of the page.
    2018         untransformedContentsRect.intersect(Platform::IntRect(Platform::IntPoint(0, 0), contentsSize));
    2019 
    2020         // Some WebKit painting backends *cough* Skia *cough* don't set this automatically
    2021         // to the dirtyRect so do so here explicitly.
    2022         graphicsContext.clip(untransformedContentsRect);
     1966        graphicsContext.scale(WebCore::FloatSize(scale, scale));
     1967        graphicsContext.translate(-documentRenderOrigin.x(), -documentRenderOrigin.y());
     1968
     1969        // Make sure the rectangle for the rendered rectangle is within the
     1970        // bounds of the page.
     1971        WebCore::IntRect renderedRect = enclosingIntRect(renderedFloatRect);
     1972        renderedRect.intersect(contentsRect);
    20231973
    20241974        // Take care of possible left overflow on RTL page.
    20251975        if (int leftOverFlow = m_client->frame()->view()->minimumScrollPosition().x()) {
    2026             untransformedContentsRect.move(leftOverFlow, 0);
     1976            renderedRect.move(leftOverFlow, 0);
    20271977            graphicsContext.translate(-leftOverFlow, 0);
    20281978        }
    20291979
    20301980        // Let WebCore render the page contents into the drawing surface.
    2031         m_client->frame()->view()->paintContents(&graphicsContext, untransformedContentsRect);
     1981        m_client->frame()->view()->paintContents(&graphicsContext, renderedRect);
    20321982
    20331983        graphicsContext.restore();
    20341984    }
    20351985
    2036     // Grab the requested region from the drawing surface into the tile image.
    2037 
    2038     delete bufferPlatformGraphicsContext;
    2039 
    2040     if (bufferDrawable)
    2041         releaseBufferDrawable(targetBuffer);
    2042     else {
    2043         const Platform::IntPoint dstPoint(contentsRect.x() - surfaceOffset.x(),
    2044                                           contentsRect.y() - surfaceOffset.y());
    2045         const Platform::IntRect dstRect(dstPoint, contentsRect.size());
    2046         const Platform::IntRect srcRect = dstRect;
    2047 
     1986    SurfacePool::globalSurfacePool()->destroyPlatformGraphicsContext(platformGraphicsContext);
     1987    Platform::Graphics::releaseBufferDrawable(drawingBuffer);
     1988
     1989    if (targetBuffer != drawingBuffer) {
    20481990        // If we couldn't directly draw to the buffer, copy from the drawing surface.
    2049         SurfacePool::globalSurfacePool()->releaseTileRenderingSurface(targetPlatformGraphicsContext);
    2050         BlackBerry::Platform::Graphics::blitToBuffer(targetBuffer, dstRect, BlackBerry::Platform::Graphics::drawingSurface(), srcRect);
    2051     }
     1991        const Platform::IntRect srcRect(Platform::IntPoint::zero(), dstRect.size());
     1992
     1993        Platform::Graphics::blitToBuffer(targetBuffer, dstRect, drawingBuffer, srcRect);
     1994        Platform::Graphics::destroyBuffer(drawingBuffer);
     1995    }
     1996
     1997    return true;
    20521998}
    20531999
     
    25242470}
    25252471
    2526 void BackingStore::drawContents(Platform::Graphics::Drawable* drawable, const Platform::IntRect& contentsRect, const Platform::IntSize& destinationSize)
    2527 {
    2528     d->renderContents(drawable, contentsRect, destinationSize);
    2529 }
    2530 
    2531 }
    2532 }
     2472bool BackingStore::drawContents(Platform::Graphics::Buffer* buffer, const Platform::IntRect& dstRect, double scale, const Platform::FloatPoint& documentScrollPosition)
     2473{
     2474    if (!buffer || dstRect.isEmpty())
     2475        return false;
     2476
     2477    d->requestLayoutIfNeeded();
     2478
     2479    return d->renderContents(buffer, dstRect, scale, documentScrollPosition);
     2480}
     2481
     2482}
     2483}
  • trunk/Source/WebKit/blackberry/Api/BackingStore.h

    r140191 r142037  
    2121
    2222#include "BlackBerryGlobal.h"
    23 #include <BlackBerryPlatformGraphics.h>
    2423#include <BlackBerryPlatformMisc.h>
    2524
     
    3534namespace Platform {
    3635class IntRect;
     36class FloatPoint;
     37
     38namespace Graphics {
     39class Buffer;
     40}
    3741}
    3842}
     
    7579    void releaseOwnedBackingStoreMemory();
    7680
    77     void drawContents(Platform::Graphics::Drawable*, const Platform::IntRect& /*contentsRect*/, const Platform::IntSize& /*destinationSize*/);
     81    bool drawContents(BlackBerry::Platform::Graphics::Buffer*, const BlackBerry::Platform::IntRect& dstRect, double scale, const BlackBerry::Platform::FloatPoint& documentScrollPosition);
    7882
    7983private:
  • trunk/Source/WebKit/blackberry/Api/BackingStore_p.h

    r138539 r142037  
    3434namespace WebCore {
    3535class IntRect;
     36class FloatPoint;
    3637class FloatRect;
    3738class LayerRenderer;
     
    306307
    307308    // This takes transformed contents coordinates.
    308     void renderContents(BlackBerry::Platform::Graphics::Buffer*, const Platform::IntPoint& surfaceOffset, const Platform::IntRect& contentsRect) const;
    309     void renderContents(Platform::Graphics::Drawable* /*drawable*/, const Platform::IntRect& /*contentsRect*/, const Platform::IntSize& /*destinationSize*/) const;
     309    bool renderContents(BlackBerry::Platform::Graphics::Buffer*, const BlackBerry::Platform::IntRect& dstRect, double scale, const BlackBerry::Platform::FloatPoint& documentScrollPosition) const;
    310310
    311311    void blitToWindow(const Platform::IntRect& dstRect, const BlackBerry::Platform::Graphics::Buffer* srcBuffer, const Platform::IntRect& srcRect, BlackBerry::Platform::Graphics::BlendMode, unsigned char globalAlpha);
  • trunk/Source/WebKit/blackberry/ChangeLog

    r142019 r142037  
     12013-02-06  Jakob Petsovits  <jpetsovits@rim.com>
     2
     3        [BlackBerry] Refactor renderContents() for cleaner code.
     4        https://bugs.webkit.org/show_bug.cgi?id=109059
     5        RIM PR 280374
     6
     7        Reviewed by Rob Buis.
     8        Internally reviewed by Arvid Nilsson.
     9
     10        The fact that we've got two renderContents() implementations
     11        in BackingStore.cpp, one of which was tailored to just
     12        being called from drawContents(), is a major annoyance.
     13
     14        With this patch, the regular renderContents() is modified
     15        in a way so that drawContents() can make use of it as well.
     16        This includes an API change for both functions which makes
     17        it more flexible and enables further cleanups and improvements
     18        to accuracy. The second, unloved renderContents() is removed.
     19
     20        The user-visible changes are improved (float) accuracy for
     21        render offsets, clipping to exactly the dstRect that has
     22        been specified, and the changed public drawContents() API.
     23
     24        * Api/BackingStore.cpp:
     25        (BlackBerry::WebKit::BackingStorePrivate::renderDirectToWindow):
     26        (BlackBerry::WebKit::BackingStorePrivate::render):
     27        (BlackBerry::WebKit::BackingStorePrivate::renderContents):
     28        (BlackBerry::WebKit::BackingStore::drawContents):
     29        * Api/BackingStore.h:
     30        (Platform):
     31        (Graphics):
     32        * Api/BackingStore_p.h:
     33        (WebCore):
     34        (BackingStorePrivate):
     35        * WebKitSupport/SurfacePool.cpp:
     36        (BlackBerry::WebKit::SurfacePool::SurfacePool):
     37        (BlackBerry::WebKit::SurfacePool::initialize):
     38        (BlackBerry::WebKit::SurfacePool::destroyPlatformGraphicsContext):
     39        * WebKitSupport/SurfacePool.h:
     40        (SurfacePool):
     41
    1422013-02-06  Nima Ghanavatian  <nghanavatian@rim.com>
    243
  • trunk/Source/WebKit/blackberry/WebKitSupport/SurfacePool.cpp

    r138028 r142037  
    5757SurfacePool::SurfacePool()
    5858    : m_numberOfFrontBuffers(0)
    59     , m_tileRenderingSurface(0)
    6059    , m_initialized(false)
    6160    , m_buffersSuspended(false)
     
    8685        }
    8786    }
    88 
    89     m_tileRenderingSurface = Platform::Graphics::drawingSurface();
    9087
    9188    if (!m_numberOfFrontBuffers)
     
    129126}
    130127
    131 PlatformGraphicsContext* SurfacePool::lockTileRenderingSurface() const
    132 {
    133     if (!m_tileRenderingSurface)
    134         return 0;
    135 
    136     return createPlatformGraphicsContext(Platform::Graphics::lockBufferDrawable(m_tileRenderingSurface));
    137 }
    138 
    139 void SurfacePool::releaseTileRenderingSurface(PlatformGraphicsContext* context) const
    140 {
    141     if (!m_tileRenderingSurface)
    142         return;
    143 
    144     delete context;
    145     Platform::Graphics::releaseBufferDrawable(m_tileRenderingSurface);
     128void SurfacePool::destroyPlatformGraphicsContext(PlatformGraphicsContext* platformGraphicsContext) const
     129{
     130    delete platformGraphicsContext;
    146131}
    147132
  • trunk/Source/WebKit/blackberry/WebKitSupport/SurfacePool.h

    r138028 r142037  
    4444
    4545    PlatformGraphicsContext* createPlatformGraphicsContext(BlackBerry::Platform::Graphics::Drawable*) const;
    46     PlatformGraphicsContext* lockTileRenderingSurface() const;
    47     void releaseTileRenderingSurface(PlatformGraphicsContext*) const;
     46    void destroyPlatformGraphicsContext(PlatformGraphicsContext*) const;
    4847
    4948    // The surface pool will allocate as many back buffers as specified by
     
    7978    TileBufferList m_availableBackBufferPool;
    8079    unsigned m_numberOfFrontBuffers;
    81     BlackBerry::Platform::Graphics::Buffer* m_tileRenderingSurface;
    8280    bool m_initialized; // SurfacePool has been set up, with or without buffers.
    8381    bool m_buffersSuspended; // Buffer objects exist, but pixel memory has been freed.
Note: See TracChangeset for help on using the changeset viewer.