Changeset 106300 in webkit


Ignore:
Timestamp:
Jan 30, 2012 4:29:02 PM (12 years ago)
Author:
commit-queue@webkit.org
Message:

[chromium] Use region reported painted opaque for draw culling
​https://bugs.webkit.org/show_bug.cgi?id=76015

Patch by Dana Jansens <​danakj@chromium.org> on 2012-01-30
Reviewed by James Robinson.

Source/WebCore:

New unit tests in CCTiledLayerImplTest.cpp, CCQuadCullerTest.cpp, CCLayerTreeHostImplTest.cpp

  • platform/graphics/chromium/LayerChromium.cpp:

(WebCore::LayerChromium::setOpaque):

  • platform/graphics/chromium/TiledLayerChromium.cpp:

(UpdatableTile):
(WebCore::TiledLayerChromium::pushPropertiesTo):
(WebCore::TiledLayerChromium::prepareToUpdateTiles):

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

(WebCore::CCDrawQuad::opaqueRect):
(WebCore):

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

(CCDrawQuad):
(WebCore::CCDrawQuad::needsBlending):

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

(WebCore::CCQuadCuller::cullOccludedQuads):

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

(WebCore::CCSolidColorDrawQuad::CCSolidColorDrawQuad):

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

(WebCore::CCTileDrawQuad::create):
(WebCore::CCTileDrawQuad::CCTileDrawQuad):

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

(CCTileDrawQuad):

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

(DrawableTile):
(WebCore::DrawableTile::opaqueRect):
(WebCore::DrawableTile::setOpaqueRect):
(WebCore::CCTiledLayerImpl::appendQuads):
(WebCore::CCTiledLayerImpl::pushTileProperties):

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

(CCTiledLayerImpl):

Source/WebKit/chromium:

  • tests/CCLayerTreeHostImplTest.cpp:

(WebKit::BlendStateCheckLayer::appendQuads):
(WebKit::BlendStateCheckLayer::setOpaqueColor):
(BlendStateCheckLayer):
(WebKit::BlendStateCheckLayer::BlendStateCheckLayer):
(WebKit::TEST_F):

  • tests/CCQuadCullerTest.cpp:

(WebCore::MakeTileQuad):
(WebCore::setQuads):
(WebCore::TEST):
(WebCore):

  • tests/CCTiledLayerImplTest.cpp:

(CCLayerTestCommon::createLayer):
(CCLayerTestCommon::TEST):
(CCLayerTestCommon::getQuads):
(CCLayerTestCommon::coverageVisibleRectOnTileBoundaries):
(CCLayerTestCommon::coverageVisibleRectIntersectsTiles):
(CCLayerTestCommon::coverageVisibleRectIntersectsBounds):
(CCLayerTestCommon):

LayoutTests:

  • platform/chromium-linux/compositing/iframes/iframe-in-composited-layer-expected.png:
  • platform/chromium-mac-leopard/fast/repaint/block-selection-gap-in-composited-layer-expected.png: Removed.
  • platform/chromium-mac-snowleopard/fast/repaint/block-selection-gap-in-composited-layer-expected.png: Removed.
  • platform/chromium-win/fast/repaint/block-selection-gap-in-composited-layer-expected.png: Removed.
  • platform/chromium/fast/repaint/block-selection-gap-in-composited-layer-expected.png: Renamed from LayoutTests/platform/chromium-linux/fast/repaint/block-selection-gap-in-composited-layer-expected.png.
  • platform/chromium/test_expectations.txt:
