cc/tiled_layer_impl_unittest.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/tiled_layer_impl.h"
   6
   7 #include "cc/append_quads_data.h"
   8 #include "cc/layer_tiling_data.h"
   9 #include "cc/single_thread_proxy.h"
  10 #include "cc/test/fake_impl_proxy.h"
  11 #include "cc/test/fake_layer_tree_host_impl.h"
  12 #include "cc/test/layer_test_common.h"
  13 #include "cc/test/mock_quad_culler.h"
  14 #include "cc/tile_draw_quad.h"
  15 #include "testing/gmock/include/gmock/gmock.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace cc {
  19 namespace {
  20
  21 class TiledLayerImplTest : public testing::Test
  22 {
  23 public:
  24     TiledLayerImplTest()
  25         : m_hostImpl(&m_proxy)
  26     {
  27     }
  28
  29     // Create a default tiled layer with textures for all tiles and a default
  30     // visibility of the entire layer size.
  31     scoped_ptr<TiledLayerImpl> createLayer(const gfx::Size& tileSize, const gfx::Size& layerSize, LayerTilingData::BorderTexelOption borderTexels)
  32     {
  33         scoped_ptr<TiledLayerImpl> layer = TiledLayerImpl::create(m_hostImpl.activeTree(), 1);
  34         scoped_ptr<LayerTilingData> tiler = LayerTilingData::create(tileSize, borderTexels);
  35         tiler->setBounds(layerSize);
  36         layer->setTilingData(*tiler);
  37         layer->setSkipsDraw(false);
  38         layer->drawProperties().visible_content_rect = gfx::Rect(gfx::Point(), layerSize);
  39         layer->drawProperties().opacity = 1;
  40         layer->setBounds(layerSize);
  41         layer->setContentBounds(layerSize);
  42         layer->createRenderSurface();
  43         layer->drawProperties().render_target = layer.get();
  44
  45         ResourceProvider::ResourceId resourceId = 1;
  46         for (int i = 0; i < tiler->numTilesX(); ++i)
  47             for (int j = 0; j < tiler->numTilesY(); ++j)
  48                 layer->pushTileProperties(i, j, resourceId++, gfx::Rect(0, 0, 1, 1), false);
  49
  50         return layer.Pass();
  51     }
  52
  53     void getQuads(QuadList& quads, SharedQuadStateList& sharedStates, gfx::Size tileSize, const gfx::Size& layerSize, LayerTilingData::BorderTexelOption borderTexelOption, const gfx::Rect& visibleContentRect)
  54     {
  55         scoped_ptr<TiledLayerImpl> layer = createLayer(tileSize, layerSize, borderTexelOption);
  56         layer->drawProperties().visible_content_rect = visibleContentRect;
  57         layer->setBounds(layerSize);
  58
  59         MockQuadCuller quadCuller(quads, sharedStates);
  60         AppendQuadsData data;
  61         layer->appendQuads(quadCuller, data);
  62     }
  63
  64 protected:
  65     FakeImplProxy m_proxy;
  66     FakeLayerTreeHostImpl m_hostImpl;
  67 };
  68
  69 TEST_F(TiledLayerImplTest, emptyQuadList)
  70 {
  71     const gfx::Size tileSize(90, 90);
  72     const int numTilesX = 8;
  73     const int numTilesY = 4;
  74     const gfx::Size layerSize(tileSize.width() * numTilesX, tileSize.height() * numTilesY);
  75
  76     // Verify default layer does creates quads
  77     {
  78         scoped_ptr<TiledLayerImpl> layer = createLayer(tileSize, layerSize, LayerTilingData::NoBorderTexels);
  79         MockQuadCuller quadCuller;
  80         AppendQuadsData data;
  81         layer->appendQuads(quadCuller, data);
  82         const unsigned numTiles = numTilesX * numTilesY;
  83         EXPECT_EQ(quadCuller.quadList().size(), numTiles);
  84     }
  85
  86     // Layer with empty visible layer rect produces no quads
  87     {
  88         scoped_ptr<TiledLayerImpl> layer = createLayer(tileSize, layerSize, LayerTilingData::NoBorderTexels);
  89         layer->drawProperties().visible_content_rect = gfx::Rect();
  90
  91         MockQuadCuller quadCuller;
  92         AppendQuadsData data;
  93         layer->appendQuads(quadCuller, data);
  94         EXPECT_EQ(quadCuller.quadList().size(), 0u);
  95     }
  96
  97     // Layer with non-intersecting visible layer rect produces no quads
  98     {
  99         scoped_ptr<TiledLayerImpl> layer = createLayer(tileSize, layerSize, LayerTilingData::NoBorderTexels);
 100
 101         gfx::Rect outsideBounds(gfx::Point(-100, -100), gfx::Size(50, 50));
 102         layer->drawProperties().visible_content_rect = outsideBounds;
 103
 104         MockQuadCuller quadCuller;
 105         AppendQuadsData data;
 106         layer->appendQuads(quadCuller, data);
 107         EXPECT_EQ(quadCuller.quadList().size(), 0u);
 108     }
 109
 110     // Layer with skips draw produces no quads
 111     {
 112         scoped_ptr<TiledLayerImpl> layer = createLayer(tileSize, layerSize, LayerTilingData::NoBorderTexels);
 113         layer->setSkipsDraw(true);
 114
 115         MockQuadCuller quadCuller;
 116         AppendQuadsData data;
 117         layer->appendQuads(quadCuller, data);
 118         EXPECT_EQ(quadCuller.quadList().size(), 0u);
 119     }
 120 }
 121
 122 TEST_F(TiledLayerImplTest, checkerboarding)
 123 {
 124     const gfx::Size tileSize(10, 10);
 125     const int numTilesX = 2;
 126     const int numTilesY = 2;
 127     const gfx::Size layerSize(tileSize.width() * numTilesX, tileSize.height() * numTilesY);
 128
 129     scoped_ptr<TiledLayerImpl> layer = createLayer(tileSize, layerSize, LayerTilingData::NoBorderTexels);
 130
 131     // No checkerboarding
 132     {
 133         MockQuadCuller quadCuller;
 134         AppendQuadsData data;
 135         layer->appendQuads(quadCuller, data);
 136         EXPECT_EQ(quadCuller.quadList().size(), 4u);
 137         EXPECT_EQ(0u, data.numMissingTiles);
 138
 139         for (size_t i = 0; i < quadCuller.quadList().size(); ++i)
 140             EXPECT_EQ(quadCuller.quadList()[i]->material, DrawQuad::TILED_CONTENT);
 141     }
 142
 143     for (int i = 0; i < numTilesX; ++i)
 144         for (int j = 0; j < numTilesY; ++j)
 145             layer->pushTileProperties(i, j, 0, gfx::Rect(), false);
 146
 147     // All checkerboarding
 148     {
 149         MockQuadCuller quadCuller;
 150         AppendQuadsData data;
 151         layer->appendQuads(quadCuller, data);
 152         EXPECT_LT(0u, data.numMissingTiles);
 153         EXPECT_EQ(quadCuller.quadList().size(), 4u);
 154         for (size_t i = 0; i < quadCuller.quadList().size(); ++i)
 155             EXPECT_NE(quadCuller.quadList()[i]->material, DrawQuad::TILED_CONTENT);
 156     }
 157 }
 158
 159 // Test with both border texels and without.
 160 #define WITH_AND_WITHOUT_BORDER_TEST(testFixtureName)             \
 161     TEST_F(TiledLayerImplBorderTest, testFixtureName##NoBorders)  \
 162     {                                                             \
 163         testFixtureName(LayerTilingData::NoBorderTexels);         \
 164     }                                                             \
 165     TEST_F(TiledLayerImplBorderTest, testFixtureName##HasBorders) \
 166     {                                                             \
 167         testFixtureName(LayerTilingData::HasBorderTexels);        \
 168     }
 169
 170 class TiledLayerImplBorderTest : public TiledLayerImplTest
 171 {
 172 public:
 173     void coverageVisibleRectOnTileBoundaries(LayerTilingData::BorderTexelOption borders)
 174     {
 175         gfx::Size layerSize(1000, 1000);
 176         QuadList quads;
 177         SharedQuadStateList sharedStates;
 178         getQuads(quads, sharedStates, gfx::Size(100, 100), layerSize, borders, gfx::Rect(gfx::Point(), layerSize));
 179         LayerTestCommon::verifyQuadsExactlyCoverRect(quads, gfx::Rect(gfx::Point(), layerSize));
 180     }
 181
 182     void coverageVisibleRectIntersectsTiles(LayerTilingData::BorderTexelOption borders)
 183     {
 184         // This rect intersects the middle 3x3 of the 5x5 tiles.
 185         gfx::Point topLeft(65, 73);
 186         gfx::Point bottomRight(182, 198);
 187         gfx::Rect visibleContentRect = gfx::BoundingRect(topLeft, bottomRight);
 188
 189         gfx::Size layerSize(250, 250);
 190         QuadList quads;
 191         SharedQuadStateList sharedStates;
 192         getQuads(quads, sharedStates, gfx::Size(50, 50), gfx::Size(250, 250), LayerTilingData::NoBorderTexels, visibleContentRect);
 193         LayerTestCommon::verifyQuadsExactlyCoverRect(quads, visibleContentRect);
 194     }
 195
 196     void coverageVisibleRectIntersectsBounds(LayerTilingData::BorderTexelOption borders)
 197     {
 198         gfx::Size layerSize(220, 210);
 199         gfx::Rect visibleContentRect(gfx::Point(), layerSize);
 200         QuadList quads;
 201         SharedQuadStateList sharedStates;
 202         getQuads(quads, sharedStates, gfx::Size(100, 100), layerSize, LayerTilingData::NoBorderTexels, visibleContentRect);
 203         LayerTestCommon::verifyQuadsExactlyCoverRect(quads, visibleContentRect);
 204     }
 205 };
 206 WITH_AND_WITHOUT_BORDER_TEST(coverageVisibleRectOnTileBoundaries);
 207
 208 WITH_AND_WITHOUT_BORDER_TEST(coverageVisibleRectIntersectsTiles);
 209
 210 WITH_AND_WITHOUT_BORDER_TEST(coverageVisibleRectIntersectsBounds);
 211
 212 TEST_F(TiledLayerImplTest, textureInfoForLayerNoBorders)
 213 {
 214     gfx::Size tileSize(50, 50);
 215     gfx::Size layerSize(250, 250);
 216     QuadList quads;
 217     SharedQuadStateList sharedStates;
 218     getQuads(quads, sharedStates, tileSize, layerSize, LayerTilingData::NoBorderTexels, gfx::Rect(gfx::Point(), layerSize));
 219
 220     for (size_t i = 0; i < quads.size(); ++i) {
 221         const TileDrawQuad* quad = TileDrawQuad::MaterialCast(quads[i]);
 222
 223         EXPECT_NE(0u, quad->resource_id) << LayerTestCommon::quadString << i;
 224         EXPECT_EQ(gfx::RectF(gfx::PointF(), tileSize), quad->tex_coord_rect) << LayerTestCommon::quadString << i;
 225         EXPECT_EQ(tileSize, quad->texture_size) << LayerTestCommon::quadString << i;
 226         EXPECT_EQ(gfx::Rect(0, 0, 1, 1), quad->opaque_rect) << LayerTestCommon::quadString << i;
 227     }
 228 }
 229
 230 }  // namespace
 231 }  // namespace cc