Update cc snapshot to WK r126941

cc/CCTiledLayerImplTest.cpp

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "CCTiledLayerImpl.h"
 
+#include "CCAppendQuadsData.h"
 #include "CCLayerTestCommon.h"
 #include "CCLayerTilingData.h"
 #include "CCSingleThreadProxy.h"
 #include "CCTileDrawQuad.h"
 #include "MockCCQuadCuller.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 using namespace WebCore;
 using namespace CCLayerTestCommon;
@@ skipping 30 matching lines @@
 
     const IntSize tileSize(90, 90);
     const int numTilesX = 8;
     const int numTilesY = 4;
     const IntSize layerSize(tileSize.width() * numTilesX, tileSize.height() * numTilesY);
 
     // Verify default layer does creates quads
     {
         OwnPtr<CCTiledLayerImpl> layer = createLayer(tileSize, layerSize, CCLayerTilingData::NoBorderTexels);
         MockCCQuadCuller quadCuller;
-        bool hadMissingTiles = false;
-        layer->appendQuads(quadCuller, hadMissingTiles);
+        CCAppendQuadsData data;
+        layer->appendQuads(quadCuller, data);
         const unsigned numTiles = numTilesX * numTilesY;
         EXPECT_EQ(quadCuller.quadList().size(), numTiles);
     }
 
     // Layer with empty visible layer rect produces no quads
     {
         OwnPtr<CCTiledLayerImpl> layer = createLayer(tileSize, layerSize, CCLayerTilingData::NoBorderTexels);
         layer->setVisibleContentRect(IntRect());
 
         MockCCQuadCuller quadCuller;
-        bool hadMissingTiles = false;
-        layer->appendQuads(quadCuller, hadMissingTiles);
+        CCAppendQuadsData data;
+        layer->appendQuads(quadCuller, data);
         EXPECT_EQ(quadCuller.quadList().size(), 0u);
     }
 
     // Layer with non-intersecting visible layer rect produces no quads
     {
         OwnPtr<CCTiledLayerImpl> layer = createLayer(tileSize, layerSize, CCLayerTilingData::NoBorderTexels);
 
         IntRect outsideBounds(IntPoint(-100, -100), IntSize(50, 50));
         layer->setVisibleContentRect(outsideBounds);
 
         MockCCQuadCuller quadCuller;
-        bool hadMissingTiles = false;
-        layer->appendQuads(quadCuller, hadMissingTiles);
+        CCAppendQuadsData data;
+        layer->appendQuads(quadCuller, data);
         EXPECT_EQ(quadCuller.quadList().size(), 0u);
     }
 
     // Layer with skips draw produces no quads
     {
         OwnPtr<CCTiledLayerImpl> layer = createLayer(tileSize, layerSize, CCLayerTilingData::NoBorderTexels);
         layer->setSkipsDraw(true);
 
         MockCCQuadCuller quadCuller;
-        bool hadMissingTiles = false;
-        layer->appendQuads(quadCuller, hadMissingTiles);
+        CCAppendQuadsData data;
+        layer->appendQuads(quadCuller, data);
         EXPECT_EQ(quadCuller.quadList().size(), 0u);
     }
 }
 
 TEST(CCTiledLayerImplTest, checkerboarding)
 {
     DebugScopedSetImplThread scopedImplThread;
 
     const IntSize tileSize(10, 10);
     const int numTilesX = 2;
     const int numTilesY = 2;
     const IntSize layerSize(tileSize.width() * numTilesX, tileSize.height() * numTilesY);
 
     OwnPtr<CCTiledLayerImpl> layer = createLayer(tileSize, layerSize, CCLayerTilingData::NoBorderTexels);
 
     // No checkerboarding
     {
         MockCCQuadCuller quadCuller;
-        bool hadMissingTiles = false;
-        layer->appendQuads(quadCuller, hadMissingTiles);
+        CCAppendQuadsData data;
+        layer->appendQuads(quadCuller, data);
         EXPECT_EQ(quadCuller.quadList().size(), 4u);
-        EXPECT_FALSE(hadMissingTiles);
+        EXPECT_FALSE(data.hadMissingTiles);
 
         for (size_t i = 0; i < quadCuller.quadList().size(); ++i)
             EXPECT_EQ(quadCuller.quadList()[i]->material(), CCDrawQuad::TiledContent);
     }
 
     for (int i = 0; i < numTilesX; ++i)
         for (int j = 0; j < numTilesY; ++j)
             layer->pushTileProperties(i, j, 0, IntRect());
 
     // All checkerboarding
     {
         MockCCQuadCuller quadCuller;
-        bool hadMissingTiles = false;
-        layer->appendQuads(quadCuller, hadMissingTiles);
-        EXPECT_TRUE(hadMissingTiles);
+        CCAppendQuadsData data;
+        layer->appendQuads(quadCuller, data);
+        EXPECT_TRUE(data.hadMissingTiles);
         EXPECT_EQ(quadCuller.quadList().size(), 4u);
         for (size_t i = 0; i < quadCuller.quadList().size(); ++i)
             EXPECT_NE(quadCuller.quadList()[i]->material(), CCDrawQuad::TiledContent);
     }
 }
 
 static void getQuads(CCQuadList& quads, CCSharedQuadStateList& sharedStates, IntSize tileSize, const IntSize& layerSize, CCLayerTilingData::BorderTexelOption borderTexelOption, const IntRect& visibleContentRect)
 {
     OwnPtr<CCTiledLayerImpl> layer = createLayer(tileSize, layerSize, borderTexelOption);
     layer->setVisibleContentRect(visibleContentRect);
     layer->setBounds(layerSize);
 
     MockCCQuadCuller quadCuller(quads, sharedStates);
-    bool hadMissingTiles = false;
-    layer->appendQuads(quadCuller, hadMissingTiles);
+    CCAppendQuadsData data;
+    layer->appendQuads(quadCuller, data);
 }
 
 // Test with both border texels and without.
 #define WITH_AND_WITHOUT_BORDER_TEST(testFixtureName)       \
     TEST(CCTiledLayerImplTest, testFixtureName##NoBorders)  \
     {                                                       \
         testFixtureName(CCLayerTilingData::NoBorderTexels); \
     }                                                       \
     TEST(CCTiledLayerImplTest, testFixtureName##HasBorders) \
     {                                                       \
@@ skipping 75 matching lines @@
 
     for (size_t i = 0; i < quads.size(); ++i) {
         ASSERT_EQ(quads[i]->material(), CCDrawQuad::TiledContent) << quadString << i;
         CCTileDrawQuad* quad = static_cast<CCTileDrawQuad*>(quads[i].get());
 
         EXPECT_EQ(IntRect(0, 0, 1, 1), quad->opaqueRect()) << quadString << i;
     }
 }
 
 } // namespace