Location:
trunk
Files:
3 deleted
18 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r106299 r106300  
     12012-01-30  Dana Jansens  <danakj@chromium.org>
     2
     3        [chromium] Use region reported painted opaque for draw culling
     4        https://bugs.webkit.org/show_bug.cgi?id=76015
     5
     6        Reviewed by James Robinson.
     7
     8        * platform/chromium-linux/compositing/iframes/iframe-in-composited-layer-expected.png:
     9        * platform/chromium-mac-leopard/fast/repaint/block-selection-gap-in-composited-layer-expected.png: Removed.
     10        * platform/chromium-mac-snowleopard/fast/repaint/block-selection-gap-in-composited-layer-expected.png: Removed.
     11        * platform/chromium-win/fast/repaint/block-selection-gap-in-composited-layer-expected.png: Removed.
     12        * platform/chromium/fast/repaint/block-selection-gap-in-composited-layer-expected.png: Renamed from LayoutTests/platform/chromium-linux/fast/repaint/block-selection-gap-in-composited-layer-expected.png.
     13        * platform/chromium/test_expectations.txt:
     14
    1152012-01-30  Shadi Khalek  <shadi@chromium.org>
    216

  • trunk/LayoutTests/platform/chromium/test_expectations.txt

    r106299 r106300  
    40094009BUG_CARYCLARK MAC : fast/dom/blur-contenteditable.html = IMAGE
    40104010
     4011// May fail if these platforms differ from Linux. Remove this or rebaseline them once the bug lands.
     4012BUGWK76015 WIN MAC : fast/repaint/block-selection-gap-in-composited-layer.html = IMAGE
     4013
    40114014// Need to implement file name logging.
    40124015BUGWK76572 : http/tests/download = FAIL

  • trunk/Source/WebCore/ChangeLog

    r106298 r106300  
     12012-01-30  Dana Jansens  <danakj@chromium.org>
     2
     3        [chromium] Use region reported painted opaque for draw culling
     4        https://bugs.webkit.org/show_bug.cgi?id=76015
     5
     6        Reviewed by James Robinson.
     7
     8        New unit tests in CCTiledLayerImplTest.cpp, CCQuadCullerTest.cpp, CCLayerTreeHostImplTest.cpp
     9
     10        * platform/graphics/chromium/LayerChromium.cpp:
     11        (WebCore::LayerChromium::setOpaque):
     12        * platform/graphics/chromium/TiledLayerChromium.cpp:
     13        (UpdatableTile):
     14        (WebCore::TiledLayerChromium::pushPropertiesTo):
     15        (WebCore::TiledLayerChromium::prepareToUpdateTiles):
     16        * platform/graphics/chromium/cc/CCDrawQuad.cpp:
     17        (WebCore::CCDrawQuad::opaqueRect):
     18        (WebCore):
     19        * platform/graphics/chromium/cc/CCDrawQuad.h:
     20        (CCDrawQuad):
     21        (WebCore::CCDrawQuad::needsBlending):
     22        * platform/graphics/chromium/cc/CCQuadCuller.cpp:
     23        (WebCore::CCQuadCuller::cullOccludedQuads):
     24        * platform/graphics/chromium/cc/CCSolidColorDrawQuad.cpp:
     25        (WebCore::CCSolidColorDrawQuad::CCSolidColorDrawQuad):
     26        * platform/graphics/chromium/cc/CCTileDrawQuad.cpp:
     27        (WebCore::CCTileDrawQuad::create):
     28        (WebCore::CCTileDrawQuad::CCTileDrawQuad):
     29        * platform/graphics/chromium/cc/CCTileDrawQuad.h:
     30        (CCTileDrawQuad):
     31        * platform/graphics/chromium/cc/CCTiledLayerImpl.cpp:
     32        (DrawableTile):
     33        (WebCore::DrawableTile::opaqueRect):
     34        (WebCore::DrawableTile::setOpaqueRect):
     35        (WebCore::CCTiledLayerImpl::appendQuads):
     36        (WebCore::CCTiledLayerImpl::pushTileProperties):
     37        * platform/graphics/chromium/cc/CCTiledLayerImpl.h:
     38        (CCTiledLayerImpl):
     39
    1402012-01-30  Ryosuke Niwa  <rniwa@webkit.org>
    241

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

    r106289 r106300  
    327327        return;
    328328    m_opaque = opaque;
    329     setNeedsCommit();
     329    setNeedsDisplay();
    330330}
    331331

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

    r106289 r106300  
    6868    IntRect m_dirtyRect;
    6969    IntRect m_updateRect;
     70    IntRect m_opaqueRect;
    7071private:
    7172    OwnPtr<LayerTextureUpdater::Texture> m_texture;
    … …  
    274275            continue;
    275276
    276         tiledLayer->syncTextureId(i, j, tile->managedTexture()->textureId());
     277        tiledLayer->pushTileProperties(i, j, tile->managedTexture()->textureId(), tile->m_opaqueRect);
    277278    }
    278279}
    … …  
    422423    // so we grab a local reference here to hold the updater alive until the paint completes.
    423424    RefPtr<LayerTextureUpdater> protector(textureUpdater());
    424     IntRect opaqueRect; // FIXME: unused. remove this and store in the layer to pass to impl for draw culling
    425     textureUpdater()->prepareToUpdate(m_paintRect, m_tiler->tileSize(), m_tiler->hasBorderTexels(), contentsScale(), &opaqueRect);
     425    IntRect paintedOpaqueRect;
     426    textureUpdater()->prepareToUpdate(m_paintRect, m_tiler->tileSize(), m_tiler->hasBorderTexels(), contentsScale(), &paintedOpaqueRect);
    426427    for (int j = top; j <= bottom; ++j) {
    427428        for (int i = left; i <= right; ++i) {
    … …  
    431432            if (!tile)
    432433                CRASH();
     434
     435            IntRect tileRect = m_tiler->tileBounds(i, j);
     436
     437            // Save what was painted opaque in the tile. If everything painted in the tile was opaque, and the area is a subset of an
     438            // already opaque area, keep the old area.
     439            IntRect tilePaintedRect = intersection(tileRect, m_paintRect);
     440            IntRect tilePaintedOpaqueRect = intersection(tileRect, paintedOpaqueRect);
     441            if (tilePaintedOpaqueRect != tilePaintedRect || !tile->m_opaqueRect.contains(tilePaintedOpaqueRect))
     442                tile->m_opaqueRect = tilePaintedOpaqueRect;
    433443
    434444            // Use m_updateRect as copyAndClearDirty above moved the existing dirty rect to m_updateRect.
    … …  
    437447                continue;
    438448
     449            // sourceRect starts as a full-sized tile with border texels included.
    439450            IntRect sourceRect = m_tiler->tileRect(tile);
    440451            sourceRect.intersect(dirtyRect);

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

    r106076 r106300  
    5151}
    5252
     53IntRect CCDrawQuad::opaqueRect() const
     54{
     55    if (opacity() != 1)
     56        return IntRect();
     57    if (m_sharedQuadState->isOpaque() && m_quadOpaque)
     58        return m_quadRect;
     59    return m_opaqueRect;
     60}
     61
    5362void CCDrawQuad::setQuadVisibleRect(const IntRect& quadVisibleRect)
    5463{

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

    r106076 r106300  
    5252    const IntRect& clipRect() const { return m_sharedQuadState->clipRect(); }
    5353    float opacity() const { return m_sharedQuadState->opacity(); }
    54     // For the purposes of culling, are the contents of this quad opaque?
    55     bool drawsOpaque() const { return m_sharedQuadState->isOpaque() && m_quadOpaque && opacity() == 1; }
    56     bool needsBlending() const { return !m_sharedQuadState->isOpaque() || m_needsBlending || opacity() != 1; }
     54    // For the purposes of culling, what part of the contents of this quad are opaque?
     55    IntRect opaqueRect() const;
     56    bool needsBlending() const { return m_needsBlending || opaqueRect() != m_quadRect; }
    5757    bool isLayerAxisAlignedIntRect() const { return m_sharedQuadState->isLayerAxisAlignedIntRect(); }
    5858
    … …  
    9797    bool m_quadOpaque;
    9898    bool m_needsBlending;
     99
     100    // Be default, this rect is empty. It is used when the shared quad state and above
     101    // variables determine that the quad is not fully opaque but may be partially opaque.
     102    IntRect m_opaqueRect;
    99103};
    100104

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

    r106076 r106300  
    114114
    115115        // When adding rect to opaque region, deflate it to stay conservative.
    116         if (keepQuad && drawQuad->drawsOpaque() && drawQuad->isLayerAxisAlignedIntRect())
    117             opaqueCoverageThusFar.unite(Region(enclosedIntRect(floatTransformedRect)));
     116        if (keepQuad && drawQuad->isLayerAxisAlignedIntRect()) {
     117            FloatRect floatOpaqueRect = drawQuad->quadTransform().mapRect(FloatRect(drawQuad->opaqueRect()));
     118            opaqueCoverageThusFar.unite(Region(enclosedIntRect(floatOpaqueRect)));
     119        }
    118120
    119121        if (keepQuad)

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

    r105371 r106300  
    3939    , m_color(color)
    4040{
    41     if (m_color.alpha() != 1)
     41    if (m_color.hasAlpha())
    4242        m_quadOpaque = false;
     43    else
     44        m_opaqueRect = quadRect;
    4345}
    4446

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

    r105371 r106300  
    3030namespace WebCore {
    3131
    32 PassOwnPtr<CCTileDrawQuad> CCTileDrawQuad::create(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect, Platform3DObject textureId, const IntPoint& textureOffset, const IntSize& textureSize, GC3Dint textureFilter, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA)
     32PassOwnPtr<CCTileDrawQuad> CCTileDrawQuad::create(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect, const IntRect& opaqueRect, Platform3DObject textureId, const IntPoint& textureOffset, const IntSize& textureSize, GC3Dint textureFilter, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA)
    3333{
    34     return adoptPtr(new CCTileDrawQuad(sharedQuadState, quadRect, textureId, textureOffset, textureSize, textureFilter, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA));
     34    return adoptPtr(new CCTileDrawQuad(sharedQuadState, quadRect, opaqueRect, textureId, textureOffset, textureSize, textureFilter, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA));
    3535}
    3636
    37 CCTileDrawQuad::CCTileDrawQuad(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect, Platform3DObject textureId, const IntPoint& textureOffset, const IntSize& textureSize, GC3Dint textureFilter, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA)
     37CCTileDrawQuad::CCTileDrawQuad(const CCSharedQuadState* sharedQuadState, const IntRect& quadRect, const IntRect& opaqueRect, Platform3DObject textureId, const IntPoint& textureOffset, const IntSize& textureSize, GC3Dint textureFilter, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA)
    3838    : CCDrawQuad(sharedQuadState, CCDrawQuad::TiledContent, quadRect)
    3939    , m_textureId(textureId)
    … …  
    4949    if (isAntialiased())
    5050        m_needsBlending = true;
     51    m_opaqueRect = opaqueRect;
    5152}
    5253

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

    r105371 r106300  
    3636    WTF_MAKE_NONCOPYABLE(CCTileDrawQuad);
    3737public:
    38     static PassOwnPtr<CCTileDrawQuad> create(const CCSharedQuadState*, const IntRect& quadRect, Platform3DObject textureId, const IntPoint& textureOffset, const IntSize& textureSize, GC3Dint textureFilter, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA);
     38    static PassOwnPtr<CCTileDrawQuad> create(const CCSharedQuadState*, const IntRect& quadRect, const IntRect& opaqueRect, Platform3DObject textureId, const IntPoint& textureOffset, const IntSize& textureSize, GC3Dint textureFilter, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA);
    3939
    4040    Platform3DObject textureId() const { return m_textureId; }
    … …  
    5252
    5353private:
    54     CCTileDrawQuad(const CCSharedQuadState*, const IntRect& quadRect, Platform3DObject textureId, const IntPoint& textureOffset, const IntSize& textureSize, GC3Dint textureFilter, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA);
     54    CCTileDrawQuad(const CCSharedQuadState*, const IntRect& quadRect, const IntRect& opaqueRect, Platform3DObject textureId, const IntPoint& textureOffset, const IntSize& textureSize, GC3Dint textureFilter, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA);
    5555
    5656    Platform3DObject m_textureId;

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

    r106160 r106300  
    5252    Platform3DObject textureId() const { return m_textureId; }
    5353    void setTextureId(Platform3DObject textureId) { m_textureId = textureId; }
     54
     55    const IntRect& opaqueRect() const { return m_opaqueRect; }
     56    void setOpaqueRect(const IntRect& opaqueRect) { m_opaqueRect = opaqueRect; }
     57
    5458private:
    5559    Platform3DObject m_textureId;
     60    IntRect m_opaqueRect;
    5661};
    5762
    … …  
    149154            }
    150155
     156            IntRect tileOpaqueRect = tile->opaqueRect();
     157            tileOpaqueRect.intersect(layerRect);
     158
    151159            // Keep track of how the top left has moved, so the texture can be
    152160            // offset the same amount.
    … …  
    165173
    166174            const GC3Dint textureFilter = m_tiler->hasBorderTexels() ? GraphicsContext3D::LINEAR : GraphicsContext3D::NEAREST;
    167             quadList.append(CCTileDrawQuad::create(sharedQuadState, tileRect, tile->textureId(), textureOffset, textureSize, textureFilter, contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA));
     175            quadList.append(CCTileDrawQuad::create(sharedQuadState, tileRect, tileOpaqueRect, tile->textureId(), textureOffset, textureSize, textureFilter, contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA));
    168176
    169177            if (hasDebugBorders()) {
    … …  
    184192}
    185193
    186 void CCTiledLayerImpl::syncTextureId(int i, int j, Platform3DObject textureId)
     194void CCTiledLayerImpl::pushTileProperties(int i, int j, Platform3DObject textureId, const IntRect& opaqueRect)
    187195{
    188196    DrawableTile* tile = tileAt(i, j);
    … …  
    190198        tile = createTile(i, j);
    191199    tile->setTextureId(textureId);
    192 }
    193 
    194 }
     200    tile->setOpaqueRect(opaqueRect);
     201}
     202
     203} // namespace WebCore
    195204
    196205#endif // USE(ACCELERATED_COMPOSITING)

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

    r105371 r106300  
    5252    void setSkipsDraw(bool skipsDraw) { m_skipsDraw = skipsDraw; }
    5353    void setTilingData(const CCLayerTilingData& tiler);
    54     void syncTextureId(int, int, Platform3DObject textureId);
     54    void pushTileProperties(int, int, Platform3DObject textureId, const IntRect& opaqueRect);
    5555
    5656    void setContentsSwizzled(bool contentsSwizzled) { m_contentsSwizzled = contentsSwizzled; }

  • trunk/Source/WebKit/chromium/ChangeLog

    r106289 r106300  
     12012-01-30  Dana Jansens  <danakj@chromium.org>
     2
     3        [chromium] Use region reported painted opaque for draw culling
     4        https://bugs.webkit.org/show_bug.cgi?id=76015
     5
     6        Reviewed by James Robinson.
     7
     8        * tests/CCLayerTreeHostImplTest.cpp:
     9        (WebKit::BlendStateCheckLayer::appendQuads):
     10        (WebKit::BlendStateCheckLayer::setOpaqueColor):
     11        (BlendStateCheckLayer):
     12        (WebKit::BlendStateCheckLayer::BlendStateCheckLayer):
     13        (WebKit::TEST_F):
     14        * tests/CCQuadCullerTest.cpp:
     15        (WebCore::MakeTileQuad):
     16        (WebCore::setQuads):
     17        (WebCore::TEST):
     18        (WebCore):
     19        * tests/CCTiledLayerImplTest.cpp:
     20        (CCLayerTestCommon::createLayer):
     21        (CCLayerTestCommon::TEST):
     22        (CCLayerTestCommon::getQuads):
     23        (CCLayerTestCommon::coverageVisibleRectOnTileBoundaries):
     24        (CCLayerTestCommon::coverageVisibleRectIntersectsTiles):
     25        (CCLayerTestCommon::coverageVisibleRectIntersectsBounds):
     26        (CCLayerTestCommon):
     27
    1282012-01-30  Adrienne Walker  <enne@google.com>
    229

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

    r105566 r106300  
    308308    {
    309309        m_quadsAppended = true;
    310        
    311         OwnPtr<CCDrawQuad> testBlendingDrawQuad = CCSolidColorDrawQuad::create(sharedQuadState, IntRect(5, 5, 5, 5), Color::white);
     310
     311        Color color = m_opaqueColor ? Color::white : Color(0, 0, 0, 0);
     312        OwnPtr<CCDrawQuad> testBlendingDrawQuad = CCSolidColorDrawQuad::create(sharedQuadState, IntRect(5, 5, 5, 5), color);
    312313        EXPECT_EQ(m_blend, testBlendingDrawQuad->needsBlending());
    313314        EXPECT_EQ(m_hasRenderSurface, !!renderSurface());
    … …  
    322323
    323324    bool quadsAppended() const { return m_quadsAppended; }
     325
     326    void setOpaqueColor(bool opaqueColor) { m_opaqueColor = opaqueColor; }
    324327
    325328private:
    … …  
    329332        , m_hasRenderSurface(false)
    330333        , m_quadsAppended(false)
     334        , m_opaqueColor(true)
    331335    {
    332336        setAnchorPoint(FloatPoint(0, 0));
    … …  
    338342    bool m_hasRenderSurface;
    339343    bool m_quadsAppended;
     344    bool m_opaqueColor;
    340345};
    341346
    … …  
    359364    // Opaque layer, drawn without blending.
    360365    layer1->setOpaque(true);
     366    layer1->setOpaqueColor(true);
    361367    layer1->setExpectation(false, false);
    362368    m_hostImpl->drawLayers();
    363369    EXPECT_TRUE(layer1->quadsAppended());
    364370
    365     // Layer with translucent content, drawn with blending.
     371    // Layer with translucent content, but solid color is opaque, so drawn without blending.
    366372    layer1->setOpaque(false);
     373    layer1->setOpaqueColor(true);
     374    layer1->setExpectation(false, false);
     375    m_hostImpl->drawLayers();
     376    EXPECT_TRUE(layer1->quadsAppended());
     377
     378    // Layer with translucent content and painting, so drawn with blending.
     379    layer1->setOpaque(false);
     380    layer1->setOpaqueColor(false);
    367381    layer1->setExpectation(true, false);
    368382    m_hostImpl->drawLayers();
    … …  
    371385    // Layer with translucent opacity, drawn with blending.
    372386    layer1->setOpaque(true);
     387    layer1->setOpaqueColor(true);
    373388    layer1->setOpacity(0.5);
    374389    layer1->setExpectation(true, false);
    … …  
    376391    EXPECT_TRUE(layer1->quadsAppended());
    377392
     393    // Layer with translucent opacity and painting, drawn with blending.
     394    layer1->setOpaque(true);
     395    layer1->setOpaqueColor(false);
     396    layer1->setOpacity(0.5);
     397    layer1->setExpectation(true, false);
     398    m_hostImpl->drawLayers();
     399    EXPECT_TRUE(layer1->quadsAppended());
     400
    378401    RefPtr<BlendStateCheckLayer> layer2 = BlendStateCheckLayer::create(2);
    379402    layer1->addChild(layer2);
    … …  
    381404    // 2 opaque layers, drawn without blending.
    382405    layer1->setOpaque(true);
     406    layer1->setOpaqueColor(true);
    383407    layer1->setOpacity(1);
    384408    layer1->setExpectation(false, false);
    385409    layer2->setOpaque(true);
     410    layer2->setOpaqueColor(true);
    386411    layer2->setOpacity(1);
    387412    layer2->setExpectation(false, false);
    … …  
    393418    // Child layer with opaque content, drawn without blending.
    394419    layer1->setOpaque(false);
     420    layer1->setOpaqueColor(false);
    395421    layer1->setExpectation(true, false);
     422    layer2->setExpectation(false, false);
     423    m_hostImpl->drawLayers();
     424    EXPECT_TRUE(layer1->quadsAppended());
     425    EXPECT_TRUE(layer2->quadsAppended());
     426
     427    // Parent layer with translucent content but opaque painting, drawn without blending.
     428    // Child layer with opaque content, drawn without blending.
     429    layer1->setOpaque(false);
     430    layer1->setOpaqueColor(true);
     431    layer1->setExpectation(false, false);
    396432    layer2->setExpectation(false, false);
    397433    m_hostImpl->drawLayers();
    … …  
    405441    // carries the inherited opacity).
    406442    layer1->setOpaque(true);
     443    layer1->setOpaqueColor(true);
    407444    layer1->setOpacity(0.5);
    408445    layer1->setExpectation(false, true);
    … …  
    415452    // layer1 not culled.
    416453    layer1->setOpaque(true);
     454    layer1->setOpaqueColor(true);
    417455    layer1->setOpacity(1);
    418456    layer1->setExpectation(false, false);
    419457    layer2->setOpaque(true);
     458    layer2->setOpaqueColor(true);
    420459    layer2->setOpacity(0.5);
    421460    layer2->setExpectation(true, false);
    … …  
    429468    layer1->setExpectation(false, false);
    430469    layer2->setOpaque(false);
     470    layer2->setOpaqueColor(false);
    431471    layer2->setOpacity(1);
    432472    layer2->setExpectation(true, false);
     473    m_hostImpl->drawLayers();
     474    EXPECT_TRUE(layer1->quadsAppended());
     475    EXPECT_TRUE(layer2->quadsAppended());
     476
     477    // And when the layer says its not opaque but is painted opaque, it is not blended.
     478    layer1->setOpaque(true);
     479    layer1->setOpacity(1);
     480    layer1->setExpectation(false, false);
     481    layer2->setOpaque(false);
     482    layer2->setOpaqueColor(true);
     483    layer2->setOpacity(1);
     484    layer2->setExpectation(false, false);
    433485    m_hostImpl->drawLayers();
    434486    EXPECT_TRUE(layer1->quadsAppended());

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

    r106076 r106300  
    3838};
    3939
    40 static PassOwnPtr<CCDrawQuad> MakeTileQuad(CCSharedQuadState* state, const IntRect& rect)
    41 {
    42     return CCTileDrawQuad::create(state, rect, 1, IntPoint(1, 1), IntSize(100, 100), 0, false, false, false, false, false);
    43 }
    44 
    45 void setQuads(CCSharedQuadState* rootState, CCSharedQuadState* childState, CCQuadList& quadList)
     40static PassOwnPtr<CCDrawQuad> MakeTileQuad(CCSharedQuadState* state, const IntRect& rect, const IntRect& opaqueRect = IntRect())
     41{
     42    return CCTileDrawQuad::create(state, rect, intersection(rect, opaqueRect), 1, IntPoint(1, 1), IntSize(100, 100), 0, false, false, false, false, false);
     43}
     44
     45void setQuads(CCSharedQuadState* rootState, CCSharedQuadState* childState, CCQuadList& quadList, const IntRect& opaqueRect = IntRect())
    4646{
    4747    quadList.clear();
    4848
    49     quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(), IntSize(100, 100))));
    50     quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(100, 0), IntSize(100, 100))));
    51     quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(200, 0), IntSize(100, 100))));
    52     quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(0, 100), IntSize(100, 100))));
    53     quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(100, 100), IntSize(100, 100))));
    54     quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(200, 100), IntSize(100, 100))));
    55     quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(0, 200), IntSize(100, 100))));
    56     quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(100, 200), IntSize(100, 100))));
    57     quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(200, 200), IntSize(100, 100))));
    58 
    59     quadList.append(MakeTileQuad(childState, IntRect(IntPoint(), IntSize(100, 100))));
    60     quadList.append(MakeTileQuad(childState, IntRect(IntPoint(100, 0), IntSize(100, 100))));
    61     quadList.append(MakeTileQuad(childState, IntRect(IntPoint(0, 100), IntSize(100, 100))));
    62     quadList.append(MakeTileQuad(childState, IntRect(IntPoint(100, 100), IntSize(100, 100))));
     49    quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(), IntSize(100, 100)), opaqueRect));
     50    quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(100, 0), IntSize(100, 100)), opaqueRect));
     51    quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(200, 0), IntSize(100, 100)), opaqueRect));
     52    quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(0, 100), IntSize(100, 100)), opaqueRect));
     53    quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(100, 100), IntSize(100, 100)), opaqueRect));
     54    quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(200, 100), IntSize(100, 100)), opaqueRect));
     55    quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(0, 200), IntSize(100, 100)), opaqueRect));
     56    quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(100, 200), IntSize(100, 100)), opaqueRect));
     57    quadList.append(MakeTileQuad(rootState, IntRect(IntPoint(200, 200), IntSize(100, 100)), opaqueRect));
     58
     59    quadList.append(MakeTileQuad(childState, IntRect(IntPoint(), IntSize(100, 100)), opaqueRect));
     60    quadList.append(MakeTileQuad(childState, IntRect(IntPoint(100, 0), IntSize(100, 100)), opaqueRect));
     61    quadList.append(MakeTileQuad(childState, IntRect(IntPoint(0, 100), IntSize(100, 100)), opaqueRect));
     62    quadList.append(MakeTileQuad(childState, IntRect(IntPoint(100, 100), IntSize(100, 100)), opaqueRect));
    6363}
    6464
    … …  
    201201}
    202202
     203TEST(CCQuadCullerTest, verifyCullSubRegion)
     204{
     205    DECLARE_AND_INITIALIZE_TEST_QUADS
     206
     207    childTransform.translate(50, 50);
     208
     209    OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true);
     210    OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, false);
     211    IntRect childOpaqueRect(childRect.x() + childRect.width() / 4, childRect.y() + childRect.height() / 4, childRect.width() / 2, childRect.height() / 2);
     212
     213    setQuads(rootState.get(), childState.get(), quadList, childOpaqueRect);
     214    EXPECT_EQ(quadList.size(), 13u);
     215    CCQuadCuller::cullOccludedQuads(quadList);
     216    EXPECT_EQ(quadList.size(), 12u);
     217}
     218
     219TEST(CCQuadCullerTest, verifyCullSubRegion2)
     220{
     221    DECLARE_AND_INITIALIZE_TEST_QUADS
     222
     223    childTransform.translate(50, 10);
     224
     225    OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true);
     226    OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, false);
     227    IntRect childOpaqueRect(childRect.x() + childRect.width() / 4, childRect.y() + childRect.height() / 4, childRect.width() / 2, childRect.height() * 3 / 4);
     228
     229    setQuads(rootState.get(), childState.get(), quadList, childOpaqueRect);
     230    EXPECT_EQ(quadList.size(), 13u);
     231    CCQuadCuller::cullOccludedQuads(quadList);
     232    EXPECT_EQ(quadList.size(), 12u);
     233}
     234
     235TEST(CCQuadCullerTest, verifyCullSubRegionCheckOvercull)
     236{
     237    DECLARE_AND_INITIALIZE_TEST_QUADS
     238
     239    childTransform.translate(50, 49);
     240
     241    OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true);
     242    OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, false);
     243    IntRect childOpaqueRect(childRect.x() + childRect.width() / 4, childRect.y() + childRect.height() / 4, childRect.width() / 2, childRect.height() / 2);
     244
     245    setQuads(rootState.get(), childState.get(), quadList, childOpaqueRect);
     246    EXPECT_EQ(quadList.size(), 13u);
     247    CCQuadCuller::cullOccludedQuads(quadList);
     248    EXPECT_EQ(quadList.size(), 13u);
     249}
     250
    203251TEST(CCQuadCullerTest, verifyNonAxisAlignedQuadsDontOcclude)
    204252{

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

    r105634 r106300  
    4848    layer->setSkipsDraw(false);
    4949    layer->setVisibleLayerRect(IntRect(IntPoint(), layerSize));
     50    layer->setDrawOpacity(1);
    5051
    5152    int textureId = 1;
    5253    for (int i = 0; i < tiler->numTilesX(); ++i)
    5354        for (int j = 0; j < tiler->numTilesY(); ++j)
    54             layer->syncTextureId(i, j, static_cast<Platform3DObject>(textureId++));
     55            layer->pushTileProperties(i, j, static_cast<Platform3DObject>(textureId++), IntRect(0, 0, 1, 1));
    5556
    5657    return layer.release();
    … …  
    136137    for (int i = 0; i < numTilesX; ++i)
    137138        for (int j = 0; j < numTilesY; ++j)
    138             layer->syncTextureId(i, j, static_cast<Platform3DObject>(0));
     139            layer->pushTileProperties(i, j, static_cast<Platform3DObject>(0), IntRect());
    139140
    140141    // All checkerboarding
    … …  
    148149}
    149150
    150 static void getQuads(CCQuadList& quads, IntSize tileSize, const IntSize& layerSize, CCLayerTilingData::BorderTexelOption borderTexelOption, const IntRect& visibleLayerRect)
     151static PassOwnPtr<CCSharedQuadState> getQuads(CCQuadList& quads, IntSize tileSize, const IntSize& layerSize, CCLayerTilingData::BorderTexelOption borderTexelOption, const IntRect& visibleLayerRect)
    151152{
    152153    RefPtr<CCTiledLayerImpl> layer = createLayer(tileSize, layerSize, borderTexelOption);
    … …  
    156157    OwnPtr<CCSharedQuadState> sharedQuadState = layer->createSharedQuadState();
    157158    layer->appendQuads(quads, sharedQuadState.get());
     159    return sharedQuadState.release(); // The shared data must be owned as long as the quad list exists.
    158160}
    159161
    … …  
    175177    IntSize layerSize(1000, 1000);
    176178    CCQuadList quads;
    177     getQuads(quads, IntSize(100, 100), layerSize, borders, IntRect(IntPoint(), layerSize));
     179    OwnPtr<CCSharedQuadState> sharedState;
     180    sharedState = getQuads(quads, IntSize(100, 100), layerSize, borders, IntRect(IntPoint(), layerSize));
    178181    verifyQuadsExactlyCoverRect(quads, IntRect(IntPoint(), layerSize));
    179182}
    … …  
    191194    IntSize layerSize(250, 250);
    192195    CCQuadList quads;
    193     getQuads(quads, IntSize(50, 50), IntSize(250, 250), CCLayerTilingData::NoBorderTexels, visibleLayerRect);
     196    OwnPtr<CCSharedQuadState> sharedState;
     197    sharedState = getQuads(quads, IntSize(50, 50), IntSize(250, 250), CCLayerTilingData::NoBorderTexels, visibleLayerRect);
    194198    verifyQuadsExactlyCoverRect(quads, visibleLayerRect);
    195199}
    … …  
    203207    IntRect visibleLayerRect(IntPoint(), layerSize);
    204208    CCQuadList quads;
    205     getQuads(quads, IntSize(100, 100), layerSize, CCLayerTilingData::NoBorderTexels, visibleLayerRect);
     209    OwnPtr<CCSharedQuadState> sharedState;
     210    sharedState = getQuads(quads, IntSize(100, 100), layerSize, CCLayerTilingData::NoBorderTexels, visibleLayerRect);
    206211    verifyQuadsExactlyCoverRect(quads, visibleLayerRect);
    207212}
    … …  
    215220    IntSize layerSize(250, 250);
    216221    CCQuadList quads;
    217     getQuads(quads, tileSize, layerSize, CCLayerTilingData::NoBorderTexels, IntRect(IntPoint(), layerSize));
     222    OwnPtr<CCSharedQuadState> sharedState;
     223    sharedState = getQuads(quads, tileSize, layerSize, CCLayerTilingData::NoBorderTexels, IntRect(IntPoint(), layerSize));
    218224
    219225    for (size_t i = 0; i < quads.size(); ++i) {
    … …  
    224230        EXPECT_EQ(quad->textureOffset(), IntPoint()) << quadString << i;
    225231        EXPECT_EQ(quad->textureSize(), tileSize) << quadString << i;
     232        EXPECT_EQ(IntRect(0, 0, 1, 1), quad->opaqueRect()) << quadString << i;
     233    }
     234}
     235
     236TEST(CCTiledLayerImplTest, tileOpaqueRectForLayerNoBorders)
     237{
     238    DebugScopedSetImplThread scopedImplThread;
     239
     240    IntSize tileSize(50, 50);
     241    IntSize layerSize(250, 250);
     242    CCQuadList quads;
     243    OwnPtr<CCSharedQuadState> sharedState;
     244    sharedState = getQuads(quads, tileSize, layerSize, CCLayerTilingData::NoBorderTexels, IntRect(IntPoint(), layerSize));
     245
     246    for (size_t i = 0; i < quads.size(); ++i) {
     247        ASSERT_EQ(quads[i]->material(), CCDrawQuad::TiledContent) << quadString << i;
     248        CCTileDrawQuad* quad = static_cast<CCTileDrawQuad*>(quads[i].get());
     249
     250        EXPECT_EQ(IntRect(0, 0, 1, 1), quad->opaqueRect()) << quadString << i;
    226251    }
    227252}
Note: See TracChangeset for help on using the changeset viewer.