Changeset 126240 in webkit


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

Unreviewed, rolling out r126202.
​http://trac.webkit.org/changeset/126202
​https://bugs.webkit.org/show_bug.cgi?id=94657

Causes assertion failures on Chromium Linux dbg compositing
layout tests (Requested by dominicc on #webkit).

Patch by Sheriff Bot <​webkit.review.bot@gmail.com> on 2012-08-21

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:

(LayerRendererChromium):

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

(WebCore::CCResourceProvider::createResource):
(WebCore::CCResourceProvider::createResourceFromExternalTexture):
(WebCore::CCResourceProvider::deleteResource):
(WebCore::CCResourceProvider::upload):
(WebCore::CCResourceProvider::lockForWrite):
(WebCore::CCResourceProvider::unlockForWrite):
(WebCore::CCResourceProvider::flush):
(WebCore::CCResourceProvider::shallowFlushIfSupported):
(WebCore::CCResourceProvider::lockForRead):
(WebCore::CCResourceProvider::unlockForRead):
(WebCore::CCResourceProvider::CCResourceProvider):

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

(WebCore):
(CCResourceProvider):
(WebCore::CCResourceProvider::Resource::Resource):
(Resource):
(CCScopedLockResourceForRead):
(WebCore::CCScopedLockResourceForRead::CCScopedLockResourceForRead):
(WebCore::CCScopedLockResourceForRead::~CCScopedLockResourceForRead):
(WebCore::CCScopedLockResourceForRead::textureId):
(CCScopedLockResourceForWrite):
(WebCore::CCScopedLockResourceForWrite::CCScopedLockResourceForWrite):
(WebCore::CCScopedLockResourceForWrite::~CCScopedLockResourceForWrite):
(WebCore::CCScopedLockResourceForWrite::textureId):

Source/WebKit/chromium:

  • tests/CCResourceProviderTest.cpp:

(WebKit::CCResourceProviderTest::CCResourceProviderTest):
(WebKit::CCResourceProviderTest::getResourcePixels):
(WebKit::TEST_F):

Location:
trunk/Source
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r126239 r126240  
     12012-08-21  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r126202.
     4        http://trac.webkit.org/changeset/126202
     5        https://bugs.webkit.org/show_bug.cgi?id=94657
     6
     7        Causes assertion failures on Chromium Linux dbg compositing
     8        layout tests (Requested by dominicc on #webkit).
     9
     10        * platform/graphics/chromium/FrameBufferSkPictureCanvasLayerTextureUpdater.cpp:
     11        (WebCore::FrameBufferSkPictureCanvasLayerTextureUpdater::updateTextureRect):
     12        * platform/graphics/chromium/LayerRendererChromium.cpp:
     13        (WebCore::applyFilters):
     14        (WebCore::LayerRendererChromium::drawRenderPassQuad):
     15        (WebCore::LayerRendererChromium::drawTileQuad):
     16        (WebCore::LayerRendererChromium::drawYUVVideoQuad):
     17        (WebCore::LayerRendererChromium::drawTextureQuad):
     18        (WebCore::LayerRendererChromium::getFramebufferTexture):
     19        (WebCore::LayerRendererChromium::bindFramebufferToTexture):
     20        * platform/graphics/chromium/LayerRendererChromium.h:
     21        (LayerRendererChromium):
     22        * platform/graphics/chromium/cc/CCResourceProvider.cpp:
     23        (WebCore::CCResourceProvider::createResource):
     24        (WebCore::CCResourceProvider::createResourceFromExternalTexture):
     25        (WebCore::CCResourceProvider::deleteResource):
     26        (WebCore::CCResourceProvider::upload):
     27        (WebCore::CCResourceProvider::lockForWrite):
     28        (WebCore::CCResourceProvider::unlockForWrite):
     29        (WebCore::CCResourceProvider::flush):
     30        (WebCore::CCResourceProvider::shallowFlushIfSupported):
     31        (WebCore::CCResourceProvider::lockForRead):
     32        (WebCore::CCResourceProvider::unlockForRead):
     33        (WebCore::CCResourceProvider::CCResourceProvider):
     34        * platform/graphics/chromium/cc/CCResourceProvider.h:
     35        (WebCore):
     36        (CCResourceProvider):
     37        (WebCore::CCResourceProvider::Resource::Resource):
     38        (Resource):
     39        (CCScopedLockResourceForRead):
     40        (WebCore::CCScopedLockResourceForRead::CCScopedLockResourceForRead):
     41        (WebCore::CCScopedLockResourceForRead::~CCScopedLockResourceForRead):
     42        (WebCore::CCScopedLockResourceForRead::textureId):
     43        (CCScopedLockResourceForWrite):
     44        (WebCore::CCScopedLockResourceForWrite::CCScopedLockResourceForWrite):
     45        (WebCore::CCScopedLockResourceForWrite::~CCScopedLockResourceForWrite):
     46        (WebCore::CCScopedLockResourceForWrite::textureId):
     47
    1482012-08-21  David Grogan  <dgrogan@chromium.org>
    249

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

    r126202 r126240  
    108108
    109109    texture->acquireBackingTexture(resourceProvider);
    110     CCResourceProvider::ScopedWriteLockGL lock(resourceProvider, texture->resourceId());
     110    CCScopedLockResourceForWrite 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

    r126202 r126240  
    364364    layerRenderer->context()->flush();
    365365
    366     CCResourceProvider::ScopedWriteLockGL lock(layerRenderer->resourceProvider(), sourceTexture->id());
     366    CCScopedLockResourceForWrite 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<CCResourceProvider::ScopedReadLockGL> contentsResourceLock;
     468    OwnPtr<CCScopedLockResourceForRead> contentsResourceLock;
    469469    unsigned contentsTextureId = 0;
    470470    if (filterBitmap.getTexture()) {
    … …  
    472472        contentsTextureId = texture->getTextureHandle();
    473473    } else {
    474         contentsResourceLock = adoptPtr(new CCResourceProvider::ScopedReadLockGL(m_resourceProvider, contentsTexture->id()));
     474        contentsResourceLock = adoptPtr(new CCScopedLockResourceForRead(m_resourceProvider, contentsTexture->id()));
    475475        contentsTextureId = contentsResourceLock->textureId();
    476476    }
    … …  
    479479    if (backgroundTexture) {
    480480        ASSERT(backgroundTexture->size() == quad->quadRect().size());
    481         CCResourceProvider::ScopedReadLockGL lock(m_resourceProvider, backgroundTexture->id());
     481        CCScopedLockResourceForRead lock(m_resourceProvider, backgroundTexture->id());
    482482        copyTextureToFramebuffer(frame, lock.textureId(), quad->quadRect(), quad->quadTransform());
    483483    }
    … …  
    496496    }
    497497
    498     OwnPtr<CCResourceProvider::ScopedReadLockGL> maskResourceLock;
     498    OwnPtr<CCScopedLockResourceForRead> maskResourceLock;
    499499    unsigned maskTextureId = 0;
    500500    if (quad->maskResourceId()) {
    501         maskResourceLock = adoptPtr(new CCResourceProvider::ScopedReadLockGL(m_resourceProvider, quad->maskResourceId()));
     501        maskResourceLock = adoptPtr(new CCScopedLockResourceForRead(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     CCResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());
     692    CCScopedLockResourceForRead 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     CCResourceProvider::ScopedReadLockGL yPlaneLock(m_resourceProvider, yPlane.resourceId);
    800     CCResourceProvider::ScopedReadLockGL uPlaneLock(m_resourceProvider, uPlane.resourceId);
    801     CCResourceProvider::ScopedReadLockGL vPlaneLock(m_resourceProvider, vPlane.resourceId);
     799    CCScopedLockResourceForRead yPlaneLock(m_resourceProvider, yPlane.resourceId);
     800    CCScopedLockResourceForRead uPlaneLock(m_resourceProvider, uPlane.resourceId);
     801    CCScopedLockResourceForRead 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     CCResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());
     910    CCScopedLockResourceForRead quadResourceLock(m_resourceProvider, quad->resourceId());
    911911    GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, quadResourceLock.textureId()));
    912912
    … …  
    12001200        return false;
    12011201
    1202     CCResourceProvider::ScopedWriteLockGL lock(m_resourceProvider, texture->id());
     1202    CCScopedLockResourceForWrite 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 CCResourceProvider::ScopedWriteLockGL(m_resourceProvider, texture->id()));
     1229    m_currentFramebufferLock = adoptPtr(new CCScopedLockResourceForWrite(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

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

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

    r126202 r126240  
    3232#include "LayerRendererChromium.h" // For the GLC() macro
    3333#include "LayerTextureSubImage.h"
    34 #include <limits.h>
    3534#include <public/WebGraphicsContext3D.h>
    3635#include <wtf/HashSet.h>
    … …  
    9089CCResourceProvider::ResourceId CCResourceProvider::createResource(int pool, const IntSize& size, GC3Denum format, TextureUsageHint hint)
    9190{
    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 
    104 CCResourceProvider::ResourceId CCResourceProvider::createGLTexture(int pool, const IntSize& size, GC3Denum format, TextureUsageHint hint)
    105 {
    10691    ASSERT(CCProxy::isImplThread());
    10792    unsigned textureId = 0;
    10893    WebGraphicsContext3D* context3d = m_context->context3D();
    109     ASSERT(context3d);
     94    if (!context3d) {
     95        // FIXME: Implement this path for software compositing.
     96        return 0;
     97    }
    11098    GLC(context3d, textureId = context3d->createTexture());
    11199    GLC(context3d, context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, textureId));
    … …  
    128116}
    129117
    130 CCResourceProvider::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 
     118CCResourceProvider::ResourceId CCResourceProvider::createResourceFromExternalTexture(unsigned textureId)
     119{
     120    ASSERT(CCProxy::isImplThread());
    136121    ResourceId id = m_nextId++;
    137     Resource resource(pixels, pool, size, GraphicsContext3D::RGBA);
    138     m_resources.add(id, resource);
    139     return id;
    140 }
    141 
    142 CCResourceProvider::ResourceId CCResourceProvider::createResourceFromExternalTexture(unsigned textureId)
    143 {
    144     ASSERT(CCProxy::isImplThread());
    145     ResourceId id = m_nextId++;
    146     Resource resource(textureId, 0, IntSize(), 0);
     122    Resource resource;
     123    resource.glId = textureId;
    147124    resource.external = true;
    148125    m_resources.add(id, resource);
    … …  
    153130{
    154131    ASSERT(CCProxy::isImplThread());
     132    WebGraphicsContext3D* context3d = m_context->context3D();
     133    if (!context3d) {
     134        // FIXME: Implement this path for software compositing.
     135        return;
     136    }
    155137    ResourceMap::iterator it = m_resources.find(id);
    156138    ASSERT(it != m_resources.end() && !it->second.lockedForWrite && !it->second.lockForReadCount);
    157 
    158     if (it->second.glId && !it->second.external) {
    159         WebGraphicsContext3D* context3d = m_context->context3D();
    160         ASSERT(context3d);
     139    if (!it->second.external)
    161140        GLC(context3d, context3d->deleteTexture(it->second.glId));
    162     }
    163     if (it->second.pixels)
    164         delete it->second.pixels;
    165 
    166141    m_resources.remove(it);
    167142}
    … …  
    179154}
    180155
    181 CCResourceProvider::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 
    188156void CCResourceProvider::upload(ResourceId id, const uint8_t* image, const IntRect& imageRect, const IntRect& sourceRect, const IntSize& destOffset)
    189157{
    190158    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    }
    191165    ResourceMap::iterator it = m_resources.find(id);
    192166    ASSERT(it != m_resources.end() && !it->second.lockedForWrite && !it->second.lockForReadCount && !it->second.external);
    193167
    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 
    217 void CCResourceProvider::flush()
    218 {
    219     ASSERT(CCProxy::isImplThread());
    220     WebGraphicsContext3D* context3d = m_context->context3D();
    221     if (context3d)
    222         context3d->flush();
    223 }
    224 
    225 bool 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 
    236 const 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 
    245 void 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 
    253 const CCResourceProvider::Resource* CCResourceProvider::lockForWrite(ResourceId id)
     168    context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, it->second.glId);
     169    m_texSubImage->upload(image, imageRect, sourceRect, destOffset, it->second.format, context3d);
     170}
     171
     172unsigned CCResourceProvider::lockForWrite(ResourceId id)
    254173{
    255174    ASSERT(CCProxy::isImplThread());
    … …  
    257176    ASSERT(it != m_resources.end() && !it->second.lockedForWrite && !it->second.lockForReadCount && !it->second.external);
    258177    it->second.lockedForWrite = true;
    259     return &it->second;
     178    return it->second.glId;
    260179}
    261180
    … …  
    268187}
    269188
    270 CCResourceProvider::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 
    278 CCResourceProvider::ScopedReadLockGL::~ScopedReadLockGL()
    279 {
    280     m_resourceProvider->unlockForRead(m_resourceId);
    281 }
    282 
    283 CCResourceProvider::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 
    291 CCResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL()
    292 {
    293     m_resourceProvider->unlockForWrite(m_resourceId);
    294 }
    295 
    296 void 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 
    304 CCResourceProvider::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 
    311 CCResourceProvider::ScopedReadLockSoftware::~ScopedReadLockSoftware()
    312 {
    313     m_resourceProvider->unlockForRead(m_resourceId);
    314 }
    315 
    316 CCResourceProvider::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 
    324 CCResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware()
    325 {
    326     m_resourceProvider->unlockForWrite(m_resourceId);
     189void 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
     200bool 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
     214unsigned 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
     223void 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);
    327229}
    328230
    … …  
    331233    , m_nextId(1)
    332234    , m_nextChild(1)
    333     , m_defaultResourceType(GLTexture)
    334235    , m_useTextureStorageExt(false)
    335236    , m_useTextureUsageHint(false)
    336237    , m_useShallowFlush(false)
    337     , m_maxTextureSize(INT_MAX)
     238    , m_maxTextureSize(0)
    338239{
    339240}

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

    r126202 r126240  
    3131#include "GraphicsContext3D.h"
    3232#include "IntSize.h"
    33 #include "SkBitmap.h"
    34 #include "SkCanvas.h"
    3533#include <wtf/Deque.h>
    3634#include <wtf/HashMap.h>
    … …  
    4745namespace WebCore {
    4846
     47class CCScopedLockResourceForRead;
     48class 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     };
    6561    struct Mailbox {
    6662        GC3Dbyte name[64];
    … …  
    9288    // Producer interface.
    9389
    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.
     90    // Creates a resource of the given size/format, into the given pool.
    9991    ResourceId createResource(int pool, const IntSize&, GC3Denum format, TextureUsageHint);
    10092
    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.
     93    // Wraps an external texture into a resource.
    10594    ResourceId createResourceFromExternalTexture(unsigned textureId);
    106 
    10795    void deleteResource(ResourceId);
    10896
    … …  
    160148    size_t mailboxCount() const { return m_mailboxes.size(); }
    161149
    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 
    223150private:
     151    friend class CCScopedLockResourceForRead;
     152    friend class CCScopedLockResourceForWrite;
     153
    224154    struct Resource {
    225155        Resource()
    226156            : glId(0)
    227             , pixels(0)
    228157            , pool(0)
    229158            , lockForReadCount(0)
    … …  
    233162            , size()
    234163            , format(0)
    235             , type(static_cast<ResourceType>(0))
    236164        { }
    237165        Resource(unsigned textureId, int pool, const IntSize& size, GC3Denum format)
    238166            : glId(textureId)
    239             , pixels(0)
    240167            , pool(pool)
    241168            , lockForReadCount(0)
    … …  
    245172            , size(size)
    246173            , 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)
    260174        { }
    261175        unsigned glId;
    262         uint8_t* pixels;
    263176        int pool;
    264177        int lockForReadCount;
    … …  
    268181        IntSize size;
    269182        GC3Denum format;
    270         ResourceType type;
    271183    };
    272184    typedef HashMap<ResourceId, Resource> ResourceMap;
    … …  
    281193    bool initialize();
    282194
    283     const Resource* lockForRead(ResourceId);
     195    // Gets a GL texture id representing the resource, that can be rendered into.
     196    unsigned lockForWrite(ResourceId);
     197    void unlockForWrite(ResourceId);
     198
     199    // Gets a GL texture id representing the resource, that can be rendered with.
     200    unsigned lockForRead(ResourceId);
    284201    void unlockForRead(ResourceId);
    285     const Resource* lockForWrite(ResourceId);
    286     void unlockForWrite(ResourceId);
    287     static void populateSkBitmapWithResource(SkBitmap*, const Resource*);
    288202
    289203    bool transferResource(WebKit::WebGraphicsContext3D*, ResourceId, TransferableResource*);
    … …  
    298212    Deque<Mailbox> m_mailboxes;
    299213
    300     ResourceType m_defaultResourceType;
    301214    bool m_useTextureStorageExt;
    302215    bool m_useTextureUsageHint;
    … …  
    306219};
    307220
     221class CCScopedLockResourceForRead {
     222    WTF_MAKE_NONCOPYABLE(CCScopedLockResourceForRead);
     223public:
     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
     239private:
     240    CCResourceProvider* m_resourceProvider;
     241    CCResourceProvider::ResourceId m_resourceId;
     242    unsigned m_textureId;
     243};
     244
     245class CCScopedLockResourceForWrite {
     246    WTF_MAKE_NONCOPYABLE(CCScopedLockResourceForWrite);
     247public:
     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
     260private:
     261    CCResourceProvider* m_resourceProvider;
     262    CCResourceProvider::ResourceId m_resourceId;
     263    unsigned m_textureId;
     264};
     265
    308266}
    309267

  • trunk/Source/WebKit/chromium/ChangeLog

    r126204 r126240  
     12012-08-21  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r126202.
     4        http://trac.webkit.org/changeset/126202
     5        https://bugs.webkit.org/show_bug.cgi?id=94657
     6
     7        Causes assertion failures on Chromium Linux dbg compositing
     8        layout tests (Requested by dominicc on #webkit).
     9
     10        * tests/CCResourceProviderTest.cpp:
     11        (WebKit::CCResourceProviderTest::CCResourceProviderTest):
     12        (WebKit::CCResourceProviderTest::getResourcePixels):
     13        (WebKit::TEST_F):
     14
    1152012-08-21  Leandro Gracia Gil  <leandrogracia@chromium.org>
    216

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

    r126202 r126240  
    288288};
    289289
    290 class CCResourceProviderTest : public testing::TestWithParam<CCResourceProvider::ResourceType> {
     290class CCResourceProviderTest : public testing::Test {
    291291public:
    292292    CCResourceProviderTest()
    … …  
    295295        , m_resourceProvider(CCResourceProvider::create(m_context.get()))
    296296    {
    297         m_resourceProvider->setDefaultResourceType(GetParam());
    298297    }
    299298
    … …  
    302301    void getResourcePixels(CCResourceProvider::ResourceId id, const IntSize& size, WGC3Denum format, uint8_t* pixels)
    303302    {
    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());
     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);
    320307    }
    321308
    … …  
    327314};
    328315
    329 TEST_P(CCResourceProviderTest, Basic)
     316TEST_F(CCResourceProviderTest, Basic)
    330317{
    331318    IntSize size(1, 1);
    … …  
    336323
    337324    CCResourceProvider::ResourceId id = m_resourceProvider->createResource(pool, size, format, CCResourceProvider::TextureUsageAny);
    338     expectNumResources(1);
     325    EXPECT_EQ(1, context()->textureCount());
    339326
    340327    uint8_t data[4] = {1, 2, 3, 4};
    … …  
    347334
    348335    m_resourceProvider->deleteResource(id);
    349     expectNumResources(0);
     336    EXPECT_EQ(0, context()->textureCount());
    350337}
    351338
    352 TEST_P(CCResourceProviderTest, DeleteOwnedResources)
     339TEST_F(CCResourceProviderTest, DeleteOwnedResources)
    353340{
    354341    IntSize size(1, 1);
    … …  
    359346    for (int i = 0; i < count; ++i)
    360347        m_resourceProvider->createResource(pool, size, format, CCResourceProvider::TextureUsageAny);
    361     expectNumResources(3);
     348    EXPECT_EQ(3, context()->textureCount());
    362349
    363350    m_resourceProvider->deleteOwnedResources(pool+1);
    364     expectNumResources(3);
     351    EXPECT_EQ(3, context()->textureCount());
    365352
    366353    m_resourceProvider->deleteOwnedResources(pool);
    367     expectNumResources(0);
     354    EXPECT_EQ(0, context()->textureCount());
    368355}
    369356
    370 TEST_P(CCResourceProviderTest, Upload)
     357TEST_F(CCResourceProviderTest, Upload)
    371358{
    372359    IntSize size(2, 2);
    … …  
    416403        EXPECT_EQ(0, memcmp(expected, result, pixelSize));
    417404    }
    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 
    430405
    431406    m_resourceProvider->deleteResource(id);
    432407}
    433408
    434 TEST_P(CCResourceProviderTest, TransferResources)
     409TEST_F(CCResourceProviderTest, TransferResources)
    435410{
    436     // Resource transfer is only supported with GL textures for now.
    437     if (GetParam() != CCResourceProvider::GLTexture)
    438         return;
    439 
    440411    OwnPtr<CCGraphicsContext> childContext(FakeWebCompositorOutputSurface::create(ResourceProviderContext::create(m_sharedData.get())));
    441412    OwnPtr<CCResourceProvider> childResourceProvider(CCResourceProvider::create(childContext.get()));
    … …  
    516487    ResourceProviderContext* childContext3D = static_cast<ResourceProviderContext*>(childContext->context3D());
    517488    {
    518         CCResourceProvider::ScopedReadLockGL lock(childResourceProvider.get(), id1);
     489        CCScopedLockResourceForRead lock(childResourceProvider.get(), id1);
    519490        ASSERT_NE(0U, lock.textureId());
    520491        childContext3D->bindTexture(GraphicsContext3D::TEXTURE_2D, lock.textureId());
    … …  
    523494    }
    524495    {
    525         CCResourceProvider::ScopedReadLockGL lock(childResourceProvider.get(), id2);
     496        CCScopedLockResourceForRead lock(childResourceProvider.get(), id2);
    526497        ASSERT_NE(0U, lock.textureId());
    527498        childContext3D->bindTexture(GraphicsContext3D::TEXTURE_2D, lock.textureId());
    … …  
    549520}
    550521
    551 INSTANTIATE_TEST_CASE_P(CCResourceProviderTests,
    552                         CCResourceProviderTest,
    553                         ::testing::Values(CCResourceProvider::GLTexture,
    554                                           CCResourceProvider::Bitmap));
    555 
    556522} // namespace
Note: See TracChangeset for help on using the changeset viewer.