Changeset 105366 in webkit


Ignore:
Timestamp:
Jan 18, 2012 5:42:30 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-18
Reviewed by James Robinson.

Source/WebCore:

New unit tests in CCQuadCullerTest.cpp and CCTiledLayerImplTest.cpp

  • platform/graphics/chromium/TiledLayerChromium.cpp:

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

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

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

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

(WebCore::CCQuadCuller::cullOccludedQuads):

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

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

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

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

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

Source/WebKit/chromium:

  • tests/CCQuadCullerTest.cpp:

(WebCore::TestDrawQuad::TestDrawQuad):
(WebCore::TestDrawQuad::create):
(WebCore::setQuads):
(WebCore::TEST):

  • tests/CCTiledLayerImplTest.cpp:

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

Location:
trunk/Source
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r105365 r105366  
     12012-01-18  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 CCQuadCullerTest.cpp and CCTiledLayerImplTest.cpp
     9
     10        * platform/graphics/chromium/TiledLayerChromium.cpp:
     11        (WebCore::TiledLayerChromium::pushPropertiesTo):
     12        (WebCore::TiledLayerChromium::prepareToUpdateTiles):
     13        * platform/graphics/chromium/cc/CCDrawQuad.h:
     14        (WebCore::CCDrawQuad::opaqueRect):
     15        (WebCore::CCDrawQuad::needsBlending):
     16        * platform/graphics/chromium/cc/CCQuadCuller.cpp:
     17        (WebCore::CCQuadCuller::cullOccludedQuads):
     18        * platform/graphics/chromium/cc/CCTileDrawQuad.cpp:
     19        (WebCore::CCTileDrawQuad::create):
     20        (WebCore::CCTileDrawQuad::CCTileDrawQuad):
     21        * platform/graphics/chromium/cc/CCTileDrawQuad.h:
     22        * platform/graphics/chromium/cc/CCTiledLayerImpl.cpp:
     23        (WebCore::DrawableTile::opaqueRect):
     24        (WebCore::DrawableTile::setOpaqueRect):
     25        (WebCore::CCTiledLayerImpl::appendQuads):
     26        (WebCore::CCTiledLayerImpl::pushTileProperties):
     27        * platform/graphics/chromium/cc/CCTiledLayerImpl.h:
     28
    1292012-01-18  Victoria Kirst  <vrk@chromium.org>
    230

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

    r105314 r105366  
    6868    IntRect m_dirtyRect;
    6969    IntRect m_updateRect;
     70    IntRect m_opaqueRect;
    7071private:
    7172    OwnPtr<LayerTextureUpdater::Texture> m_texture;
    … …  
    273274            continue;
    274275
    275         tiledLayer->syncTextureId(i, j, tile->managedTexture()->textureId());
     276        tiledLayer->pushTileProperties(i, j, tile->managedTexture()->textureId(), tile->m_opaqueRect);
    276277    }
    277278}
    … …  
    413414    // so we grab a local reference here to hold the updater alive until the paint completes.
    414415    RefPtr<LayerTextureUpdater> protector(textureUpdater());
    415     IntRect opaqueRect; // FIXME: unused. remove this and store in the layer to pass to impl for draw culling
    416     textureUpdater()->prepareToUpdate(m_paintRect, m_tiler->tileSize(), m_tiler->hasBorderTexels(), contentsScale(), &opaqueRect);
     416    IntRect paintedOpaqueRect;
     417    textureUpdater()->prepareToUpdate(m_paintRect, m_tiler->tileSize(), m_tiler->hasBorderTexels(), contentsScale(), &paintedOpaqueRect);
    417418    for (int j = top; j <= bottom; ++j) {
    418419        for (int i = left; i <= right; ++i) {
    … …  
    422423            if (!tile)
    423424                CRASH();
     425
     426            IntRect tileRect = m_tiler->tileRect(tile);
     427
     428            // Save what was painted opaque in the tile. If everything painted in the tile was opaque, and the area is a subset of an
     429            // already opaque area, keep the old area.
     430            IntRect tilePaintedRect = intersection(tileRect, m_paintRect);
     431            IntRect tilePaintedOpaqueRect = intersection(tileRect, paintedOpaqueRect);
     432            if (tilePaintedOpaqueRect != tilePaintedRect || !tile->m_opaqueRect.contains(tilePaintedOpaqueRect))
     433                tile->m_opaqueRect = tilePaintedOpaqueRect;
    424434
    425435            // Use m_updateRect as copyAndClearDirty above moved the existing dirty rect to m_updateRect.
    … …  
    428438                continue;
    429439
    430             IntRect sourceRect = m_tiler->tileRect(tile);
     440            IntRect sourceRect = tileRect;
    431441            sourceRect.intersect(dirtyRect);
    432442            // Paint rect not guaranteed to line up on tile boundaries, so

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

    r105311 r105366  
    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    {
     57        if (opacity() != 1)
     58            return IntRect();
     59        if (m_sharedQuadState->isOpaque() && m_quadOpaque)
     60            return m_quadRect;
     61        return m_opaqueRect;
     62    }
     63    bool needsBlending() const { return m_needsBlending || opaqueRect() != m_quadRect; }
    5764    bool isLayerAxisAlignedIntRect() const { return m_sharedQuadState->isLayerAxisAlignedIntRect(); }
    5865
    … …  
    9198    bool m_quadOpaque;
    9299    bool m_needsBlending;
     100
     101    // Be default, this rect is empty. It is used when the shared quad state and above
     102    // variables determine that the quad is not fully opaque but may be partially opaque.
     103    IntRect m_opaqueRect;
    93104};
    94105

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

    r105311 r105366  
    7878        bool keepQuad = !regionContainsRect(opaqueCoverageThusFar, quadRect);
    7979
    80         if (keepQuad && drawQuad->drawsOpaque() && drawQuad->isLayerAxisAlignedIntRect())
    81             opaqueCoverageThusFar.unite(Region(quadRect));
     80        if (keepQuad && drawQuad->isLayerAxisAlignedIntRect())
     81            opaqueCoverageThusFar.unite(drawQuad->quadTransform().mapRect(drawQuad->opaqueRect()));
    8282
    8383        if (keepQuad)

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

    r102838 r105366  
    4141    if (m_color.alpha() != 1)
    4242        m_quadOpaque = false;
     43    else
     44        m_opaqueRect = quadRect;
    4345}
    4446

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

    r102838 r105366  
    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

    r102838 r105366  
    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

    r104600 r105366  
    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
    … …  
    160165
    161166            const GC3Dint textureFilter = m_tiler->hasBorderTexels() ? GraphicsContext3D::LINEAR : GraphicsContext3D::NEAREST;
    162             quadList.append(CCTileDrawQuad::create(sharedQuadState, tileRect, tile->textureId(), textureOffset, textureSize, textureFilter, contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA));
     167            quadList.append(CCTileDrawQuad::create(sharedQuadState, tileRect, tile->opaqueRect(), tile->textureId(), textureOffset, textureSize, textureFilter, contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA));
    163168
    164169            if (hasDebugBorders()) {
    … …  
    179184}
    180185
    181 void CCTiledLayerImpl::syncTextureId(int i, int j, Platform3DObject textureId)
     186void CCTiledLayerImpl::pushTileProperties(int i, int j, Platform3DObject textureId, const IntRect& opaqueRect)
    182187{
    183188    DrawableTile* tile = tileAt(i, j);
    … …  
    185190        tile = createTile(i, j);
    186191    tile->setTextureId(textureId);
     192    tile->setOpaqueRect(opaqueRect);
    187193}
    188194
    189 }
     195} // namespace WebCore
    190196
    191197#endif // USE(ACCELERATED_COMPOSITING)

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

    r102838 r105366  
    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

    r105363 r105366  
     12012-01-18  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/CCQuadCullerTest.cpp:
     9        (WebCore::TestDrawQuad::TestDrawQuad):
     10        (WebCore::TestDrawQuad::create):
     11        (WebCore::setQuads):
     12        (WebCore::TEST):
     13        * tests/CCTiledLayerImplTest.cpp:
     14        (WebCore::createLayer):
     15        (WebCore::TEST):
     16        (WebCore::getQuads):
     17        (WebCore::coverageVisibleRectOnTileBoundaries):
     18        (WebCore::coverageVisibleRectIntersectsTiles):
     19        (WebCore::coverageVisibleRectIntersectsBounds):
     20
    1212012-01-18  Joshua Bell  <jsbell@chromium.org>
    222

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

    r104368 r105366  
    3939class TestDrawQuad : public CCDrawQuad {
    4040public:
    41     TestDrawQuad(const CCSharedQuadState* state, Material m, const IntRect& rect)
     41    TestDrawQuad(const CCSharedQuadState* state, Material m, const IntRect& rect, const IntRect& opaqueRect)
    4242    : CCDrawQuad(state, m, rect)
    4343    {
     44        m_opaqueRect = opaqueRect;
    4445    }
    4546
    46     static PassOwnPtr<TestDrawQuad> create(const CCSharedQuadState* state, Material m, const IntRect& rect)
     47    static PassOwnPtr<TestDrawQuad> create(const CCSharedQuadState* state, Material m, const IntRect& rect, const IntRect& opaqueRect)
    4748    {
    48         return adoptPtr(new TestDrawQuad(state, m, rect));
     49        return adoptPtr(new TestDrawQuad(state, m, rect, opaqueRect));
    4950    }
    5051};
    5152
    52 void setQuads(CCSharedQuadState* rootState, CCSharedQuadState* childState, CCQuadList& quadList)
     53void setQuads(CCSharedQuadState* rootState, CCSharedQuadState* childState, CCQuadList& quadList, const IntRect& childOpaqueRect = IntRect())
    5354{
    5455    quadList.clear();
    5556
    56     quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(), IntSize(100, 100))));
    57     quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(100, 0), IntSize(100, 100))));
    58     quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(200, 0), IntSize(100, 100))));
    59     quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(0, 100), IntSize(100, 100))));
    60     quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(100, 100), IntSize(100, 100))));
    61     quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(200, 100), IntSize(100, 100))));
    62     quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(0, 200), IntSize(100, 100))));
    63     quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(100, 200), IntSize(100, 100))));
    64     quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(200, 200), IntSize(100, 100))));
    65 
    66     quadList.append(TestDrawQuad::create(childState, CCDrawQuad::TiledContent, IntRect(IntPoint(), IntSize(100, 100))));
    67     quadList.append(TestDrawQuad::create(childState, CCDrawQuad::TiledContent, IntRect(IntPoint(100, 0), IntSize(100, 100))));
    68     quadList.append(TestDrawQuad::create(childState, CCDrawQuad::TiledContent, IntRect(IntPoint(0, 100), IntSize(100, 100))));
    69     quadList.append(TestDrawQuad::create(childState, CCDrawQuad::TiledContent, IntRect(IntPoint(100, 100), IntSize(100, 100))));
     57    quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(), IntSize(100, 100)), childOpaqueRect));
     58    quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(100, 0), IntSize(100, 100)), childOpaqueRect));
     59    quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(200, 0), IntSize(100, 100)), childOpaqueRect));
     60    quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(0, 100), IntSize(100, 100)), childOpaqueRect));
     61    quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(100, 100), IntSize(100, 100)), childOpaqueRect));
     62    quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(200, 100), IntSize(100, 100)), childOpaqueRect));
     63    quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(0, 200), IntSize(100, 100)), childOpaqueRect));
     64    quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(100, 200), IntSize(100, 100)), childOpaqueRect));
     65    quadList.append(TestDrawQuad::create(rootState, CCDrawQuad::TiledContent, IntRect(IntPoint(200, 200), IntSize(100, 100)), childOpaqueRect));
     66
     67    quadList.append(TestDrawQuad::create(childState, CCDrawQuad::TiledContent, IntRect(IntPoint(), IntSize(100, 100)), childOpaqueRect));
     68    quadList.append(TestDrawQuad::create(childState, CCDrawQuad::TiledContent, IntRect(IntPoint(100, 0), IntSize(100, 100)), childOpaqueRect));
     69    quadList.append(TestDrawQuad::create(childState, CCDrawQuad::TiledContent, IntRect(IntPoint(0, 100), IntSize(100, 100)), childOpaqueRect));
     70    quadList.append(TestDrawQuad::create(childState, CCDrawQuad::TiledContent, IntRect(IntPoint(100, 100), IntSize(100, 100)), childOpaqueRect));
    7071}
    7172
    … …  
    147148}
    148149
     150TEST(CCQuadCullerTest, verifyCullSubRegion)
     151{
     152    DECLARE_AND_INITIALIZE_TEST_QUADS
     153
     154    childTransform.translate(50, 50);
     155
     156    OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true);
     157    OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, false);
     158    IntRect childOpaqueRect(childRect.x() + childRect.width() / 4, childRect.y() + childRect.height() / 4, childRect.width() / 2, childRect.height() / 2);
     159
     160    setQuads(rootState.get(), childState.get(), quadList, childOpaqueRect);
     161    EXPECT_EQ(quadList.size(), 13u);
     162    CCQuadCuller::cullOccludedQuads(quadList);
     163    EXPECT_EQ(quadList.size(), 12u);
     164}
     165
     166TEST(CCQuadCullerTest, verifyCullSubRegion2)
     167{
     168    DECLARE_AND_INITIALIZE_TEST_QUADS
     169
     170    childTransform.translate(50, 10);
     171
     172    OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true);
     173    OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, false);
     174    IntRect childOpaqueRect(childRect.x() + childRect.width() / 4, childRect.y() + childRect.height() / 4, childRect.width() / 2, childRect.height() * 3 / 4);
     175
     176    setQuads(rootState.get(), childState.get(), quadList, childOpaqueRect);
     177    EXPECT_EQ(quadList.size(), 13u);
     178    CCQuadCuller::cullOccludedQuads(quadList);
     179    EXPECT_EQ(quadList.size(), 12u);
     180}
     181
     182TEST(CCQuadCullerTest, verifyCullSubRegionCheckOvercull)
     183{
     184    DECLARE_AND_INITIALIZE_TEST_QUADS
     185
     186    childTransform.translate(50, 49);
     187
     188    OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true);
     189    OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, false);
     190    IntRect childOpaqueRect(childRect.x() + childRect.width() / 4, childRect.y() + childRect.height() / 4, childRect.width() / 2, childRect.height() / 2);
     191
     192    setQuads(rootState.get(), childState.get(), quadList, childOpaqueRect);
     193    EXPECT_EQ(quadList.size(), 13u);
     194    CCQuadCuller::cullOccludedQuads(quadList);
     195    EXPECT_EQ(quadList.size(), 13u);
     196}
     197
    149198TEST(CCQuadCullerTest, verifyNonAxisAlignedQuadsDontOcclude)
    150199{

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

    r104176 r105366  
    4747    layer->setSkipsDraw(false);
    4848    layer->setVisibleLayerRect(IntRect(IntPoint(), layerSize));
     49    layer->setDrawOpacity(1);
    4950
    5051    int textureId = 1;
    5152    for (int i = 0; i < tiler->numTilesX(); ++i)
    5253        for (int j = 0; j < tiler->numTilesY(); ++j)
    53             layer->syncTextureId(i, j, static_cast<Platform3DObject>(textureId++));
     54            layer->pushTileProperties(i, j, static_cast<Platform3DObject>(textureId++), IntRect(0, 0, 1, 1));
    5455
    5556    return layer.release();
    … …  
    135136    for (int i = 0; i < numTilesX; ++i)
    136137        for (int j = 0; j < numTilesY; ++j)
    137             layer->syncTextureId(i, j, static_cast<Platform3DObject>(0));
     138            layer->pushTileProperties(i, j, static_cast<Platform3DObject>(0), IntRect());
    138139
    139140    // All checkerboarding
    … …  
    156157}
    157158
    158 static void getQuads(CCQuadList& quads, IntSize tileSize, const IntSize& layerSize, CCLayerTilingData::BorderTexelOption borderTexelOption, const IntRect& visibleLayerRect)
     159static PassOwnPtr<CCSharedQuadState> getQuads(CCQuadList& quads, IntSize tileSize, const IntSize& layerSize, CCLayerTilingData::BorderTexelOption borderTexelOption, const IntRect& visibleLayerRect)
    159160{
    160161    RefPtr<CCTiledLayerImpl> layer = createLayer(tileSize, layerSize, borderTexelOption);
    … …  
    164165    OwnPtr<CCSharedQuadState> sharedQuadState = layer->createSharedQuadState();
    165166    layer->appendQuads(quads, sharedQuadState.get());
     167    return sharedQuadState.release(); // The shared data must be owned as long as the quad list exists.
    166168}
    167169
    … …  
    201203    IntSize layerSize(1000, 1000);
    202204    CCQuadList quads;
    203     getQuads(quads, IntSize(100, 100), layerSize, borders, IntRect(IntPoint(), layerSize));
     205    OwnPtr<CCSharedQuadState> sharedState;
     206    sharedState = getQuads(quads, IntSize(100, 100), layerSize, borders, IntRect(IntPoint(), layerSize));
    204207    verifyQuadsExactlyCoverRect(quads, IntRect(IntPoint(), layerSize));
    205208}
    … …  
    217220    IntSize layerSize(250, 250);
    218221    CCQuadList quads;
    219     getQuads(quads, IntSize(50, 50), IntSize(250, 250), CCLayerTilingData::NoBorderTexels, visibleLayerRect);
     222    OwnPtr<CCSharedQuadState> sharedState;
     223    sharedState = getQuads(quads, IntSize(50, 50), IntSize(250, 250), CCLayerTilingData::NoBorderTexels, visibleLayerRect);
    220224    verifyQuadsExactlyCoverRect(quads, visibleLayerRect);
    221225}
    … …  
    229233    IntRect visibleLayerRect(IntPoint(), layerSize);
    230234    CCQuadList quads;
    231     getQuads(quads, IntSize(100, 100), layerSize, CCLayerTilingData::NoBorderTexels, visibleLayerRect);
     235    OwnPtr<CCSharedQuadState> sharedState;
     236    sharedState = getQuads(quads, IntSize(100, 100), layerSize, CCLayerTilingData::NoBorderTexels, visibleLayerRect);
    232237    verifyQuadsExactlyCoverRect(quads, visibleLayerRect);
    233238}
    … …  
    241246    IntSize layerSize(250, 250);
    242247    CCQuadList quads;
    243     getQuads(quads, tileSize, layerSize, CCLayerTilingData::NoBorderTexels, IntRect(IntPoint(), layerSize));
     248    OwnPtr<CCSharedQuadState> sharedState;
     249    sharedState = getQuads(quads, tileSize, layerSize, CCLayerTilingData::NoBorderTexels, IntRect(IntPoint(), layerSize));
    244250
    245251    for (size_t i = 0; i < quads.size(); ++i) {
    … …  
    250256        EXPECT_EQ(quad->textureOffset(), IntPoint()) << quadString << i;
    251257        EXPECT_EQ(quad->textureSize(), tileSize) << quadString << i;
    252     }
    253 }
    254 
     258        EXPECT_EQ(IntRect(0, 0, 1, 1), quad->opaqueRect()) << quadString << i;
     259    }
     260}
     261
     262TEST(CCTiledLayerImplTest, tileOpaqueRectForLayerNoBorders)
     263{
     264    DebugScopedSetImplThread scopedImplThread;
     265
     266    IntSize tileSize(50, 50);
     267    IntSize layerSize(250, 250);
     268    CCQuadList quads;
     269    OwnPtr<CCSharedQuadState> sharedState;
     270    sharedState = getQuads(quads, tileSize, layerSize, CCLayerTilingData::NoBorderTexels, IntRect(IntPoint(), layerSize));
     271
     272    for (size_t i = 0; i < quads.size(); ++i) {
     273        ASSERT_EQ(quads[i]->material(), CCDrawQuad::TiledContent) << quadString << i;
     274        CCTileDrawQuad* quad = static_cast<CCTileDrawQuad*>(quads[i].get());
     275
     276        EXPECT_EQ(IntRect(0, 0, 1, 1), quad->opaqueRect()) << quadString << i;
     277    }
     278}
    255279
    256280} // namespace
Note: See TracChangeset for help on using the changeset viewer.