| OLD | NEW |
|---|
| (Empty) |
| 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/layer_iterator.h" | |
| 6 | |
| 7 #include "cc/layer.h" | |
| 8 #include "cc/trees/layer_tree_host_common.h" | |
| 9 #include "testing/gmock/include/gmock/gmock.h" | |
| 10 #include "testing/gtest/include/gtest/gtest.h" | |
| 11 #include "ui/gfx/transform.h" | |
| 12 | |
| 13 using ::testing::Mock; | |
| 14 using ::testing::_; | |
| 15 using ::testing::AtLeast; | |
| 16 using ::testing::AnyNumber; | |
| 17 | |
| 18 namespace cc { | |
| 19 namespace { | |
| 20 | |
| 21 class TestLayer : public Layer { | |
| 22 public: | |
| 23 static scoped_refptr<TestLayer> Create() { return make_scoped_refptr(new Tes
tLayer()); } | |
| 24 | |
| 25 int m_countRepresentingTargetSurface; | |
| 26 int m_countRepresentingContributingSurface; | |
| 27 int m_countRepresentingItself; | |
| 28 | |
| 29 virtual bool DrawsContent() const OVERRIDE { return m_drawsContent; } | |
| 30 void setDrawsContent(bool drawsContent) { m_drawsContent = drawsContent; } | |
| 31 | |
| 32 private: | |
| 33 TestLayer() | |
| 34 : Layer() | |
| 35 , m_drawsContent(true) | |
| 36 { | |
| 37 SetBounds(gfx::Size(100, 100)); | |
| 38 SetPosition(gfx::Point()); | |
| 39 SetAnchorPoint(gfx::Point()); | |
| 40 } | |
| 41 virtual ~TestLayer() | |
| 42 { | |
| 43 } | |
| 44 | |
| 45 bool m_drawsContent; | |
| 46 }; | |
| 47 | |
| 48 #define EXPECT_COUNT(layer, target, contrib, itself) \ | |
| 49 EXPECT_EQ(target, layer->m_countRepresentingTargetSurface); \ | |
| 50 EXPECT_EQ(contrib, layer->m_countRepresentingContributingSurface); \ | |
| 51 EXPECT_EQ(itself, layer->m_countRepresentingItself); | |
| 52 | |
| 53 typedef LayerIterator<Layer, std::vector<scoped_refptr<Layer> >, RenderSurface,
LayerIteratorActions::FrontToBack> FrontToBack; | |
| 54 typedef LayerIterator<Layer, std::vector<scoped_refptr<Layer> >, RenderSurface,
LayerIteratorActions::BackToFront> BackToFront; | |
| 55 | |
| 56 void resetCounts(std::vector<scoped_refptr<Layer> >& renderSurfaceLayerList) | |
| 57 { | |
| 58 for (unsigned surfaceIndex = 0; surfaceIndex < renderSurfaceLayerList.size()
; ++surfaceIndex) { | |
| 59 TestLayer* renderSurfaceLayer = static_cast<TestLayer*>(renderSurfaceLay
erList[surfaceIndex].get()); | |
| 60 RenderSurface* renderSurface = renderSurfaceLayer->render_surface(); | |
| 61 | |
| 62 renderSurfaceLayer->m_countRepresentingTargetSurface = -1; | |
| 63 renderSurfaceLayer->m_countRepresentingContributingSurface = -1; | |
| 64 renderSurfaceLayer->m_countRepresentingItself = -1; | |
| 65 | |
| 66 for (unsigned layerIndex = 0; layerIndex < renderSurface->layer_list().s
ize(); ++layerIndex) { | |
| 67 TestLayer* layer = static_cast<TestLayer*>(renderSurface->layer_list
()[layerIndex].get()); | |
| 68 | |
| 69 layer->m_countRepresentingTargetSurface = -1; | |
| 70 layer->m_countRepresentingContributingSurface = -1; | |
| 71 layer->m_countRepresentingItself = -1; | |
| 72 } | |
| 73 } | |
| 74 } | |
| 75 | |
| 76 void iterateFrontToBack(std::vector<scoped_refptr<Layer> >* renderSurfaceLayerLi
st) | |
| 77 { | |
| 78 resetCounts(*renderSurfaceLayerList); | |
| 79 int count = 0; | |
| 80 for (FrontToBack it = FrontToBack::begin(renderSurfaceLayerList); it != Fron
tToBack::end(renderSurfaceLayerList); ++it, ++count) { | |
| 81 TestLayer* layer = static_cast<TestLayer*>(*it); | |
| 82 if (it.representsTargetRenderSurface()) | |
| 83 layer->m_countRepresentingTargetSurface = count; | |
| 84 if (it.representsContributingRenderSurface()) | |
| 85 layer->m_countRepresentingContributingSurface = count; | |
| 86 if (it.representsItself()) | |
| 87 layer->m_countRepresentingItself = count; | |
| 88 } | |
| 89 } | |
| 90 | |
| 91 void iterateBackToFront(std::vector<scoped_refptr<Layer> >* renderSurfaceLayerLi
st) | |
| 92 { | |
| 93 resetCounts(*renderSurfaceLayerList); | |
| 94 int count = 0; | |
| 95 for (BackToFront it = BackToFront::begin(renderSurfaceLayerList); it != Back
ToFront::end(renderSurfaceLayerList); ++it, ++count) { | |
| 96 TestLayer* layer = static_cast<TestLayer*>(*it); | |
| 97 if (it.representsTargetRenderSurface()) | |
| 98 layer->m_countRepresentingTargetSurface = count; | |
| 99 if (it.representsContributingRenderSurface()) | |
| 100 layer->m_countRepresentingContributingSurface = count; | |
| 101 if (it.representsItself()) | |
| 102 layer->m_countRepresentingItself = count; | |
| 103 } | |
| 104 } | |
| 105 | |
| 106 TEST(LayerIteratorTest, emptyTree) | |
| 107 { | |
| 108 std::vector<scoped_refptr<Layer> > renderSurfaceLayerList; | |
| 109 | |
| 110 iterateBackToFront(&renderSurfaceLayerList); | |
| 111 iterateFrontToBack(&renderSurfaceLayerList); | |
| 112 } | |
| 113 | |
| 114 TEST(LayerIteratorTest, simpleTree) | |
| 115 { | |
| 116 scoped_refptr<TestLayer> rootLayer = TestLayer::Create(); | |
| 117 scoped_refptr<TestLayer> first = TestLayer::Create(); | |
| 118 scoped_refptr<TestLayer> second = TestLayer::Create(); | |
| 119 scoped_refptr<TestLayer> third = TestLayer::Create(); | |
| 120 scoped_refptr<TestLayer> fourth = TestLayer::Create(); | |
| 121 | |
| 122 rootLayer->CreateRenderSurface(); | |
| 123 | |
| 124 rootLayer->AddChild(first); | |
| 125 rootLayer->AddChild(second); | |
| 126 rootLayer->AddChild(third); | |
| 127 rootLayer->AddChild(fourth); | |
| 128 | |
| 129 std::vector<scoped_refptr<Layer> > renderSurfaceLayerList; | |
| 130 LayerTreeHostCommon::calculateDrawProperties(rootLayer.get(), rootLayer->bou
nds(), 1, 1, 256, false, renderSurfaceLayerList); | |
| 131 | |
| 132 iterateBackToFront(&renderSurfaceLayerList); | |
| 133 EXPECT_COUNT(rootLayer, 0, -1, 1); | |
| 134 EXPECT_COUNT(first, -1, -1, 2); | |
| 135 EXPECT_COUNT(second, -1, -1, 3); | |
| 136 EXPECT_COUNT(third, -1, -1, 4); | |
| 137 EXPECT_COUNT(fourth, -1, -1, 5); | |
| 138 | |
| 139 iterateFrontToBack(&renderSurfaceLayerList); | |
| 140 EXPECT_COUNT(rootLayer, 5, -1, 4); | |
| 141 EXPECT_COUNT(first, -1, -1, 3); | |
| 142 EXPECT_COUNT(second, -1, -1, 2); | |
| 143 EXPECT_COUNT(third, -1, -1, 1); | |
| 144 EXPECT_COUNT(fourth, -1, -1, 0); | |
| 145 | |
| 146 } | |
| 147 | |
| 148 TEST(LayerIteratorTest, complexTree) | |
| 149 { | |
| 150 scoped_refptr<TestLayer> rootLayer = TestLayer::Create(); | |
| 151 scoped_refptr<TestLayer> root1 = TestLayer::Create(); | |
| 152 scoped_refptr<TestLayer> root2 = TestLayer::Create(); | |
| 153 scoped_refptr<TestLayer> root3 = TestLayer::Create(); | |
| 154 scoped_refptr<TestLayer> root21 = TestLayer::Create(); | |
| 155 scoped_refptr<TestLayer> root22 = TestLayer::Create(); | |
| 156 scoped_refptr<TestLayer> root23 = TestLayer::Create(); | |
| 157 scoped_refptr<TestLayer> root221 = TestLayer::Create(); | |
| 158 scoped_refptr<TestLayer> root231 = TestLayer::Create(); | |
| 159 | |
| 160 rootLayer->CreateRenderSurface(); | |
| 161 | |
| 162 rootLayer->AddChild(root1); | |
| 163 rootLayer->AddChild(root2); | |
| 164 rootLayer->AddChild(root3); | |
| 165 root2->AddChild(root21); | |
| 166 root2->AddChild(root22); | |
| 167 root2->AddChild(root23); | |
| 168 root22->AddChild(root221); | |
| 169 root23->AddChild(root231); | |
| 170 | |
| 171 std::vector<scoped_refptr<Layer> > renderSurfaceLayerList; | |
| 172 LayerTreeHostCommon::calculateDrawProperties(rootLayer.get(), rootLayer->bou
nds(), 1, 1, 256, false, renderSurfaceLayerList); | |
| 173 | |
| 174 iterateBackToFront(&renderSurfaceLayerList); | |
| 175 EXPECT_COUNT(rootLayer, 0, -1, 1); | |
| 176 EXPECT_COUNT(root1, -1, -1, 2); | |
| 177 EXPECT_COUNT(root2, -1, -1, 3); | |
| 178 EXPECT_COUNT(root21, -1, -1, 4); | |
| 179 EXPECT_COUNT(root22, -1, -1, 5); | |
| 180 EXPECT_COUNT(root221, -1, -1, 6); | |
| 181 EXPECT_COUNT(root23, -1, -1, 7); | |
| 182 EXPECT_COUNT(root231, -1, -1, 8); | |
| 183 EXPECT_COUNT(root3, -1, -1, 9); | |
| 184 | |
| 185 iterateFrontToBack(&renderSurfaceLayerList); | |
| 186 EXPECT_COUNT(rootLayer, 9, -1, 8); | |
| 187 EXPECT_COUNT(root1, -1, -1, 7); | |
| 188 EXPECT_COUNT(root2, -1, -1, 6); | |
| 189 EXPECT_COUNT(root21, -1, -1, 5); | |
| 190 EXPECT_COUNT(root22, -1, -1, 4); | |
| 191 EXPECT_COUNT(root221, -1, -1, 3); | |
| 192 EXPECT_COUNT(root23, -1, -1, 2); | |
| 193 EXPECT_COUNT(root231, -1, -1, 1); | |
| 194 EXPECT_COUNT(root3, -1, -1, 0); | |
| 195 | |
| 196 } | |
| 197 | |
| 198 TEST(LayerIteratorTest, complexTreeMultiSurface) | |
| 199 { | |
| 200 scoped_refptr<TestLayer> rootLayer = TestLayer::Create(); | |
| 201 scoped_refptr<TestLayer> root1 = TestLayer::Create(); | |
| 202 scoped_refptr<TestLayer> root2 = TestLayer::Create(); | |
| 203 scoped_refptr<TestLayer> root3 = TestLayer::Create(); | |
| 204 scoped_refptr<TestLayer> root21 = TestLayer::Create(); | |
| 205 scoped_refptr<TestLayer> root22 = TestLayer::Create(); | |
| 206 scoped_refptr<TestLayer> root23 = TestLayer::Create(); | |
| 207 scoped_refptr<TestLayer> root221 = TestLayer::Create(); | |
| 208 scoped_refptr<TestLayer> root231 = TestLayer::Create(); | |
| 209 | |
| 210 rootLayer->CreateRenderSurface(); | |
| 211 rootLayer->render_surface()->SetContentRect(gfx::Rect(gfx::Point(), rootLaye
r->bounds())); | |
| 212 | |
| 213 rootLayer->AddChild(root1); | |
| 214 rootLayer->AddChild(root2); | |
| 215 rootLayer->AddChild(root3); | |
| 216 root2->setDrawsContent(false); | |
| 217 root2->SetOpacity(0.5); | |
| 218 root2->SetForceRenderSurface(true); // Force the layer to own a new surface. | |
| 219 root2->AddChild(root21); | |
| 220 root2->AddChild(root22); | |
| 221 root2->AddChild(root23); | |
| 222 root22->SetOpacity(0.5); | |
| 223 root22->AddChild(root221); | |
| 224 root23->SetOpacity(0.5); | |
| 225 root23->AddChild(root231); | |
| 226 | |
| 227 std::vector<scoped_refptr<Layer> > renderSurfaceLayerList; | |
| 228 LayerTreeHostCommon::calculateDrawProperties(rootLayer.get(), rootLayer->bou
nds(), 1, 1, 256, false, renderSurfaceLayerList); | |
| 229 | |
| 230 iterateBackToFront(&renderSurfaceLayerList); | |
| 231 EXPECT_COUNT(rootLayer, 0, -1, 1); | |
| 232 EXPECT_COUNT(root1, -1, -1, 2); | |
| 233 EXPECT_COUNT(root2, 4, 3, -1); | |
| 234 EXPECT_COUNT(root21, -1, -1, 5); | |
| 235 EXPECT_COUNT(root22, 7, 6, 8); | |
| 236 EXPECT_COUNT(root221, -1, -1, 9); | |
| 237 EXPECT_COUNT(root23, 11, 10, 12); | |
| 238 EXPECT_COUNT(root231, -1, -1, 13); | |
| 239 EXPECT_COUNT(root3, -1, -1, 14); | |
| 240 | |
| 241 iterateFrontToBack(&renderSurfaceLayerList); | |
| 242 EXPECT_COUNT(rootLayer, 14, -1, 13); | |
| 243 EXPECT_COUNT(root1, -1, -1, 12); | |
| 244 EXPECT_COUNT(root2, 10, 11, -1); | |
| 245 EXPECT_COUNT(root21, -1, -1, 9); | |
| 246 EXPECT_COUNT(root22, 7, 8, 6); | |
| 247 EXPECT_COUNT(root221, -1, -1, 5); | |
| 248 EXPECT_COUNT(root23, 3, 4, 2); | |
| 249 EXPECT_COUNT(root231, -1, -1, 1); | |
| 250 EXPECT_COUNT(root3, -1, -1, 0); | |
| 251 } | |
| 252 | |
| 253 } // namespace | |
| 254 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 12603013:
Part 10 of cc/ directory shuffles: layers (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src