Changeset 126202 in webkit


Ignore:
Timestamp:
Aug 21, 2012 4:00:12 PM (12 years ago)
Author:
commit-queue@webkit.org
Message:

[chromium] Add software bitmap resources to CCResourceProvider
​https://bugs.webkit.org/show_bug.cgi?id=93677

Patch by Alexandre Elias <​aelias@google.com> on 2012-08-21
Reviewed by Adrienne Walker.

This adds the ability to CCResourceProvider to use software bitmaps.
They are allocated as plain-old-memory, and exposed as Skia objects.

We want the ResourceProvider to be able to handle different resource
types at the same time. In practice, a default resource type is
desired for most uses within a single compositor instance, which is
specified by the default resource type. Default resource types are
expected to be mostly 1-to-1 with CCRenderer types.

New tests added by parametrizing existing CCResourceProvider tests.

Source/WebCore:

  • platform/graphics/chromium/FrameBufferSkPictureCanvasLayerTextureUpdater.cpp:

(WebCore::FrameBufferSkPictureCanvasLayerTextureUpdater::updateTextureRect):

  • platform/graphics/chromium/LayerRendererChromium.cpp:

(WebCore::applyFilters):
(WebCore::LayerRendererChromium::drawRenderPassQuad):
(WebCore::LayerRendererChromium::drawTileQuad):
(WebCore::LayerRendererChromium::drawYUVVideoQuad):
(WebCore::LayerRendererChromium::drawTextureQuad):
(WebCore::LayerRendererChromium::getFramebufferTexture):
(WebCore::LayerRendererChromium::bindFramebufferToTexture):

  • platform/graphics/chromium/LayerRendererChromium.h:

(DrawingFrame):

  • platform/graphics/chromium/cc/CCResourceProvider.cpp:

(WebCore::CCResourceProvider::createResource):
(WebCore):
(WebCore::CCResourceProvider::createGLTexture):
(WebCore::CCResourceProvider::createBitmap):
(WebCore::CCResourceProvider::createResourceFromExternalTexture):
(WebCore::CCResourceProvider::deleteResource):
(WebCore::CCResourceProvider::upload):
(WebCore::CCResourceProvider::flush):
(WebCore::CCResourceProvider::shallowFlushIfSupported):
(WebCore::CCResourceProvider::lockForRead):
(WebCore::CCResourceProvider::unlockForRead):
(WebCore::CCResourceProvider::lockForWrite):
(WebCore::CCResourceProvider::unlockForWrite):
(WebCore::CCResourceProvider::ScopedReadLockGL::ScopedReadLockGL):
(WebCore::CCResourceProvider::ScopedReadLockGL::~ScopedReadLockGL):
(WebCore::CCResourceProvider::ScopedWriteLockGL::ScopedWriteLockGL):
(WebCore::CCResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL):
(WebCore::CCResourceProvider::populateSkBitmapWithResource):
(WebCore::CCResourceProvider::ScopedReadLockSoftware::ScopedReadLockSoftware):
(WebCore::CCResourceProvider::ScopedReadLockSoftware::~ScopedReadLockSoftware):
(WebCore::CCResourceProvider::ScopedWriteLockSoftware::ScopedWriteLockSoftware):
(WebCore::CCResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware):
(WebCore::CCResourceProvider::CCResourceProvider):

  • platform/graphics/chromium/cc/CCResourceProvider.h:

(WebCore):
(WebCore::CCResourceProvider::setCreationPolicy):
(WebCore::CCResourceProvider::creationPolicy):
(CCResourceProvider):
(ScopedReadLockGL):
(WebCore::CCResourceProvider::ScopedReadLockGL::textureId):
(ScopedWriteLockGL):
(WebCore::CCResourceProvider::ScopedWriteLockGL::textureId):
(ScopedReadLockSoftware):
(WebCore::CCResourceProvider::ScopedReadLockSoftware::skBitmap):
(ScopedWriteLockSoftware):
(WebCore::CCResourceProvider::ScopedWriteLockSoftware::skCanvas):
(Resource):

Source/WebKit/chromium:

  • tests/CCResourceProviderTest.cpp:

(WebKit::CCResourceProviderTest::getResourcePixels):

