OLD | NEW |
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/trees/layer_tree_host.h" | 5 #include "cc/trees/layer_tree_host.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/callback.h" | 8 #include "base/callback.h" |
9 #include "base/location.h" | 9 #include "base/location.h" |
10 #include "base/message_loop/message_loop_proxy.h" | 10 #include "base/message_loop/message_loop_proxy.h" |
11 #include "base/time/time.h" | 11 #include "base/time/time.h" |
12 #include "cc/test/fake_content_layer.h" | 12 #include "cc/test/fake_content_layer.h" |
13 #include "cc/test/fake_content_layer_client.h" | 13 #include "cc/test/fake_content_layer_client.h" |
14 #include "cc/test/fake_painted_scrollbar_layer.h" | 14 #include "cc/test/fake_painted_scrollbar_layer.h" |
15 #include "cc/test/fake_picture_layer.h" | 15 #include "cc/test/fake_picture_layer.h" |
16 #include "cc/test/layer_tree_test.h" | 16 #include "cc/test/layer_tree_test.h" |
17 #include "cc/trees/damage_tracker.h" | 17 #include "cc/trees/damage_tracker.h" |
18 #include "cc/trees/layer_tree_impl.h" | 18 #include "cc/trees/layer_tree_impl.h" |
19 | 19 |
20 namespace cc { | 20 namespace cc { |
21 namespace { | 21 namespace { |
22 | 22 |
23 // These tests deal with damage tracking. | 23 // These tests deal with damage tracking. |
24 class LayerTreeHostDamageTest : public LayerTreeTest {}; | 24 class LayerTreeHostDamageTest : public LayerTreeTest {}; |
25 | 25 |
26 // LayerTreeHost::SetNeedsRedraw should damage the whole viewport. | 26 // LayerTreeHost::SetNeedsRedraw should damage the whole viewport. |
27 class LayerTreeHostDamageTestSetNeedsRedraw | 27 class LayerTreeHostDamageTestSetNeedsRedraw |
28 : public LayerTreeHostDamageTest { | 28 : public LayerTreeHostDamageTest { |
29 virtual void SetupTree() OVERRIDE { | 29 virtual void SetupTree() override { |
30 // Viewport is 10x10. | 30 // Viewport is 10x10. |
31 scoped_refptr<FakeContentLayer> root = FakeContentLayer::Create(&client_); | 31 scoped_refptr<FakeContentLayer> root = FakeContentLayer::Create(&client_); |
32 root->SetBounds(gfx::Size(10, 10)); | 32 root->SetBounds(gfx::Size(10, 10)); |
33 | 33 |
34 layer_tree_host()->SetRootLayer(root); | 34 layer_tree_host()->SetRootLayer(root); |
35 LayerTreeHostDamageTest::SetupTree(); | 35 LayerTreeHostDamageTest::SetupTree(); |
36 } | 36 } |
37 | 37 |
38 virtual void BeginTest() OVERRIDE { | 38 virtual void BeginTest() override { |
39 draw_count_ = 0; | 39 draw_count_ = 0; |
40 PostSetNeedsCommitToMainThread(); | 40 PostSetNeedsCommitToMainThread(); |
41 } | 41 } |
42 | 42 |
43 virtual void DidCommitAndDrawFrame() OVERRIDE { | 43 virtual void DidCommitAndDrawFrame() override { |
44 switch (layer_tree_host()->source_frame_number()) { | 44 switch (layer_tree_host()->source_frame_number()) { |
45 case 1: | 45 case 1: |
46 layer_tree_host()->SetNeedsRedraw(); | 46 layer_tree_host()->SetNeedsRedraw(); |
47 break; | 47 break; |
48 } | 48 } |
49 } | 49 } |
50 | 50 |
51 virtual DrawResult PrepareToDrawOnThread( | 51 virtual DrawResult PrepareToDrawOnThread( |
52 LayerTreeHostImpl* impl, | 52 LayerTreeHostImpl* impl, |
53 LayerTreeHostImpl::FrameData* frame_data, | 53 LayerTreeHostImpl::FrameData* frame_data, |
54 DrawResult draw_result) OVERRIDE { | 54 DrawResult draw_result) override { |
55 EXPECT_EQ(DRAW_SUCCESS, draw_result); | 55 EXPECT_EQ(DRAW_SUCCESS, draw_result); |
56 | 56 |
57 RenderSurfaceImpl* root_surface = | 57 RenderSurfaceImpl* root_surface = |
58 impl->active_tree()->root_layer()->render_surface(); | 58 impl->active_tree()->root_layer()->render_surface(); |
59 gfx::RectF root_damage = | 59 gfx::RectF root_damage = |
60 root_surface->damage_tracker()->current_damage_rect(); | 60 root_surface->damage_tracker()->current_damage_rect(); |
61 | 61 |
62 switch (draw_count_) { | 62 switch (draw_count_) { |
63 case 0: | 63 case 0: |
64 // The first frame has full damage. | 64 // The first frame has full damage. |
65 EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString()); | 65 EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString()); |
66 break; | 66 break; |
67 case 1: | 67 case 1: |
68 // The second frame has full damage. | 68 // The second frame has full damage. |
69 EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString()); | 69 EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString()); |
70 EndTest(); | 70 EndTest(); |
71 break; | 71 break; |
72 case 2: | 72 case 2: |
73 NOTREACHED(); | 73 NOTREACHED(); |
74 } | 74 } |
75 | 75 |
76 ++draw_count_; | 76 ++draw_count_; |
77 return draw_result; | 77 return draw_result; |
78 } | 78 } |
79 | 79 |
80 virtual void AfterTest() OVERRIDE {} | 80 virtual void AfterTest() override {} |
81 | 81 |
82 int draw_count_; | 82 int draw_count_; |
83 FakeContentLayerClient client_; | 83 FakeContentLayerClient client_; |
84 }; | 84 }; |
85 | 85 |
86 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDamageTestSetNeedsRedraw); | 86 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDamageTestSetNeedsRedraw); |
87 | 87 |
88 // LayerTreeHost::SetViewportSize should damage the whole viewport. | 88 // LayerTreeHost::SetViewportSize should damage the whole viewport. |
89 class LayerTreeHostDamageTestSetViewportSize | 89 class LayerTreeHostDamageTestSetViewportSize |
90 : public LayerTreeHostDamageTest { | 90 : public LayerTreeHostDamageTest { |
91 virtual void SetupTree() OVERRIDE { | 91 virtual void SetupTree() override { |
92 // Viewport is 10x10. | 92 // Viewport is 10x10. |
93 scoped_refptr<FakeContentLayer> root = FakeContentLayer::Create(&client_); | 93 scoped_refptr<FakeContentLayer> root = FakeContentLayer::Create(&client_); |
94 root->SetBounds(gfx::Size(10, 10)); | 94 root->SetBounds(gfx::Size(10, 10)); |
95 | 95 |
96 layer_tree_host()->SetRootLayer(root); | 96 layer_tree_host()->SetRootLayer(root); |
97 LayerTreeHostDamageTest::SetupTree(); | 97 LayerTreeHostDamageTest::SetupTree(); |
98 } | 98 } |
99 | 99 |
100 virtual void BeginTest() OVERRIDE { | 100 virtual void BeginTest() override { |
101 draw_count_ = 0; | 101 draw_count_ = 0; |
102 PostSetNeedsCommitToMainThread(); | 102 PostSetNeedsCommitToMainThread(); |
103 } | 103 } |
104 | 104 |
105 virtual void DidCommitAndDrawFrame() OVERRIDE { | 105 virtual void DidCommitAndDrawFrame() override { |
106 switch (layer_tree_host()->source_frame_number()) { | 106 switch (layer_tree_host()->source_frame_number()) { |
107 case 1: | 107 case 1: |
108 layer_tree_host()->SetViewportSize(gfx::Size(15, 15)); | 108 layer_tree_host()->SetViewportSize(gfx::Size(15, 15)); |
109 break; | 109 break; |
110 } | 110 } |
111 } | 111 } |
112 | 112 |
113 virtual DrawResult PrepareToDrawOnThread( | 113 virtual DrawResult PrepareToDrawOnThread( |
114 LayerTreeHostImpl* impl, | 114 LayerTreeHostImpl* impl, |
115 LayerTreeHostImpl::FrameData* frame_data, | 115 LayerTreeHostImpl::FrameData* frame_data, |
116 DrawResult draw_result) OVERRIDE { | 116 DrawResult draw_result) override { |
117 EXPECT_EQ(DRAW_SUCCESS, draw_result); | 117 EXPECT_EQ(DRAW_SUCCESS, draw_result); |
118 | 118 |
119 RenderSurfaceImpl* root_surface = | 119 RenderSurfaceImpl* root_surface = |
120 impl->active_tree()->root_layer()->render_surface(); | 120 impl->active_tree()->root_layer()->render_surface(); |
121 gfx::RectF root_damage = | 121 gfx::RectF root_damage = |
122 root_surface->damage_tracker()->current_damage_rect(); | 122 root_surface->damage_tracker()->current_damage_rect(); |
123 | 123 |
124 switch (draw_count_) { | 124 switch (draw_count_) { |
125 case 0: | 125 case 0: |
126 // The first frame has full damage. | 126 // The first frame has full damage. |
127 EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString()); | 127 EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString()); |
128 break; | 128 break; |
129 case 1: | 129 case 1: |
130 // The second frame has full damage. | 130 // The second frame has full damage. |
131 EXPECT_EQ(gfx::RectF(15.f, 15.f).ToString(), root_damage.ToString()); | 131 EXPECT_EQ(gfx::RectF(15.f, 15.f).ToString(), root_damage.ToString()); |
132 EndTest(); | 132 EndTest(); |
133 break; | 133 break; |
134 case 2: | 134 case 2: |
135 NOTREACHED(); | 135 NOTREACHED(); |
136 } | 136 } |
137 | 137 |
138 ++draw_count_; | 138 ++draw_count_; |
139 return draw_result; | 139 return draw_result; |
140 } | 140 } |
141 | 141 |
142 virtual void AfterTest() OVERRIDE {} | 142 virtual void AfterTest() override {} |
143 | 143 |
144 int draw_count_; | 144 int draw_count_; |
145 FakeContentLayerClient client_; | 145 FakeContentLayerClient client_; |
146 }; | 146 }; |
147 | 147 |
148 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDamageTestSetViewportSize); | 148 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDamageTestSetViewportSize); |
149 | 149 |
150 class LayerTreeHostDamageTestNoDamageDoesNotSwap | 150 class LayerTreeHostDamageTestNoDamageDoesNotSwap |
151 : public LayerTreeHostDamageTest { | 151 : public LayerTreeHostDamageTest { |
152 virtual void BeginTest() OVERRIDE { | 152 virtual void BeginTest() override { |
153 expect_swap_and_succeed_ = 0; | 153 expect_swap_and_succeed_ = 0; |
154 did_swaps_ = 0; | 154 did_swaps_ = 0; |
155 did_swap_and_succeed_ = 0; | 155 did_swap_and_succeed_ = 0; |
156 PostSetNeedsCommitToMainThread(); | 156 PostSetNeedsCommitToMainThread(); |
157 } | 157 } |
158 | 158 |
159 virtual void SetupTree() OVERRIDE { | 159 virtual void SetupTree() override { |
160 scoped_refptr<FakeContentLayer> root = FakeContentLayer::Create(&client_); | 160 scoped_refptr<FakeContentLayer> root = FakeContentLayer::Create(&client_); |
161 root->SetBounds(gfx::Size(10, 10)); | 161 root->SetBounds(gfx::Size(10, 10)); |
162 | 162 |
163 // Most of the layer isn't visible. | 163 // Most of the layer isn't visible. |
164 content_ = FakeContentLayer::Create(&client_); | 164 content_ = FakeContentLayer::Create(&client_); |
165 content_->SetBounds(gfx::Size(2000, 100)); | 165 content_->SetBounds(gfx::Size(2000, 100)); |
166 root->AddChild(content_); | 166 root->AddChild(content_); |
167 | 167 |
168 layer_tree_host()->SetRootLayer(root); | 168 layer_tree_host()->SetRootLayer(root); |
169 LayerTreeHostDamageTest::SetupTree(); | 169 LayerTreeHostDamageTest::SetupTree(); |
170 } | 170 } |
171 | 171 |
172 virtual DrawResult PrepareToDrawOnThread( | 172 virtual DrawResult PrepareToDrawOnThread( |
173 LayerTreeHostImpl* host_impl, | 173 LayerTreeHostImpl* host_impl, |
174 LayerTreeHostImpl::FrameData* frame_data, | 174 LayerTreeHostImpl::FrameData* frame_data, |
175 DrawResult draw_result) OVERRIDE { | 175 DrawResult draw_result) override { |
176 EXPECT_EQ(DRAW_SUCCESS, draw_result); | 176 EXPECT_EQ(DRAW_SUCCESS, draw_result); |
177 | 177 |
178 int source_frame = host_impl->active_tree()->source_frame_number(); | 178 int source_frame = host_impl->active_tree()->source_frame_number(); |
179 switch (source_frame) { | 179 switch (source_frame) { |
180 case 0: | 180 case 0: |
181 // The first frame has damage, so we should draw and swap. | 181 // The first frame has damage, so we should draw and swap. |
182 ++expect_swap_and_succeed_; | 182 ++expect_swap_and_succeed_; |
183 break; | 183 break; |
184 case 1: | 184 case 1: |
185 // The second frame has no damage, so we should not draw and swap. | 185 // The second frame has no damage, so we should not draw and swap. |
186 break; | 186 break; |
187 case 2: | 187 case 2: |
188 // The third frame has damage again, so we should draw and swap. | 188 // The third frame has damage again, so we should draw and swap. |
189 ++expect_swap_and_succeed_; | 189 ++expect_swap_and_succeed_; |
190 break; | 190 break; |
191 case 3: | 191 case 3: |
192 // The fourth frame has no visible damage, so we should not draw and | 192 // The fourth frame has no visible damage, so we should not draw and |
193 // swap. | 193 // swap. |
194 EndTest(); | 194 EndTest(); |
195 break; | 195 break; |
196 } | 196 } |
197 return draw_result; | 197 return draw_result; |
198 } | 198 } |
199 | 199 |
200 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, | 200 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, |
201 bool result) OVERRIDE { | 201 bool result) override { |
202 ++did_swaps_; | 202 ++did_swaps_; |
203 if (result) | 203 if (result) |
204 ++did_swap_and_succeed_; | 204 ++did_swap_and_succeed_; |
205 EXPECT_EQ(expect_swap_and_succeed_, did_swap_and_succeed_); | 205 EXPECT_EQ(expect_swap_and_succeed_, did_swap_and_succeed_); |
206 } | 206 } |
207 | 207 |
208 virtual void DidCommit() OVERRIDE { | 208 virtual void DidCommit() override { |
209 int next_frame = layer_tree_host()->source_frame_number(); | 209 int next_frame = layer_tree_host()->source_frame_number(); |
210 switch (next_frame) { | 210 switch (next_frame) { |
211 case 1: | 211 case 1: |
212 layer_tree_host()->SetNeedsCommit(); | 212 layer_tree_host()->SetNeedsCommit(); |
213 break; | 213 break; |
214 case 2: | 214 case 2: |
215 // Cause visible damage. | 215 // Cause visible damage. |
216 content_->SetNeedsDisplayRect( | 216 content_->SetNeedsDisplayRect( |
217 gfx::Rect(layer_tree_host()->device_viewport_size())); | 217 gfx::Rect(layer_tree_host()->device_viewport_size())); |
218 break; | 218 break; |
219 case 3: | 219 case 3: |
220 // Cause non-visible damage. | 220 // Cause non-visible damage. |
221 content_->SetNeedsDisplayRect(gfx::Rect(1990, 1990, 10, 10)); | 221 content_->SetNeedsDisplayRect(gfx::Rect(1990, 1990, 10, 10)); |
222 layer_tree_host()->SetNeedsCommit(); | 222 layer_tree_host()->SetNeedsCommit(); |
223 break; | 223 break; |
224 } | 224 } |
225 } | 225 } |
226 | 226 |
227 virtual void AfterTest() OVERRIDE { | 227 virtual void AfterTest() override { |
228 EXPECT_EQ(4, did_swaps_); | 228 EXPECT_EQ(4, did_swaps_); |
229 EXPECT_EQ(2, expect_swap_and_succeed_); | 229 EXPECT_EQ(2, expect_swap_and_succeed_); |
230 EXPECT_EQ(expect_swap_and_succeed_, did_swap_and_succeed_); | 230 EXPECT_EQ(expect_swap_and_succeed_, did_swap_and_succeed_); |
231 } | 231 } |
232 | 232 |
233 FakeContentLayerClient client_; | 233 FakeContentLayerClient client_; |
234 scoped_refptr<FakeContentLayer> content_; | 234 scoped_refptr<FakeContentLayer> content_; |
235 int expect_swap_and_succeed_; | 235 int expect_swap_and_succeed_; |
236 int did_swaps_; | 236 int did_swaps_; |
237 int did_swap_and_succeed_; | 237 int did_swap_and_succeed_; |
238 }; | 238 }; |
239 | 239 |
240 SINGLE_AND_MULTI_THREAD_NOIMPL_TEST_F( | 240 SINGLE_AND_MULTI_THREAD_NOIMPL_TEST_F( |
241 LayerTreeHostDamageTestNoDamageDoesNotSwap); | 241 LayerTreeHostDamageTestNoDamageDoesNotSwap); |
242 | 242 |
243 class LayerTreeHostDamageTestForcedFullDamage : public LayerTreeHostDamageTest { | 243 class LayerTreeHostDamageTestForcedFullDamage : public LayerTreeHostDamageTest { |
244 virtual void BeginTest() OVERRIDE { | 244 virtual void BeginTest() override { |
245 PostSetNeedsCommitToMainThread(); | 245 PostSetNeedsCommitToMainThread(); |
246 } | 246 } |
247 | 247 |
248 virtual void SetupTree() OVERRIDE { | 248 virtual void SetupTree() override { |
249 root_ = FakeContentLayer::Create(&client_); | 249 root_ = FakeContentLayer::Create(&client_); |
250 child_ = FakeContentLayer::Create(&client_); | 250 child_ = FakeContentLayer::Create(&client_); |
251 | 251 |
252 root_->SetBounds(gfx::Size(500, 500)); | 252 root_->SetBounds(gfx::Size(500, 500)); |
253 child_->SetPosition(gfx::Point(100, 100)); | 253 child_->SetPosition(gfx::Point(100, 100)); |
254 child_->SetBounds(gfx::Size(30, 30)); | 254 child_->SetBounds(gfx::Size(30, 30)); |
255 | 255 |
256 root_->AddChild(child_); | 256 root_->AddChild(child_); |
257 layer_tree_host()->SetRootLayer(root_); | 257 layer_tree_host()->SetRootLayer(root_); |
258 LayerTreeHostDamageTest::SetupTree(); | 258 LayerTreeHostDamageTest::SetupTree(); |
259 } | 259 } |
260 | 260 |
261 virtual DrawResult PrepareToDrawOnThread( | 261 virtual DrawResult PrepareToDrawOnThread( |
262 LayerTreeHostImpl* host_impl, | 262 LayerTreeHostImpl* host_impl, |
263 LayerTreeHostImpl::FrameData* frame_data, | 263 LayerTreeHostImpl::FrameData* frame_data, |
264 DrawResult draw_result) OVERRIDE { | 264 DrawResult draw_result) override { |
265 EXPECT_EQ(DRAW_SUCCESS, draw_result); | 265 EXPECT_EQ(DRAW_SUCCESS, draw_result); |
266 | 266 |
267 RenderSurfaceImpl* root_surface = | 267 RenderSurfaceImpl* root_surface = |
268 host_impl->active_tree()->root_layer()->render_surface(); | 268 host_impl->active_tree()->root_layer()->render_surface(); |
269 gfx::RectF root_damage = | 269 gfx::RectF root_damage = |
270 root_surface->damage_tracker()->current_damage_rect(); | 270 root_surface->damage_tracker()->current_damage_rect(); |
271 root_damage.Intersect(root_surface->content_rect()); | 271 root_damage.Intersect(root_surface->content_rect()); |
272 | 272 |
273 int source_frame = host_impl->active_tree()->source_frame_number(); | 273 int source_frame = host_impl->active_tree()->source_frame_number(); |
274 switch (source_frame) { | 274 switch (source_frame) { |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
327 EXPECT_EQ(gfx::RectF(root_surface->content_rect()).ToString(), | 327 EXPECT_EQ(gfx::RectF(root_surface->content_rect()).ToString(), |
328 root_damage.ToString()); | 328 root_damage.ToString()); |
329 EXPECT_FALSE(frame_data->has_no_damage); | 329 EXPECT_FALSE(frame_data->has_no_damage); |
330 | 330 |
331 EndTest(); | 331 EndTest(); |
332 break; | 332 break; |
333 } | 333 } |
334 return draw_result; | 334 return draw_result; |
335 } | 335 } |
336 | 336 |
337 virtual void DidCommitAndDrawFrame() OVERRIDE { | 337 virtual void DidCommitAndDrawFrame() override { |
338 if (!TestEnded()) | 338 if (!TestEnded()) |
339 layer_tree_host()->SetNeedsCommit(); | 339 layer_tree_host()->SetNeedsCommit(); |
340 | 340 |
341 if (!child_damage_rect_.IsEmpty()) { | 341 if (!child_damage_rect_.IsEmpty()) { |
342 child_->SetNeedsDisplayRect(child_damage_rect_); | 342 child_->SetNeedsDisplayRect(child_damage_rect_); |
343 child_damage_rect_ = gfx::RectF(); | 343 child_damage_rect_ = gfx::RectF(); |
344 } | 344 } |
345 } | 345 } |
346 | 346 |
347 virtual void AfterTest() OVERRIDE {} | 347 virtual void AfterTest() override {} |
348 | 348 |
349 FakeContentLayerClient client_; | 349 FakeContentLayerClient client_; |
350 scoped_refptr<FakeContentLayer> root_; | 350 scoped_refptr<FakeContentLayer> root_; |
351 scoped_refptr<FakeContentLayer> child_; | 351 scoped_refptr<FakeContentLayer> child_; |
352 gfx::RectF child_damage_rect_; | 352 gfx::RectF child_damage_rect_; |
353 }; | 353 }; |
354 | 354 |
355 SINGLE_AND_MULTI_THREAD_NOIMPL_TEST_F(LayerTreeHostDamageTestForcedFullDamage); | 355 SINGLE_AND_MULTI_THREAD_NOIMPL_TEST_F(LayerTreeHostDamageTestForcedFullDamage); |
356 | 356 |
357 class LayerTreeHostScrollbarDamageTest : public LayerTreeHostDamageTest { | 357 class LayerTreeHostScrollbarDamageTest : public LayerTreeHostDamageTest { |
358 virtual void SetupTree() OVERRIDE { | 358 virtual void SetupTree() override { |
359 scoped_refptr<Layer> root_layer = Layer::Create(); | 359 scoped_refptr<Layer> root_layer = Layer::Create(); |
360 root_layer->SetBounds(gfx::Size(400, 400)); | 360 root_layer->SetBounds(gfx::Size(400, 400)); |
361 root_layer->SetMasksToBounds(true); | 361 root_layer->SetMasksToBounds(true); |
362 layer_tree_host()->SetRootLayer(root_layer); | 362 layer_tree_host()->SetRootLayer(root_layer); |
363 | 363 |
364 scoped_refptr<Layer> scroll_clip_layer = Layer::Create(); | 364 scoped_refptr<Layer> scroll_clip_layer = Layer::Create(); |
365 scoped_refptr<Layer> content_layer = FakeContentLayer::Create(&client_); | 365 scoped_refptr<Layer> content_layer = FakeContentLayer::Create(&client_); |
366 content_layer->SetScrollClipLayerId(scroll_clip_layer->id()); | 366 content_layer->SetScrollClipLayerId(scroll_clip_layer->id()); |
367 content_layer->SetScrollOffset(gfx::ScrollOffset(10, 20)); | 367 content_layer->SetScrollOffset(gfx::ScrollOffset(10, 20)); |
368 content_layer->SetBounds(gfx::Size(100, 200)); | 368 content_layer->SetBounds(gfx::Size(100, 200)); |
(...skipping 19 matching lines...) Expand all Loading... |
388 | 388 |
389 LayerTreeHostDamageTest::SetupTree(); | 389 LayerTreeHostDamageTest::SetupTree(); |
390 } | 390 } |
391 | 391 |
392 private: | 392 private: |
393 FakeContentLayerClient client_; | 393 FakeContentLayerClient client_; |
394 }; | 394 }; |
395 | 395 |
396 class LayerTreeHostDamageTestScrollbarDoesDamage | 396 class LayerTreeHostDamageTestScrollbarDoesDamage |
397 : public LayerTreeHostScrollbarDamageTest { | 397 : public LayerTreeHostScrollbarDamageTest { |
398 virtual void BeginTest() OVERRIDE { | 398 virtual void BeginTest() override { |
399 did_swaps_ = 0; | 399 did_swaps_ = 0; |
400 PostSetNeedsCommitToMainThread(); | 400 PostSetNeedsCommitToMainThread(); |
401 } | 401 } |
402 | 402 |
403 virtual DrawResult PrepareToDrawOnThread( | 403 virtual DrawResult PrepareToDrawOnThread( |
404 LayerTreeHostImpl* host_impl, | 404 LayerTreeHostImpl* host_impl, |
405 LayerTreeHostImpl::FrameData* frame_data, | 405 LayerTreeHostImpl::FrameData* frame_data, |
406 DrawResult draw_result) OVERRIDE { | 406 DrawResult draw_result) override { |
407 EXPECT_EQ(DRAW_SUCCESS, draw_result); | 407 EXPECT_EQ(DRAW_SUCCESS, draw_result); |
408 RenderSurfaceImpl* root_surface = | 408 RenderSurfaceImpl* root_surface = |
409 host_impl->active_tree()->root_layer()->render_surface(); | 409 host_impl->active_tree()->root_layer()->render_surface(); |
410 gfx::RectF root_damage = | 410 gfx::RectF root_damage = |
411 root_surface->damage_tracker()->current_damage_rect(); | 411 root_surface->damage_tracker()->current_damage_rect(); |
412 root_damage.Intersect(root_surface->content_rect()); | 412 root_damage.Intersect(root_surface->content_rect()); |
413 switch (did_swaps_) { | 413 switch (did_swaps_) { |
414 case 0: | 414 case 0: |
415 // The first frame has damage, so we should draw and swap. | 415 // The first frame has damage, so we should draw and swap. |
416 break; | 416 break; |
417 case 1: | 417 case 1: |
418 // The second frame should not damage the scrollbars. | 418 // The second frame should not damage the scrollbars. |
419 EXPECT_FALSE(root_damage.Intersects(gfx::Rect(300, 300, 10, 100))); | 419 EXPECT_FALSE(root_damage.Intersects(gfx::Rect(300, 300, 10, 100))); |
420 break; | 420 break; |
421 case 2: | 421 case 2: |
422 // The third frame should damage the scrollbars. | 422 // The third frame should damage the scrollbars. |
423 EXPECT_TRUE(root_damage.Contains(gfx::Rect(300, 300, 10, 100))); | 423 EXPECT_TRUE(root_damage.Contains(gfx::Rect(300, 300, 10, 100))); |
424 break; | 424 break; |
425 case 3: | 425 case 3: |
426 // The fourth frame should damage the scrollbars. | 426 // The fourth frame should damage the scrollbars. |
427 EXPECT_TRUE(root_damage.Contains(gfx::Rect(300, 300, 10, 100))); | 427 EXPECT_TRUE(root_damage.Contains(gfx::Rect(300, 300, 10, 100))); |
428 EndTest(); | 428 EndTest(); |
429 break; | 429 break; |
430 } | 430 } |
431 return draw_result; | 431 return draw_result; |
432 } | 432 } |
433 | 433 |
434 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, | 434 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, |
435 bool result) OVERRIDE { | 435 bool result) override { |
436 ++did_swaps_; | 436 ++did_swaps_; |
437 EXPECT_TRUE(result); | 437 EXPECT_TRUE(result); |
438 LayerImpl* root = host_impl->active_tree()->root_layer(); | 438 LayerImpl* root = host_impl->active_tree()->root_layer(); |
439 LayerImpl* scroll_clip_layer = root->children()[0]; | 439 LayerImpl* scroll_clip_layer = root->children()[0]; |
440 LayerImpl* scroll_layer = scroll_clip_layer->children()[0]; | 440 LayerImpl* scroll_layer = scroll_clip_layer->children()[0]; |
441 switch (did_swaps_) { | 441 switch (did_swaps_) { |
442 case 1: | 442 case 1: |
443 // Test that modifying the position of the content layer (not | 443 // Test that modifying the position of the content layer (not |
444 // scrolling) won't damage the scrollbar. | 444 // scrolling) won't damage the scrollbar. |
445 scroll_layer->SetPosition(gfx::Point(1, 1)); | 445 scroll_layer->SetPosition(gfx::Point(1, 1)); |
446 scroll_layer->SetScrollOffset(scroll_layer->scroll_offset()); | 446 scroll_layer->SetScrollOffset(scroll_layer->scroll_offset()); |
447 host_impl->SetNeedsRedraw(); | 447 host_impl->SetNeedsRedraw(); |
448 break; | 448 break; |
449 case 2: | 449 case 2: |
450 scroll_layer->ScrollBy(gfx::Vector2dF(10.f, 10.f)); | 450 scroll_layer->ScrollBy(gfx::Vector2dF(10.f, 10.f)); |
451 host_impl->SetNeedsRedraw(); | 451 host_impl->SetNeedsRedraw(); |
452 break; | 452 break; |
453 case 3: | 453 case 3: |
454 scroll_layer->SetBounds(gfx::Size(root->bounds().width() + 60, | 454 scroll_layer->SetBounds(gfx::Size(root->bounds().width() + 60, |
455 root->bounds().height() + 100)); | 455 root->bounds().height() + 100)); |
456 host_impl->SetNeedsRedraw(); | 456 host_impl->SetNeedsRedraw(); |
457 break; | 457 break; |
458 } | 458 } |
459 } | 459 } |
460 | 460 |
461 virtual void AfterTest() OVERRIDE { | 461 virtual void AfterTest() override { |
462 EXPECT_EQ(4, did_swaps_); | 462 EXPECT_EQ(4, did_swaps_); |
463 } | 463 } |
464 | 464 |
465 int did_swaps_; | 465 int did_swaps_; |
466 }; | 466 }; |
467 | 467 |
468 MULTI_THREAD_TEST_F(LayerTreeHostDamageTestScrollbarDoesDamage); | 468 MULTI_THREAD_TEST_F(LayerTreeHostDamageTestScrollbarDoesDamage); |
469 | 469 |
470 class LayerTreeHostDamageTestScrollbarCommitDoesNoDamage | 470 class LayerTreeHostDamageTestScrollbarCommitDoesNoDamage |
471 : public LayerTreeHostScrollbarDamageTest { | 471 : public LayerTreeHostScrollbarDamageTest { |
472 virtual void BeginTest() OVERRIDE { | 472 virtual void BeginTest() override { |
473 did_swaps_ = 0; | 473 did_swaps_ = 0; |
474 PostSetNeedsCommitToMainThread(); | 474 PostSetNeedsCommitToMainThread(); |
475 } | 475 } |
476 | 476 |
477 virtual DrawResult PrepareToDrawOnThread( | 477 virtual DrawResult PrepareToDrawOnThread( |
478 LayerTreeHostImpl* host_impl, | 478 LayerTreeHostImpl* host_impl, |
479 LayerTreeHostImpl::FrameData* frame_data, | 479 LayerTreeHostImpl::FrameData* frame_data, |
480 DrawResult draw_result) OVERRIDE { | 480 DrawResult draw_result) override { |
481 EXPECT_EQ(DRAW_SUCCESS, draw_result); | 481 EXPECT_EQ(DRAW_SUCCESS, draw_result); |
482 RenderSurfaceImpl* root_surface = | 482 RenderSurfaceImpl* root_surface = |
483 host_impl->active_tree()->root_layer()->render_surface(); | 483 host_impl->active_tree()->root_layer()->render_surface(); |
484 gfx::RectF root_damage = | 484 gfx::RectF root_damage = |
485 root_surface->damage_tracker()->current_damage_rect(); | 485 root_surface->damage_tracker()->current_damage_rect(); |
486 root_damage.Intersect(root_surface->content_rect()); | 486 root_damage.Intersect(root_surface->content_rect()); |
487 int frame = host_impl->active_tree()->source_frame_number(); | 487 int frame = host_impl->active_tree()->source_frame_number(); |
488 switch (did_swaps_) { | 488 switch (did_swaps_) { |
489 case 0: | 489 case 0: |
490 // The first frame has damage, so we should draw and swap. | 490 // The first frame has damage, so we should draw and swap. |
(...skipping 10 matching lines...) Expand all Loading... |
501 EXPECT_FALSE(root_damage.Intersects(gfx::Rect(300, 300, 10, 100))); | 501 EXPECT_FALSE(root_damage.Intersects(gfx::Rect(300, 300, 10, 100))); |
502 break; | 502 break; |
503 default: | 503 default: |
504 NOTREACHED(); | 504 NOTREACHED(); |
505 break; | 505 break; |
506 } | 506 } |
507 return draw_result; | 507 return draw_result; |
508 } | 508 } |
509 | 509 |
510 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, | 510 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, |
511 bool result) OVERRIDE { | 511 bool result) override { |
512 ++did_swaps_; | 512 ++did_swaps_; |
513 EXPECT_TRUE(result); | 513 EXPECT_TRUE(result); |
514 LayerImpl* root = host_impl->active_tree()->root_layer(); | 514 LayerImpl* root = host_impl->active_tree()->root_layer(); |
515 LayerImpl* scroll_clip_layer = root->children()[0]; | 515 LayerImpl* scroll_clip_layer = root->children()[0]; |
516 LayerImpl* scroll_layer = scroll_clip_layer->children()[0]; | 516 LayerImpl* scroll_layer = scroll_clip_layer->children()[0]; |
517 switch (did_swaps_) { | 517 switch (did_swaps_) { |
518 case 1: | 518 case 1: |
519 // Scroll on the thread. This should damage the scrollbar for the | 519 // Scroll on the thread. This should damage the scrollbar for the |
520 // next draw on the thread. | 520 // next draw on the thread. |
521 scroll_layer->ScrollBy(gfx::Vector2dF(10.f, 10.f)); | 521 scroll_layer->ScrollBy(gfx::Vector2dF(10.f, 10.f)); |
522 host_impl->SetNeedsRedraw(); | 522 host_impl->SetNeedsRedraw(); |
523 break; | 523 break; |
524 case 2: | 524 case 2: |
525 // Forcibly send the scroll to the main thread. | 525 // Forcibly send the scroll to the main thread. |
526 PostSetNeedsCommitToMainThread(); | 526 PostSetNeedsCommitToMainThread(); |
527 break; | 527 break; |
528 case 3: | 528 case 3: |
529 // First swap after second commit. | 529 // First swap after second commit. |
530 EndTest(); | 530 EndTest(); |
531 break; | 531 break; |
532 default: | 532 default: |
533 NOTREACHED(); | 533 NOTREACHED(); |
534 break; | 534 break; |
535 } | 535 } |
536 } | 536 } |
537 | 537 |
538 virtual void AfterTest() OVERRIDE { | 538 virtual void AfterTest() override { |
539 EXPECT_EQ(3, did_swaps_); | 539 EXPECT_EQ(3, did_swaps_); |
540 } | 540 } |
541 | 541 |
542 int did_swaps_; | 542 int did_swaps_; |
543 }; | 543 }; |
544 | 544 |
545 MULTI_THREAD_TEST_F(LayerTreeHostDamageTestScrollbarCommitDoesNoDamage); | 545 MULTI_THREAD_TEST_F(LayerTreeHostDamageTestScrollbarCommitDoesNoDamage); |
546 | 546 |
547 class LayerTreeHostDamageTestVisibleTilesStillTriggerDraws | 547 class LayerTreeHostDamageTestVisibleTilesStillTriggerDraws |
548 : public LayerTreeHostDamageTest { | 548 : public LayerTreeHostDamageTest { |
549 | 549 |
550 virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE { | 550 virtual void InitializeSettings(LayerTreeSettings* settings) override { |
551 settings->impl_side_painting = true; | 551 settings->impl_side_painting = true; |
552 } | 552 } |
553 | 553 |
554 virtual void BeginTest() OVERRIDE { | 554 virtual void BeginTest() override { |
555 PostSetNeedsCommitToMainThread(); | 555 PostSetNeedsCommitToMainThread(); |
556 } | 556 } |
557 | 557 |
558 virtual void SetupTree() OVERRIDE { | 558 virtual void SetupTree() override { |
559 scoped_refptr<FakePictureLayer> root = FakePictureLayer::Create(&client_); | 559 scoped_refptr<FakePictureLayer> root = FakePictureLayer::Create(&client_); |
560 root->SetBounds(gfx::Size(500, 500)); | 560 root->SetBounds(gfx::Size(500, 500)); |
561 layer_tree_host()->SetRootLayer(root); | 561 layer_tree_host()->SetRootLayer(root); |
562 LayerTreeHostDamageTest::SetupTree(); | 562 LayerTreeHostDamageTest::SetupTree(); |
563 | 563 |
564 swap_count_ = 0; | 564 swap_count_ = 0; |
565 prepare_to_draw_count_ = 0; | 565 prepare_to_draw_count_ = 0; |
566 update_visible_tile_count_ = 0; | 566 update_visible_tile_count_ = 0; |
567 } | 567 } |
568 | 568 |
569 virtual DrawResult PrepareToDrawOnThread( | 569 virtual DrawResult PrepareToDrawOnThread( |
570 LayerTreeHostImpl* host_impl, | 570 LayerTreeHostImpl* host_impl, |
571 LayerTreeHostImpl::FrameData* frame_data, | 571 LayerTreeHostImpl::FrameData* frame_data, |
572 DrawResult draw_result) OVERRIDE { | 572 DrawResult draw_result) override { |
573 EXPECT_EQ(DRAW_SUCCESS, draw_result); | 573 EXPECT_EQ(DRAW_SUCCESS, draw_result); |
574 prepare_to_draw_count_++; | 574 prepare_to_draw_count_++; |
575 switch (prepare_to_draw_count_) { | 575 switch (prepare_to_draw_count_) { |
576 case 1: | 576 case 1: |
577 // Detect that we have an incomplete tile, during the first frame. | 577 // Detect that we have an incomplete tile, during the first frame. |
578 // The first frame should have damage. | 578 // The first frame should have damage. |
579 frame_data->contains_incomplete_tile = true; | 579 frame_data->contains_incomplete_tile = true; |
580 DCHECK(!frame_data->has_no_damage); | 580 DCHECK(!frame_data->has_no_damage); |
581 break; | 581 break; |
582 case 2: | 582 case 2: |
(...skipping 10 matching lines...) Expand all Loading... |
593 break; | 593 break; |
594 default: | 594 default: |
595 NOTREACHED(); | 595 NOTREACHED(); |
596 break; | 596 break; |
597 } | 597 } |
598 | 598 |
599 return draw_result; | 599 return draw_result; |
600 } | 600 } |
601 | 601 |
602 virtual void UpdateVisibleTilesOnThread( | 602 virtual void UpdateVisibleTilesOnThread( |
603 LayerTreeHostImpl* host_impl) OVERRIDE { | 603 LayerTreeHostImpl* host_impl) override { |
604 // Simulate creating some visible tiles (that trigger prepare-to-draws). | 604 // Simulate creating some visible tiles (that trigger prepare-to-draws). |
605 // The first we make into a no-damage-frame during prepare-to-draw (see | 605 // The first we make into a no-damage-frame during prepare-to-draw (see |
606 // above). This is to ensure we still get UpdateVisibleTiles calls after | 606 // above). This is to ensure we still get UpdateVisibleTiles calls after |
607 // a no-damage or aborted frame. | 607 // a no-damage or aborted frame. |
608 update_visible_tile_count_++; | 608 update_visible_tile_count_++; |
609 switch (update_visible_tile_count_) { | 609 switch (update_visible_tile_count_) { |
610 case 3: | 610 case 3: |
611 case 6: | 611 case 6: |
612 host_impl->DidInitializeVisibleTileForTesting(); | 612 host_impl->DidInitializeVisibleTileForTesting(); |
613 break; | 613 break; |
614 case 7: | 614 case 7: |
615 NOTREACHED(); | 615 NOTREACHED(); |
616 break; | 616 break; |
617 } | 617 } |
618 } | 618 } |
619 | 619 |
620 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, | 620 virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, |
621 bool didSwap) OVERRIDE { | 621 bool didSwap) override { |
622 if (!didSwap) | 622 if (!didSwap) |
623 return; | 623 return; |
624 ++swap_count_; | 624 ++swap_count_; |
625 } | 625 } |
626 | 626 |
627 virtual void AfterTest() OVERRIDE { | 627 virtual void AfterTest() override { |
628 // We should keep getting update-visible-tiles calls | 628 // We should keep getting update-visible-tiles calls |
629 // until we report there are no more incomplete-tiles. | 629 // until we report there are no more incomplete-tiles. |
630 EXPECT_EQ(update_visible_tile_count_, 6); | 630 EXPECT_EQ(update_visible_tile_count_, 6); |
631 // First frame, plus two triggered by DidInitializeVisibleTile() | 631 // First frame, plus two triggered by DidInitializeVisibleTile() |
632 EXPECT_EQ(prepare_to_draw_count_, 3); | 632 EXPECT_EQ(prepare_to_draw_count_, 3); |
633 // First swap, plus final swap (contained damage). | 633 // First swap, plus final swap (contained damage). |
634 EXPECT_EQ(swap_count_, 2); | 634 EXPECT_EQ(swap_count_, 2); |
635 } | 635 } |
636 | 636 |
637 FakeContentLayerClient client_; | 637 FakeContentLayerClient client_; |
638 int swap_count_; | 638 int swap_count_; |
639 int prepare_to_draw_count_; | 639 int prepare_to_draw_count_; |
640 int update_visible_tile_count_; | 640 int update_visible_tile_count_; |
641 }; | 641 }; |
642 | 642 |
643 MULTI_THREAD_TEST_F(LayerTreeHostDamageTestVisibleTilesStillTriggerDraws); | 643 MULTI_THREAD_TEST_F(LayerTreeHostDamageTestVisibleTilesStillTriggerDraws); |
644 | 644 |
645 } // namespace | 645 } // namespace |
646 } // namespace cc | 646 } // namespace cc |
OLD | NEW |