Changeset 109304 in webkit


Ignore:
Timestamp:
Feb 29, 2012 8:33:03 PM (12 years ago)
Author:
wjmaclean@chromium.org
Message:

[chromium] Estimate pixel count for frame rate control
https://bugs.webkit.org/show_bug.cgi?id=74982

Reviewed by James Robinson.

Source/WebCore:

Value checks added to unit tests.

Adds mechanism to compute and collect statistics on pixel overdraw for selected frames.

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

(WebCore::CCLayerTreeHostImpl::optimizeRenderPasses):

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

(WebCore::wedgeProduct):
(WebCore):
(WebCore::quadArea):
(WebCore::CCQuadCuller::cullOccludedQuads):

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

(CCQuadCuller):

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

(WebCore::CCRenderPass::optimizeQuads):

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

(CCOverdrawCounts):
(WebCore):
(CCRenderPass):

Source/WebKit/chromium:

Adds mechanism to compute and collect statistics on pixel overdraw for selected frames.

  • tests/CCQuadCullerTest.cpp:

(WebCore):
(WebCore::TEST):

Location:
trunk/Source
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r109301 r109304  
     12012-02-29  W. James MacLean  <wjmaclean@chromium.org>
     2
     3        [chromium] Estimate pixel count for frame rate control
     4        https://bugs.webkit.org/show_bug.cgi?id=74982
     5
     6        Reviewed by James Robinson.
     7
     8        Value checks added to unit tests.
     9
     10        Adds mechanism to compute and collect statistics on pixel overdraw for selected frames.
     11
     12        * platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp:
     13        (WebCore::CCLayerTreeHostImpl::optimizeRenderPasses):
     14        * platform/graphics/chromium/cc/CCQuadCuller.cpp:
     15        (WebCore::wedgeProduct):
     16        (WebCore):
     17        (WebCore::quadArea):
     18        (WebCore::CCQuadCuller::cullOccludedQuads):
     19        * platform/graphics/chromium/cc/CCQuadCuller.h:
     20        (CCQuadCuller):
     21        * platform/graphics/chromium/cc/CCRenderPass.cpp:
     22        (WebCore::CCRenderPass::optimizeQuads):
     23        * platform/graphics/chromium/cc/CCRenderPass.h:
     24        (CCOverdrawCounts):
     25        (WebCore):
     26        (CCRenderPass):
     27
    1282012-02-29  Jason Liu  <jason.liu@torchmobile.com.cn>
    229
  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostImpl.cpp

    r108937 r109304  
    235235    bool haveDamageRect = layerRendererCapabilities().usingPartialSwap;
    236236
     237    // FIXME: compute overdraw metrics only occasionally, not every frame.
     238    CCOverdrawCounts overdrawCounts;
    237239    for (unsigned i = 0; i < passes.size(); ++i) {
    238240        FloatRect damageRect = passes[i]->targetSurface()->damageTracker()->currentDamageRect();
    239         passes[i]->optimizeQuads(haveDamageRect, damageRect);
    240     }
     241        passes[i]->optimizeQuads(haveDamageRect, damageRect, &overdrawCounts);
     242    }
     243
     244    float normalization = 1000.f / (m_layerRenderer->viewportWidth() * m_layerRenderer->viewportHeight());
     245    PlatformSupport::histogramCustomCounts("Renderer4.pixelOverdrawOpaque", static_cast<int>(normalization * overdrawCounts.m_pixelsDrawnOpaque), 100, 1000000, 50);
     246    PlatformSupport::histogramCustomCounts("Renderer4.pixelOverdrawTransparent", static_cast<int>(normalization * overdrawCounts.m_pixelsDrawnTransparent), 100, 1000000, 50);
     247    PlatformSupport::histogramCustomCounts("Renderer4.pixelOverdrawCulled", static_cast<int>(normalization * overdrawCounts.m_pixelsCulled), 100, 1000000, 50);
    241248}
    242249
  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCQuadCuller.cpp

    r108764 r109304  
    7676}
    7777
    78 void CCQuadCuller::cullOccludedQuads(CCQuadList& quadList, bool haveDamageRect, const FloatRect& damageRect)
     78static float wedgeProduct(const FloatPoint& p1, const FloatPoint& p2)
     79{
     80    return p1.x() * p2.y() - p1.y() * p2.x();
     81}
     82
     83// Computes area of quads that are possibly non-rectangular. Can
     84// be easily extended to polygons.
     85static float quadArea(const FloatQuad& quad)
     86{
     87    return fabs(0.5 * (wedgeProduct(quad.p1(), quad.p2()) +
     88                   wedgeProduct(quad.p2(), quad.p3()) +
     89                   wedgeProduct(quad.p3(), quad.p4()) +
     90                   wedgeProduct(quad.p4(), quad.p1())));
     91}
     92
     93void CCQuadCuller::cullOccludedQuads(CCQuadList& quadList, bool haveDamageRect, const FloatRect& damageRect, CCOverdrawCounts* overdrawMetrics)
    7994{
    8095    if (!quadList.size())
     
    97112        IntRect transformedVisibleQuadRect = rectSubtractRegion(opaqueCoverageThusFar, transformedQuadRect);
    98113        bool keepQuad = !transformedVisibleQuadRect.isEmpty();
    99         if (!keepQuad)
    100             continue;
    101114
    102115        // See if we can reduce the number of pixels to draw by reducing the size of the draw
    103116        // quad - we do this by changing its visible rect.
    104         if (transformedVisibleQuadRect != transformedQuadRect && drawQuad->isLayerAxisAlignedIntRect())
    105             drawQuad->setQuadVisibleRect(drawQuad->quadTransform().inverse().mapRect(transformedVisibleQuadRect));
     117        bool didReduceQuadSize = false;
     118        if (keepQuad) {
     119            if (transformedVisibleQuadRect != transformedQuadRect && drawQuad->isLayerAxisAlignedIntRect()) {
     120                drawQuad->setQuadVisibleRect(drawQuad->quadTransform().inverse().mapRect(transformedVisibleQuadRect));
     121                didReduceQuadSize = true;
     122            }
    106123
    107         // When adding rect to opaque region, deflate it to stay conservative.
    108         if (drawQuad->isLayerAxisAlignedIntRect() && !drawQuad->opaqueRect().isEmpty()) {
    109             FloatRect floatOpaqueRect = drawQuad->quadTransform().mapRect(FloatRect(drawQuad->opaqueRect()));
    110             opaqueCoverageThusFar.unite(Region(enclosedIntRect(floatOpaqueRect)));
     124            // When adding rect to opaque region, deflate it to stay conservative.
     125            if (drawQuad->isLayerAxisAlignedIntRect() && !drawQuad->opaqueRect().isEmpty()) {
     126                FloatRect floatOpaqueRect = drawQuad->quadTransform().mapRect(FloatRect(drawQuad->opaqueRect()));
     127                opaqueCoverageThusFar.unite(Region(enclosedIntRect(floatOpaqueRect)));
     128            }
     129
     130            culledList.append(quadList[i].release());
    111131        }
    112132
    113         culledList.append(quadList[i].release());
     133        if (overdrawMetrics) {
     134            TRACE_EVENT("CCQuadCuller::cullOccludedQuads_OverdrawMetrics", 0, 0);
     135            // We compute the area of the transformed quad, as this should be in pixels.
     136            float area = quadArea(drawQuad->quadTransform().mapQuad(FloatQuad(drawQuad->quadRect())));
     137            if (keepQuad) {
     138                if (didReduceQuadSize) {
     139                    float visibleQuadRectArea = quadArea(drawQuad->quadTransform().mapQuad(FloatQuad(drawQuad->quadVisibleRect())));
     140                    overdrawMetrics->m_pixelsCulled += area - visibleQuadRectArea;
     141                    area = visibleQuadRectArea;
     142                }
     143                IntRect visibleOpaqueRect(drawQuad->quadVisibleRect());
     144                visibleOpaqueRect.intersect(drawQuad->opaqueRect());
     145                FloatQuad visibleOpaqueQuad = drawQuad->quadTransform().mapQuad(FloatQuad(visibleOpaqueRect));
     146                float opaqueArea = quadArea(visibleOpaqueQuad);
     147                overdrawMetrics->m_pixelsDrawnOpaque += opaqueArea;
     148                overdrawMetrics->m_pixelsDrawnTransparent += area - opaqueArea;
     149            } else
     150                overdrawMetrics->m_pixelsCulled += area;
     151        }
    114152    }
    115153    quadList.clear(); // Release anything that remains.
  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCQuadCuller.h

    r108458 r109304  
    3333class CCQuadCuller {
    3434public:
    35     static void cullOccludedQuads(CCQuadList&, bool haveDamageRect, const FloatRect& damageRect);
     35    // Passing 0 for CCOverdrawCounts* is valid, and disable the extra computation
     36    // done to estimate over draw statistics.
     37    static void cullOccludedQuads(CCQuadList&, bool haveDamageRect, const FloatRect& damageRect, CCOverdrawCounts*);
    3638
    3739private:
  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCRenderPass.cpp

    r108458 r109304  
    6666}
    6767
    68 void CCRenderPass::optimizeQuads(bool haveDamageRect, const FloatRect& damageRect)
     68void CCRenderPass::optimizeQuads(bool haveDamageRect, const FloatRect& damageRect, CCOverdrawCounts* overdraw)
    6969{
    70     CCQuadCuller::cullOccludedQuads(m_quadList, haveDamageRect, damageRect);
     70    CCQuadCuller::cullOccludedQuads(m_quadList, haveDamageRect, damageRect, overdraw);
    7171}
    7272
  • trunk/Source/WebCore/platform/graphics/chromium/cc/CCRenderPass.h

    r108458 r109304  
    3939typedef Vector<OwnPtr<CCDrawQuad> > CCQuadList;
    4040
     41struct CCOverdrawCounts {
     42    // Count of pixels that are opaque (and thus occlude). Ideally this is no more
     43    // than wiewport width x height.
     44    float m_pixelsDrawnOpaque;
     45    // Count of pixels that are possibly transparent, and cannot occlude.
     46    float m_pixelsDrawnTransparent;
     47    // Count of pixels not drawn as they are occluded by somthing opaque.
     48    float m_pixelsCulled;
     49};
     50
    4151class CCRenderPass {
    4252    WTF_MAKE_NONCOPYABLE(CCRenderPass);
     
    4757    void appendQuadsForRenderSurfaceLayer(CCLayerImpl*);
    4858
    49     void optimizeQuads(bool haveDamageRect, const FloatRect& damageRect);
     59    // Passing in 0 for CCOverdrawCounts is valid, and disables performing overdraw calculations.
     60    void optimizeQuads(bool haveDamageRect, const FloatRect& damageRect, CCOverdrawCounts*);
    5061
    5162    const CCQuadList& quadList() const { return m_quadList; }
  • trunk/Source/WebKit/chromium/ChangeLog

    r109300 r109304  
     12012-02-29  W. James MacLean  <wjmaclean@chromium.org>
     2
     3        [chromium] Estimate pixel count for frame rate control
     4        https://bugs.webkit.org/show_bug.cgi?id=74982
     5
     6        Reviewed by James Robinson.
     7
     8        Adds mechanism to compute and collect statistics on pixel overdraw for selected frames.
     9
     10        * tests/CCQuadCullerTest.cpp:
     11        (WebCore):
     12        (WebCore::TEST):
     13
    1142012-02-29  James Simonsen  <simonjam@chromium.org>
    215
  • trunk/Source/WebKit/chromium/tests/CCQuadCullerTest.cpp

    r108458 r109304  
    6565#define DECLARE_AND_INITIALIZE_TEST_QUADS               \
    6666    CCQuadList quadList;                                \
     67    CCOverdrawCounts overdraw = {0, 0, 0};              \
    6768    TransformationMatrix childTransform;                \
    6869    IntSize rootSize = IntSize(300, 300);               \
     
    8081    setQuads(rootState.get(), childState.get(), quadList);
    8182    EXPECT_EQ(quadList.size(), 13u);
    82     CCQuadCuller::cullOccludedQuads(quadList, false, IntRect());
     83    CCQuadCuller::cullOccludedQuads(quadList, false, IntRect(), &overdraw);
    8384    EXPECT_EQ(quadList.size(), 9u);
     85    EXPECT_NEAR(overdraw.m_pixelsDrawnOpaque, 90000, 1);
     86    EXPECT_NEAR(overdraw.m_pixelsDrawnTransparent, 0, 1);
     87    EXPECT_NEAR(overdraw.m_pixelsCulled, 40000, 1);
    8488}
    8589
     
    9397    setQuads(rootState.get(), childState.get(), quadList);
    9498    EXPECT_EQ(quadList.size(), 13u);
    95     CCQuadCuller::cullOccludedQuads(quadList, false, IntRect());
    96     EXPECT_EQ(quadList.size(), 13u);
     99    CCQuadCuller::cullOccludedQuads(quadList, false, IntRect(), &overdraw);
     100    EXPECT_EQ(quadList.size(), 13u);
     101    EXPECT_NEAR(overdraw.m_pixelsDrawnOpaque, 90000, 1);
     102    EXPECT_NEAR(overdraw.m_pixelsDrawnTransparent, 40000, 1);
     103    EXPECT_NEAR(overdraw.m_pixelsCulled, 0, 1);
    97104}
    98105
     
    106113    setQuads(rootState.get(), childState.get(), quadList);
    107114    EXPECT_EQ(quadList.size(), 13u);
    108     CCQuadCuller::cullOccludedQuads(quadList, false, IntRect());
    109     EXPECT_EQ(quadList.size(), 13u);
     115    CCQuadCuller::cullOccludedQuads(quadList, false, IntRect(), &overdraw);
     116    EXPECT_EQ(quadList.size(), 13u);
     117    EXPECT_NEAR(overdraw.m_pixelsDrawnOpaque, 90000, 1);
     118    EXPECT_NEAR(overdraw.m_pixelsDrawnTransparent, 40000, 1);
     119    EXPECT_NEAR(overdraw.m_pixelsCulled, 0, 1);
    110120}
    111121
     
    121131    setQuads(rootState.get(), childState.get(), quadList);
    122132    EXPECT_EQ(quadList.size(), 13u);
    123     CCQuadCuller::cullOccludedQuads(quadList, false, IntRect());
     133    CCQuadCuller::cullOccludedQuads(quadList, false, IntRect(), &overdraw);
    124134    EXPECT_EQ(quadList.size(), 12u);
    125135
     
    138148    EXPECT_EQ(quadVisibleRect6.height(), 50);
    139149    EXPECT_EQ(quadVisibleRect6.y(), 250);
     150
     151    EXPECT_NEAR(overdraw.m_pixelsDrawnOpaque, 100000, 1);
     152    EXPECT_NEAR(overdraw.m_pixelsDrawnTransparent, 0, 1);
     153    EXPECT_NEAR(overdraw.m_pixelsCulled, 30000, 1);
    140154}
    141155
     
    159173
    160174    EXPECT_EQ(quadList.size(), 2u);
    161     CCQuadCuller::cullOccludedQuads(quadList, false, IntRect());
     175    CCQuadCuller::cullOccludedQuads(quadList, false, IntRect(), &overdraw);
    162176    EXPECT_EQ(quadList.size(), 2u);
     177
     178    EXPECT_NEAR(overdraw.m_pixelsDrawnOpaque, 20363, 1);
     179    EXPECT_NEAR(overdraw.m_pixelsDrawnTransparent, 0, 1);
     180    EXPECT_NEAR(overdraw.m_pixelsCulled, 0, 1);
    163181}
    164182
     
    182200
    183201    EXPECT_EQ(quadList.size(), 2u);
    184     CCQuadCuller::cullOccludedQuads(quadList, false, IntRect());
     202    CCQuadCuller::cullOccludedQuads(quadList, false, IntRect(), &overdraw);
    185203    EXPECT_EQ(quadList.size(), 2u);
     204
     205    EXPECT_NEAR(overdraw.m_pixelsDrawnOpaque, 19643, 1);
     206    EXPECT_NEAR(overdraw.m_pixelsDrawnTransparent, 0, 1);
     207    EXPECT_NEAR(overdraw.m_pixelsCulled, 0, 1);
    186208}
    187209
     
    197219    setQuads(rootState.get(), childState.get(), quadList);
    198220    EXPECT_EQ(quadList.size(), 13u);
    199     CCQuadCuller::cullOccludedQuads(quadList, false, IntRect());
     221    CCQuadCuller::cullOccludedQuads(quadList, false, IntRect(), &overdraw);
    200222    EXPECT_EQ(quadList.size(), 9u);
     223    EXPECT_NEAR(overdraw.m_pixelsDrawnOpaque, 90000, 1);
     224    EXPECT_NEAR(overdraw.m_pixelsDrawnTransparent, 0, 1);
     225    EXPECT_NEAR(overdraw.m_pixelsCulled, 40000, 1);
    201226}
    202227
     
    213238    setQuads(rootState.get(), childState.get(), quadList, childOpaqueRect);
    214239    EXPECT_EQ(quadList.size(), 13u);
    215     CCQuadCuller::cullOccludedQuads(quadList, false, IntRect());
     240    CCQuadCuller::cullOccludedQuads(quadList, false, IntRect(), &overdraw);
    216241    EXPECT_EQ(quadList.size(), 12u);
     242    EXPECT_NEAR(overdraw.m_pixelsDrawnOpaque, 90000, 1);
     243    EXPECT_NEAR(overdraw.m_pixelsDrawnTransparent, 30000, 1);
     244    EXPECT_NEAR(overdraw.m_pixelsCulled, 10000, 1);
    217245}
    218246
     
    229257    setQuads(rootState.get(), childState.get(), quadList, childOpaqueRect);
    230258    EXPECT_EQ(quadList.size(), 13u);
    231     CCQuadCuller::cullOccludedQuads(quadList, false, IntRect());
     259    CCQuadCuller::cullOccludedQuads(quadList, false, IntRect(), &overdraw);
    232260    EXPECT_EQ(quadList.size(), 12u);
     261    EXPECT_NEAR(overdraw.m_pixelsDrawnOpaque, 90000, 1);
     262    EXPECT_NEAR(overdraw.m_pixelsDrawnTransparent, 25000, 1);
     263    EXPECT_NEAR(overdraw.m_pixelsCulled, 15000, 1);
    233264}
    234265
     
    245276    setQuads(rootState.get(), childState.get(), quadList, childOpaqueRect);
    246277    EXPECT_EQ(quadList.size(), 13u);
    247     CCQuadCuller::cullOccludedQuads(quadList, false, IntRect());
     278    CCQuadCuller::cullOccludedQuads(quadList, false, IntRect(), &overdraw);
    248279    EXPECT_EQ(quadList.size(), 13u);
    249280}
     
    261292    setQuads(rootState.get(), childState.get(), quadList);
    262293    EXPECT_EQ(quadList.size(), 13u);
    263     CCQuadCuller::cullOccludedQuads(quadList, false, IntRect());
    264     EXPECT_EQ(quadList.size(), 13u);
     294    CCQuadCuller::cullOccludedQuads(quadList, false, IntRect(), &overdraw);
     295    EXPECT_EQ(quadList.size(), 13u);
     296    EXPECT_NEAR(overdraw.m_pixelsDrawnOpaque, 130000, 1);
     297    EXPECT_NEAR(overdraw.m_pixelsDrawnTransparent, 0, 1);
     298    EXPECT_NEAR(overdraw.m_pixelsCulled, 0, 1);
    265299}
    266300
     
    283317    setQuads(rootState.get(), childState.get(), quadList);
    284318    EXPECT_EQ(quadList.size(), 13u);
    285     CCQuadCuller::cullOccludedQuads(quadList, false, IntRect());
     319    CCQuadCuller::cullOccludedQuads(quadList, false, IntRect(), &overdraw);
    286320    EXPECT_EQ(quadList.size(), 12u);
    287 }
    288 
    289 TEST(CCQuadCullerTest, veriftyCullOutsideScissorOverTile)
    290 {
    291     DECLARE_AND_INITIALIZE_TEST_QUADS
    292 
    293     OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true);
    294     OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, true);
    295 
    296     setQuads(rootState.get(), childState.get(), quadList);
    297     EXPECT_EQ(quadList.size(), 13u);
    298     CCQuadCuller::cullOccludedQuads(quadList, true, IntRect(200, 100, 100, 100));
     321    EXPECT_NEAR(overdraw.m_pixelsDrawnOpaque, 120000, 1);
     322    EXPECT_NEAR(overdraw.m_pixelsDrawnTransparent, 0, 1);
     323    EXPECT_NEAR(overdraw.m_pixelsCulled, 10000, 1);
     324}
     325
     326TEST(CCQuadCullerTest, verifyCullOutsideScissorOverTile)
     327{
     328    DECLARE_AND_INITIALIZE_TEST_QUADS
     329
     330    OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true);
     331    OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, true);
     332
     333    setQuads(rootState.get(), childState.get(), quadList);
     334    EXPECT_EQ(quadList.size(), 13u);
     335    CCQuadCuller::cullOccludedQuads(quadList, true, IntRect(200, 100, 100, 100), &overdraw);
    299336    EXPECT_EQ(quadList.size(), 1u);
    300 }
    301 
    302 TEST(CCQuadCullerTest, veriftyCullOutsideScissorOverCulledTile)
    303 {
    304     DECLARE_AND_INITIALIZE_TEST_QUADS
    305 
    306     OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true);
    307     OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, true);
    308 
    309     setQuads(rootState.get(), childState.get(), quadList);
    310     EXPECT_EQ(quadList.size(), 13u);
    311     CCQuadCuller::cullOccludedQuads(quadList, true, IntRect(100, 100, 100, 100));
     337    EXPECT_NEAR(overdraw.m_pixelsDrawnOpaque, 10000, 1);
     338    EXPECT_NEAR(overdraw.m_pixelsDrawnTransparent, 0, 1);
     339    EXPECT_NEAR(overdraw.m_pixelsCulled, 120000, 1);
     340}
     341
     342TEST(CCQuadCullerTest, verifyCullOutsideScissorOverCulledTile)
     343{
     344    DECLARE_AND_INITIALIZE_TEST_QUADS
     345
     346    OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true);
     347    OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, true);
     348
     349    setQuads(rootState.get(), childState.get(), quadList);
     350    EXPECT_EQ(quadList.size(), 13u);
     351    CCQuadCuller::cullOccludedQuads(quadList, true, IntRect(100, 100, 100, 100), &overdraw);
    312352    EXPECT_EQ(quadList.size(), 1u);
    313353}
    314354
    315 TEST(CCQuadCullerTest, veriftyCullOutsideScissorOverPartialTiles)
    316 {
    317     DECLARE_AND_INITIALIZE_TEST_QUADS
    318 
    319     OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true);
    320     OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, true);
    321 
    322     setQuads(rootState.get(), childState.get(), quadList);
    323     EXPECT_EQ(quadList.size(), 13u);
    324     CCQuadCuller::cullOccludedQuads(quadList, true, IntRect(50, 50, 200, 200));
     355TEST(CCQuadCullerTest, verifyCullOutsideScissorOverPartialTiles)
     356{
     357    DECLARE_AND_INITIALIZE_TEST_QUADS
     358
     359    OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true);
     360    OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, true);
     361
     362    setQuads(rootState.get(), childState.get(), quadList);
     363    EXPECT_EQ(quadList.size(), 13u);
     364    CCQuadCuller::cullOccludedQuads(quadList, true, IntRect(50, 50, 200, 200), &overdraw);
    325365    EXPECT_EQ(quadList.size(), 9u);
    326366}
    327367
    328 TEST(CCQuadCullerTest, veriftyCullOutsideScissorOverNoTiles)
    329 {
    330     DECLARE_AND_INITIALIZE_TEST_QUADS
    331 
    332     OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true);
    333     OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, true);
    334 
    335     setQuads(rootState.get(), childState.get(), quadList);
    336     EXPECT_EQ(quadList.size(), 13u);
    337     CCQuadCuller::cullOccludedQuads(quadList, true, IntRect(500, 500, 100, 100));
     368TEST(CCQuadCullerTest, verifyCullOutsideScissorOverNoTiles)
     369{
     370    DECLARE_AND_INITIALIZE_TEST_QUADS
     371
     372    OwnPtr<CCSharedQuadState> rootState = CCSharedQuadState::create(TransformationMatrix(), TransformationMatrix(), rootRect, IntRect(), 1.0, true);
     373    OwnPtr<CCSharedQuadState> childState = CCSharedQuadState::create(childTransform, TransformationMatrix(), childRect, IntRect(), 1.0, true);
     374
     375    setQuads(rootState.get(), childState.get(), quadList);
     376    EXPECT_EQ(quadList.size(), 13u);
     377    CCQuadCuller::cullOccludedQuads(quadList, true, IntRect(500, 500, 100, 100), &overdraw);
    338378    EXPECT_EQ(quadList.size(), 0u);
     379    EXPECT_NEAR(overdraw.m_pixelsDrawnOpaque, 0, 1);
     380    EXPECT_NEAR(overdraw.m_pixelsDrawnTransparent, 0, 1);
     381    EXPECT_NEAR(overdraw.m_pixelsCulled, 130000, 1);
    339382}
    340383
Note: See TracChangeset for help on using the changeset viewer.