Location:
trunk/Source
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r126201 r126202  
     12012-08-21  Alexandre Elias  <aelias@google.com>
     2
     3        [chromium] Add software bitmap resources to CCResourceProvider
     4        https://bugs.webkit.org/show_bug.cgi?id=93677
     5
     6        Reviewed by Adrienne Walker.
     7
     8        This adds the ability to CCResourceProvider to use software bitmaps.
     9        They are allocated as plain-old-memory, and exposed as Skia objects.
     10
     11        We want the ResourceProvider to be able to handle different resource
     12        types at the same time.  In practice, a default resource type is
     13        desired for most uses within a single compositor instance, which is
     14        specified by the default resource type.  Default resource types are
     15        expected to be mostly 1-to-1 with CCRenderer types.
     16
     17        New tests added by parametrizing existing CCResourceProvider tests.
     18
     19        * platform/graphics/chromium/FrameBufferSkPictureCanvasLayerTextureUpdater.cpp:
     20        (WebCore::FrameBufferSkPictureCanvasLayerTextureUpdater::updateTextureRect):
     21        * platform/graphics/chromium/LayerRendererChromium.cpp:
     22        (WebCore::applyFilters):
     23        (WebCore::LayerRendererChromium::drawRenderPassQuad):
     24        (WebCore::LayerRendererChromium::drawTileQuad):
     25        (WebCore::LayerRendererChromium::drawYUVVideoQuad):
     26        (WebCore::LayerRendererChromium::drawTextureQuad):
     27        (WebCore::LayerRendererChromium::getFramebufferTexture):
     28        (WebCore::LayerRendererChromium::bindFramebufferToTexture):
     29        * platform/graphics/chromium/LayerRendererChromium.h:
     30        (DrawingFrame):
     31        * platform/graphics/chromium/cc/CCResourceProvider.cpp:
     32        (WebCore::CCResourceProvider::createResource):
     33        (WebCore):
     34        (WebCore::CCResourceProvider::createGLTexture):
     35        (WebCore::CCResourceProvider::createBitmap):
     36        (WebCore::CCResourceProvider::createResourceFromExternalTexture):
     37        (WebCore::CCResourceProvider::deleteResource):
     38        (WebCore::CCResourceProvider::upload):
     39        (WebCore::CCResourceProvider::flush):
     40        (WebCore::CCResourceProvider::shallowFlushIfSupported):
     41        (WebCore::CCResourceProvider::lockForRead):
     42        (WebCore::CCResourceProvider::unlockForRead):
     43        (WebCore::CCResourceProvider::lockForWrite):
     44        (WebCore::CCResourceProvider::unlockForWrite):
     45        (WebCore::CCResourceProvider::ScopedReadLockGL::ScopedReadLockGL):
     46        (WebCore::CCResourceProvider::ScopedReadLockGL::~ScopedReadLockGL):
     47        (WebCore::CCResourceProvider::ScopedWriteLockGL::ScopedWriteLockGL):
     48        (WebCore::CCResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL):
     49        (WebCore::CCResourceProvider::populateSkBitmapWithResource):
     50        (WebCore::CCResourceProvider::ScopedReadLockSoftware::ScopedReadLockSoftware):
     51        (WebCore::CCResourceProvider::ScopedReadLockSoftware::~ScopedReadLockSoftware):
     52        (WebCore::CCResourceProvider::ScopedWriteLockSoftware::ScopedWriteLockSoftware):
     53        (WebCore::CCResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware):
     54        (WebCore::CCResourceProvider::CCResourceProvider):
     55        * platform/graphics/chromium/cc/CCResourceProvider.h:
     56        (WebCore):
     57        (WebCore::CCResourceProvider::setCreationPolicy):
     58        (WebCore::CCResourceProvider::creationPolicy):
     59        (CCResourceProvider):
     60        (ScopedReadLockGL):
     61        (WebCore::CCResourceProvider::ScopedReadLockGL::textureId):
     62        (ScopedWriteLockGL):
     63        (WebCore::CCResourceProvider::ScopedWriteLockGL::textureId):
     64        (ScopedReadLockSoftware):
     65        (WebCore::CCResourceProvider::ScopedReadLockSoftware::skBitmap):
     66        (ScopedWriteLockSoftware):
     67        (WebCore::CCResourceProvider::ScopedWriteLockSoftware::skCanvas):
     68        (Resource):
     69
    1702012-08-21  Tab Atkins  <tabatkins@google.com>
    271

  • trunk/Source/WebCore/platform/graphics/chromium/FrameBufferSkPictureCanvasLayerTextureUpdater.cpp

    r125932 r126202  
    108108
    109109    texture->acquireBackingTexture(resourceProvider);
    110     CCScopedLockResourceForWrite lock(resourceProvider, texture->resourceId());
     110    CCResourceProvider::ScopedWriteLockGL lock(resourceProvider, texture->resourceId());
    111111    // Create an accelerated canvas to draw on.
    112112    OwnPtr<SkCanvas> canvas = createAcceleratedCanvas(grContext, texture->size(), lock.textureId());

  • trunk/Source/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp

    r126052 r126202  
    364364    layerRenderer->context()->flush();
    365365
    366     CCScopedLockResourceForWrite lock(layerRenderer->resourceProvider(), sourceTexture->id());
     366    CCResourceProvider::ScopedWriteLockGL lock(layerRenderer->resourceProvider(), sourceTexture->id());
    367367    SkBitmap source = CCRenderSurfaceFilters::apply(filters, lock.textureId(), sourceTexture->size(), filterContext, filterGrContext);
    368368    return source;
    … …  
    466466    // Apply filters to the contents texture.
    467467    SkBitmap filterBitmap = applyFilters(this, renderPass->filters(), contentsTexture);
    468     OwnPtr<CCScopedLockResourceForRead> contentsResourceLock;
     468    OwnPtr<CCResourceProvider::ScopedReadLockGL> contentsResourceLock;
    469469    unsigned contentsTextureId = 0;
    470470    if (filterBitmap.getTexture()) {
    … …  
    472472        contentsTextureId = texture->getTextureHandle();
    473473    } else {
    474         contentsResourceLock = adoptPtr(new CCScopedLockResourceForRead(m_resourceProvider, contentsTexture->id()));
     474        contentsResourceLock = adoptPtr(new CCResourceProvider::ScopedReadLockGL(m_resourceProvider, contentsTexture->id()));
    475475        contentsTextureId = contentsResourceLock->textureId();
    476476    }
    … …  
    479479    if (backgroundTexture) {
    480480        ASSERT(backgroundTexture->size() == quad->quadRect().size());
    481         CCScopedLockResourceForRead lock(m_resourceProvider, backgroundTexture->id());
     481        CCResourceProvider::ScopedReadLockGL lock(m_resourceProvider, backgroundTexture->id());
    482482        copyTextureToFramebuffer(frame, lock.textureId(), quad->quadRect(), quad->quadTransform());
    483483    }
    … …  
    496496    }
    497497
    498     OwnPtr<CCScopedLockResourceForRead> maskResourceLock;
     498    OwnPtr<CCResourceProvider::ScopedReadLockGL> maskResourceLock;
    499499    unsigned maskTextureId = 0;
    500500    if (quad->maskResourceId()) {
    501         maskResourceLock = adoptPtr(new CCScopedLockResourceForRead(m_resourceProvider, quad->maskResourceId()));
     501        maskResourceLock = adoptPtr(new CCResourceProvider::ScopedReadLockGL(m_resourceProvider, quad->maskResourceId()));
    502502        maskTextureId = maskResourceLock->textureId();
    503503    }
    … …  
    690690    GLC(context(), context()->uniform1i(uniforms.samplerLocation, 0));
    691691    GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));
    692     CCScopedLockResourceForRead quadResourceLock(m_resourceProvider, quad->resourceId());
     692    CCResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());
    693693    GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, quadResourceLock.textureId()));
    694694    GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, quad->textureFilter()));
    … …  
    797797    const CCVideoLayerImpl::FramePlane& vPlane = quad->vPlane();
    798798
    799     CCScopedLockResourceForRead yPlaneLock(m_resourceProvider, yPlane.resourceId);
    800     CCScopedLockResourceForRead uPlaneLock(m_resourceProvider, uPlane.resourceId);
    801     CCScopedLockResourceForRead vPlaneLock(m_resourceProvider, vPlane.resourceId);
     799    CCResourceProvider::ScopedReadLockGL yPlaneLock(m_resourceProvider, yPlane.resourceId);
     800    CCResourceProvider::ScopedReadLockGL uPlaneLock(m_resourceProvider, uPlane.resourceId);
     801    CCResourceProvider::ScopedReadLockGL vPlaneLock(m_resourceProvider, vPlane.resourceId);
    802802    GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE1));
    803803    GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, yPlaneLock.textureId()));
    … …  
    908908
    909909    GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));
    910     CCScopedLockResourceForRead quadResourceLock(m_resourceProvider, quad->resourceId());
     910    CCResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());
    911911    GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, quadResourceLock.textureId()));
    912912
    … …  
    12001200        return false;
    12011201
    1202     CCScopedLockResourceForWrite lock(m_resourceProvider, texture->id());
     1202    CCResourceProvider::ScopedWriteLockGL lock(m_resourceProvider, texture->id());
    12031203    GLC(m_context, m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, lock.textureId()));
    12041204    GLC(m_context, m_context->copyTexImage2D(GraphicsContext3D::TEXTURE_2D, 0, texture->format(),
    … …  
    12271227
    12281228    GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_offscreenFramebufferId));
    1229     m_currentFramebufferLock = adoptPtr(new CCScopedLockResourceForWrite(m_resourceProvider, texture->id()));
     1229    m_currentFramebufferLock = adoptPtr(new CCResourceProvider::ScopedWriteLockGL(m_resourceProvider, texture->id()));
    12301230    unsigned textureId = m_currentFramebufferLock->textureId();
    12311231    GLC(m_context, m_context->framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, textureId, 0));

  • trunk/Source/WebCore/platform/graphics/chromium/LayerRendererChromium.h

    r126052 r126202  
    249249    TextureUploaderOption m_textureUploaderSetting;
    250250
    251     OwnPtr<CCScopedLockResourceForWrite> m_currentFramebufferLock;
     251    OwnPtr<CCResourceProvider::ScopedWriteLockGL> m_currentFramebufferLock;
    252252};
    253253

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCResourceProvider.cpp

    r125932 r126202  
    3232#include "LayerRendererChromium.h" // For the GLC() macro
    3333#include "LayerTextureSubImage.h"
     34#include <limits.h>
    3435#include <public/WebGraphicsContext3D.h>
    3536#include <wtf/HashSet.h>
    … …  
    8990CCResourceProvider::ResourceId CCResourceProvider::createResource(int pool, const IntSize& size, GC3Denum format, TextureUsageHint hint)
    9091{
     92    switch (m_defaultResourceType) {
     93    case GLTexture:
     94        return createGLTexture(pool, size, format, hint);
     95    case Bitmap:
     96        ASSERT(format == GraphicsContext3D::RGBA);
     97        return createBitmap(pool, size);
     98    }
     99
     100    CRASH();
     101    return 0;
     102}
     103
     104CCResourceProvider::ResourceId CCResourceProvider::createGLTexture(int pool, const IntSize& size, GC3Denum format, TextureUsageHint hint)
     105{
    91106    ASSERT(CCProxy::isImplThread());
    92107    unsigned textureId = 0;
    93108    WebGraphicsContext3D* context3d = m_context->context3D();
    94     if (!context3d) {
    95         // FIXME: Implement this path for software compositing.
    96         return 0;
    97     }
     109    ASSERT(context3d);
    98110    GLC(context3d, textureId = context3d->createTexture());
    99111    GLC(context3d, context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, textureId));
    … …  
    116128}
    117129
     130CCResourceProvider::ResourceId CCResourceProvider::createBitmap(int pool, const IntSize& size)
     131{
     132    ASSERT(CCProxy::isImplThread());
     133
     134    uint8_t* pixels = new uint8_t[size.width() * size.height() * 4];
     135
     136    ResourceId id = m_nextId++;
     137    Resource resource(pixels, pool, size, GraphicsContext3D::RGBA);
     138    m_resources.add(id, resource);
     139    return id;
     140}
     141
    118142CCResourceProvider::ResourceId CCResourceProvider::createResourceFromExternalTexture(unsigned textureId)
    119143{
    120144    ASSERT(CCProxy::isImplThread());
    121145    ResourceId id = m_nextId++;
    122     Resource resource;
    123     resource.glId = textureId;
     146    Resource resource(textureId, 0, IntSize(), 0);
    124147    resource.external = true;
    125148    m_resources.add(id, resource);
    … …  
    130153{
    131154    ASSERT(CCProxy::isImplThread());
    132     WebGraphicsContext3D* context3d = m_context->context3D();
    133     if (!context3d) {
    134         // FIXME: Implement this path for software compositing.
    135         return;
    136     }
    137155    ResourceMap::iterator it = m_resources.find(id);
    138156    ASSERT(it != m_resources.end() && !it->second.lockedForWrite && !it->second.lockForReadCount);
    139     if (!it->second.external)
     157
     158    if (it->second.glId && !it->second.external) {
     159        WebGraphicsContext3D* context3d = m_context->context3D();
     160        ASSERT(context3d);
    140161        GLC(context3d, context3d->deleteTexture(it->second.glId));
     162    }
     163    if (it->second.pixels)
     164        delete it->second.pixels;
     165
    141166    m_resources.remove(it);
    142167}
    … …  
    154179}
    155180
     181CCResourceProvider::ResourceType CCResourceProvider::resourceType(ResourceId id)
     182{
     183    ResourceMap::iterator it = m_resources.find(id);
     184    ASSERT(it != m_resources.end());
     185    return it->second.type;
     186}
     187
    156188void CCResourceProvider::upload(ResourceId id, const uint8_t* image, const IntRect& imageRect, const IntRect& sourceRect, const IntSize& destOffset)
    157189{
    158190    ASSERT(CCProxy::isImplThread());
    159     ASSERT(m_texSubImage.get());
    160     WebGraphicsContext3D* context3d = m_context->context3D();
    161     if (!context3d) {
    162         // FIXME: Implement this path for software compositing.
    163         return;
    164     }
    165191    ResourceMap::iterator it = m_resources.find(id);
    166192    ASSERT(it != m_resources.end() && !it->second.lockedForWrite && !it->second.lockForReadCount && !it->second.external);
    167193
    168     context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, it->second.glId);
    169     m_texSubImage->upload(image, imageRect, sourceRect, destOffset, it->second.format, context3d);
    170 }
    171 
    172 unsigned CCResourceProvider::lockForWrite(ResourceId id)
     194    if (it->second.glId) {
     195        WebGraphicsContext3D* context3d = m_context->context3D();
     196        ASSERT(context3d);
     197        ASSERT(m_texSubImage.get());
     198        context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, it->second.glId);
     199        m_texSubImage->upload(image, imageRect, sourceRect, destOffset, it->second.format, context3d);
     200    }
     201
     202    if (it->second.pixels) {
     203        SkBitmap srcFull;
     204        srcFull.setConfig(SkBitmap::kARGB_8888_Config, imageRect.width(), imageRect.height());
     205        srcFull.setPixels(const_cast<uint8_t*>(image));
     206        SkBitmap srcSubset;
     207        SkIRect skSourceRect = SkIRect::MakeXYWH(sourceRect.x(), sourceRect.y(), sourceRect.width(), sourceRect.height());
     208        skSourceRect.offset(-imageRect.x(), -imageRect.y());
     209        srcFull.extractSubset(&srcSubset, skSourceRect);
     210
     211        ScopedWriteLockSoftware lock(this, id);
     212        SkCanvas* dest = lock.skCanvas();
     213        dest->writePixels(srcSubset, destOffset.width(), destOffset.height());
     214    }
     215}
     216
     217void CCResourceProvider::flush()
     218{
     219    ASSERT(CCProxy::isImplThread());
     220    WebGraphicsContext3D* context3d = m_context->context3D();
     221    if (context3d)
     222        context3d->flush();
     223}
     224
     225bool CCResourceProvider::shallowFlushIfSupported()
     226{
     227    ASSERT(CCProxy::isImplThread());
     228    WebGraphicsContext3D* context3d = m_context->context3D();
     229    if (!context3d || !m_useShallowFlush)
     230        return false;
     231
     232    context3d->shallowFlushCHROMIUM();
     233    return true;
     234}
     235
     236const CCResourceProvider::Resource* CCResourceProvider::lockForRead(ResourceId id)
     237{
     238    ASSERT(CCProxy::isImplThread());
     239    ResourceMap::iterator it = m_resources.find(id);
     240    ASSERT(it != m_resources.end() && !it->second.lockedForWrite);
     241    it->second.lockForReadCount++;
     242    return &it->second;
     243}
     244
     245void CCResourceProvider::unlockForRead(ResourceId id)
     246{
     247    ASSERT(CCProxy::isImplThread());
     248    ResourceMap::iterator it = m_resources.find(id);
     249    ASSERT(it != m_resources.end() && it->second.lockForReadCount > 0);
     250    it->second.lockForReadCount--;
     251}
     252
     253const CCResourceProvider::Resource* CCResourceProvider::lockForWrite(ResourceId id)
    173254{
    174255    ASSERT(CCProxy::isImplThread());
    … …  
    176257    ASSERT(it != m_resources.end() && !it->second.lockedForWrite && !it->second.lockForReadCount && !it->second.external);
    177258    it->second.lockedForWrite = true;
    178     return it->second.glId;
     259    return &it->second;
    179260}
    180261
    … …  
    187268}
    188269
    189 void CCResourceProvider::flush()
    190 {
    191     ASSERT(CCProxy::isImplThread());
    192     WebGraphicsContext3D* context3d = m_context->context3D();
    193     if (!context3d) {
    194         // FIXME: Implement this path for software compositing.
    195         return;
    196     }
    197     context3d->flush();
    198 }
    199 
    200 bool CCResourceProvider::shallowFlushIfSupported()
    201 {
    202     ASSERT(CCProxy::isImplThread());
    203     WebGraphicsContext3D* context3d = m_context->context3D();
    204     if (!context3d) {
    205         // FIXME: Implement this path for software compositing.
    206         return false;
    207     }
    208 
    209     if (m_useShallowFlush)
    210         context3d->shallowFlushCHROMIUM();
    211     return m_useShallowFlush;
    212 }
    213 
    214 unsigned CCResourceProvider::lockForRead(ResourceId id)
    215 {
    216     ASSERT(CCProxy::isImplThread());
    217     ResourceMap::iterator it = m_resources.find(id);
    218     ASSERT(it != m_resources.end() && !it->second.lockedForWrite);
    219     ++(it->second.lockForReadCount);
    220     return it->second.glId;
    221 }
    222 
    223 void CCResourceProvider::unlockForRead(ResourceId id)
    224 {
    225     ASSERT(CCProxy::isImplThread());
    226     ResourceMap::iterator it = m_resources.find(id);
    227     ASSERT(it != m_resources.end() && it->second.lockForReadCount > 0);
    228     --(it->second.lockForReadCount);
     270CCResourceProvider::ScopedReadLockGL::ScopedReadLockGL(CCResourceProvider* resourceProvider, CCResourceProvider::ResourceId resourceId)
     271    : m_resourceProvider(resourceProvider)
     272    , m_resourceId(resourceId)
     273    , m_textureId(resourceProvider->lockForRead(resourceId)->glId)
     274{
     275    ASSERT(m_textureId);
     276}
     277
     278CCResourceProvider::ScopedReadLockGL::~ScopedReadLockGL()
     279{
     280    m_resourceProvider->unlockForRead(m_resourceId);
     281}
     282
     283CCResourceProvider::ScopedWriteLockGL::ScopedWriteLockGL(CCResourceProvider* resourceProvider, CCResourceProvider::ResourceId resourceId)
     284    : m_resourceProvider(resourceProvider)
     285    , m_resourceId(resourceId)
     286    , m_textureId(resourceProvider->lockForWrite(resourceId)->glId)
     287{
     288    ASSERT(m_textureId);
     289}
     290
     291CCResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL()
     292{
     293    m_resourceProvider->unlockForWrite(m_resourceId);
     294}
     295
     296void CCResourceProvider::populateSkBitmapWithResource(SkBitmap* skBitmap, const Resource* resource)
     297{
     298    ASSERT(resource->pixels);
     299    ASSERT(resource->format == GraphicsContext3D::RGBA);
     300    skBitmap->setConfig(SkBitmap::kARGB_8888_Config, resource->size.width(), resource->size.height());
     301    skBitmap->setPixels(resource->pixels);
     302}
     303
     304CCResourceProvider::ScopedReadLockSoftware::ScopedReadLockSoftware(CCResourceProvider* resourceProvider, CCResourceProvider::ResourceId resourceId)
     305    : m_resourceProvider(resourceProvider)
     306    , m_resourceId(resourceId)
     307{
     308    CCResourceProvider::populateSkBitmapWithResource(&m_skBitmap, resourceProvider->lockForRead(resourceId));
     309}
     310
     311CCResourceProvider::ScopedReadLockSoftware::~ScopedReadLockSoftware()
     312{
     313    m_resourceProvider->unlockForRead(m_resourceId);
     314}
     315
     316CCResourceProvider::ScopedWriteLockSoftware::ScopedWriteLockSoftware(CCResourceProvider* resourceProvider, CCResourceProvider::ResourceId resourceId)
     317    : m_resourceProvider(resourceProvider)
     318    , m_resourceId(resourceId)
     319{
     320    CCResourceProvider::populateSkBitmapWithResource(&m_skBitmap, resourceProvider->lockForWrite(resourceId));
     321    m_skCanvas.setBitmapDevice(m_skBitmap);
     322}
     323
     324CCResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware()
     325{
     326    m_resourceProvider->unlockForWrite(m_resourceId);
    229327}
    230328
    … …  
    233331    , m_nextId(1)
    234332    , m_nextChild(1)
     333    , m_defaultResourceType(GLTexture)
    235334    , m_useTextureStorageExt(false)
    236335    , m_useTextureUsageHint(false)
    237336    , m_useShallowFlush(false)
    238     , m_maxTextureSize(0)
     337    , m_maxTextureSize(INT_MAX)
    239338{
    240339}

  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCResourceProvider.h

    r126122 r126202  
    3131#include "GraphicsContext3D.h"
    3232#include "IntSize.h"
     33#include "SkBitmap.h"
     34#include "SkCanvas.h"
    3335#include <wtf/Deque.h>
    3436#include <wtf/HashMap.h>
    … …  
    4547namespace WebCore {
    4648
    47 class CCScopedLockResourceForRead;
    48 class CCScopedLockResourceForWrite;
    4949class IntRect;
    5050class LayerTextureSubImage;
    … …  
    5959    typedef HashMap<ResourceId, ResourceId> ResourceIdMap;
    6060    enum TextureUsageHint { TextureUsageAny, TextureUsageFramebuffer };
     61    enum ResourceType {
     62        GLTexture = 1,
     63        Bitmap,
     64    };
    6165    struct Mailbox {
    6266        GC3Dbyte name[64];
    … …  
    8892    // Producer interface.
    8993
    90     // Creates a resource of the given size/format, into the given pool.
     94    void setDefaultResourceType(ResourceType type) { m_defaultResourceType = type; }
     95    ResourceType defaultResourceType() const { return m_defaultResourceType; }
     96    ResourceType resourceType(ResourceId);
     97
     98    // Creates a resource of the default resource type.
    9199    ResourceId createResource(int pool, const IntSize&, GC3Denum format, TextureUsageHint);
    92100
    93     // Wraps an external texture into a resource.
     101    // You can also explicitly create a specific resource type.
     102    ResourceId createGLTexture(int pool, const IntSize&, GC3Denum format, TextureUsageHint);
     103    ResourceId createBitmap(int pool, const IntSize&);
     104    // Wraps an external texture into a GL resource.
    94105    ResourceId createResourceFromExternalTexture(unsigned textureId);
     106
    95107    void deleteResource(ResourceId);
    96108
    … …  
    148160    size_t mailboxCount() const { return m_mailboxes.size(); }
    149161
     162    // The following lock classes are part of the CCResourceProvider API and are
     163    // needed to read and write the resource contents. The user must ensure
     164    // that they only use GL locks on GL resources, etc, and this is enforced
     165    // by assertions.
     166    class ScopedReadLockGL {
     167        WTF_MAKE_NONCOPYABLE(ScopedReadLockGL);
     168    public:
     169        ScopedReadLockGL(CCResourceProvider*, CCResourceProvider::ResourceId);
     170        ~ScopedReadLockGL();
     171
     172        unsigned textureId() const { return m_textureId; }
     173
     174    private:
     175        CCResourceProvider* m_resourceProvider;
     176        CCResourceProvider::ResourceId m_resourceId;
     177        unsigned m_textureId;
     178    };
     179
     180    class ScopedWriteLockGL {
     181        WTF_MAKE_NONCOPYABLE(ScopedWriteLockGL);
     182    public:
     183        ScopedWriteLockGL(CCResourceProvider*, CCResourceProvider::ResourceId);
     184        ~ScopedWriteLockGL();
     185
     186        unsigned textureId() const { return m_textureId; }
     187
     188    private:
     189        CCResourceProvider* m_resourceProvider;
     190        CCResourceProvider::ResourceId m_resourceId;
     191        unsigned m_textureId;
     192    };
     193
     194    class ScopedReadLockSoftware {
     195        WTF_MAKE_NONCOPYABLE(ScopedReadLockSoftware);
     196    public:
     197        ScopedReadLockSoftware(CCResourceProvider*, CCResourceProvider::ResourceId);
     198        ~ScopedReadLockSoftware();
     199
     200        const SkBitmap* skBitmap() const { return &m_skBitmap; }
     201
     202    private:
     203        CCResourceProvider* m_resourceProvider;
     204        CCResourceProvider::ResourceId m_resourceId;
     205        SkBitmap m_skBitmap;
     206    };
     207
     208    class ScopedWriteLockSoftware {
     209        WTF_MAKE_NONCOPYABLE(ScopedWriteLockSoftware);
     210    public:
     211        ScopedWriteLockSoftware(CCResourceProvider*, CCResourceProvider::ResourceId);
     212        ~ScopedWriteLockSoftware();
     213
     214        SkCanvas* skCanvas() { return &m_skCanvas; }
     215
     216    private:
     217        CCResourceProvider* m_resourceProvider;
     218        CCResourceProvider::ResourceId m_resourceId;
     219        SkBitmap m_skBitmap;
     220        SkCanvas m_skCanvas;
     221    };
     222
    150223private:
    151     friend class CCScopedLockResourceForRead;
    152     friend class CCScopedLockResourceForWrite;
    153 
    154224    struct Resource {
    155225        Resource()
    156226            : glId(0)
     227            , pixels(0)
    157228            , pool(0)
    158229            , lockForReadCount(0)
    … …  
    162233            , size()
    163234            , format(0)
     235            , type(static_cast<ResourceType>(0))
    164236        { }
    165237        Resource(unsigned textureId, int pool, const IntSize& size, GC3Denum format)
    166238            : glId(textureId)
     239            , pixels(0)
    167240            , pool(pool)
    168241            , lockForReadCount(0)
    … …  
    172245            , size(size)
    173246            , format(format)
     247            , type(GLTexture)
     248        { }
     249        Resource(uint8_t* pixels, int pool, const IntSize& size, GC3Denum format)
     250            : glId(0)
     251            , pixels(pixels)
     252            , pool(pool)
     253            , lockForReadCount(0)
     254            , lockedForWrite(false)
     255            , external(false)
     256            , exported(false)
     257            , size(size)
     258            , format(format)
     259            , type(Bitmap)
    174260        { }
    175261        unsigned glId;
     262        uint8_t* pixels;
    176263        int pool;
    177264        int lockForReadCount;
    … …  
    181268        IntSize size;
    182269        GC3Denum format;
     270        ResourceType type;
    183271    };
    184272    typedef HashMap<ResourceId, Resource> ResourceMap;
    … …  
    193281    bool initialize();
    194282
    195     // Gets a GL texture id representing the resource, that can be rendered into.
    196     unsigned lockForWrite(ResourceId);
     283    const Resource* lockForRead(ResourceId);
     284    void unlockForRead(ResourceId);
     285    const Resource* lockForWrite(ResourceId);
    197286    void unlockForWrite(ResourceId);
    198 
    199     // Gets a GL texture id representing the resource, that can be rendered with.
    200     unsigned lockForRead(ResourceId);
    201     void unlockForRead(ResourceId);
     287    static void populateSkBitmapWithResource(SkBitmap*, const Resource*);
    202288
    203289    bool transferResource(WebKit::WebGraphicsContext3D*, ResourceId, TransferableResource*);
    … …  
    212298    Deque<Mailbox> m_mailboxes;
    213299
     300    ResourceType m_defaultResourceType;
    214301    bool m_useTextureStorageExt;
    215302    bool m_useTextureUsageHint;
    … …  
    219306};
    220307
    221 class CCScopedLockResourceForRead {
    222     WTF_MAKE_NONCOPYABLE(CCScopedLockResourceForRead);
    223 public:
    224     CCScopedLockResourceForRead(CCResourceProvider* resourceProvider, CCResourceProvider::ResourceId resourceId)
    225         : m_resourceProvider(resourceProvider)
    226         , m_resourceId(resourceId)
    227         , m_textureId(resourceProvider->lockForRead(resourceId))
    228     {
    229         ASSERT(m_textureId);
    230     }
    231 
    232     ~CCScopedLockResourceForRead()
    233     {
    234         m_resourceProvider->unlockForRead(m_resourceId);
    235     }
    236 
    237     unsigned textureId() const { return m_textureId; }
    238 
    239 private:
    240     CCResourceProvider* m_resourceProvider;
    241     CCResourceProvider::ResourceId m_resourceId;
    242     unsigned m_textureId;
    243 };
    244 
    245 class CCScopedLockResourceForWrite {
    246     WTF_MAKE_NONCOPYABLE(CCScopedLockResourceForWrite);
    247 public:
    248     CCScopedLockResourceForWrite(CCResourceProvider* resourceProvider, CCResourceProvider::ResourceId resourceId)
    249         : m_resourceProvider(resourceProvider)
    250         , m_resourceId(resourceId)
    251         , m_textureId(resourceProvider->lockForWrite(resourceId)) { }
    252 
    253     ~CCScopedLockResourceForWrite()
    254     {
    255         m_resourceProvider->unlockForWrite(m_resourceId);
    256     }
    257 
    258     unsigned textureId() const { return m_textureId; }
    259 
    260 private:
    261     CCResourceProvider* m_resourceProvider;
    262     CCResourceProvider::ResourceId m_resourceId;
    263     unsigned m_textureId;
    264 };
    265 
    266308}
    267309

  • trunk/Source/WebKit/chromium/ChangeLog

    r126200 r126202  
     12012-08-21  Alexandre Elias  <aelias@google.com>
     2
     3        [chromium] Add software bitmap resources to CCResourceProvider
     4        https://bugs.webkit.org/show_bug.cgi?id=93677
     5
     6        Reviewed by Adrienne Walker.
     7
     8        This adds the ability to CCResourceProvider to use software bitmaps.
     9        They are allocated as plain-old-memory, and exposed as Skia objects.
     10
     11        We want the ResourceProvider to be able to handle different resource
     12        types at the same time.  In practice, a default resource type is
     13        desired for most uses within a single compositor instance, which is
     14        specified by the default resource type.  Default resource types are
     15        expected to be mostly 1-to-1 with CCRenderer types.
     16
     17        New tests added by parametrizing existing CCResourceProvider tests.
     18
     19        * tests/CCResourceProviderTest.cpp:
     20        (WebKit::CCResourceProviderTest::getResourcePixels):
     21
    1222012-08-21  Oli Lan  <olilan@chromium.org>
    223

  • trunk/Source/WebKit/chromium/tests/CCResourceProviderTest.cpp

    r125932 r126202  
    288288};
    289289
    290 class CCResourceProviderTest : public testing::Test {
     290class CCResourceProviderTest : public testing::TestWithParam<CCResourceProvider::ResourceType> {
    291291public:
    292292    CCResourceProviderTest()
    … …  
    295295        , m_resourceProvider(CCResourceProvider::create(m_context.get()))
    296296    {
     297        m_resourceProvider->setDefaultResourceType(GetParam());
    297298    }
    298299
    … …  
    301302    void getResourcePixels(CCResourceProvider::ResourceId id, const IntSize& size, WGC3Denum format, uint8_t* pixels)
    302303    {
    303         CCScopedLockResourceForRead lock(m_resourceProvider.get(), id);
    304         ASSERT_NE(0U, lock.textureId());
    305         context()->bindTexture(GraphicsContext3D::TEXTURE_2D, lock.textureId());
    306         context()->getPixels(size, format, pixels);
     304        if (GetParam() == CCResourceProvider::GLTexture) {
     305            CCResourceProvider::ScopedReadLockGL lockGL(m_resourceProvider.get(), id);
     306            ASSERT_NE(0U, lockGL.textureId());
     307            context()->bindTexture(GraphicsContext3D::TEXTURE_2D, lockGL.textureId());
     308            context()->getPixels(size, format, pixels);
     309        } else if (GetParam() == CCResourceProvider::Bitmap) {
     310            CCResourceProvider::ScopedReadLockSoftware lockSoftware(m_resourceProvider.get(), id);
     311            memcpy(pixels, lockSoftware.skBitmap()->getPixels(), lockSoftware.skBitmap()->getSize());
     312        }
     313    }
     314
     315    void expectNumResources(int count)
     316    {
     317        EXPECT_EQ(count, static_cast<int>(m_resourceProvider->numResources()));
     318        if (GetParam() == CCResourceProvider::GLTexture)
     319            EXPECT_EQ(count, context()->textureCount());
    307320    }
    308321
    … …  
    314327};
    315328
    316 TEST_F(CCResourceProviderTest, Basic)
     329TEST_P(CCResourceProviderTest, Basic)
    317330{
    318331    IntSize size(1, 1);
    … …  
    323336
    324337    CCResourceProvider::ResourceId id = m_resourceProvider->createResource(pool, size, format, CCResourceProvider::TextureUsageAny);
    325     EXPECT_EQ(1, context()->textureCount());
     338    expectNumResources(1);
    326339
    327340    uint8_t data[4] = {1, 2, 3, 4};
    … …  
    334347
    335348    m_resourceProvider->deleteResource(id);
    336     EXPECT_EQ(0, context()->textureCount());
     349    expectNumResources(0);
    337350}
    338351
    339 TEST_F(CCResourceProviderTest, DeleteOwnedResources)
     352TEST_P(CCResourceProviderTest, DeleteOwnedResources)
    340353{
    341354    IntSize size(1, 1);
    … …  
    346359    for (int i = 0; i < count; ++i)
    347360        m_resourceProvider->createResource(pool, size, format, CCResourceProvider::TextureUsageAny);
    348     EXPECT_EQ(3, context()->textureCount());
     361    expectNumResources(3);
    349362
    350363    m_resourceProvider->deleteOwnedResources(pool+1);
    351     EXPECT_EQ(3, context()->textureCount());
     364    expectNumResources(3);
    352365
    353366    m_resourceProvider->deleteOwnedResources(pool);
    354     EXPECT_EQ(0, context()->textureCount());
     367    expectNumResources(0);
    355368}
    356369
    357 TEST_F(CCResourceProviderTest, Upload)
     370TEST_P(CCResourceProviderTest, Upload)
    358371{
    359372    IntSize size(2, 2);
    … …  
    403416        EXPECT_EQ(0, memcmp(expected, result, pixelSize));
    404417    }
     418    {
     419        IntRect offsetImageRect(IntPoint(100, 100), size);
     420        IntRect sourceRect(100, 100, 1, 1);
     421        IntSize destOffset(1, 0);
     422        m_resourceProvider->upload(id, image, offsetImageRect, sourceRect, destOffset);
     423
     424        uint8_t expected[16] = {0, 1, 2, 3,   0, 1, 2, 3,
     425                                4, 5, 6, 7,   0, 1, 2, 3};
     426        getResourcePixels(id, size, format, result);
     427        EXPECT_EQ(0, memcmp(expected, result, pixelSize));
     428    }
     429
    405430
    406431    m_resourceProvider->deleteResource(id);
    407432}
    408433
    409 TEST_F(CCResourceProviderTest, TransferResources)
     434TEST_P(CCResourceProviderTest, TransferResources)
    410435{
     436    // Resource transfer is only supported with GL textures for now.
     437    if (GetParam() != CCResourceProvider::GLTexture)
     438        return;
     439
    411440    OwnPtr<CCGraphicsContext> childContext(FakeWebCompositorOutputSurface::create(ResourceProviderContext::create(m_sharedData.get())));
    412441    OwnPtr<CCResourceProvider> childResourceProvider(CCResourceProvider::create(childContext.get()));
    … …  
    487516    ResourceProviderContext* childContext3D = static_cast<ResourceProviderContext*>(childContext->context3D());
    488517    {
    489         CCScopedLockResourceForRead lock(childResourceProvider.get(), id1);
     518        CCResourceProvider::ScopedReadLockGL lock(childResourceProvider.get(), id1);
    490519        ASSERT_NE(0U, lock.textureId());
    491520        childContext3D->bindTexture(GraphicsContext3D::TEXTURE_2D, lock.textureId());
    … …  
    494523    }
    495524    {
    496         CCScopedLockResourceForRead lock(childResourceProvider.get(), id2);
     525        CCResourceProvider::ScopedReadLockGL lock(childResourceProvider.get(), id2);
    497526        ASSERT_NE(0U, lock.textureId());
    498527        childContext3D->bindTexture(GraphicsContext3D::TEXTURE_2D, lock.textureId());
    … …  
    520549}
    521550
     551INSTANTIATE_TEST_CASE_P(CCResourceProviderTests,
     552                        CCResourceProviderTest,
     553                        ::testing::Values(CCResourceProvider::GLTexture,
     554                                          CCResourceProvider::Bitmap));
     555
    522556} // namespace
Note: See TracChangeset for help on using the changeset viewer.