OLD | NEW |
---|---|
1 // Copyright 2011 The Chromium Authors. All rights reserved. | 1 // Copyright 2011 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_common.h" | 5 #include "cc/trees/layer_tree_host_common.h" |
6 | 6 |
7 #include <set> | 7 #include <set> |
8 | 8 |
9 #include "cc/animation/layer_animation_controller.h" | 9 #include "cc/animation/layer_animation_controller.h" |
10 #include "cc/animation/transform_operations.h" | 10 #include "cc/animation/transform_operations.h" |
(...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
118 scoped_refptr<Layer> grand_child = Layer::Create(); | 118 scoped_refptr<Layer> grand_child = Layer::Create(); |
119 parent->AddChild(child); | 119 parent->AddChild(child); |
120 child->AddChild(grand_child); | 120 child->AddChild(grand_child); |
121 | 121 |
122 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 122 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
123 host->SetRootLayer(parent); | 123 host->SetRootLayer(parent); |
124 | 124 |
125 gfx::Transform identity_matrix; | 125 gfx::Transform identity_matrix; |
126 SetLayerPropertiesForTesting(parent.get(), | 126 SetLayerPropertiesForTesting(parent.get(), |
127 identity_matrix, | 127 identity_matrix, |
128 gfx::PointF(), | 128 gfx::Point3F(), |
129 gfx::PointF(), | 129 gfx::PointF(), |
130 gfx::Size(100, 100), | 130 gfx::Size(100, 100), |
131 true, | 131 true, |
132 false); | 132 false); |
133 SetLayerPropertiesForTesting(child.get(), | 133 SetLayerPropertiesForTesting(child.get(), |
134 identity_matrix, | 134 identity_matrix, |
135 gfx::PointF(), | 135 gfx::Point3F(), |
136 gfx::PointF(), | 136 gfx::PointF(), |
137 gfx::Size(), | 137 gfx::Size(), |
138 true, | 138 true, |
139 false); | 139 false); |
140 SetLayerPropertiesForTesting(grand_child.get(), | 140 SetLayerPropertiesForTesting(grand_child.get(), |
141 identity_matrix, | 141 identity_matrix, |
142 gfx::PointF(), | 142 gfx::Point3F(), |
143 gfx::PointF(), | 143 gfx::PointF(), |
144 gfx::Size(), | 144 gfx::Size(), |
145 true, | 145 true, |
146 false); | 146 false); |
147 | 147 |
148 ExecuteCalculateDrawProperties(parent.get()); | 148 ExecuteCalculateDrawProperties(parent.get()); |
149 | 149 |
150 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform()); | 150 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform()); |
151 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, | 151 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, |
152 child->screen_space_transform()); | 152 child->screen_space_transform()); |
153 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, | 153 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, |
154 grand_child->draw_transform()); | 154 grand_child->draw_transform()); |
155 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, | 155 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, |
156 grand_child->screen_space_transform()); | 156 grand_child->screen_space_transform()); |
157 } | 157 } |
158 | 158 |
159 TEST_F(LayerTreeHostCommonTest, TransformsForSingleLayer) { | 159 TEST_F(LayerTreeHostCommonTest, TransformsForSingleLayer) { |
160 gfx::Transform identity_matrix; | 160 gfx::Transform identity_matrix; |
161 scoped_refptr<Layer> layer = Layer::Create(); | 161 scoped_refptr<Layer> layer = Layer::Create(); |
162 | 162 |
163 scoped_refptr<Layer> root = Layer::Create(); | 163 scoped_refptr<Layer> root = Layer::Create(); |
164 SetLayerPropertiesForTesting(root.get(), | 164 SetLayerPropertiesForTesting(root.get(), |
165 identity_matrix, | 165 identity_matrix, |
166 gfx::PointF(), | 166 gfx::Point3F(), |
167 gfx::PointF(), | 167 gfx::PointF(), |
168 gfx::Size(1, 2), | 168 gfx::Size(1, 2), |
169 true, | 169 true, |
170 false); | 170 false); |
171 root->AddChild(layer); | 171 root->AddChild(layer); |
172 | 172 |
173 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 173 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
174 host->SetRootLayer(root); | 174 host->SetRootLayer(root); |
175 | 175 |
176 // Case 2: Setting the bounds of the layer should not affect either the draw | 176 // Case 2: Setting the bounds of the layer should not affect either the draw |
177 // transform or the screenspace transform. | 177 // transform or the screenspace transform. |
178 gfx::Transform translation_to_center; | 178 gfx::Transform translation_to_center; |
179 translation_to_center.Translate(5.0, 6.0); | 179 translation_to_center.Translate(5.0, 6.0); |
180 SetLayerPropertiesForTesting(layer.get(), | 180 SetLayerPropertiesForTesting(layer.get(), |
181 identity_matrix, | 181 identity_matrix, |
182 gfx::PointF(), | 182 gfx::Point3F(), |
183 gfx::PointF(), | 183 gfx::PointF(), |
184 gfx::Size(10, 12), | 184 gfx::Size(10, 12), |
185 true, | 185 true, |
186 false); | 186 false); |
187 ExecuteCalculateDrawProperties(root.get()); | 187 ExecuteCalculateDrawProperties(root.get()); |
188 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, layer->draw_transform()); | 188 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, layer->draw_transform()); |
189 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, | 189 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, |
190 layer->screen_space_transform()); | 190 layer->screen_space_transform()); |
191 | 191 |
192 // Case 3: The anchor point by itself (without a layer transform) should have | 192 // Case 3: The anchor point by itself (without a layer transform) should have |
193 // no effect on the transforms. | 193 // no effect on the transforms. |
194 SetLayerPropertiesForTesting(layer.get(), | 194 SetLayerPropertiesForTesting(layer.get(), |
195 identity_matrix, | 195 identity_matrix, |
196 gfx::PointF(0.25f, 0.25f), | 196 gfx::Point3F(2.5f, 3.0f, 0.f), |
197 gfx::PointF(), | 197 gfx::PointF(), |
198 gfx::Size(10, 12), | 198 gfx::Size(10, 12), |
199 true, | 199 true, |
200 false); | 200 false); |
201 ExecuteCalculateDrawProperties(root.get()); | 201 ExecuteCalculateDrawProperties(root.get()); |
202 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, layer->draw_transform()); | 202 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, layer->draw_transform()); |
203 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, | 203 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, |
204 layer->screen_space_transform()); | 204 layer->screen_space_transform()); |
205 | 205 |
206 // Case 4: A change in actual position affects both the draw transform and | 206 // Case 4: A change in actual position affects both the draw transform and |
207 // screen space transform. | 207 // screen space transform. |
208 gfx::Transform position_transform; | 208 gfx::Transform position_transform; |
209 position_transform.Translate(0.f, 1.2f); | 209 position_transform.Translate(0.f, 1.2f); |
210 SetLayerPropertiesForTesting(layer.get(), | 210 SetLayerPropertiesForTesting(layer.get(), |
211 identity_matrix, | 211 identity_matrix, |
212 gfx::PointF(0.25f, 0.25f), | 212 gfx::Point3F(2.5f, 3.0f, 0.f), |
213 gfx::PointF(0.f, 1.2f), | 213 gfx::PointF(0.f, 1.2f), |
214 gfx::Size(10, 12), | 214 gfx::Size(10, 12), |
215 true, | 215 true, |
216 false); | 216 false); |
217 ExecuteCalculateDrawProperties(root.get()); | 217 ExecuteCalculateDrawProperties(root.get()); |
218 EXPECT_TRANSFORMATION_MATRIX_EQ(position_transform, layer->draw_transform()); | 218 EXPECT_TRANSFORMATION_MATRIX_EQ(position_transform, layer->draw_transform()); |
219 EXPECT_TRANSFORMATION_MATRIX_EQ(position_transform, | 219 EXPECT_TRANSFORMATION_MATRIX_EQ(position_transform, |
220 layer->screen_space_transform()); | 220 layer->screen_space_transform()); |
221 | 221 |
222 // Case 5: In the correct sequence of transforms, the layer transform should | 222 // Case 5: In the correct sequence of transforms, the layer transform should |
223 // pre-multiply the translation_to_center. This is easily tested by using a | 223 // pre-multiply the translation_to_center. This is easily tested by using a |
224 // scale transform, because scale and translation are not commutative. | 224 // scale transform, because scale and translation are not commutative. |
225 gfx::Transform layer_transform; | 225 gfx::Transform layer_transform; |
226 layer_transform.Scale3d(2.0, 2.0, 1.0); | 226 layer_transform.Scale3d(2.0, 2.0, 1.0); |
227 SetLayerPropertiesForTesting(layer.get(), | 227 SetLayerPropertiesForTesting(layer.get(), |
228 layer_transform, | 228 layer_transform, |
229 gfx::PointF(), | 229 gfx::Point3F(), |
230 gfx::PointF(), | 230 gfx::PointF(), |
231 gfx::Size(10, 12), | 231 gfx::Size(10, 12), |
232 true, | 232 true, |
233 false); | 233 false); |
234 ExecuteCalculateDrawProperties(root.get()); | 234 ExecuteCalculateDrawProperties(root.get()); |
235 EXPECT_TRANSFORMATION_MATRIX_EQ(layer_transform, layer->draw_transform()); | 235 EXPECT_TRANSFORMATION_MATRIX_EQ(layer_transform, layer->draw_transform()); |
236 EXPECT_TRANSFORMATION_MATRIX_EQ(layer_transform, | 236 EXPECT_TRANSFORMATION_MATRIX_EQ(layer_transform, |
237 layer->screen_space_transform()); | 237 layer->screen_space_transform()); |
238 | 238 |
239 // Case 6: The layer transform should occur with respect to the anchor point. | 239 // Case 6: The layer transform should occur with respect to the anchor point. |
240 gfx::Transform translation_to_anchor; | 240 gfx::Transform translation_to_anchor; |
241 translation_to_anchor.Translate(5.0, 0.0); | 241 translation_to_anchor.Translate(5.0, 0.0); |
242 gfx::Transform expected_result = | 242 gfx::Transform expected_result = |
243 translation_to_anchor * layer_transform * Inverse(translation_to_anchor); | 243 translation_to_anchor * layer_transform * Inverse(translation_to_anchor); |
244 SetLayerPropertiesForTesting(layer.get(), | 244 SetLayerPropertiesForTesting(layer.get(), |
245 layer_transform, | 245 layer_transform, |
246 gfx::PointF(0.5f, 0.f), | 246 gfx::Point3F(5.0f, 0.f, 0.f), |
247 gfx::PointF(), | 247 gfx::PointF(), |
248 gfx::Size(10, 12), | 248 gfx::Size(10, 12), |
249 true, | 249 true, |
250 false); | 250 false); |
251 ExecuteCalculateDrawProperties(root.get()); | 251 ExecuteCalculateDrawProperties(root.get()); |
252 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_result, layer->draw_transform()); | 252 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_result, layer->draw_transform()); |
253 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_result, | 253 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_result, |
254 layer->screen_space_transform()); | 254 layer->screen_space_transform()); |
255 | 255 |
256 // Case 7: Verify that position pre-multiplies the layer transform. The | 256 // Case 7: Verify that position pre-multiplies the layer transform. The |
257 // current implementation of CalculateDrawProperties does this implicitly, but | 257 // current implementation of CalculateDrawProperties does this implicitly, but |
258 // it is still worth testing to detect accidental regressions. | 258 // it is still worth testing to detect accidental regressions. |
259 expected_result = position_transform * translation_to_anchor * | 259 expected_result = position_transform * translation_to_anchor * |
260 layer_transform * Inverse(translation_to_anchor); | 260 layer_transform * Inverse(translation_to_anchor); |
261 SetLayerPropertiesForTesting(layer.get(), | 261 SetLayerPropertiesForTesting(layer.get(), |
262 layer_transform, | 262 layer_transform, |
263 gfx::PointF(0.5f, 0.f), | 263 gfx::Point3F(5.0f, 0.f, 0.f), |
264 gfx::PointF(0.f, 1.2f), | 264 gfx::PointF(0.f, 1.2f), |
265 gfx::Size(10, 12), | 265 gfx::Size(10, 12), |
266 true, | 266 true, |
267 false); | 267 false); |
268 ExecuteCalculateDrawProperties(root.get()); | 268 ExecuteCalculateDrawProperties(root.get()); |
269 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_result, layer->draw_transform()); | 269 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_result, layer->draw_transform()); |
270 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_result, | 270 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_result, |
271 layer->screen_space_transform()); | 271 layer->screen_space_transform()); |
272 } | 272 } |
273 | 273 |
(...skipping 11 matching lines...) Expand all Loading... | |
285 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); | 285 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); |
286 | 286 |
287 gfx::Transform identity_matrix; | 287 gfx::Transform identity_matrix; |
288 scoped_ptr<LayerImpl> sublayer_scoped_ptr( | 288 scoped_ptr<LayerImpl> sublayer_scoped_ptr( |
289 LayerImpl::Create(host_impl.active_tree(), 1)); | 289 LayerImpl::Create(host_impl.active_tree(), 1)); |
290 LayerImpl* sublayer = sublayer_scoped_ptr.get(); | 290 LayerImpl* sublayer = sublayer_scoped_ptr.get(); |
291 sublayer->SetContentsScale(kPageScale * kDeviceScale, | 291 sublayer->SetContentsScale(kPageScale * kDeviceScale, |
292 kPageScale * kDeviceScale); | 292 kPageScale * kDeviceScale); |
293 SetLayerPropertiesForTesting(sublayer, | 293 SetLayerPropertiesForTesting(sublayer, |
294 identity_matrix, | 294 identity_matrix, |
295 gfx::Point(), | 295 gfx::Point3F(), |
296 gfx::PointF(), | 296 gfx::PointF(), |
297 gfx::Size(500, 500), | 297 gfx::Size(500, 500), |
298 true, | 298 true, |
299 false); | 299 false); |
300 | 300 |
301 scoped_ptr<LayerImpl> scroll_layer_scoped_ptr( | 301 scoped_ptr<LayerImpl> scroll_layer_scoped_ptr( |
302 LayerImpl::Create(host_impl.active_tree(), 2)); | 302 LayerImpl::Create(host_impl.active_tree(), 2)); |
303 LayerImpl* scroll_layer = scroll_layer_scoped_ptr.get(); | 303 LayerImpl* scroll_layer = scroll_layer_scoped_ptr.get(); |
304 SetLayerPropertiesForTesting(scroll_layer, | 304 SetLayerPropertiesForTesting(scroll_layer, |
305 identity_matrix, | 305 identity_matrix, |
306 gfx::PointF(), | 306 gfx::Point3F(), |
307 gfx::PointF(), | 307 gfx::PointF(), |
308 gfx::Size(10, 20), | 308 gfx::Size(10, 20), |
309 true, | 309 true, |
310 false); | 310 false); |
311 scoped_ptr<LayerImpl> clip_layer_scoped_ptr( | 311 scoped_ptr<LayerImpl> clip_layer_scoped_ptr( |
312 LayerImpl::Create(host_impl.active_tree(), 4)); | 312 LayerImpl::Create(host_impl.active_tree(), 4)); |
313 LayerImpl* clip_layer = clip_layer_scoped_ptr.get(); | 313 LayerImpl* clip_layer = clip_layer_scoped_ptr.get(); |
314 | 314 |
315 scroll_layer->SetScrollClipLayer(clip_layer->id()); | 315 scroll_layer->SetScrollClipLayer(clip_layer->id()); |
316 clip_layer->SetBounds( | 316 clip_layer->SetBounds( |
317 gfx::Size(scroll_layer->bounds().width() + kMaxScrollOffset.x(), | 317 gfx::Size(scroll_layer->bounds().width() + kMaxScrollOffset.x(), |
318 scroll_layer->bounds().height() + kMaxScrollOffset.y())); | 318 scroll_layer->bounds().height() + kMaxScrollOffset.y())); |
319 scroll_layer->SetScrollClipLayer(clip_layer->id()); | 319 scroll_layer->SetScrollClipLayer(clip_layer->id()); |
320 scroll_layer->SetScrollDelta(kScrollDelta); | 320 scroll_layer->SetScrollDelta(kScrollDelta); |
321 gfx::Transform impl_transform; | 321 gfx::Transform impl_transform; |
322 scroll_layer->AddChild(sublayer_scoped_ptr.Pass()); | 322 scroll_layer->AddChild(sublayer_scoped_ptr.Pass()); |
323 LayerImpl* scroll_layer_raw_ptr = scroll_layer_scoped_ptr.get(); | 323 LayerImpl* scroll_layer_raw_ptr = scroll_layer_scoped_ptr.get(); |
324 clip_layer->AddChild(scroll_layer_scoped_ptr.Pass()); | 324 clip_layer->AddChild(scroll_layer_scoped_ptr.Pass()); |
325 scroll_layer_raw_ptr->SetScrollOffset(kScrollOffset); | 325 scroll_layer_raw_ptr->SetScrollOffset(kScrollOffset); |
326 | 326 |
327 scoped_ptr<LayerImpl> root(LayerImpl::Create(host_impl.active_tree(), 3)); | 327 scoped_ptr<LayerImpl> root(LayerImpl::Create(host_impl.active_tree(), 3)); |
328 SetLayerPropertiesForTesting(root.get(), | 328 SetLayerPropertiesForTesting(root.get(), |
329 identity_matrix, | 329 identity_matrix, |
330 gfx::PointF(), | 330 gfx::Point3F(), |
331 gfx::PointF(), | 331 gfx::PointF(), |
332 gfx::Size(3, 4), | 332 gfx::Size(3, 4), |
333 true, | 333 true, |
334 false); | 334 false); |
335 root->AddChild(clip_layer_scoped_ptr.Pass()); | 335 root->AddChild(clip_layer_scoped_ptr.Pass()); |
336 | 336 |
337 ExecuteCalculateDrawProperties( | 337 ExecuteCalculateDrawProperties( |
338 root.get(), kDeviceScale, kPageScale, scroll_layer->parent()); | 338 root.get(), kDeviceScale, kPageScale, scroll_layer->parent()); |
339 gfx::Transform expected_transform = identity_matrix; | 339 gfx::Transform expected_transform = identity_matrix; |
340 gfx::PointF sub_layer_screen_position = kScrollLayerPosition - kScrollDelta; | 340 gfx::PointF sub_layer_screen_position = kScrollLayerPosition - kScrollDelta; |
341 sub_layer_screen_position.Scale(kPageScale * kDeviceScale); | 341 sub_layer_screen_position.Scale(kPageScale * kDeviceScale); |
342 expected_transform.Translate(MathUtil::Round(sub_layer_screen_position.x()), | 342 expected_transform.Translate(MathUtil::Round(sub_layer_screen_position.x()), |
343 MathUtil::Round(sub_layer_screen_position.y())); | 343 MathUtil::Round(sub_layer_screen_position.y())); |
344 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform, | 344 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform, |
345 sublayer->draw_transform()); | 345 sublayer->draw_transform()); |
346 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform, | 346 EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform, |
347 sublayer->screen_space_transform()); | 347 sublayer->screen_space_transform()); |
348 | 348 |
349 gfx::Transform arbitrary_translate; | 349 gfx::Transform arbitrary_translate; |
350 const float kTranslateX = 10.6f; | 350 const float kTranslateX = 10.6f; |
351 const float kTranslateY = 20.6f; | 351 const float kTranslateY = 20.6f; |
352 arbitrary_translate.Translate(kTranslateX, kTranslateY); | 352 arbitrary_translate.Translate(kTranslateX, kTranslateY); |
353 SetLayerPropertiesForTesting(scroll_layer, | 353 SetLayerPropertiesForTesting(scroll_layer, |
354 arbitrary_translate, | 354 arbitrary_translate, |
355 gfx::PointF(), | 355 gfx::Point3F(), |
356 gfx::PointF(), | 356 gfx::PointF(), |
357 gfx::Size(10, 20), | 357 gfx::Size(10, 20), |
358 true, | 358 true, |
359 false); | 359 false); |
360 ExecuteCalculateDrawProperties( | 360 ExecuteCalculateDrawProperties( |
361 root.get(), kDeviceScale, kPageScale, scroll_layer->parent()); | 361 root.get(), kDeviceScale, kPageScale, scroll_layer->parent()); |
362 expected_transform.MakeIdentity(); | 362 expected_transform.MakeIdentity(); |
363 expected_transform.Translate( | 363 expected_transform.Translate( |
364 MathUtil::Round(kTranslateX * kPageScale * kDeviceScale + | 364 MathUtil::Round(kTranslateX * kPageScale * kDeviceScale + |
365 sub_layer_screen_position.x()), | 365 sub_layer_screen_position.x()), |
(...skipping 12 matching lines...) Expand all Loading... | |
378 root->AddChild(parent); | 378 root->AddChild(parent); |
379 parent->AddChild(child); | 379 parent->AddChild(child); |
380 child->AddChild(grand_child); | 380 child->AddChild(grand_child); |
381 | 381 |
382 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 382 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
383 host->SetRootLayer(root); | 383 host->SetRootLayer(root); |
384 | 384 |
385 // One-time setup of root layer | 385 // One-time setup of root layer |
386 SetLayerPropertiesForTesting(root.get(), | 386 SetLayerPropertiesForTesting(root.get(), |
387 identity_matrix, | 387 identity_matrix, |
388 gfx::PointF(), | 388 gfx::Point3F(), |
389 gfx::PointF(), | 389 gfx::PointF(), |
390 gfx::Size(1, 2), | 390 gfx::Size(1, 2), |
391 true, | 391 true, |
392 false); | 392 false); |
393 | 393 |
394 // Case 1: parent's anchor point should not affect child or grand_child. | 394 // Case 1: parent's anchor point should not affect child or grand_child. |
395 SetLayerPropertiesForTesting(parent.get(), | 395 SetLayerPropertiesForTesting(parent.get(), |
396 identity_matrix, | 396 identity_matrix, |
397 gfx::PointF(0.25f, 0.25f), | 397 gfx::Point3F(2.5f, 3.0f, 0.f), |
398 gfx::PointF(), | 398 gfx::PointF(), |
399 gfx::Size(10, 12), | 399 gfx::Size(10, 12), |
400 true, | 400 true, |
401 false); | 401 false); |
402 SetLayerPropertiesForTesting(child.get(), | 402 SetLayerPropertiesForTesting(child.get(), |
403 identity_matrix, | 403 identity_matrix, |
404 gfx::PointF(), | 404 gfx::Point3F(), |
405 gfx::PointF(), | 405 gfx::PointF(), |
406 gfx::Size(16, 18), | 406 gfx::Size(16, 18), |
407 true, | 407 true, |
408 false); | 408 false); |
409 SetLayerPropertiesForTesting(grand_child.get(), | 409 SetLayerPropertiesForTesting(grand_child.get(), |
410 identity_matrix, | 410 identity_matrix, |
411 gfx::PointF(), | 411 gfx::Point3F(), |
412 gfx::PointF(), | 412 gfx::PointF(), |
413 gfx::Size(76, 78), | 413 gfx::Size(76, 78), |
414 true, | 414 true, |
415 false); | 415 false); |
416 ExecuteCalculateDrawProperties(root.get()); | 416 ExecuteCalculateDrawProperties(root.get()); |
417 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform()); | 417 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform()); |
418 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, | 418 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, |
419 child->screen_space_transform()); | 419 child->screen_space_transform()); |
420 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, | 420 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, |
421 grand_child->draw_transform()); | 421 grand_child->draw_transform()); |
422 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, | 422 EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, |
423 grand_child->screen_space_transform()); | 423 grand_child->screen_space_transform()); |
424 | 424 |
425 // Case 2: parent's position affects child and grand_child. | 425 // Case 2: parent's position affects child and grand_child. |
426 gfx::Transform parent_position_transform; | 426 gfx::Transform parent_position_transform; |
427 parent_position_transform.Translate(0.f, 1.2f); | 427 parent_position_transform.Translate(0.f, 1.2f); |
428 SetLayerPropertiesForTesting(parent.get(), | 428 SetLayerPropertiesForTesting(parent.get(), |
429 identity_matrix, | 429 identity_matrix, |
430 gfx::PointF(0.25f, 0.25f), | 430 gfx::Point3F(2.5f, 3.0f, 0.f), |
431 gfx::PointF(0.f, 1.2f), | 431 gfx::PointF(0.f, 1.2f), |
432 gfx::Size(10, 12), | 432 gfx::Size(10, 12), |
433 true, | 433 true, |
434 false); | 434 false); |
435 SetLayerPropertiesForTesting(child.get(), | 435 SetLayerPropertiesForTesting(child.get(), |
436 identity_matrix, | 436 identity_matrix, |
437 gfx::PointF(), | 437 gfx::Point3F(), |
438 gfx::PointF(), | 438 gfx::PointF(), |
439 gfx::Size(16, 18), | 439 gfx::Size(16, 18), |
440 true, | 440 true, |
441 false); | 441 false); |
442 SetLayerPropertiesForTesting(grand_child.get(), | 442 SetLayerPropertiesForTesting(grand_child.get(), |
443 identity_matrix, | 443 identity_matrix, |
444 gfx::PointF(), | 444 gfx::Point3F(), |
445 gfx::PointF(), | 445 gfx::PointF(), |
446 gfx::Size(76, 78), | 446 gfx::Size(76, 78), |
447 true, | 447 true, |
448 false); | 448 false); |
449 ExecuteCalculateDrawProperties(root.get()); | 449 ExecuteCalculateDrawProperties(root.get()); |
450 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_position_transform, | 450 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_position_transform, |
451 child->draw_transform()); | 451 child->draw_transform()); |
452 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_position_transform, | 452 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_position_transform, |
453 child->screen_space_transform()); | 453 child->screen_space_transform()); |
454 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_position_transform, | 454 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_position_transform, |
455 grand_child->draw_transform()); | 455 grand_child->draw_transform()); |
456 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_position_transform, | 456 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_position_transform, |
457 grand_child->screen_space_transform()); | 457 grand_child->screen_space_transform()); |
458 | 458 |
459 // Case 3: parent's local transform affects child and grandchild | 459 // Case 3: parent's local transform affects child and grandchild |
460 gfx::Transform parent_layer_transform; | 460 gfx::Transform parent_layer_transform; |
461 parent_layer_transform.Scale3d(2.0, 2.0, 1.0); | 461 parent_layer_transform.Scale3d(2.0, 2.0, 1.0); |
462 gfx::Transform parent_translation_to_anchor; | 462 gfx::Transform parent_translation_to_anchor; |
463 parent_translation_to_anchor.Translate(2.5, 3.0); | 463 parent_translation_to_anchor.Translate(2.5, 3.0); |
464 gfx::Transform parent_composite_transform = | 464 gfx::Transform parent_composite_transform = |
465 parent_translation_to_anchor * parent_layer_transform * | 465 parent_translation_to_anchor * parent_layer_transform * |
466 Inverse(parent_translation_to_anchor); | 466 Inverse(parent_translation_to_anchor); |
467 SetLayerPropertiesForTesting(parent.get(), | 467 SetLayerPropertiesForTesting(parent.get(), |
468 parent_layer_transform, | 468 parent_layer_transform, |
469 gfx::PointF(0.25f, 0.25f), | 469 gfx::Point3F(2.5f, 3.0f, 0.f), |
470 gfx::PointF(), | 470 gfx::PointF(), |
471 gfx::Size(10, 12), | 471 gfx::Size(10, 12), |
472 true, | 472 true, |
473 false); | 473 false); |
474 SetLayerPropertiesForTesting(child.get(), | 474 SetLayerPropertiesForTesting(child.get(), |
475 identity_matrix, | 475 identity_matrix, |
476 gfx::PointF(), | 476 gfx::Point3F(), |
477 gfx::PointF(), | 477 gfx::PointF(), |
478 gfx::Size(16, 18), | 478 gfx::Size(16, 18), |
479 true, | 479 true, |
480 false); | 480 false); |
481 SetLayerPropertiesForTesting(grand_child.get(), | 481 SetLayerPropertiesForTesting(grand_child.get(), |
482 identity_matrix, | 482 identity_matrix, |
483 gfx::PointF(), | 483 gfx::Point3F(), |
484 gfx::PointF(), | 484 gfx::PointF(), |
485 gfx::Size(76, 78), | 485 gfx::Size(76, 78), |
486 true, | 486 true, |
487 false); | 487 false); |
488 ExecuteCalculateDrawProperties(root.get()); | 488 ExecuteCalculateDrawProperties(root.get()); |
489 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform, | 489 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform, |
490 child->draw_transform()); | 490 child->draw_transform()); |
491 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform, | 491 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform, |
492 child->screen_space_transform()); | 492 child->screen_space_transform()); |
493 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform, | 493 EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform, |
(...skipping 12 matching lines...) Expand all Loading... | |
506 parent->AddChild(child); | 506 parent->AddChild(child); |
507 child->AddChild(grand_child); | 507 child->AddChild(grand_child); |
508 | 508 |
509 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 509 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
510 host->SetRootLayer(root); | 510 host->SetRootLayer(root); |
511 | 511 |
512 // One-time setup of root layer | 512 // One-time setup of root layer |
513 gfx::Transform identity_matrix; | 513 gfx::Transform identity_matrix; |
514 SetLayerPropertiesForTesting(root.get(), | 514 SetLayerPropertiesForTesting(root.get(), |
515 identity_matrix, | 515 identity_matrix, |
516 gfx::PointF(), | 516 gfx::Point3F(), |
517 gfx::PointF(), | 517 gfx::PointF(), |
518 gfx::Size(1, 2), | 518 gfx::Size(1, 2), |
519 true, | 519 true, |
520 false); | 520 false); |
521 | 521 |
522 // Child is set up so that a new render surface should be created. | 522 // Child is set up so that a new render surface should be created. |
523 child->SetOpacity(0.5f); | 523 child->SetOpacity(0.5f); |
524 child->SetForceRenderSurface(true); | 524 child->SetForceRenderSurface(true); |
525 | 525 |
526 gfx::Transform parent_layer_transform; | 526 gfx::Transform parent_layer_transform; |
(...skipping 11 matching lines...) Expand all Loading... | |
538 surface_sublayer_transform.Scale(parent_composite_scale.x(), | 538 surface_sublayer_transform.Scale(parent_composite_scale.x(), |
539 parent_composite_scale.y()); | 539 parent_composite_scale.y()); |
540 gfx::Transform surface_sublayer_composite_transform = | 540 gfx::Transform surface_sublayer_composite_transform = |
541 parent_composite_transform * Inverse(surface_sublayer_transform); | 541 parent_composite_transform * Inverse(surface_sublayer_transform); |
542 | 542 |
543 // Child's render surface should not exist yet. | 543 // Child's render surface should not exist yet. |
544 ASSERT_FALSE(child->render_surface()); | 544 ASSERT_FALSE(child->render_surface()); |
545 | 545 |
546 SetLayerPropertiesForTesting(parent.get(), | 546 SetLayerPropertiesForTesting(parent.get(), |
547 parent_layer_transform, | 547 parent_layer_transform, |
548 gfx::PointF(0.25f, 0.25f), | 548 gfx::Point3F(25.0f, 30.0f, 0.f), |
549 gfx::PointF(), | 549 gfx::PointF(), |
550 gfx::Size(100, 120), | 550 gfx::Size(100, 120), |
551 true, | 551 true, |
552 false); | 552 false); |
553 SetLayerPropertiesForTesting(child.get(), | 553 SetLayerPropertiesForTesting(child.get(), |
554 identity_matrix, | 554 identity_matrix, |
555 gfx::PointF(), | 555 gfx::Point3F(), |
556 gfx::PointF(), | 556 gfx::PointF(), |
557 gfx::Size(16, 18), | 557 gfx::Size(16, 18), |
558 true, | 558 true, |
559 false); | 559 false); |
560 SetLayerPropertiesForTesting(grand_child.get(), | 560 SetLayerPropertiesForTesting(grand_child.get(), |
561 identity_matrix, | 561 identity_matrix, |
562 gfx::PointF(), | 562 gfx::Point3F(), |
563 gfx::PointF(), | 563 gfx::PointF(), |
564 gfx::Size(8, 10), | 564 gfx::Size(8, 10), |
565 true, | 565 true, |
566 false); | 566 false); |
567 ExecuteCalculateDrawProperties(root.get()); | 567 ExecuteCalculateDrawProperties(root.get()); |
568 | 568 |
569 // Render surface should have been created now. | 569 // Render surface should have been created now. |
570 ASSERT_TRUE(child->render_surface()); | 570 ASSERT_TRUE(child->render_surface()); |
571 ASSERT_EQ(child, child->render_target()); | 571 ASSERT_EQ(child, child->render_target()); |
572 | 572 |
(...skipping 30 matching lines...) Expand all Loading... | |
603 child->AddChild(grand_child); | 603 child->AddChild(grand_child); |
604 child->SetReplicaLayer(child_replica.get()); | 604 child->SetReplicaLayer(child_replica.get()); |
605 | 605 |
606 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 606 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
607 host->SetRootLayer(root); | 607 host->SetRootLayer(root); |
608 | 608 |
609 // One-time setup of root layer | 609 // One-time setup of root layer |
610 gfx::Transform identity_matrix; | 610 gfx::Transform identity_matrix; |
611 SetLayerPropertiesForTesting(root.get(), | 611 SetLayerPropertiesForTesting(root.get(), |
612 identity_matrix, | 612 identity_matrix, |
613 gfx::PointF(), | 613 gfx::Point3F(), |
614 gfx::PointF(), | 614 gfx::PointF(), |
615 gfx::Size(1, 2), | 615 gfx::Size(1, 2), |
616 true, | 616 true, |
617 false); | 617 false); |
618 | 618 |
619 // Child is set up so that a new render surface should be created. | 619 // Child is set up so that a new render surface should be created. |
620 child->SetOpacity(0.5f); | 620 child->SetOpacity(0.5f); |
621 | 621 |
622 gfx::Transform parent_layer_transform; | 622 gfx::Transform parent_layer_transform; |
623 parent_layer_transform.Scale3d(2.0, 2.0, 1.0); | 623 parent_layer_transform.Scale3d(2.0, 2.0, 1.0); |
(...skipping 12 matching lines...) Expand all Loading... | |
636 parent_composite_scale.y()); | 636 parent_composite_scale.y()); |
637 gfx::Transform replica_composite_transform = | 637 gfx::Transform replica_composite_transform = |
638 parent_composite_transform * replica_layer_transform * | 638 parent_composite_transform * replica_layer_transform * |
639 Inverse(surface_sublayer_transform); | 639 Inverse(surface_sublayer_transform); |
640 | 640 |
641 // Child's render surface should not exist yet. | 641 // Child's render surface should not exist yet. |
642 ASSERT_FALSE(child->render_surface()); | 642 ASSERT_FALSE(child->render_surface()); |
643 | 643 |
644 SetLayerPropertiesForTesting(parent.get(), | 644 SetLayerPropertiesForTesting(parent.get(), |
645 parent_layer_transform, | 645 parent_layer_transform, |
646 gfx::PointF(0.25f, 0.25f), | 646 gfx::Point3F(2.5f, 3.0f, 0.f), |
647 gfx::PointF(), | 647 gfx::PointF(), |
648 gfx::Size(10, 12), | 648 gfx::Size(10, 12), |
649 true, | 649 true, |
650 false); | 650 false); |
651 SetLayerPropertiesForTesting(child.get(), | 651 SetLayerPropertiesForTesting(child.get(), |
652 identity_matrix, | 652 identity_matrix, |
653 gfx::PointF(), | 653 gfx::Point3F(), |
654 gfx::PointF(), | 654 gfx::PointF(), |
655 gfx::Size(16, 18), | 655 gfx::Size(16, 18), |
656 true, | 656 true, |
657 false); | 657 false); |
658 SetLayerPropertiesForTesting(grand_child.get(), | 658 SetLayerPropertiesForTesting(grand_child.get(), |
659 identity_matrix, | 659 identity_matrix, |
660 gfx::PointF(), | 660 gfx::Point3F(), |
661 gfx::PointF(-0.5f, -0.5f), | 661 gfx::PointF(-0.5f, -0.5f), |
662 gfx::Size(1, 1), | 662 gfx::Size(1, 1), |
663 true, | 663 true, |
664 false); | 664 false); |
665 SetLayerPropertiesForTesting(child_replica.get(), | 665 SetLayerPropertiesForTesting(child_replica.get(), |
666 replica_layer_transform, | 666 replica_layer_transform, |
667 gfx::PointF(), | 667 gfx::Point3F(), |
668 gfx::PointF(), | 668 gfx::PointF(), |
669 gfx::Size(), | 669 gfx::Size(), |
670 true, | 670 true, |
671 false); | 671 false); |
672 ExecuteCalculateDrawProperties(root.get()); | 672 ExecuteCalculateDrawProperties(root.get()); |
673 | 673 |
674 // Render surface should have been created now. | 674 // Render surface should have been created now. |
675 ASSERT_TRUE(child->render_surface()); | 675 ASSERT_TRUE(child->render_surface()); |
676 ASSERT_EQ(child, child->render_target()); | 676 ASSERT_EQ(child, child->render_target()); |
677 | 677 |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
729 | 729 |
730 // In combination with descendant draws content, opacity != 1 forces the layer | 730 // In combination with descendant draws content, opacity != 1 forces the layer |
731 // to have a new render surface. | 731 // to have a new render surface. |
732 render_surface1->SetOpacity(0.5f); | 732 render_surface1->SetOpacity(0.5f); |
733 render_surface2->SetOpacity(0.33f); | 733 render_surface2->SetOpacity(0.33f); |
734 | 734 |
735 // One-time setup of root layer | 735 // One-time setup of root layer |
736 gfx::Transform identity_matrix; | 736 gfx::Transform identity_matrix; |
737 SetLayerPropertiesForTesting(root.get(), | 737 SetLayerPropertiesForTesting(root.get(), |
738 identity_matrix, | 738 identity_matrix, |
739 gfx::PointF(), | 739 gfx::Point3F(), |
740 gfx::PointF(), | 740 gfx::PointF(), |
741 gfx::Size(1, 2), | 741 gfx::Size(1, 2), |
742 true, | 742 true, |
743 false); | 743 false); |
744 | 744 |
745 // All layers in the tree are initialized with an anchor at .25 and a size of | 745 // All layers in the tree are initialized with an anchor at .25 and a size of |
746 // (10,10). matrix "A" is the composite layer transform used in all layers, | 746 // (10,10). matrix "A" is the composite layer transform used in all layers, |
747 // Matrix "R" is the composite replica transform used in all replica layers. | 747 // Matrix "R" is the composite replica transform used in all replica layers. |
748 gfx::Transform translation_to_anchor; | 748 gfx::Transform translation_to_anchor; |
749 translation_to_anchor.Translate(2.5, 0.0); | 749 translation_to_anchor.Translate(2.5, 0.0); |
(...skipping 26 matching lines...) Expand all Loading... | |
776 surface2_parent_transform_scale.y()); | 776 surface2_parent_transform_scale.y()); |
777 | 777 |
778 // SS2 = transform given to the subtree of render_surface2 | 778 // SS2 = transform given to the subtree of render_surface2 |
779 gfx::Transform SS2 = surface2_sublayer_transform; | 779 gfx::Transform SS2 = surface2_sublayer_transform; |
780 // S2 = transform to move from render_surface2 pixels to the layer space of | 780 // S2 = transform to move from render_surface2 pixels to the layer space of |
781 // the owning layer | 781 // the owning layer |
782 gfx::Transform S2 = Inverse(surface2_sublayer_transform); | 782 gfx::Transform S2 = Inverse(surface2_sublayer_transform); |
783 | 783 |
784 SetLayerPropertiesForTesting(parent.get(), | 784 SetLayerPropertiesForTesting(parent.get(), |
785 layer_transform, | 785 layer_transform, |
786 gfx::PointF(0.25f, 0.f), | 786 gfx::Point3F(2.5f, 0.f, 0.f), |
787 gfx::PointF(), | 787 gfx::PointF(), |
788 gfx::Size(10, 10), | 788 gfx::Size(10, 10), |
789 true, | 789 true, |
790 false); | 790 false); |
791 SetLayerPropertiesForTesting(render_surface1.get(), | 791 SetLayerPropertiesForTesting(render_surface1.get(), |
792 layer_transform, | 792 layer_transform, |
793 gfx::PointF(0.25f, 0.f), | 793 gfx::Point3F(2.5f, 0.f, 0.f), |
794 gfx::PointF(), | 794 gfx::PointF(), |
795 gfx::Size(10, 10), | 795 gfx::Size(10, 10), |
796 true, | 796 true, |
797 false); | 797 false); |
798 SetLayerPropertiesForTesting(render_surface2.get(), | 798 SetLayerPropertiesForTesting(render_surface2.get(), |
799 layer_transform, | 799 layer_transform, |
800 gfx::PointF(0.25f, 0.f), | 800 gfx::Point3F(2.5f, 0.f, 0.f), |
801 gfx::PointF(), | 801 gfx::PointF(), |
802 gfx::Size(10, 10), | 802 gfx::Size(10, 10), |
803 true, | 803 true, |
804 false); | 804 false); |
805 SetLayerPropertiesForTesting(child_of_root.get(), | 805 SetLayerPropertiesForTesting(child_of_root.get(), |
806 layer_transform, | 806 layer_transform, |
807 gfx::PointF(0.25f, 0.f), | 807 gfx::Point3F(2.5f, 0.f, 0.f), |
808 gfx::PointF(), | 808 gfx::PointF(), |
809 gfx::Size(10, 10), | 809 gfx::Size(10, 10), |
810 true, | 810 true, |
811 false); | 811 false); |
812 SetLayerPropertiesForTesting(child_of_rs1.get(), | 812 SetLayerPropertiesForTesting(child_of_rs1.get(), |
813 layer_transform, | 813 layer_transform, |
814 gfx::PointF(0.25f, 0.f), | 814 gfx::Point3F(2.5f, 0.f, 0.f), |
815 gfx::PointF(), | 815 gfx::PointF(), |
816 gfx::Size(10, 10), | 816 gfx::Size(10, 10), |
817 true, | 817 true, |
818 false); | 818 false); |
819 SetLayerPropertiesForTesting(child_of_rs2.get(), | 819 SetLayerPropertiesForTesting(child_of_rs2.get(), |
820 layer_transform, | 820 layer_transform, |
821 gfx::PointF(0.25f, 0.f), | 821 gfx::Point3F(2.5f, 0.f, 0.f), |
822 gfx::PointF(), | 822 gfx::PointF(), |
823 gfx::Size(10, 10), | 823 gfx::Size(10, 10), |
824 true, | 824 true, |
825 false); | 825 false); |
826 SetLayerPropertiesForTesting(grand_child_of_root.get(), | 826 SetLayerPropertiesForTesting(grand_child_of_root.get(), |
827 layer_transform, | 827 layer_transform, |
828 gfx::PointF(0.25f, 0.f), | 828 gfx::Point3F(2.5f, 0.f, 0.f), |
829 gfx::PointF(), | 829 gfx::PointF(), |
830 gfx::Size(10, 10), | 830 gfx::Size(10, 10), |
831 true, | 831 true, |
832 false); | 832 false); |
833 SetLayerPropertiesForTesting(grand_child_of_rs1.get(), | 833 SetLayerPropertiesForTesting(grand_child_of_rs1.get(), |
834 layer_transform, | 834 layer_transform, |
835 gfx::PointF(0.25f, 0.f), | 835 gfx::Point3F(2.5f, 0.f, 0.f), |
836 gfx::PointF(), | 836 gfx::PointF(), |
837 gfx::Size(10, 10), | 837 gfx::Size(10, 10), |
838 true, | 838 true, |
839 false); | 839 false); |
840 SetLayerPropertiesForTesting(grand_child_of_rs2.get(), | 840 SetLayerPropertiesForTesting(grand_child_of_rs2.get(), |
841 layer_transform, | 841 layer_transform, |
842 gfx::PointF(0.25f, 0.f), | 842 gfx::Point3F(2.5f, 0.f, 0.f), |
843 gfx::PointF(), | 843 gfx::PointF(), |
844 gfx::Size(10, 10), | 844 gfx::Size(10, 10), |
845 true, | 845 true, |
846 false); | 846 false); |
847 SetLayerPropertiesForTesting(replica_of_rs1.get(), | 847 SetLayerPropertiesForTesting(replica_of_rs1.get(), |
848 replica_layer_transform, | 848 replica_layer_transform, |
849 gfx::PointF(0.25f, 0.f), | 849 gfx::Point3F(2.5f, 0.f, 0.f), |
850 gfx::PointF(), | 850 gfx::PointF(), |
851 gfx::Size(), | 851 gfx::Size(), |
852 true, | 852 true, |
853 false); | 853 false); |
854 SetLayerPropertiesForTesting(replica_of_rs2.get(), | 854 SetLayerPropertiesForTesting(replica_of_rs2.get(), |
855 replica_layer_transform, | 855 replica_layer_transform, |
856 gfx::PointF(0.25f, 0.f), | 856 gfx::Point3F(2.5f, 0.f, 0.f), |
857 gfx::PointF(), | 857 gfx::PointF(), |
858 gfx::Size(), | 858 gfx::Size(), |
859 true, | 859 true, |
860 false); | 860 false); |
861 | 861 |
862 ExecuteCalculateDrawProperties(root.get()); | 862 ExecuteCalculateDrawProperties(root.get()); |
863 | 863 |
864 // Only layers that are associated with render surfaces should have an actual | 864 // Only layers that are associated with render surfaces should have an actual |
865 // RenderSurface() value. | 865 // RenderSurface() value. |
866 ASSERT_TRUE(root->render_surface()); | 866 ASSERT_TRUE(root->render_surface()); |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
988 scoped_refptr<Layer> child = Layer::Create(); | 988 scoped_refptr<Layer> child = Layer::Create(); |
989 scoped_refptr<LayerWithForcedDrawsContent> grand_child = | 989 scoped_refptr<LayerWithForcedDrawsContent> grand_child = |
990 make_scoped_refptr(new LayerWithForcedDrawsContent()); | 990 make_scoped_refptr(new LayerWithForcedDrawsContent()); |
991 | 991 |
992 gfx::Transform rotation_about_y_axis; | 992 gfx::Transform rotation_about_y_axis; |
993 rotation_about_y_axis.RotateAboutYAxis(30.0); | 993 rotation_about_y_axis.RotateAboutYAxis(30.0); |
994 | 994 |
995 const gfx::Transform identity_matrix; | 995 const gfx::Transform identity_matrix; |
996 SetLayerPropertiesForTesting(root.get(), | 996 SetLayerPropertiesForTesting(root.get(), |
997 identity_matrix, | 997 identity_matrix, |
998 gfx::PointF(), | 998 gfx::Point3F(), |
999 gfx::PointF(), | 999 gfx::PointF(), |
1000 gfx::Size(100, 100), | 1000 gfx::Size(100, 100), |
1001 true, | 1001 true, |
1002 false); | 1002 false); |
1003 SetLayerPropertiesForTesting(child.get(), | 1003 SetLayerPropertiesForTesting(child.get(), |
1004 rotation_about_y_axis, | 1004 rotation_about_y_axis, |
1005 gfx::PointF(), | 1005 gfx::Point3F(), |
1006 gfx::PointF(), | 1006 gfx::PointF(), |
1007 gfx::Size(10, 10), | 1007 gfx::Size(10, 10), |
1008 true, | 1008 true, |
1009 false); | 1009 false); |
1010 SetLayerPropertiesForTesting(grand_child.get(), | 1010 SetLayerPropertiesForTesting(grand_child.get(), |
1011 rotation_about_y_axis, | 1011 rotation_about_y_axis, |
1012 gfx::PointF(), | 1012 gfx::Point3F(), |
1013 gfx::PointF(), | 1013 gfx::PointF(), |
1014 gfx::Size(10, 10), | 1014 gfx::Size(10, 10), |
1015 true, | 1015 true, |
1016 false); | 1016 false); |
1017 | 1017 |
1018 root->AddChild(child); | 1018 root->AddChild(child); |
1019 child->AddChild(grand_child); | 1019 child->AddChild(grand_child); |
1020 child->SetForceRenderSurface(true); | 1020 child->SetForceRenderSurface(true); |
1021 | 1021 |
1022 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 1022 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1067 scoped_refptr<Layer> root = Layer::Create(); | 1067 scoped_refptr<Layer> root = Layer::Create(); |
1068 scoped_refptr<Layer> child = Layer::Create(); | 1068 scoped_refptr<Layer> child = Layer::Create(); |
1069 scoped_refptr<LayerWithForcedDrawsContent> grand_child = | 1069 scoped_refptr<LayerWithForcedDrawsContent> grand_child = |
1070 make_scoped_refptr(new LayerWithForcedDrawsContent()); | 1070 make_scoped_refptr(new LayerWithForcedDrawsContent()); |
1071 | 1071 |
1072 // The child height is zero, but has non-zero width that should be accounted | 1072 // The child height is zero, but has non-zero width that should be accounted |
1073 // for while computing draw transforms. | 1073 // for while computing draw transforms. |
1074 const gfx::Transform identity_matrix; | 1074 const gfx::Transform identity_matrix; |
1075 SetLayerPropertiesForTesting(root.get(), | 1075 SetLayerPropertiesForTesting(root.get(), |
1076 identity_matrix, | 1076 identity_matrix, |
1077 gfx::PointF(), | 1077 gfx::Point3F(), |
1078 gfx::PointF(), | 1078 gfx::PointF(), |
1079 gfx::Size(100, 100), | 1079 gfx::Size(100, 100), |
1080 true, | 1080 true, |
1081 false); | 1081 false); |
1082 SetLayerPropertiesForTesting(child.get(), | 1082 SetLayerPropertiesForTesting(child.get(), |
1083 identity_matrix, | 1083 identity_matrix, |
1084 gfx::PointF(), | 1084 gfx::Point3F(), |
1085 gfx::PointF(), | 1085 gfx::PointF(), |
1086 gfx::Size(10, 0), | 1086 gfx::Size(10, 0), |
1087 true, | 1087 true, |
1088 false); | 1088 false); |
1089 SetLayerPropertiesForTesting(grand_child.get(), | 1089 SetLayerPropertiesForTesting(grand_child.get(), |
1090 identity_matrix, | 1090 identity_matrix, |
1091 gfx::PointF(), | 1091 gfx::Point3F(), |
1092 gfx::PointF(), | 1092 gfx::PointF(), |
1093 gfx::Size(10, 10), | 1093 gfx::Size(10, 10), |
1094 true, | 1094 true, |
1095 false); | 1095 false); |
1096 | 1096 |
1097 root->AddChild(child); | 1097 root->AddChild(child); |
1098 child->AddChild(grand_child); | 1098 child->AddChild(grand_child); |
1099 child->SetForceRenderSurface(true); | 1099 child->SetForceRenderSurface(true); |
1100 | 1100 |
1101 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 1101 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
(...skipping 19 matching lines...) Expand all Loading... | |
1121 scoped_refptr<LayerWithForcedDrawsContent> child = | 1121 scoped_refptr<LayerWithForcedDrawsContent> child = |
1122 new LayerWithForcedDrawsContent; | 1122 new LayerWithForcedDrawsContent; |
1123 child->SetScrollClipLayerId(root->id()); | 1123 child->SetScrollClipLayerId(root->id()); |
1124 root->AddChild(child); | 1124 root->AddChild(child); |
1125 | 1125 |
1126 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 1126 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
1127 host->SetRootLayer(root); | 1127 host->SetRootLayer(root); |
1128 | 1128 |
1129 SetLayerPropertiesForTesting(root.get(), | 1129 SetLayerPropertiesForTesting(root.get(), |
1130 identity_matrix, | 1130 identity_matrix, |
1131 gfx::PointF(), | 1131 gfx::Point3F(), |
1132 gfx::PointF(), | 1132 gfx::PointF(), |
1133 gfx::Size(20, 20), | 1133 gfx::Size(20, 20), |
1134 true, | 1134 true, |
1135 false); | 1135 false); |
1136 SetLayerPropertiesForTesting(child.get(), | 1136 SetLayerPropertiesForTesting(child.get(), |
1137 identity_matrix, | 1137 identity_matrix, |
1138 gfx::PointF(), | 1138 gfx::Point3F(), |
1139 gfx::PointF(), | 1139 gfx::PointF(), |
1140 gfx::Size(20, 20), | 1140 gfx::Size(20, 20), |
1141 true, | 1141 true, |
1142 false); | 1142 false); |
1143 | 1143 |
1144 gfx::Transform translate; | 1144 gfx::Transform translate; |
1145 translate.Translate(50, 50); | 1145 translate.Translate(50, 50); |
1146 { | 1146 { |
1147 RenderSurfaceLayerList render_surface_layer_list; | 1147 RenderSurfaceLayerList render_surface_layer_list; |
1148 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( | 1148 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( |
(...skipping 119 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1268 scoped_refptr<Layer> render_surface1 = Layer::Create(); | 1268 scoped_refptr<Layer> render_surface1 = Layer::Create(); |
1269 scoped_refptr<LayerWithForcedDrawsContent> child = | 1269 scoped_refptr<LayerWithForcedDrawsContent> child = |
1270 make_scoped_refptr(new LayerWithForcedDrawsContent()); | 1270 make_scoped_refptr(new LayerWithForcedDrawsContent()); |
1271 | 1271 |
1272 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 1272 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
1273 host->SetRootLayer(parent); | 1273 host->SetRootLayer(parent); |
1274 | 1274 |
1275 const gfx::Transform identity_matrix; | 1275 const gfx::Transform identity_matrix; |
1276 SetLayerPropertiesForTesting(parent.get(), | 1276 SetLayerPropertiesForTesting(parent.get(), |
1277 identity_matrix, | 1277 identity_matrix, |
1278 gfx::PointF(), | 1278 gfx::Point3F(), |
1279 gfx::PointF(), | 1279 gfx::PointF(), |
1280 gfx::Size(10, 10), | 1280 gfx::Size(10, 10), |
1281 true, | 1281 true, |
1282 false); | 1282 false); |
1283 SetLayerPropertiesForTesting(render_surface1.get(), | 1283 SetLayerPropertiesForTesting(render_surface1.get(), |
1284 identity_matrix, | 1284 identity_matrix, |
1285 gfx::PointF(), | 1285 gfx::Point3F(), |
1286 gfx::PointF(), | 1286 gfx::PointF(), |
1287 gfx::Size(10, 10), | 1287 gfx::Size(10, 10), |
1288 true, | 1288 true, |
1289 false); | 1289 false); |
1290 SetLayerPropertiesForTesting(child.get(), | 1290 SetLayerPropertiesForTesting(child.get(), |
1291 identity_matrix, | 1291 identity_matrix, |
1292 gfx::PointF(), | 1292 gfx::Point3F(), |
1293 gfx::PointF(30.f, 30.f), | 1293 gfx::PointF(30.f, 30.f), |
1294 gfx::Size(10, 10), | 1294 gfx::Size(10, 10), |
1295 true, | 1295 true, |
1296 false); | 1296 false); |
1297 | 1297 |
1298 parent->AddChild(render_surface1); | 1298 parent->AddChild(render_surface1); |
1299 parent->SetMasksToBounds(true); | 1299 parent->SetMasksToBounds(true); |
1300 render_surface1->AddChild(child); | 1300 render_surface1->AddChild(child); |
1301 render_surface1->SetForceRenderSurface(true); | 1301 render_surface1->SetForceRenderSurface(true); |
1302 | 1302 |
(...skipping 19 matching lines...) Expand all Loading... | |
1322 scoped_refptr<Layer> render_surface1 = Layer::Create(); | 1322 scoped_refptr<Layer> render_surface1 = Layer::Create(); |
1323 scoped_refptr<LayerWithForcedDrawsContent> child = | 1323 scoped_refptr<LayerWithForcedDrawsContent> child = |
1324 make_scoped_refptr(new LayerWithForcedDrawsContent()); | 1324 make_scoped_refptr(new LayerWithForcedDrawsContent()); |
1325 | 1325 |
1326 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 1326 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
1327 host->SetRootLayer(parent); | 1327 host->SetRootLayer(parent); |
1328 | 1328 |
1329 const gfx::Transform identity_matrix; | 1329 const gfx::Transform identity_matrix; |
1330 SetLayerPropertiesForTesting(render_surface1.get(), | 1330 SetLayerPropertiesForTesting(render_surface1.get(), |
1331 identity_matrix, | 1331 identity_matrix, |
1332 gfx::PointF(), | 1332 gfx::Point3F(), |
1333 gfx::PointF(), | 1333 gfx::PointF(), |
1334 gfx::Size(10, 10), | 1334 gfx::Size(10, 10), |
1335 true, | 1335 true, |
1336 false); | 1336 false); |
1337 SetLayerPropertiesForTesting(child.get(), | 1337 SetLayerPropertiesForTesting(child.get(), |
1338 identity_matrix, | 1338 identity_matrix, |
1339 gfx::PointF(), | 1339 gfx::Point3F(), |
1340 gfx::PointF(), | 1340 gfx::PointF(), |
1341 gfx::Size(10, 10), | 1341 gfx::Size(10, 10), |
1342 true, | 1342 true, |
1343 false); | 1343 false); |
1344 | 1344 |
1345 parent->AddChild(render_surface1); | 1345 parent->AddChild(render_surface1); |
1346 render_surface1->AddChild(child); | 1346 render_surface1->AddChild(child); |
1347 render_surface1->SetForceRenderSurface(true); | 1347 render_surface1->SetForceRenderSurface(true); |
1348 render_surface1->SetOpacity(0.f); | 1348 render_surface1->SetOpacity(0.f); |
1349 | 1349 |
(...skipping 19 matching lines...) Expand all Loading... | |
1369 scoped_refptr<LayerWithForcedDrawsContent> child = | 1369 scoped_refptr<LayerWithForcedDrawsContent> child = |
1370 make_scoped_refptr(new LayerWithForcedDrawsContent()); | 1370 make_scoped_refptr(new LayerWithForcedDrawsContent()); |
1371 render_surface1->SetForceRenderSurface(true); | 1371 render_surface1->SetForceRenderSurface(true); |
1372 | 1372 |
1373 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 1373 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
1374 host->SetRootLayer(parent); | 1374 host->SetRootLayer(parent); |
1375 | 1375 |
1376 const gfx::Transform identity_matrix; | 1376 const gfx::Transform identity_matrix; |
1377 SetLayerPropertiesForTesting(parent.get(), | 1377 SetLayerPropertiesForTesting(parent.get(), |
1378 identity_matrix, | 1378 identity_matrix, |
1379 gfx::PointF(), | 1379 gfx::Point3F(), |
1380 gfx::PointF(), | 1380 gfx::PointF(), |
1381 gfx::Size(10, 10), | 1381 gfx::Size(10, 10), |
1382 true, | 1382 true, |
1383 false); | 1383 false); |
1384 SetLayerPropertiesForTesting(render_surface1.get(), | 1384 SetLayerPropertiesForTesting(render_surface1.get(), |
1385 identity_matrix, | 1385 identity_matrix, |
1386 gfx::PointF(), | 1386 gfx::Point3F(), |
1387 gfx::PointF(), | 1387 gfx::PointF(), |
1388 gfx::Size(10, 10), | 1388 gfx::Size(10, 10), |
1389 true, | 1389 true, |
1390 false); | 1390 false); |
1391 SetLayerPropertiesForTesting(child.get(), | 1391 SetLayerPropertiesForTesting(child.get(), |
1392 identity_matrix, | 1392 identity_matrix, |
1393 gfx::PointF(), | 1393 gfx::Point3F(), |
1394 gfx::PointF(), | 1394 gfx::PointF(), |
1395 gfx::Size(10, 10), | 1395 gfx::Size(10, 10), |
1396 true, | 1396 true, |
1397 false); | 1397 false); |
1398 | 1398 |
1399 parent->AddChild(render_surface1); | 1399 parent->AddChild(render_surface1); |
1400 render_surface1->AddChild(child); | 1400 render_surface1->AddChild(child); |
1401 | 1401 |
1402 // Sanity check before the actual test | 1402 // Sanity check before the actual test |
1403 EXPECT_FALSE(parent->render_surface()); | 1403 EXPECT_FALSE(parent->render_surface()); |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1463 host->SetRootLayer(parent); | 1463 host->SetRootLayer(parent); |
1464 | 1464 |
1465 // leaf_node1 ensures that parent and child are kept on the | 1465 // leaf_node1 ensures that parent and child are kept on the |
1466 // render_surface_layer_list, even though grand_child and great_grand_child | 1466 // render_surface_layer_list, even though grand_child and great_grand_child |
1467 // should be clipped. | 1467 // should be clipped. |
1468 child->AddChild(leaf_node1); | 1468 child->AddChild(leaf_node1); |
1469 great_grand_child->AddChild(leaf_node2); | 1469 great_grand_child->AddChild(leaf_node2); |
1470 | 1470 |
1471 SetLayerPropertiesForTesting(parent.get(), | 1471 SetLayerPropertiesForTesting(parent.get(), |
1472 identity_matrix, | 1472 identity_matrix, |
1473 gfx::PointF(), | 1473 gfx::Point3F(), |
1474 gfx::PointF(), | 1474 gfx::PointF(), |
1475 gfx::Size(500, 500), | 1475 gfx::Size(500, 500), |
1476 true, | 1476 true, |
1477 false); | 1477 false); |
1478 SetLayerPropertiesForTesting(child.get(), | 1478 SetLayerPropertiesForTesting(child.get(), |
1479 identity_matrix, | 1479 identity_matrix, |
1480 gfx::PointF(), | 1480 gfx::Point3F(), |
1481 gfx::PointF(), | 1481 gfx::PointF(), |
1482 gfx::Size(20, 20), | 1482 gfx::Size(20, 20), |
1483 true, | 1483 true, |
1484 false); | 1484 false); |
1485 SetLayerPropertiesForTesting(grand_child.get(), | 1485 SetLayerPropertiesForTesting(grand_child.get(), |
1486 identity_matrix, | 1486 identity_matrix, |
1487 gfx::PointF(), | 1487 gfx::Point3F(), |
1488 gfx::PointF(45.f, 45.f), | 1488 gfx::PointF(45.f, 45.f), |
1489 gfx::Size(10, 10), | 1489 gfx::Size(10, 10), |
1490 true, | 1490 true, |
1491 false); | 1491 false); |
1492 SetLayerPropertiesForTesting(great_grand_child.get(), | 1492 SetLayerPropertiesForTesting(great_grand_child.get(), |
1493 identity_matrix, | 1493 identity_matrix, |
1494 gfx::PointF(), | 1494 gfx::Point3F(), |
1495 gfx::PointF(), | 1495 gfx::PointF(), |
1496 gfx::Size(10, 10), | 1496 gfx::Size(10, 10), |
1497 true, | 1497 true, |
1498 false); | 1498 false); |
1499 SetLayerPropertiesForTesting(leaf_node1.get(), | 1499 SetLayerPropertiesForTesting(leaf_node1.get(), |
1500 identity_matrix, | 1500 identity_matrix, |
1501 gfx::PointF(), | 1501 gfx::Point3F(), |
1502 gfx::PointF(), | 1502 gfx::PointF(), |
1503 gfx::Size(500, 500), | 1503 gfx::Size(500, 500), |
1504 true, | 1504 true, |
1505 false); | 1505 false); |
1506 SetLayerPropertiesForTesting(leaf_node2.get(), | 1506 SetLayerPropertiesForTesting(leaf_node2.get(), |
1507 identity_matrix, | 1507 identity_matrix, |
1508 gfx::PointF(), | 1508 gfx::Point3F(), |
1509 gfx::PointF(), | 1509 gfx::PointF(), |
1510 gfx::Size(20, 20), | 1510 gfx::Size(20, 20), |
1511 true, | 1511 true, |
1512 false); | 1512 false); |
1513 | 1513 |
1514 child->SetMasksToBounds(true); | 1514 child->SetMasksToBounds(true); |
1515 child->SetOpacity(0.4f); | 1515 child->SetOpacity(0.4f); |
1516 child->SetForceRenderSurface(true); | 1516 child->SetForceRenderSurface(true); |
1517 grand_child->SetOpacity(0.5f); | 1517 grand_child->SetOpacity(0.5f); |
1518 great_grand_child->SetOpacity(0.4f); | 1518 great_grand_child->SetOpacity(0.4f); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1555 make_scoped_refptr(new LayerWithForcedDrawsContent()); | 1555 make_scoped_refptr(new LayerWithForcedDrawsContent()); |
1556 parent->AddChild(child); | 1556 parent->AddChild(child); |
1557 child->AddChild(grand_child); | 1557 child->AddChild(grand_child); |
1558 grand_child->AddChild(leaf_node); | 1558 grand_child->AddChild(leaf_node); |
1559 | 1559 |
1560 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 1560 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
1561 host->SetRootLayer(parent); | 1561 host->SetRootLayer(parent); |
1562 | 1562 |
1563 SetLayerPropertiesForTesting(parent.get(), | 1563 SetLayerPropertiesForTesting(parent.get(), |
1564 identity_matrix, | 1564 identity_matrix, |
1565 gfx::PointF(), | 1565 gfx::Point3F(), |
1566 gfx::PointF(), | 1566 gfx::PointF(), |
1567 gfx::Size(100, 100), | 1567 gfx::Size(100, 100), |
1568 true, | 1568 true, |
1569 false); | 1569 false); |
1570 SetLayerPropertiesForTesting(child.get(), | 1570 SetLayerPropertiesForTesting(child.get(), |
1571 identity_matrix, | 1571 identity_matrix, |
1572 gfx::PointF(), | 1572 gfx::Point3F(), |
1573 gfx::PointF(), | 1573 gfx::PointF(), |
1574 gfx::Size(20, 20), | 1574 gfx::Size(20, 20), |
1575 true, | 1575 true, |
1576 false); | 1576 false); |
1577 SetLayerPropertiesForTesting(grand_child.get(), | 1577 SetLayerPropertiesForTesting(grand_child.get(), |
1578 identity_matrix, | 1578 identity_matrix, |
1579 gfx::PointF(), | 1579 gfx::Point3F(), |
1580 gfx::PointF(200.f, 200.f), | 1580 gfx::PointF(200.f, 200.f), |
1581 gfx::Size(10, 10), | 1581 gfx::Size(10, 10), |
1582 true, | 1582 true, |
1583 false); | 1583 false); |
1584 SetLayerPropertiesForTesting(leaf_node.get(), | 1584 SetLayerPropertiesForTesting(leaf_node.get(), |
1585 identity_matrix, | 1585 identity_matrix, |
1586 gfx::PointF(), | 1586 gfx::Point3F(), |
1587 gfx::PointF(), | 1587 gfx::PointF(), |
1588 gfx::Size(10, 10), | 1588 gfx::Size(10, 10), |
1589 true, | 1589 true, |
1590 false); | 1590 false); |
1591 | 1591 |
1592 parent->SetMasksToBounds(true); | 1592 parent->SetMasksToBounds(true); |
1593 child->SetOpacity(0.4f); | 1593 child->SetOpacity(0.4f); |
1594 child->SetForceRenderSurface(true); | 1594 child->SetForceRenderSurface(true); |
1595 grand_child->SetOpacity(0.4f); | 1595 grand_child->SetOpacity(0.4f); |
1596 grand_child->SetForceRenderSurface(true); | 1596 grand_child->SetForceRenderSurface(true); |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1659 child2->AddChild(leaf_node2); | 1659 child2->AddChild(leaf_node2); |
1660 grand_child->AddChild(leaf_node1); | 1660 grand_child->AddChild(leaf_node1); |
1661 | 1661 |
1662 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 1662 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
1663 host->SetRootLayer(root); | 1663 host->SetRootLayer(root); |
1664 | 1664 |
1665 child2->SetForceRenderSurface(true); | 1665 child2->SetForceRenderSurface(true); |
1666 | 1666 |
1667 SetLayerPropertiesForTesting(root.get(), | 1667 SetLayerPropertiesForTesting(root.get(), |
1668 identity_matrix, | 1668 identity_matrix, |
1669 gfx::PointF(), | 1669 gfx::Point3F(), |
1670 gfx::PointF(), | 1670 gfx::PointF(), |
1671 gfx::Size(100, 100), | 1671 gfx::Size(100, 100), |
1672 true, | 1672 true, |
1673 false); | 1673 false); |
1674 SetLayerPropertiesForTesting(parent.get(), | 1674 SetLayerPropertiesForTesting(parent.get(), |
1675 identity_matrix, | 1675 identity_matrix, |
1676 gfx::PointF(), | 1676 gfx::Point3F(), |
1677 gfx::PointF(), | 1677 gfx::PointF(), |
1678 gfx::Size(100, 100), | 1678 gfx::Size(100, 100), |
1679 true, | 1679 true, |
1680 false); | 1680 false); |
1681 SetLayerPropertiesForTesting(child1.get(), | 1681 SetLayerPropertiesForTesting(child1.get(), |
1682 identity_matrix, | 1682 identity_matrix, |
1683 gfx::PointF(), | 1683 gfx::Point3F(), |
1684 gfx::PointF(), | 1684 gfx::PointF(), |
1685 gfx::Size(100, 100), | 1685 gfx::Size(100, 100), |
1686 true, | 1686 true, |
1687 false); | 1687 false); |
1688 SetLayerPropertiesForTesting(child2.get(), | 1688 SetLayerPropertiesForTesting(child2.get(), |
1689 identity_matrix, | 1689 identity_matrix, |
1690 gfx::PointF(), | 1690 gfx::Point3F(), |
1691 gfx::PointF(), | 1691 gfx::PointF(), |
1692 gfx::Size(100, 100), | 1692 gfx::Size(100, 100), |
1693 true, | 1693 true, |
1694 false); | 1694 false); |
1695 SetLayerPropertiesForTesting(grand_child.get(), | 1695 SetLayerPropertiesForTesting(grand_child.get(), |
1696 identity_matrix, | 1696 identity_matrix, |
1697 gfx::PointF(), | 1697 gfx::Point3F(), |
1698 gfx::PointF(), | 1698 gfx::PointF(), |
1699 gfx::Size(100, 100), | 1699 gfx::Size(100, 100), |
1700 true, | 1700 true, |
1701 false); | 1701 false); |
1702 SetLayerPropertiesForTesting(leaf_node1.get(), | 1702 SetLayerPropertiesForTesting(leaf_node1.get(), |
1703 identity_matrix, | 1703 identity_matrix, |
1704 gfx::PointF(), | 1704 gfx::Point3F(), |
1705 gfx::PointF(), | 1705 gfx::PointF(), |
1706 gfx::Size(100, 100), | 1706 gfx::Size(100, 100), |
1707 true, | 1707 true, |
1708 false); | 1708 false); |
1709 SetLayerPropertiesForTesting(leaf_node2.get(), | 1709 SetLayerPropertiesForTesting(leaf_node2.get(), |
1710 identity_matrix, | 1710 identity_matrix, |
1711 gfx::PointF(), | 1711 gfx::Point3F(), |
1712 gfx::PointF(), | 1712 gfx::PointF(), |
1713 gfx::Size(100, 100), | 1713 gfx::Size(100, 100), |
1714 true, | 1714 true, |
1715 false); | 1715 false); |
1716 | 1716 |
1717 // Case 1: nothing is clipped except the root render surface. | 1717 // Case 1: nothing is clipped except the root render surface. |
1718 { | 1718 { |
1719 RenderSurfaceLayerList render_surface_layer_list; | 1719 RenderSurfaceLayerList render_surface_layer_list; |
1720 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( | 1720 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( |
1721 root.get(), parent->bounds(), &render_surface_layer_list); | 1721 root.get(), parent->bounds(), &render_surface_layer_list); |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1815 child->AddChild(grand_child1); | 1815 child->AddChild(grand_child1); |
1816 child->AddChild(grand_child2); | 1816 child->AddChild(grand_child2); |
1817 child->AddChild(grand_child3); | 1817 child->AddChild(grand_child3); |
1818 child->AddChild(grand_child4); | 1818 child->AddChild(grand_child4); |
1819 | 1819 |
1820 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 1820 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
1821 host->SetRootLayer(parent); | 1821 host->SetRootLayer(parent); |
1822 | 1822 |
1823 SetLayerPropertiesForTesting(parent.get(), | 1823 SetLayerPropertiesForTesting(parent.get(), |
1824 identity_matrix, | 1824 identity_matrix, |
1825 gfx::PointF(), | 1825 gfx::Point3F(), |
1826 gfx::PointF(), | 1826 gfx::PointF(), |
1827 gfx::Size(500, 500), | 1827 gfx::Size(500, 500), |
1828 true, | 1828 true, |
1829 false); | 1829 false); |
1830 SetLayerPropertiesForTesting(child.get(), | 1830 SetLayerPropertiesForTesting(child.get(), |
1831 identity_matrix, | 1831 identity_matrix, |
1832 gfx::PointF(), | 1832 gfx::Point3F(), |
1833 gfx::PointF(), | 1833 gfx::PointF(), |
1834 gfx::Size(20, 20), | 1834 gfx::Size(20, 20), |
1835 true, | 1835 true, |
1836 false); | 1836 false); |
1837 SetLayerPropertiesForTesting(grand_child1.get(), | 1837 SetLayerPropertiesForTesting(grand_child1.get(), |
1838 identity_matrix, | 1838 identity_matrix, |
1839 gfx::PointF(), | 1839 gfx::Point3F(), |
1840 gfx::PointF(5.f, 5.f), | 1840 gfx::PointF(5.f, 5.f), |
1841 gfx::Size(10, 10), | 1841 gfx::Size(10, 10), |
1842 true, | 1842 true, |
1843 false); | 1843 false); |
1844 SetLayerPropertiesForTesting(grand_child2.get(), | 1844 SetLayerPropertiesForTesting(grand_child2.get(), |
1845 identity_matrix, | 1845 identity_matrix, |
1846 gfx::PointF(), | 1846 gfx::Point3F(), |
1847 gfx::PointF(15.f, 15.f), | 1847 gfx::PointF(15.f, 15.f), |
1848 gfx::Size(10, 10), | 1848 gfx::Size(10, 10), |
1849 true, | 1849 true, |
1850 false); | 1850 false); |
1851 SetLayerPropertiesForTesting(grand_child3.get(), | 1851 SetLayerPropertiesForTesting(grand_child3.get(), |
1852 identity_matrix, | 1852 identity_matrix, |
1853 gfx::PointF(), | 1853 gfx::Point3F(), |
1854 gfx::PointF(15.f, 15.f), | 1854 gfx::PointF(15.f, 15.f), |
1855 gfx::Size(10, 10), | 1855 gfx::Size(10, 10), |
1856 true, | 1856 true, |
1857 false); | 1857 false); |
1858 SetLayerPropertiesForTesting(grand_child4.get(), | 1858 SetLayerPropertiesForTesting(grand_child4.get(), |
1859 identity_matrix, | 1859 identity_matrix, |
1860 gfx::PointF(), | 1860 gfx::Point3F(), |
1861 gfx::PointF(45.f, 45.f), | 1861 gfx::PointF(45.f, 45.f), |
1862 gfx::Size(10, 10), | 1862 gfx::Size(10, 10), |
1863 true, | 1863 true, |
1864 false); | 1864 false); |
1865 | 1865 |
1866 child->SetMasksToBounds(true); | 1866 child->SetMasksToBounds(true); |
1867 grand_child3->SetMasksToBounds(true); | 1867 grand_child3->SetMasksToBounds(true); |
1868 | 1868 |
1869 // Force everyone to be a render surface. | 1869 // Force everyone to be a render surface. |
1870 child->SetOpacity(0.4f); | 1870 child->SetOpacity(0.4f); |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1923 | 1923 |
1924 // the leaf nodes ensure that these grand_children become render surfaces for | 1924 // the leaf nodes ensure that these grand_children become render surfaces for |
1925 // this test. | 1925 // this test. |
1926 grand_child1->AddChild(leaf_node1); | 1926 grand_child1->AddChild(leaf_node1); |
1927 grand_child2->AddChild(leaf_node2); | 1927 grand_child2->AddChild(leaf_node2); |
1928 grand_child3->AddChild(leaf_node3); | 1928 grand_child3->AddChild(leaf_node3); |
1929 grand_child4->AddChild(leaf_node4); | 1929 grand_child4->AddChild(leaf_node4); |
1930 | 1930 |
1931 SetLayerPropertiesForTesting(parent.get(), | 1931 SetLayerPropertiesForTesting(parent.get(), |
1932 identity_matrix, | 1932 identity_matrix, |
1933 gfx::PointF(), | 1933 gfx::Point3F(), |
1934 gfx::PointF(), | 1934 gfx::PointF(), |
1935 gfx::Size(500, 500), | 1935 gfx::Size(500, 500), |
1936 true, | 1936 true, |
1937 false); | 1937 false); |
1938 SetLayerPropertiesForTesting(child.get(), | 1938 SetLayerPropertiesForTesting(child.get(), |
1939 identity_matrix, | 1939 identity_matrix, |
1940 gfx::PointF(), | 1940 gfx::Point3F(), |
1941 gfx::PointF(), | 1941 gfx::PointF(), |
1942 gfx::Size(20, 20), | 1942 gfx::Size(20, 20), |
1943 true, | 1943 true, |
1944 false); | 1944 false); |
1945 SetLayerPropertiesForTesting(grand_child1.get(), | 1945 SetLayerPropertiesForTesting(grand_child1.get(), |
1946 identity_matrix, | 1946 identity_matrix, |
1947 gfx::PointF(), | 1947 gfx::Point3F(), |
1948 gfx::PointF(5.f, 5.f), | 1948 gfx::PointF(5.f, 5.f), |
1949 gfx::Size(10, 10), | 1949 gfx::Size(10, 10), |
1950 true, | 1950 true, |
1951 false); | 1951 false); |
1952 SetLayerPropertiesForTesting(grand_child2.get(), | 1952 SetLayerPropertiesForTesting(grand_child2.get(), |
1953 identity_matrix, | 1953 identity_matrix, |
1954 gfx::PointF(), | 1954 gfx::Point3F(), |
1955 gfx::PointF(15.f, 15.f), | 1955 gfx::PointF(15.f, 15.f), |
1956 gfx::Size(10, 10), | 1956 gfx::Size(10, 10), |
1957 true, | 1957 true, |
1958 false); | 1958 false); |
1959 SetLayerPropertiesForTesting(grand_child3.get(), | 1959 SetLayerPropertiesForTesting(grand_child3.get(), |
1960 identity_matrix, | 1960 identity_matrix, |
1961 gfx::PointF(), | 1961 gfx::Point3F(), |
1962 gfx::PointF(15.f, 15.f), | 1962 gfx::PointF(15.f, 15.f), |
1963 gfx::Size(10, 10), | 1963 gfx::Size(10, 10), |
1964 true, | 1964 true, |
1965 false); | 1965 false); |
1966 SetLayerPropertiesForTesting(grand_child4.get(), | 1966 SetLayerPropertiesForTesting(grand_child4.get(), |
1967 identity_matrix, | 1967 identity_matrix, |
1968 gfx::PointF(), | 1968 gfx::Point3F(), |
1969 gfx::PointF(45.f, 45.f), | 1969 gfx::PointF(45.f, 45.f), |
1970 gfx::Size(10, 10), | 1970 gfx::Size(10, 10), |
1971 true, | 1971 true, |
1972 false); | 1972 false); |
1973 SetLayerPropertiesForTesting(leaf_node1.get(), | 1973 SetLayerPropertiesForTesting(leaf_node1.get(), |
1974 identity_matrix, | 1974 identity_matrix, |
1975 gfx::PointF(), | 1975 gfx::Point3F(), |
1976 gfx::PointF(), | 1976 gfx::PointF(), |
1977 gfx::Size(10, 10), | 1977 gfx::Size(10, 10), |
1978 true, | 1978 true, |
1979 false); | 1979 false); |
1980 SetLayerPropertiesForTesting(leaf_node2.get(), | 1980 SetLayerPropertiesForTesting(leaf_node2.get(), |
1981 identity_matrix, | 1981 identity_matrix, |
1982 gfx::PointF(), | 1982 gfx::Point3F(), |
1983 gfx::PointF(), | 1983 gfx::PointF(), |
1984 gfx::Size(10, 10), | 1984 gfx::Size(10, 10), |
1985 true, | 1985 true, |
1986 false); | 1986 false); |
1987 SetLayerPropertiesForTesting(leaf_node3.get(), | 1987 SetLayerPropertiesForTesting(leaf_node3.get(), |
1988 identity_matrix, | 1988 identity_matrix, |
1989 gfx::PointF(), | 1989 gfx::Point3F(), |
1990 gfx::PointF(), | 1990 gfx::PointF(), |
1991 gfx::Size(10, 10), | 1991 gfx::Size(10, 10), |
1992 true, | 1992 true, |
1993 false); | 1993 false); |
1994 SetLayerPropertiesForTesting(leaf_node4.get(), | 1994 SetLayerPropertiesForTesting(leaf_node4.get(), |
1995 identity_matrix, | 1995 identity_matrix, |
1996 gfx::PointF(), | 1996 gfx::Point3F(), |
1997 gfx::PointF(), | 1997 gfx::PointF(), |
1998 gfx::Size(10, 10), | 1998 gfx::Size(10, 10), |
1999 true, | 1999 true, |
2000 false); | 2000 false); |
2001 | 2001 |
2002 child->SetMasksToBounds(true); | 2002 child->SetMasksToBounds(true); |
2003 grand_child3->SetMasksToBounds(true); | 2003 grand_child3->SetMasksToBounds(true); |
2004 grand_child4->SetMasksToBounds(true); | 2004 grand_child4->SetMasksToBounds(true); |
2005 | 2005 |
2006 // Force everyone to be a render surface. | 2006 // Force everyone to be a render surface. |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2060 | 2060 |
2061 // Make our render surfaces. | 2061 // Make our render surfaces. |
2062 render_surface1->SetForceRenderSurface(true); | 2062 render_surface1->SetForceRenderSurface(true); |
2063 render_surface2->SetForceRenderSurface(true); | 2063 render_surface2->SetForceRenderSurface(true); |
2064 | 2064 |
2065 gfx::Transform layer_transform; | 2065 gfx::Transform layer_transform; |
2066 layer_transform.Translate(1.0, 1.0); | 2066 layer_transform.Translate(1.0, 1.0); |
2067 | 2067 |
2068 SetLayerPropertiesForTesting(parent.get(), | 2068 SetLayerPropertiesForTesting(parent.get(), |
2069 layer_transform, | 2069 layer_transform, |
2070 gfx::PointF(0.25f, 0.f), | 2070 gfx::Point3F(0.25f, 0.f, 0.f), |
2071 gfx::PointF(2.5f, 0.f), | 2071 gfx::PointF(2.5f, 0.f), |
2072 gfx::Size(10, 10), | 2072 gfx::Size(10, 10), |
2073 true, | 2073 true, |
2074 false); | 2074 false); |
2075 SetLayerPropertiesForTesting(render_surface1.get(), | 2075 SetLayerPropertiesForTesting(render_surface1.get(), |
2076 layer_transform, | 2076 layer_transform, |
2077 gfx::PointF(0.25f, 0.f), | 2077 gfx::Point3F(0.25f, 0.f, 0.f), |
2078 gfx::PointF(2.5f, 0.f), | 2078 gfx::PointF(2.5f, 0.f), |
2079 gfx::Size(10, 10), | 2079 gfx::Size(10, 10), |
2080 true, | 2080 true, |
2081 false); | 2081 false); |
2082 SetLayerPropertiesForTesting(render_surface2.get(), | 2082 SetLayerPropertiesForTesting(render_surface2.get(), |
2083 layer_transform, | 2083 layer_transform, |
2084 gfx::PointF(0.25f, 0.f), | 2084 gfx::Point3F(0.25f, 0.f, 0.f), |
2085 gfx::PointF(2.5f, 0.f), | 2085 gfx::PointF(2.5f, 0.f), |
2086 gfx::Size(10, 10), | 2086 gfx::Size(10, 10), |
2087 true, | 2087 true, |
2088 false); | 2088 false); |
2089 SetLayerPropertiesForTesting(child_of_root.get(), | 2089 SetLayerPropertiesForTesting(child_of_root.get(), |
2090 layer_transform, | 2090 layer_transform, |
2091 gfx::PointF(0.25f, 0.f), | 2091 gfx::Point3F(0.25f, 0.f, 0.f), |
2092 gfx::PointF(2.5f, 0.f), | 2092 gfx::PointF(2.5f, 0.f), |
2093 gfx::Size(10, 10), | 2093 gfx::Size(10, 10), |
2094 true, | 2094 true, |
2095 false); | 2095 false); |
2096 SetLayerPropertiesForTesting(child_of_rs1.get(), | 2096 SetLayerPropertiesForTesting(child_of_rs1.get(), |
2097 layer_transform, | 2097 layer_transform, |
2098 gfx::PointF(0.25f, 0.f), | 2098 gfx::Point3F(0.25f, 0.f, 0.f), |
2099 gfx::PointF(2.5f, 0.f), | 2099 gfx::PointF(2.5f, 0.f), |
2100 gfx::Size(10, 10), | 2100 gfx::Size(10, 10), |
2101 true, | 2101 true, |
2102 false); | 2102 false); |
2103 SetLayerPropertiesForTesting(child_of_rs2.get(), | 2103 SetLayerPropertiesForTesting(child_of_rs2.get(), |
2104 layer_transform, | 2104 layer_transform, |
2105 gfx::PointF(0.25f, 0.f), | 2105 gfx::Point3F(0.25f, 0.f, 0.f), |
2106 gfx::PointF(2.5f, 0.f), | 2106 gfx::PointF(2.5f, 0.f), |
2107 gfx::Size(10, 10), | 2107 gfx::Size(10, 10), |
2108 true, | 2108 true, |
2109 false); | 2109 false); |
2110 SetLayerPropertiesForTesting(grand_child_of_root.get(), | 2110 SetLayerPropertiesForTesting(grand_child_of_root.get(), |
2111 layer_transform, | 2111 layer_transform, |
2112 gfx::PointF(0.25f, 0.f), | 2112 gfx::Point3F(0.25f, 0.f, 0.f), |
2113 gfx::PointF(2.5f, 0.f), | 2113 gfx::PointF(2.5f, 0.f), |
2114 gfx::Size(10, 10), | 2114 gfx::Size(10, 10), |
2115 true, | 2115 true, |
2116 false); | 2116 false); |
2117 SetLayerPropertiesForTesting(grand_child_of_rs1.get(), | 2117 SetLayerPropertiesForTesting(grand_child_of_rs1.get(), |
2118 layer_transform, | 2118 layer_transform, |
2119 gfx::PointF(0.25f, 0.f), | 2119 gfx::Point3F(0.25f, 0.f, 0.f), |
2120 gfx::PointF(2.5f, 0.f), | 2120 gfx::PointF(2.5f, 0.f), |
2121 gfx::Size(10, 10), | 2121 gfx::Size(10, 10), |
2122 true, | 2122 true, |
2123 false); | 2123 false); |
2124 SetLayerPropertiesForTesting(grand_child_of_rs2.get(), | 2124 SetLayerPropertiesForTesting(grand_child_of_rs2.get(), |
2125 layer_transform, | 2125 layer_transform, |
2126 gfx::PointF(0.25f, 0.f), | 2126 gfx::Point3F(0.25f, 0.f, 0.f), |
2127 gfx::PointF(2.5f, 0.f), | 2127 gfx::PointF(2.5f, 0.f), |
2128 gfx::Size(10, 10), | 2128 gfx::Size(10, 10), |
2129 true, | 2129 true, |
2130 false); | 2130 false); |
2131 | 2131 |
2132 // Put an animated opacity on the render surface. | 2132 // Put an animated opacity on the render surface. |
2133 AddOpacityTransitionToController( | 2133 AddOpacityTransitionToController( |
2134 render_surface1->layer_animation_controller(), 10.0, 1.f, 0.f, false); | 2134 render_surface1->layer_animation_controller(), 10.0, 1.f, 0.f, false); |
2135 | 2135 |
2136 // Also put an animated opacity on a layer without descendants. | 2136 // Also put an animated opacity on a layer without descendants. |
(...skipping 405 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2542 root->AddChild(child1); | 2542 root->AddChild(child1); |
2543 root->AddChild(child2); | 2543 root->AddChild(child2); |
2544 root->AddChild(child3); | 2544 root->AddChild(child3); |
2545 | 2545 |
2546 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 2546 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
2547 host->SetRootLayer(root); | 2547 host->SetRootLayer(root); |
2548 | 2548 |
2549 gfx::Transform identity_matrix; | 2549 gfx::Transform identity_matrix; |
2550 SetLayerPropertiesForTesting(root.get(), | 2550 SetLayerPropertiesForTesting(root.get(), |
2551 identity_matrix, | 2551 identity_matrix, |
2552 gfx::PointF(), | 2552 gfx::Point3F(), |
2553 gfx::PointF(), | 2553 gfx::PointF(), |
2554 gfx::Size(100, 100), | 2554 gfx::Size(100, 100), |
2555 true, | 2555 true, |
2556 false); | 2556 false); |
2557 SetLayerPropertiesForTesting(child1.get(), | 2557 SetLayerPropertiesForTesting(child1.get(), |
2558 identity_matrix, | 2558 identity_matrix, |
2559 gfx::PointF(), | 2559 gfx::Point3F(), |
2560 gfx::PointF(), | 2560 gfx::PointF(), |
2561 gfx::Size(50, 50), | 2561 gfx::Size(50, 50), |
2562 true, | 2562 true, |
2563 false); | 2563 false); |
2564 SetLayerPropertiesForTesting(child2.get(), | 2564 SetLayerPropertiesForTesting(child2.get(), |
2565 identity_matrix, | 2565 identity_matrix, |
2566 gfx::PointF(), | 2566 gfx::Point3F(), |
2567 gfx::PointF(75.f, 75.f), | 2567 gfx::PointF(75.f, 75.f), |
2568 gfx::Size(50, 50), | 2568 gfx::Size(50, 50), |
2569 true, | 2569 true, |
2570 false); | 2570 false); |
2571 SetLayerPropertiesForTesting(child3.get(), | 2571 SetLayerPropertiesForTesting(child3.get(), |
2572 identity_matrix, | 2572 identity_matrix, |
2573 gfx::PointF(), | 2573 gfx::Point3F(), |
2574 gfx::PointF(125.f, 125.f), | 2574 gfx::PointF(125.f, 125.f), |
2575 gfx::Size(50, 50), | 2575 gfx::Size(50, 50), |
2576 true, | 2576 true, |
2577 false); | 2577 false); |
2578 | 2578 |
2579 ExecuteCalculateDrawProperties(root.get()); | 2579 ExecuteCalculateDrawProperties(root.get()); |
2580 | 2580 |
2581 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), | 2581 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), |
2582 root->render_surface()->DrawableContentRect()); | 2582 root->render_surface()->DrawableContentRect()); |
2583 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect()); | 2583 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect()); |
(...skipping 26 matching lines...) Expand all Loading... | |
2610 child->AddChild(grand_child1); | 2610 child->AddChild(grand_child1); |
2611 child->AddChild(grand_child2); | 2611 child->AddChild(grand_child2); |
2612 child->AddChild(grand_child3); | 2612 child->AddChild(grand_child3); |
2613 | 2613 |
2614 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 2614 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
2615 host->SetRootLayer(root); | 2615 host->SetRootLayer(root); |
2616 | 2616 |
2617 gfx::Transform identity_matrix; | 2617 gfx::Transform identity_matrix; |
2618 SetLayerPropertiesForTesting(root.get(), | 2618 SetLayerPropertiesForTesting(root.get(), |
2619 identity_matrix, | 2619 identity_matrix, |
2620 gfx::PointF(), | 2620 gfx::Point3F(), |
2621 gfx::PointF(), | 2621 gfx::PointF(), |
2622 gfx::Size(100, 100), | 2622 gfx::Size(100, 100), |
2623 true, | 2623 true, |
2624 false); | 2624 false); |
2625 SetLayerPropertiesForTesting(child.get(), | 2625 SetLayerPropertiesForTesting(child.get(), |
2626 identity_matrix, | 2626 identity_matrix, |
2627 gfx::PointF(), | 2627 gfx::Point3F(), |
2628 gfx::PointF(), | 2628 gfx::PointF(), |
2629 gfx::Size(100, 100), | 2629 gfx::Size(100, 100), |
2630 true, | 2630 true, |
2631 false); | 2631 false); |
2632 SetLayerPropertiesForTesting(grand_child1.get(), | 2632 SetLayerPropertiesForTesting(grand_child1.get(), |
2633 identity_matrix, | 2633 identity_matrix, |
2634 gfx::PointF(), | 2634 gfx::Point3F(), |
2635 gfx::PointF(5.f, 5.f), | 2635 gfx::PointF(5.f, 5.f), |
2636 gfx::Size(50, 50), | 2636 gfx::Size(50, 50), |
2637 true, | 2637 true, |
2638 false); | 2638 false); |
2639 SetLayerPropertiesForTesting(grand_child2.get(), | 2639 SetLayerPropertiesForTesting(grand_child2.get(), |
2640 identity_matrix, | 2640 identity_matrix, |
2641 gfx::PointF(), | 2641 gfx::Point3F(), |
2642 gfx::PointF(75.f, 75.f), | 2642 gfx::PointF(75.f, 75.f), |
2643 gfx::Size(50, 50), | 2643 gfx::Size(50, 50), |
2644 true, | 2644 true, |
2645 false); | 2645 false); |
2646 SetLayerPropertiesForTesting(grand_child3.get(), | 2646 SetLayerPropertiesForTesting(grand_child3.get(), |
2647 identity_matrix, | 2647 identity_matrix, |
2648 gfx::PointF(), | 2648 gfx::Point3F(), |
2649 gfx::PointF(125.f, 125.f), | 2649 gfx::PointF(125.f, 125.f), |
2650 gfx::Size(50, 50), | 2650 gfx::Size(50, 50), |
2651 true, | 2651 true, |
2652 false); | 2652 false); |
2653 | 2653 |
2654 child->SetMasksToBounds(true); | 2654 child->SetMasksToBounds(true); |
2655 ExecuteCalculateDrawProperties(root.get()); | 2655 ExecuteCalculateDrawProperties(root.get()); |
2656 | 2656 |
2657 ASSERT_FALSE(child->render_surface()); | 2657 ASSERT_FALSE(child->render_surface()); |
2658 | 2658 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2691 render_surface1->AddChild(child1); | 2691 render_surface1->AddChild(child1); |
2692 render_surface1->AddChild(child2); | 2692 render_surface1->AddChild(child2); |
2693 render_surface1->AddChild(child3); | 2693 render_surface1->AddChild(child3); |
2694 | 2694 |
2695 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 2695 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
2696 host->SetRootLayer(root); | 2696 host->SetRootLayer(root); |
2697 | 2697 |
2698 gfx::Transform identity_matrix; | 2698 gfx::Transform identity_matrix; |
2699 SetLayerPropertiesForTesting(root.get(), | 2699 SetLayerPropertiesForTesting(root.get(), |
2700 identity_matrix, | 2700 identity_matrix, |
2701 gfx::PointF(), | 2701 gfx::Point3F(), |
2702 gfx::PointF(), | 2702 gfx::PointF(), |
2703 gfx::Size(100, 100), | 2703 gfx::Size(100, 100), |
2704 true, | 2704 true, |
2705 false); | 2705 false); |
2706 SetLayerPropertiesForTesting(render_surface1.get(), | 2706 SetLayerPropertiesForTesting(render_surface1.get(), |
2707 identity_matrix, | 2707 identity_matrix, |
2708 gfx::PointF(), | 2708 gfx::Point3F(), |
2709 gfx::PointF(), | 2709 gfx::PointF(), |
2710 gfx::Size(3, 4), | 2710 gfx::Size(3, 4), |
2711 true, | 2711 true, |
2712 false); | 2712 false); |
2713 SetLayerPropertiesForTesting(child1.get(), | 2713 SetLayerPropertiesForTesting(child1.get(), |
2714 identity_matrix, | 2714 identity_matrix, |
2715 gfx::PointF(), | 2715 gfx::Point3F(), |
2716 gfx::PointF(5.f, 5.f), | 2716 gfx::PointF(5.f, 5.f), |
2717 gfx::Size(50, 50), | 2717 gfx::Size(50, 50), |
2718 true, | 2718 true, |
2719 false); | 2719 false); |
2720 SetLayerPropertiesForTesting(child2.get(), | 2720 SetLayerPropertiesForTesting(child2.get(), |
2721 identity_matrix, | 2721 identity_matrix, |
2722 gfx::PointF(), | 2722 gfx::Point3F(), |
2723 gfx::PointF(75.f, 75.f), | 2723 gfx::PointF(75.f, 75.f), |
2724 gfx::Size(50, 50), | 2724 gfx::Size(50, 50), |
2725 true, | 2725 true, |
2726 false); | 2726 false); |
2727 SetLayerPropertiesForTesting(child3.get(), | 2727 SetLayerPropertiesForTesting(child3.get(), |
2728 identity_matrix, | 2728 identity_matrix, |
2729 gfx::PointF(), | 2729 gfx::Point3F(), |
2730 gfx::PointF(125.f, 125.f), | 2730 gfx::PointF(125.f, 125.f), |
2731 gfx::Size(50, 50), | 2731 gfx::Size(50, 50), |
2732 true, | 2732 true, |
2733 false); | 2733 false); |
2734 | 2734 |
2735 render_surface1->SetForceRenderSurface(true); | 2735 render_surface1->SetForceRenderSurface(true); |
2736 ExecuteCalculateDrawProperties(root.get()); | 2736 ExecuteCalculateDrawProperties(root.get()); |
2737 | 2737 |
2738 ASSERT_TRUE(render_surface1->render_surface()); | 2738 ASSERT_TRUE(render_surface1->render_surface()); |
2739 | 2739 |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2771 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 2771 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
2772 host->SetRootLayer(root); | 2772 host->SetRootLayer(root); |
2773 | 2773 |
2774 // Case 1: a truly degenerate matrix | 2774 // Case 1: a truly degenerate matrix |
2775 gfx::Transform identity_matrix; | 2775 gfx::Transform identity_matrix; |
2776 gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); | 2776 gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); |
2777 ASSERT_FALSE(uninvertible_matrix.IsInvertible()); | 2777 ASSERT_FALSE(uninvertible_matrix.IsInvertible()); |
2778 | 2778 |
2779 SetLayerPropertiesForTesting(root.get(), | 2779 SetLayerPropertiesForTesting(root.get(), |
2780 identity_matrix, | 2780 identity_matrix, |
2781 gfx::PointF(), | 2781 gfx::Point3F(), |
2782 gfx::PointF(), | 2782 gfx::PointF(), |
2783 gfx::Size(100, 100), | 2783 gfx::Size(100, 100), |
2784 true, | 2784 true, |
2785 false); | 2785 false); |
2786 SetLayerPropertiesForTesting(child.get(), | 2786 SetLayerPropertiesForTesting(child.get(), |
2787 uninvertible_matrix, | 2787 uninvertible_matrix, |
2788 gfx::PointF(), | 2788 gfx::Point3F(), |
2789 gfx::PointF(5.f, 5.f), | 2789 gfx::PointF(5.f, 5.f), |
2790 gfx::Size(50, 50), | 2790 gfx::Size(50, 50), |
2791 true, | 2791 true, |
2792 false); | 2792 false); |
2793 | 2793 |
2794 ExecuteCalculateDrawProperties(root.get()); | 2794 ExecuteCalculateDrawProperties(root.get()); |
2795 | 2795 |
2796 EXPECT_TRUE(child->visible_content_rect().IsEmpty()); | 2796 EXPECT_TRUE(child->visible_content_rect().IsEmpty()); |
2797 EXPECT_TRUE(child->drawable_content_rect().IsEmpty()); | 2797 EXPECT_TRUE(child->drawable_content_rect().IsEmpty()); |
2798 | 2798 |
2799 // Case 2: a matrix with flattened z, uninvertible and not visible according | 2799 // Case 2: a matrix with flattened z, uninvertible and not visible according |
2800 // to the CSS spec. | 2800 // to the CSS spec. |
2801 uninvertible_matrix.MakeIdentity(); | 2801 uninvertible_matrix.MakeIdentity(); |
2802 uninvertible_matrix.matrix().set(2, 2, 0.0); | 2802 uninvertible_matrix.matrix().set(2, 2, 0.0); |
2803 ASSERT_FALSE(uninvertible_matrix.IsInvertible()); | 2803 ASSERT_FALSE(uninvertible_matrix.IsInvertible()); |
2804 | 2804 |
2805 SetLayerPropertiesForTesting(child.get(), | 2805 SetLayerPropertiesForTesting(child.get(), |
2806 uninvertible_matrix, | 2806 uninvertible_matrix, |
2807 gfx::PointF(), | 2807 gfx::Point3F(), |
2808 gfx::PointF(5.f, 5.f), | 2808 gfx::PointF(5.f, 5.f), |
2809 gfx::Size(50, 50), | 2809 gfx::Size(50, 50), |
2810 true, | 2810 true, |
2811 false); | 2811 false); |
2812 | 2812 |
2813 ExecuteCalculateDrawProperties(root.get()); | 2813 ExecuteCalculateDrawProperties(root.get()); |
2814 | 2814 |
2815 EXPECT_TRUE(child->visible_content_rect().IsEmpty()); | 2815 EXPECT_TRUE(child->visible_content_rect().IsEmpty()); |
2816 EXPECT_TRUE(child->drawable_content_rect().IsEmpty()); | 2816 EXPECT_TRUE(child->drawable_content_rect().IsEmpty()); |
2817 | 2817 |
2818 // Case 3: a matrix with flattened z, also uninvertible and not visible. | 2818 // Case 3: a matrix with flattened z, also uninvertible and not visible. |
2819 uninvertible_matrix.MakeIdentity(); | 2819 uninvertible_matrix.MakeIdentity(); |
2820 uninvertible_matrix.Translate(500.0, 0.0); | 2820 uninvertible_matrix.Translate(500.0, 0.0); |
2821 uninvertible_matrix.matrix().set(2, 2, 0.0); | 2821 uninvertible_matrix.matrix().set(2, 2, 0.0); |
2822 ASSERT_FALSE(uninvertible_matrix.IsInvertible()); | 2822 ASSERT_FALSE(uninvertible_matrix.IsInvertible()); |
2823 | 2823 |
2824 SetLayerPropertiesForTesting(child.get(), | 2824 SetLayerPropertiesForTesting(child.get(), |
2825 uninvertible_matrix, | 2825 uninvertible_matrix, |
2826 gfx::PointF(), | 2826 gfx::Point3F(), |
2827 gfx::PointF(5.f, 5.f), | 2827 gfx::PointF(5.f, 5.f), |
2828 gfx::Size(50, 50), | 2828 gfx::Size(50, 50), |
2829 true, | 2829 true, |
2830 false); | 2830 false); |
2831 | 2831 |
2832 ExecuteCalculateDrawProperties(root.get()); | 2832 ExecuteCalculateDrawProperties(root.get()); |
2833 | 2833 |
2834 EXPECT_TRUE(child->visible_content_rect().IsEmpty()); | 2834 EXPECT_TRUE(child->visible_content_rect().IsEmpty()); |
2835 EXPECT_TRUE(child->drawable_content_rect().IsEmpty()); | 2835 EXPECT_TRUE(child->drawable_content_rect().IsEmpty()); |
2836 } | 2836 } |
2837 | 2837 |
2838 TEST_F(LayerTreeHostCommonTest, | 2838 TEST_F(LayerTreeHostCommonTest, |
2839 SingularTransformDoesNotPreventClearingDrawProperties) { | 2839 SingularTransformDoesNotPreventClearingDrawProperties) { |
2840 scoped_refptr<Layer> root = Layer::Create(); | 2840 scoped_refptr<Layer> root = Layer::Create(); |
2841 scoped_refptr<LayerWithForcedDrawsContent> child = | 2841 scoped_refptr<LayerWithForcedDrawsContent> child = |
2842 make_scoped_refptr(new LayerWithForcedDrawsContent()); | 2842 make_scoped_refptr(new LayerWithForcedDrawsContent()); |
2843 root->AddChild(child); | 2843 root->AddChild(child); |
2844 | 2844 |
2845 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 2845 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
2846 host->SetRootLayer(root); | 2846 host->SetRootLayer(root); |
2847 | 2847 |
2848 gfx::Transform identity_matrix; | 2848 gfx::Transform identity_matrix; |
2849 gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); | 2849 gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); |
2850 ASSERT_FALSE(uninvertible_matrix.IsInvertible()); | 2850 ASSERT_FALSE(uninvertible_matrix.IsInvertible()); |
2851 | 2851 |
2852 SetLayerPropertiesForTesting(root.get(), | 2852 SetLayerPropertiesForTesting(root.get(), |
2853 uninvertible_matrix, | 2853 uninvertible_matrix, |
2854 gfx::PointF(), | 2854 gfx::Point3F(), |
2855 gfx::PointF(), | 2855 gfx::PointF(), |
2856 gfx::Size(100, 100), | 2856 gfx::Size(100, 100), |
2857 true, | 2857 true, |
2858 false); | 2858 false); |
2859 SetLayerPropertiesForTesting(child.get(), | 2859 SetLayerPropertiesForTesting(child.get(), |
2860 identity_matrix, | 2860 identity_matrix, |
2861 gfx::PointF(), | 2861 gfx::Point3F(), |
2862 gfx::PointF(5.f, 5.f), | 2862 gfx::PointF(5.f, 5.f), |
2863 gfx::Size(50, 50), | 2863 gfx::Size(50, 50), |
2864 true, | 2864 true, |
2865 false); | 2865 false); |
2866 | 2866 |
2867 child->draw_properties().sorted_for_recursion = true; | 2867 child->draw_properties().sorted_for_recursion = true; |
2868 | 2868 |
2869 TransformOperations start_transform_operations; | 2869 TransformOperations start_transform_operations; |
2870 start_transform_operations.AppendScale(1.f, 0.f, 0.f); | 2870 start_transform_operations.AppendScale(1.f, 0.f, 0.f); |
2871 | 2871 |
(...skipping 16 matching lines...) Expand all Loading... | |
2888 | 2888 |
2889 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 2889 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
2890 host->SetRootLayer(root); | 2890 host->SetRootLayer(root); |
2891 | 2891 |
2892 gfx::Transform identity_matrix; | 2892 gfx::Transform identity_matrix; |
2893 gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); | 2893 gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); |
2894 ASSERT_FALSE(uninvertible_matrix.IsInvertible()); | 2894 ASSERT_FALSE(uninvertible_matrix.IsInvertible()); |
2895 | 2895 |
2896 SetLayerPropertiesForTesting(root.get(), | 2896 SetLayerPropertiesForTesting(root.get(), |
2897 uninvertible_matrix, | 2897 uninvertible_matrix, |
2898 gfx::PointF(), | 2898 gfx::Point3F(), |
2899 gfx::PointF(), | 2899 gfx::PointF(), |
2900 gfx::Size(100, 100), | 2900 gfx::Size(100, 100), |
2901 true, | 2901 true, |
2902 false); | 2902 false); |
2903 | 2903 |
2904 root->draw_properties().sorted_for_recursion = true; | 2904 root->draw_properties().sorted_for_recursion = true; |
2905 | 2905 |
2906 EXPECT_FALSE(root->TransformIsAnimating()); | 2906 EXPECT_FALSE(root->TransformIsAnimating()); |
2907 | 2907 |
2908 ExecuteCalculateDrawProperties(root.get()); | 2908 ExecuteCalculateDrawProperties(root.get()); |
(...skipping 15 matching lines...) Expand all Loading... | |
2924 render_surface1->AddChild(child1); | 2924 render_surface1->AddChild(child1); |
2925 render_surface1->AddChild(child2); | 2925 render_surface1->AddChild(child2); |
2926 render_surface1->AddChild(child3); | 2926 render_surface1->AddChild(child3); |
2927 | 2927 |
2928 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 2928 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
2929 host->SetRootLayer(root); | 2929 host->SetRootLayer(root); |
2930 | 2930 |
2931 gfx::Transform identity_matrix; | 2931 gfx::Transform identity_matrix; |
2932 SetLayerPropertiesForTesting(root.get(), | 2932 SetLayerPropertiesForTesting(root.get(), |
2933 identity_matrix, | 2933 identity_matrix, |
2934 gfx::PointF(), | 2934 gfx::Point3F(), |
2935 gfx::PointF(), | 2935 gfx::PointF(), |
2936 gfx::Size(100, 100), | 2936 gfx::Size(100, 100), |
2937 true, | 2937 true, |
2938 false); | 2938 false); |
2939 SetLayerPropertiesForTesting(render_surface1.get(), | 2939 SetLayerPropertiesForTesting(render_surface1.get(), |
2940 identity_matrix, | 2940 identity_matrix, |
2941 gfx::PointF(), | 2941 gfx::Point3F(), |
2942 gfx::PointF(), | 2942 gfx::PointF(), |
2943 gfx::Size(3, 4), | 2943 gfx::Size(3, 4), |
2944 true, | 2944 true, |
2945 false); | 2945 false); |
2946 SetLayerPropertiesForTesting(child1.get(), | 2946 SetLayerPropertiesForTesting(child1.get(), |
2947 identity_matrix, | 2947 identity_matrix, |
2948 gfx::PointF(), | 2948 gfx::Point3F(), |
2949 gfx::PointF(5.f, 5.f), | 2949 gfx::PointF(5.f, 5.f), |
2950 gfx::Size(50, 50), | 2950 gfx::Size(50, 50), |
2951 true, | 2951 true, |
2952 false); | 2952 false); |
2953 SetLayerPropertiesForTesting(child2.get(), | 2953 SetLayerPropertiesForTesting(child2.get(), |
2954 identity_matrix, | 2954 identity_matrix, |
2955 gfx::PointF(), | 2955 gfx::Point3F(), |
2956 gfx::PointF(75.f, 75.f), | 2956 gfx::PointF(75.f, 75.f), |
2957 gfx::Size(50, 50), | 2957 gfx::Size(50, 50), |
2958 true, | 2958 true, |
2959 false); | 2959 false); |
2960 SetLayerPropertiesForTesting(child3.get(), | 2960 SetLayerPropertiesForTesting(child3.get(), |
2961 identity_matrix, | 2961 identity_matrix, |
2962 gfx::PointF(), | 2962 gfx::Point3F(), |
2963 gfx::PointF(125.f, 125.f), | 2963 gfx::PointF(125.f, 125.f), |
2964 gfx::Size(50, 50), | 2964 gfx::Size(50, 50), |
2965 true, | 2965 true, |
2966 false); | 2966 false); |
2967 | 2967 |
2968 root->SetMasksToBounds(true); | 2968 root->SetMasksToBounds(true); |
2969 render_surface1->SetForceRenderSurface(true); | 2969 render_surface1->SetForceRenderSurface(true); |
2970 ExecuteCalculateDrawProperties(root.get()); | 2970 ExecuteCalculateDrawProperties(root.get()); |
2971 | 2971 |
2972 ASSERT_TRUE(render_surface1->render_surface()); | 2972 ASSERT_TRUE(render_surface1->render_surface()); |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3014 render_surface2->AddChild(child1); | 3014 render_surface2->AddChild(child1); |
3015 render_surface2->AddChild(child2); | 3015 render_surface2->AddChild(child2); |
3016 render_surface2->AddChild(child3); | 3016 render_surface2->AddChild(child3); |
3017 | 3017 |
3018 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 3018 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
3019 host->SetRootLayer(root); | 3019 host->SetRootLayer(root); |
3020 | 3020 |
3021 gfx::Transform identity_matrix; | 3021 gfx::Transform identity_matrix; |
3022 SetLayerPropertiesForTesting(root.get(), | 3022 SetLayerPropertiesForTesting(root.get(), |
3023 identity_matrix, | 3023 identity_matrix, |
3024 gfx::PointF(), | 3024 gfx::Point3F(), |
3025 gfx::PointF(), | 3025 gfx::PointF(), |
3026 gfx::Size(100, 100), | 3026 gfx::Size(100, 100), |
3027 true, | 3027 true, |
3028 false); | 3028 false); |
3029 SetLayerPropertiesForTesting(render_surface1.get(), | 3029 SetLayerPropertiesForTesting(render_surface1.get(), |
3030 identity_matrix, | 3030 identity_matrix, |
3031 gfx::PointF(), | 3031 gfx::Point3F(), |
3032 gfx::PointF(), | 3032 gfx::PointF(), |
3033 gfx::Size(3, 4), | 3033 gfx::Size(3, 4), |
3034 true, | 3034 true, |
3035 false); | 3035 false); |
3036 SetLayerPropertiesForTesting(render_surface2.get(), | 3036 SetLayerPropertiesForTesting(render_surface2.get(), |
3037 identity_matrix, | 3037 identity_matrix, |
3038 gfx::PointF(), | 3038 gfx::Point3F(), |
3039 gfx::PointF(), | 3039 gfx::PointF(), |
3040 gfx::Size(7, 13), | 3040 gfx::Size(7, 13), |
3041 true, | 3041 true, |
3042 false); | 3042 false); |
3043 SetLayerPropertiesForTesting(child1.get(), | 3043 SetLayerPropertiesForTesting(child1.get(), |
3044 identity_matrix, | 3044 identity_matrix, |
3045 gfx::PointF(), | 3045 gfx::Point3F(), |
3046 gfx::PointF(5.f, 5.f), | 3046 gfx::PointF(5.f, 5.f), |
3047 gfx::Size(50, 50), | 3047 gfx::Size(50, 50), |
3048 true, | 3048 true, |
3049 false); | 3049 false); |
3050 SetLayerPropertiesForTesting(child2.get(), | 3050 SetLayerPropertiesForTesting(child2.get(), |
3051 identity_matrix, | 3051 identity_matrix, |
3052 gfx::PointF(), | 3052 gfx::Point3F(), |
3053 gfx::PointF(75.f, 75.f), | 3053 gfx::PointF(75.f, 75.f), |
3054 gfx::Size(50, 50), | 3054 gfx::Size(50, 50), |
3055 true, | 3055 true, |
3056 false); | 3056 false); |
3057 SetLayerPropertiesForTesting(child3.get(), | 3057 SetLayerPropertiesForTesting(child3.get(), |
3058 identity_matrix, | 3058 identity_matrix, |
3059 gfx::PointF(), | 3059 gfx::Point3F(), |
3060 gfx::PointF(125.f, 125.f), | 3060 gfx::PointF(125.f, 125.f), |
3061 gfx::Size(50, 50), | 3061 gfx::Size(50, 50), |
3062 true, | 3062 true, |
3063 false); | 3063 false); |
3064 | 3064 |
3065 root->SetMasksToBounds(true); | 3065 root->SetMasksToBounds(true); |
3066 render_surface1->SetForceRenderSurface(true); | 3066 render_surface1->SetForceRenderSurface(true); |
3067 render_surface2->SetForceRenderSurface(true); | 3067 render_surface2->SetForceRenderSurface(true); |
3068 ExecuteCalculateDrawProperties(root.get()); | 3068 ExecuteCalculateDrawProperties(root.get()); |
3069 | 3069 |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3116 render_surface1->AddChild(child1); | 3116 render_surface1->AddChild(child1); |
3117 | 3117 |
3118 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 3118 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
3119 host->SetRootLayer(root); | 3119 host->SetRootLayer(root); |
3120 | 3120 |
3121 gfx::Transform identity_matrix; | 3121 gfx::Transform identity_matrix; |
3122 gfx::Transform child_rotation; | 3122 gfx::Transform child_rotation; |
3123 child_rotation.Rotate(45.0); | 3123 child_rotation.Rotate(45.0); |
3124 SetLayerPropertiesForTesting(root.get(), | 3124 SetLayerPropertiesForTesting(root.get(), |
3125 identity_matrix, | 3125 identity_matrix, |
3126 gfx::PointF(), | 3126 gfx::Point3F(), |
3127 gfx::PointF(), | 3127 gfx::PointF(), |
3128 gfx::Size(100, 100), | 3128 gfx::Size(100, 100), |
3129 true, | 3129 true, |
3130 false); | 3130 false); |
3131 SetLayerPropertiesForTesting(render_surface1.get(), | 3131 SetLayerPropertiesForTesting(render_surface1.get(), |
3132 identity_matrix, | 3132 identity_matrix, |
3133 gfx::PointF(), | 3133 gfx::Point3F(), |
3134 gfx::PointF(), | 3134 gfx::PointF(), |
3135 gfx::Size(3, 4), | 3135 gfx::Size(3, 4), |
3136 true, | 3136 true, |
3137 false); | 3137 false); |
3138 SetLayerPropertiesForTesting(child1.get(), | 3138 SetLayerPropertiesForTesting(child1.get(), |
3139 child_rotation, | 3139 child_rotation, |
3140 gfx::PointF(0.5f, 0.5f), | 3140 gfx::Point3F(25, 25, 0.f), |
3141 gfx::PointF(25.f, 25.f), | 3141 gfx::PointF(25.f, 25.f), |
3142 gfx::Size(50, 50), | 3142 gfx::Size(50, 50), |
3143 true, | 3143 true, |
3144 false); | 3144 false); |
3145 | 3145 |
3146 render_surface1->SetForceRenderSurface(true); | 3146 render_surface1->SetForceRenderSurface(true); |
3147 ExecuteCalculateDrawProperties(root.get()); | 3147 ExecuteCalculateDrawProperties(root.get()); |
3148 | 3148 |
3149 ASSERT_TRUE(render_surface1->render_surface()); | 3149 ASSERT_TRUE(render_surface1->render_surface()); |
3150 | 3150 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3187 render_surface1->AddChild(child1); | 3187 render_surface1->AddChild(child1); |
3188 | 3188 |
3189 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 3189 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
3190 host->SetRootLayer(root); | 3190 host->SetRootLayer(root); |
3191 | 3191 |
3192 gfx::Transform identity_matrix; | 3192 gfx::Transform identity_matrix; |
3193 gfx::Transform child_rotation; | 3193 gfx::Transform child_rotation; |
3194 child_rotation.Rotate(45.0); | 3194 child_rotation.Rotate(45.0); |
3195 SetLayerPropertiesForTesting(root.get(), | 3195 SetLayerPropertiesForTesting(root.get(), |
3196 identity_matrix, | 3196 identity_matrix, |
3197 gfx::PointF(), | 3197 gfx::Point3F(), |
3198 gfx::PointF(), | 3198 gfx::PointF(), |
3199 gfx::Size(50, 50), | 3199 gfx::Size(50, 50), |
3200 true, | 3200 true, |
3201 false); | 3201 false); |
3202 SetLayerPropertiesForTesting(render_surface1.get(), | 3202 SetLayerPropertiesForTesting(render_surface1.get(), |
3203 identity_matrix, | 3203 identity_matrix, |
3204 gfx::PointF(), | 3204 gfx::Point3F(), |
3205 gfx::PointF(), | 3205 gfx::PointF(), |
3206 gfx::Size(3, 4), | 3206 gfx::Size(3, 4), |
3207 true, | 3207 true, |
3208 false); | 3208 false); |
3209 LOG(ERROR) << child1->bounds().height(); | |
enne (OOO)
2014/06/03 22:25:52
ಠ_à²
chrishtr
2014/06/03 23:14:54
Done.
| |
3209 SetLayerPropertiesForTesting(child1.get(), | 3210 SetLayerPropertiesForTesting(child1.get(), |
3210 child_rotation, | 3211 child_rotation, |
3211 gfx::PointF(0.5f, 0.5f), | 3212 gfx::Point3F(25, 25, 0.f), |
3212 gfx::PointF(25.f, 25.f), | 3213 gfx::PointF(25.f, 25.f), |
3213 gfx::Size(50, 50), | 3214 gfx::Size(50, 50), |
3214 true, | 3215 true, |
3215 false); | 3216 false); |
3216 | 3217 |
3217 root->SetMasksToBounds(true); | 3218 root->SetMasksToBounds(true); |
3218 render_surface1->SetForceRenderSurface(true); | 3219 render_surface1->SetForceRenderSurface(true); |
3219 ExecuteCalculateDrawProperties(root.get()); | 3220 ExecuteCalculateDrawProperties(root.get()); |
3220 | 3221 |
3221 ASSERT_TRUE(render_surface1->render_surface()); | 3222 ASSERT_TRUE(render_surface1->render_surface()); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3259 render_surface2->AddChild(child1); | 3260 render_surface2->AddChild(child1); |
3260 render_surface2->AddChild(child2); | 3261 render_surface2->AddChild(child2); |
3261 render_surface2->AddChild(child3); | 3262 render_surface2->AddChild(child3); |
3262 | 3263 |
3263 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 3264 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
3264 host->SetRootLayer(root); | 3265 host->SetRootLayer(root); |
3265 | 3266 |
3266 gfx::Transform identity_matrix; | 3267 gfx::Transform identity_matrix; |
3267 SetLayerPropertiesForTesting(root.get(), | 3268 SetLayerPropertiesForTesting(root.get(), |
3268 identity_matrix, | 3269 identity_matrix, |
3269 gfx::PointF(), | 3270 gfx::Point3F(), |
3270 gfx::PointF(), | 3271 gfx::PointF(), |
3271 gfx::Size(100, 100), | 3272 gfx::Size(100, 100), |
3272 true, | 3273 true, |
3273 false); | 3274 false); |
3274 SetLayerPropertiesForTesting(render_surface1.get(), | 3275 SetLayerPropertiesForTesting(render_surface1.get(), |
3275 identity_matrix, | 3276 identity_matrix, |
3276 gfx::PointF(), | 3277 gfx::Point3F(), |
3277 gfx::PointF(5.f, 5.f), | 3278 gfx::PointF(5.f, 5.f), |
3278 gfx::Size(3, 4), | 3279 gfx::Size(3, 4), |
3279 true, | 3280 true, |
3280 false); | 3281 false); |
3281 SetLayerPropertiesForTesting(render_surface2.get(), | 3282 SetLayerPropertiesForTesting(render_surface2.get(), |
3282 identity_matrix, | 3283 identity_matrix, |
3283 gfx::PointF(), | 3284 gfx::Point3F(), |
3284 gfx::PointF(5.f, 5.f), | 3285 gfx::PointF(5.f, 5.f), |
3285 gfx::Size(7, 13), | 3286 gfx::Size(7, 13), |
3286 true, | 3287 true, |
3287 false); | 3288 false); |
3288 SetLayerPropertiesForTesting(child1.get(), | 3289 SetLayerPropertiesForTesting(child1.get(), |
3289 identity_matrix, | 3290 identity_matrix, |
3290 gfx::PointF(), | 3291 gfx::Point3F(), |
3291 gfx::PointF(5.f, 5.f), | 3292 gfx::PointF(5.f, 5.f), |
3292 gfx::Size(50, 50), | 3293 gfx::Size(50, 50), |
3293 true, | 3294 true, |
3294 false); | 3295 false); |
3295 SetLayerPropertiesForTesting(child2.get(), | 3296 SetLayerPropertiesForTesting(child2.get(), |
3296 identity_matrix, | 3297 identity_matrix, |
3297 gfx::PointF(), | 3298 gfx::Point3F(), |
3298 gfx::PointF(75.f, 75.f), | 3299 gfx::PointF(75.f, 75.f), |
3299 gfx::Size(50, 50), | 3300 gfx::Size(50, 50), |
3300 true, | 3301 true, |
3301 false); | 3302 false); |
3302 SetLayerPropertiesForTesting(child3.get(), | 3303 SetLayerPropertiesForTesting(child3.get(), |
3303 identity_matrix, | 3304 identity_matrix, |
3304 gfx::PointF(), | 3305 gfx::Point3F(), |
3305 gfx::PointF(125.f, 125.f), | 3306 gfx::PointF(125.f, 125.f), |
3306 gfx::Size(50, 50), | 3307 gfx::Size(50, 50), |
3307 true, | 3308 true, |
3308 false); | 3309 false); |
3309 | 3310 |
3310 float device_scale_factor = 2.f; | 3311 float device_scale_factor = 2.f; |
3311 | 3312 |
3312 root->SetMasksToBounds(true); | 3313 root->SetMasksToBounds(true); |
3313 render_surface1->SetForceRenderSurface(true); | 3314 render_surface1->SetForceRenderSurface(true); |
3314 render_surface2->SetForceRenderSurface(true); | 3315 render_surface2->SetForceRenderSurface(true); |
(...skipping 92 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3407 | 3408 |
3408 // Having a descendant and opacity will force these to have render surfaces. | 3409 // Having a descendant and opacity will force these to have render surfaces. |
3409 front_facing_surface->SetOpacity(0.5f); | 3410 front_facing_surface->SetOpacity(0.5f); |
3410 back_facing_surface->SetOpacity(0.5f); | 3411 back_facing_surface->SetOpacity(0.5f); |
3411 | 3412 |
3412 // Nothing preserves 3d. According to current W3C CSS gfx::Transforms spec, | 3413 // Nothing preserves 3d. According to current W3C CSS gfx::Transforms spec, |
3413 // these layers should blindly use their own local transforms to determine | 3414 // these layers should blindly use their own local transforms to determine |
3414 // back-face culling. | 3415 // back-face culling. |
3415 SetLayerPropertiesForTesting(parent.get(), | 3416 SetLayerPropertiesForTesting(parent.get(), |
3416 identity_matrix, | 3417 identity_matrix, |
3417 gfx::PointF(), | 3418 gfx::Point3F(), |
3418 gfx::PointF(), | 3419 gfx::PointF(), |
3419 gfx::Size(100, 100), | 3420 gfx::Size(100, 100), |
3420 true, | 3421 true, |
3421 false); | 3422 false); |
3422 SetLayerPropertiesForTesting(front_facing_child.get(), | 3423 SetLayerPropertiesForTesting(front_facing_child.get(), |
3423 identity_matrix, | 3424 identity_matrix, |
3424 gfx::PointF(), | 3425 gfx::Point3F(), |
3425 gfx::PointF(), | 3426 gfx::PointF(), |
3426 gfx::Size(100, 100), | 3427 gfx::Size(100, 100), |
3427 true, | 3428 true, |
3428 false); | 3429 false); |
3429 SetLayerPropertiesForTesting(back_facing_child.get(), | 3430 SetLayerPropertiesForTesting(back_facing_child.get(), |
3430 backface_matrix, | 3431 backface_matrix, |
3431 gfx::PointF(), | 3432 gfx::Point3F(), |
3432 gfx::PointF(), | 3433 gfx::PointF(), |
3433 gfx::Size(100, 100), | 3434 gfx::Size(100, 100), |
3434 true, | 3435 true, |
3435 false); | 3436 false); |
3436 SetLayerPropertiesForTesting(front_facing_surface.get(), | 3437 SetLayerPropertiesForTesting(front_facing_surface.get(), |
3437 identity_matrix, | 3438 identity_matrix, |
3438 gfx::PointF(), | 3439 gfx::Point3F(), |
3439 gfx::PointF(), | 3440 gfx::PointF(), |
3440 gfx::Size(100, 100), | 3441 gfx::Size(100, 100), |
3441 true, | 3442 true, |
3442 false); | 3443 false); |
3443 SetLayerPropertiesForTesting(back_facing_surface.get(), | 3444 SetLayerPropertiesForTesting(back_facing_surface.get(), |
3444 backface_matrix, | 3445 backface_matrix, |
3445 gfx::PointF(), | 3446 gfx::Point3F(), |
3446 gfx::PointF(), | 3447 gfx::PointF(), |
3447 gfx::Size(100, 100), | 3448 gfx::Size(100, 100), |
3448 true, | 3449 true, |
3449 false); | 3450 false); |
3450 SetLayerPropertiesForTesting(front_facing_child_of_front_facing_surface.get(), | 3451 SetLayerPropertiesForTesting(front_facing_child_of_front_facing_surface.get(), |
3451 identity_matrix, | 3452 identity_matrix, |
3452 gfx::PointF(), | 3453 gfx::Point3F(), |
3453 gfx::PointF(), | 3454 gfx::PointF(), |
3454 gfx::Size(100, 100), | 3455 gfx::Size(100, 100), |
3455 true, | 3456 true, |
3456 false); | 3457 false); |
3457 SetLayerPropertiesForTesting(back_facing_child_of_front_facing_surface.get(), | 3458 SetLayerPropertiesForTesting(back_facing_child_of_front_facing_surface.get(), |
3458 backface_matrix, | 3459 backface_matrix, |
3459 gfx::PointF(), | 3460 gfx::Point3F(), |
3460 gfx::PointF(), | 3461 gfx::PointF(), |
3461 gfx::Size(100, 100), | 3462 gfx::Size(100, 100), |
3462 true, | 3463 true, |
3463 false); | 3464 false); |
3464 SetLayerPropertiesForTesting(front_facing_child_of_back_facing_surface.get(), | 3465 SetLayerPropertiesForTesting(front_facing_child_of_back_facing_surface.get(), |
3465 identity_matrix, | 3466 identity_matrix, |
3466 gfx::PointF(), | 3467 gfx::Point3F(), |
3467 gfx::PointF(), | 3468 gfx::PointF(), |
3468 gfx::Size(100, 100), | 3469 gfx::Size(100, 100), |
3469 true, | 3470 true, |
3470 false); | 3471 false); |
3471 SetLayerPropertiesForTesting(back_facing_child_of_back_facing_surface.get(), | 3472 SetLayerPropertiesForTesting(back_facing_child_of_back_facing_surface.get(), |
3472 backface_matrix, | 3473 backface_matrix, |
3473 gfx::PointF(), | 3474 gfx::Point3F(), |
3474 gfx::PointF(), | 3475 gfx::PointF(), |
3475 gfx::Size(100, 100), | 3476 gfx::Size(100, 100), |
3476 true, | 3477 true, |
3477 false); | 3478 false); |
3478 | 3479 |
3479 RenderSurfaceLayerList render_surface_layer_list; | 3480 RenderSurfaceLayerList render_surface_layer_list; |
3480 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( | 3481 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( |
3481 parent.get(), parent->bounds(), &render_surface_layer_list); | 3482 parent.get(), parent->bounds(), &render_surface_layer_list); |
3482 inputs.can_adjust_raster_scales = true; | 3483 inputs.can_adjust_raster_scales = true; |
3483 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 3484 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3617 front_facing_surface->SetReplicaLayer(dummy_replica_layer1.get()); | 3618 front_facing_surface->SetReplicaLayer(dummy_replica_layer1.get()); |
3618 back_facing_surface->SetReplicaLayer(dummy_replica_layer2.get()); | 3619 back_facing_surface->SetReplicaLayer(dummy_replica_layer2.get()); |
3619 | 3620 |
3620 // Each surface creates its own new 3d rendering context (as defined by W3C | 3621 // Each surface creates its own new 3d rendering context (as defined by W3C |
3621 // spec). According to current W3C CSS gfx::Transforms spec, layers in a 3d | 3622 // spec). According to current W3C CSS gfx::Transforms spec, layers in a 3d |
3622 // rendering context should use the transform with respect to that context. | 3623 // rendering context should use the transform with respect to that context. |
3623 // This 3d rendering context occurs when (a) parent's transform style is flat | 3624 // This 3d rendering context occurs when (a) parent's transform style is flat |
3624 // and (b) the layer's transform style is preserve-3d. | 3625 // and (b) the layer's transform style is preserve-3d. |
3625 SetLayerPropertiesForTesting(parent.get(), | 3626 SetLayerPropertiesForTesting(parent.get(), |
3626 identity_matrix, | 3627 identity_matrix, |
3627 gfx::PointF(), | 3628 gfx::Point3F(), |
3628 gfx::PointF(), | 3629 gfx::PointF(), |
3629 gfx::Size(100, 100), | 3630 gfx::Size(100, 100), |
3630 true, | 3631 true, |
3631 false); // parent transform style is flat. | 3632 false); // parent transform style is flat. |
3632 SetLayerPropertiesForTesting(front_facing_child.get(), | 3633 SetLayerPropertiesForTesting(front_facing_child.get(), |
3633 identity_matrix, | 3634 identity_matrix, |
3634 gfx::PointF(), | 3635 gfx::Point3F(), |
3635 gfx::PointF(), | 3636 gfx::PointF(), |
3636 gfx::Size(100, 100), | 3637 gfx::Size(100, 100), |
3637 true, | 3638 true, |
3638 false); | 3639 false); |
3639 SetLayerPropertiesForTesting(back_facing_child.get(), | 3640 SetLayerPropertiesForTesting(back_facing_child.get(), |
3640 backface_matrix, | 3641 backface_matrix, |
3641 gfx::PointF(), | 3642 gfx::Point3F(), |
3642 gfx::PointF(), | 3643 gfx::PointF(), |
3643 gfx::Size(100, 100), | 3644 gfx::Size(100, 100), |
3644 true, | 3645 true, |
3645 false); | 3646 false); |
3646 // surface transform style is preserve-3d. | 3647 // surface transform style is preserve-3d. |
3647 SetLayerPropertiesForTesting(front_facing_surface.get(), | 3648 SetLayerPropertiesForTesting(front_facing_surface.get(), |
3648 identity_matrix, | 3649 identity_matrix, |
3649 gfx::PointF(), | 3650 gfx::Point3F(), |
3650 gfx::PointF(), | 3651 gfx::PointF(), |
3651 gfx::Size(100, 100), | 3652 gfx::Size(100, 100), |
3652 false, | 3653 false, |
3653 true); | 3654 true); |
3654 // surface transform style is preserve-3d. | 3655 // surface transform style is preserve-3d. |
3655 SetLayerPropertiesForTesting(back_facing_surface.get(), | 3656 SetLayerPropertiesForTesting(back_facing_surface.get(), |
3656 backface_matrix, | 3657 backface_matrix, |
3657 gfx::PointF(), | 3658 gfx::Point3F(), |
3658 gfx::PointF(), | 3659 gfx::PointF(), |
3659 gfx::Size(100, 100), | 3660 gfx::Size(100, 100), |
3660 false, | 3661 false, |
3661 true); | 3662 true); |
3662 SetLayerPropertiesForTesting(front_facing_child_of_front_facing_surface.get(), | 3663 SetLayerPropertiesForTesting(front_facing_child_of_front_facing_surface.get(), |
3663 identity_matrix, | 3664 identity_matrix, |
3664 gfx::PointF(), | 3665 gfx::Point3F(), |
3665 gfx::PointF(), | 3666 gfx::PointF(), |
3666 gfx::Size(100, 100), | 3667 gfx::Size(100, 100), |
3667 true, | 3668 true, |
3668 true); | 3669 true); |
3669 SetLayerPropertiesForTesting(back_facing_child_of_front_facing_surface.get(), | 3670 SetLayerPropertiesForTesting(back_facing_child_of_front_facing_surface.get(), |
3670 backface_matrix, | 3671 backface_matrix, |
3671 gfx::PointF(), | 3672 gfx::Point3F(), |
3672 gfx::PointF(), | 3673 gfx::PointF(), |
3673 gfx::Size(100, 100), | 3674 gfx::Size(100, 100), |
3674 true, | 3675 true, |
3675 true); | 3676 true); |
3676 SetLayerPropertiesForTesting(front_facing_child_of_back_facing_surface.get(), | 3677 SetLayerPropertiesForTesting(front_facing_child_of_back_facing_surface.get(), |
3677 identity_matrix, | 3678 identity_matrix, |
3678 gfx::PointF(), | 3679 gfx::Point3F(), |
3679 gfx::PointF(), | 3680 gfx::PointF(), |
3680 gfx::Size(100, 100), | 3681 gfx::Size(100, 100), |
3681 true, | 3682 true, |
3682 true); | 3683 true); |
3683 SetLayerPropertiesForTesting(back_facing_child_of_back_facing_surface.get(), | 3684 SetLayerPropertiesForTesting(back_facing_child_of_back_facing_surface.get(), |
3684 backface_matrix, | 3685 backface_matrix, |
3685 gfx::PointF(), | 3686 gfx::Point3F(), |
3686 gfx::PointF(), | 3687 gfx::PointF(), |
3687 gfx::Size(100, 100), | 3688 gfx::Size(100, 100), |
3688 true, | 3689 true, |
3689 true); | 3690 true); |
3690 | 3691 |
3691 RenderSurfaceLayerList render_surface_layer_list; | 3692 RenderSurfaceLayerList render_surface_layer_list; |
3692 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( | 3693 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( |
3693 parent.get(), parent->bounds(), &render_surface_layer_list); | 3694 parent.get(), parent->bounds(), &render_surface_layer_list); |
3694 inputs.can_adjust_raster_scales = true; | 3695 inputs.can_adjust_raster_scales = true; |
3695 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 3696 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3779 | 3780 |
3780 // Animate the transform on the render surface. | 3781 // Animate the transform on the render surface. |
3781 AddAnimatedTransformToController( | 3782 AddAnimatedTransformToController( |
3782 animating_surface->layer_animation_controller(), 10.0, 30, 0); | 3783 animating_surface->layer_animation_controller(), 10.0, 30, 0); |
3783 // This is just an animating layer, not a surface. | 3784 // This is just an animating layer, not a surface. |
3784 AddAnimatedTransformToController( | 3785 AddAnimatedTransformToController( |
3785 animating_child->layer_animation_controller(), 10.0, 30, 0); | 3786 animating_child->layer_animation_controller(), 10.0, 30, 0); |
3786 | 3787 |
3787 SetLayerPropertiesForTesting(parent.get(), | 3788 SetLayerPropertiesForTesting(parent.get(), |
3788 identity_matrix, | 3789 identity_matrix, |
3789 gfx::PointF(), | 3790 gfx::Point3F(), |
3790 gfx::PointF(), | 3791 gfx::PointF(), |
3791 gfx::Size(100, 100), | 3792 gfx::Size(100, 100), |
3792 true, | 3793 true, |
3793 false); | 3794 false); |
3794 SetLayerPropertiesForTesting(child.get(), | 3795 SetLayerPropertiesForTesting(child.get(), |
3795 backface_matrix, | 3796 backface_matrix, |
3796 gfx::PointF(), | 3797 gfx::Point3F(), |
3797 gfx::PointF(), | 3798 gfx::PointF(), |
3798 gfx::Size(100, 100), | 3799 gfx::Size(100, 100), |
3799 true, | 3800 true, |
3800 false); | 3801 false); |
3801 SetLayerPropertiesForTesting(animating_surface.get(), | 3802 SetLayerPropertiesForTesting(animating_surface.get(), |
3802 backface_matrix, | 3803 backface_matrix, |
3803 gfx::PointF(), | 3804 gfx::Point3F(), |
3804 gfx::PointF(), | 3805 gfx::PointF(), |
3805 gfx::Size(100, 100), | 3806 gfx::Size(100, 100), |
3806 true, | 3807 true, |
3807 false); | 3808 false); |
3808 SetLayerPropertiesForTesting(child_of_animating_surface.get(), | 3809 SetLayerPropertiesForTesting(child_of_animating_surface.get(), |
3809 backface_matrix, | 3810 backface_matrix, |
3810 gfx::PointF(), | 3811 gfx::Point3F(), |
3811 gfx::PointF(), | 3812 gfx::PointF(), |
3812 gfx::Size(100, 100), | 3813 gfx::Size(100, 100), |
3813 true, | 3814 true, |
3814 false); | 3815 false); |
3815 SetLayerPropertiesForTesting(animating_child.get(), | 3816 SetLayerPropertiesForTesting(animating_child.get(), |
3816 backface_matrix, | 3817 backface_matrix, |
3817 gfx::PointF(), | 3818 gfx::Point3F(), |
3818 gfx::PointF(), | 3819 gfx::PointF(), |
3819 gfx::Size(100, 100), | 3820 gfx::Size(100, 100), |
3820 true, | 3821 true, |
3821 false); | 3822 false); |
3822 SetLayerPropertiesForTesting(child2.get(), | 3823 SetLayerPropertiesForTesting(child2.get(), |
3823 identity_matrix, | 3824 identity_matrix, |
3824 gfx::PointF(), | 3825 gfx::Point3F(), |
3825 gfx::PointF(), | 3826 gfx::PointF(), |
3826 gfx::Size(100, 100), | 3827 gfx::Size(100, 100), |
3827 true, | 3828 true, |
3828 false); | 3829 false); |
3829 | 3830 |
3830 RenderSurfaceLayerList render_surface_layer_list; | 3831 RenderSurfaceLayerList render_surface_layer_list; |
3831 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( | 3832 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( |
3832 parent.get(), parent->bounds(), &render_surface_layer_list); | 3833 parent.get(), parent->bounds(), &render_surface_layer_list); |
3833 inputs.can_adjust_raster_scales = true; | 3834 inputs.can_adjust_raster_scales = true; |
3834 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | 3835 LayerTreeHostCommon::CalculateDrawProperties(&inputs); |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3912 front_facing_surface->SetDoubleSided(false); | 3913 front_facing_surface->SetDoubleSided(false); |
3913 back_facing_surface->SetDoubleSided(false); | 3914 back_facing_surface->SetDoubleSided(false); |
3914 | 3915 |
3915 gfx::Transform backface_matrix; | 3916 gfx::Transform backface_matrix; |
3916 backface_matrix.Translate(50.0, 50.0); | 3917 backface_matrix.Translate(50.0, 50.0); |
3917 backface_matrix.RotateAboutYAxis(180.0); | 3918 backface_matrix.RotateAboutYAxis(180.0); |
3918 backface_matrix.Translate(-50.0, -50.0); | 3919 backface_matrix.Translate(-50.0, -50.0); |
3919 | 3920 |
3920 SetLayerPropertiesForTesting(parent.get(), | 3921 SetLayerPropertiesForTesting(parent.get(), |
3921 identity_matrix, | 3922 identity_matrix, |
3922 gfx::PointF(), | 3923 gfx::Point3F(), |
3923 gfx::PointF(), | 3924 gfx::PointF(), |
3924 gfx::Size(100, 100), | 3925 gfx::Size(100, 100), |
3925 false, | 3926 false, |
3926 true); // parent transform style is preserve3d. | 3927 true); // parent transform style is preserve3d. |
3927 SetLayerPropertiesForTesting(front_facing_surface.get(), | 3928 SetLayerPropertiesForTesting(front_facing_surface.get(), |
3928 identity_matrix, | 3929 identity_matrix, |
3929 gfx::PointF(), | 3930 gfx::Point3F(), |
3930 gfx::PointF(), | 3931 gfx::PointF(), |
3931 gfx::Size(100, 100), | 3932 gfx::Size(100, 100), |
3932 true, | 3933 true, |
3933 true); // surface transform style is flat. | 3934 true); // surface transform style is flat. |
3934 SetLayerPropertiesForTesting(back_facing_surface.get(), | 3935 SetLayerPropertiesForTesting(back_facing_surface.get(), |
3935 backface_matrix, | 3936 backface_matrix, |
3936 gfx::PointF(), | 3937 gfx::Point3F(), |
3937 gfx::PointF(), | 3938 gfx::PointF(), |
3938 gfx::Size(100, 100), | 3939 gfx::Size(100, 100), |
3939 true, | 3940 true, |
3940 true); // surface transform style is flat. | 3941 true); // surface transform style is flat. |
3941 SetLayerPropertiesForTesting(child1.get(), | 3942 SetLayerPropertiesForTesting(child1.get(), |
3942 identity_matrix, | 3943 identity_matrix, |
3943 gfx::PointF(), | 3944 gfx::Point3F(), |
3944 gfx::PointF(), | 3945 gfx::PointF(), |
3945 gfx::Size(100, 100), | 3946 gfx::Size(100, 100), |
3946 true, | 3947 true, |
3947 false); | 3948 false); |
3948 SetLayerPropertiesForTesting(child2.get(), | 3949 SetLayerPropertiesForTesting(child2.get(), |
3949 identity_matrix, | 3950 identity_matrix, |
3950 gfx::PointF(), | 3951 gfx::Point3F(), |
3951 gfx::PointF(), | 3952 gfx::PointF(), |
3952 gfx::Size(100, 100), | 3953 gfx::Size(100, 100), |
3953 true, | 3954 true, |
3954 false); | 3955 false); |
3955 | 3956 |
3956 front_facing_surface->SetIs3dSorted(true); | 3957 front_facing_surface->SetIs3dSorted(true); |
3957 back_facing_surface->SetIs3dSorted(true); | 3958 back_facing_surface->SetIs3dSorted(true); |
3958 | 3959 |
3959 RenderSurfaceLayerList render_surface_layer_list; | 3960 RenderSurfaceLayerList render_surface_layer_list; |
3960 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( | 3961 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4035 } | 4036 } |
4036 | 4037 |
4037 TEST_F(LayerTreeHostCommonTest, LayerTransformsInHighDPI) { | 4038 TEST_F(LayerTreeHostCommonTest, LayerTransformsInHighDPI) { |
4038 // Verify draw and screen space transforms of layers not in a surface. | 4039 // Verify draw and screen space transforms of layers not in a surface. |
4039 MockContentLayerClient delegate; | 4040 MockContentLayerClient delegate; |
4040 gfx::Transform identity_matrix; | 4041 gfx::Transform identity_matrix; |
4041 | 4042 |
4042 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); | 4043 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); |
4043 SetLayerPropertiesForTesting(parent.get(), | 4044 SetLayerPropertiesForTesting(parent.get(), |
4044 identity_matrix, | 4045 identity_matrix, |
4045 gfx::PointF(), | 4046 gfx::Point3F(), |
4046 gfx::PointF(), | 4047 gfx::PointF(), |
4047 gfx::Size(100, 100), | 4048 gfx::Size(100, 100), |
4048 false, | 4049 false, |
4049 true); | 4050 true); |
4050 | 4051 |
4051 scoped_refptr<ContentLayer> child = CreateDrawableContentLayer(&delegate); | 4052 scoped_refptr<ContentLayer> child = CreateDrawableContentLayer(&delegate); |
4052 SetLayerPropertiesForTesting(child.get(), | 4053 SetLayerPropertiesForTesting(child.get(), |
4053 identity_matrix, | 4054 identity_matrix, |
4054 gfx::PointF(), | 4055 gfx::Point3F(), |
4055 gfx::PointF(2.f, 2.f), | 4056 gfx::PointF(2.f, 2.f), |
4056 gfx::Size(10, 10), | 4057 gfx::Size(10, 10), |
4057 false, | 4058 false, |
4058 true); | 4059 true); |
4059 | 4060 |
4060 scoped_refptr<ContentLayer> child_empty = | 4061 scoped_refptr<ContentLayer> child_empty = |
4061 CreateDrawableContentLayer(&delegate); | 4062 CreateDrawableContentLayer(&delegate); |
4062 SetLayerPropertiesForTesting(child_empty.get(), | 4063 SetLayerPropertiesForTesting(child_empty.get(), |
4063 identity_matrix, | 4064 identity_matrix, |
4064 gfx::PointF(), | 4065 gfx::Point3F(), |
4065 gfx::PointF(2.f, 2.f), | 4066 gfx::PointF(2.f, 2.f), |
4066 gfx::Size(), | 4067 gfx::Size(), |
4067 false, | 4068 false, |
4068 true); | 4069 true); |
4069 | 4070 |
4070 scoped_refptr<NoScaleContentLayer> child_no_scale = | 4071 scoped_refptr<NoScaleContentLayer> child_no_scale = |
4071 CreateNoScaleDrawableContentLayer(&delegate); | 4072 CreateNoScaleDrawableContentLayer(&delegate); |
4072 SetLayerPropertiesForTesting(child_no_scale.get(), | 4073 SetLayerPropertiesForTesting(child_no_scale.get(), |
4073 identity_matrix, | 4074 identity_matrix, |
4074 gfx::PointF(), | 4075 gfx::Point3F(), |
4075 gfx::PointF(2.f, 2.f), | 4076 gfx::PointF(2.f, 2.f), |
4076 gfx::Size(10, 10), | 4077 gfx::Size(10, 10), |
4077 false, | 4078 false, |
4078 true); | 4079 true); |
4079 | 4080 |
4080 parent->AddChild(child); | 4081 parent->AddChild(child); |
4081 parent->AddChild(child_empty); | 4082 parent->AddChild(child_empty); |
4082 parent->AddChild(child_no_scale); | 4083 parent->AddChild(child_no_scale); |
4083 | 4084 |
4084 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 4085 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
(...skipping 94 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4179 perspective_matrix.ApplyPerspectiveDepth(2.0); | 4180 perspective_matrix.ApplyPerspectiveDepth(2.0); |
4180 | 4181 |
4181 gfx::Transform scale_small_matrix; | 4182 gfx::Transform scale_small_matrix; |
4182 scale_small_matrix.Scale(SK_MScalar1 / 10.f, SK_MScalar1 / 12.f); | 4183 scale_small_matrix.Scale(SK_MScalar1 / 10.f, SK_MScalar1 / 12.f); |
4183 | 4184 |
4184 scoped_refptr<Layer> root = Layer::Create(); | 4185 scoped_refptr<Layer> root = Layer::Create(); |
4185 | 4186 |
4186 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); | 4187 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); |
4187 SetLayerPropertiesForTesting(parent.get(), | 4188 SetLayerPropertiesForTesting(parent.get(), |
4188 identity_matrix, | 4189 identity_matrix, |
4189 gfx::PointF(), | 4190 gfx::Point3F(), |
4190 gfx::PointF(), | 4191 gfx::PointF(), |
4191 gfx::Size(100, 100), | 4192 gfx::Size(100, 100), |
4192 false, | 4193 false, |
4193 true); | 4194 true); |
4194 | 4195 |
4195 scoped_refptr<ContentLayer> perspective_surface = | 4196 scoped_refptr<ContentLayer> perspective_surface = |
4196 CreateDrawableContentLayer(&delegate); | 4197 CreateDrawableContentLayer(&delegate); |
4197 SetLayerPropertiesForTesting(perspective_surface.get(), | 4198 SetLayerPropertiesForTesting(perspective_surface.get(), |
4198 perspective_matrix * scale_small_matrix, | 4199 perspective_matrix * scale_small_matrix, |
4199 gfx::PointF(), | 4200 gfx::Point3F(), |
4200 gfx::PointF(2.f, 2.f), | 4201 gfx::PointF(2.f, 2.f), |
4201 gfx::Size(10, 10), | 4202 gfx::Size(10, 10), |
4202 false, | 4203 false, |
4203 true); | 4204 true); |
4204 | 4205 |
4205 scoped_refptr<ContentLayer> scale_surface = | 4206 scoped_refptr<ContentLayer> scale_surface = |
4206 CreateDrawableContentLayer(&delegate); | 4207 CreateDrawableContentLayer(&delegate); |
4207 SetLayerPropertiesForTesting(scale_surface.get(), | 4208 SetLayerPropertiesForTesting(scale_surface.get(), |
4208 scale_small_matrix, | 4209 scale_small_matrix, |
4209 gfx::PointF(), | 4210 gfx::Point3F(), |
4210 gfx::PointF(2.f, 2.f), | 4211 gfx::PointF(2.f, 2.f), |
4211 gfx::Size(10, 10), | 4212 gfx::Size(10, 10), |
4212 false, | 4213 false, |
4213 true); | 4214 true); |
4214 | 4215 |
4215 perspective_surface->SetForceRenderSurface(true); | 4216 perspective_surface->SetForceRenderSurface(true); |
4216 scale_surface->SetForceRenderSurface(true); | 4217 scale_surface->SetForceRenderSurface(true); |
4217 | 4218 |
4218 parent->AddChild(perspective_surface); | 4219 parent->AddChild(perspective_surface); |
4219 parent->AddChild(scale_surface); | 4220 parent->AddChild(scale_surface); |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4283 | 4284 |
4284 TEST_F(LayerTreeHostCommonTest, | 4285 TEST_F(LayerTreeHostCommonTest, |
4285 LayerTransformsInHighDPIAccurateScaleZeroChildPosition) { | 4286 LayerTransformsInHighDPIAccurateScaleZeroChildPosition) { |
4286 // Verify draw and screen space transforms of layers not in a surface. | 4287 // Verify draw and screen space transforms of layers not in a surface. |
4287 MockContentLayerClient delegate; | 4288 MockContentLayerClient delegate; |
4288 gfx::Transform identity_matrix; | 4289 gfx::Transform identity_matrix; |
4289 | 4290 |
4290 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); | 4291 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); |
4291 SetLayerPropertiesForTesting(parent.get(), | 4292 SetLayerPropertiesForTesting(parent.get(), |
4292 identity_matrix, | 4293 identity_matrix, |
4293 gfx::PointF(), | 4294 gfx::Point3F(), |
4294 gfx::PointF(), | 4295 gfx::PointF(), |
4295 gfx::Size(133, 133), | 4296 gfx::Size(133, 133), |
4296 false, | 4297 false, |
4297 true); | 4298 true); |
4298 | 4299 |
4299 scoped_refptr<ContentLayer> child = CreateDrawableContentLayer(&delegate); | 4300 scoped_refptr<ContentLayer> child = CreateDrawableContentLayer(&delegate); |
4300 SetLayerPropertiesForTesting(child.get(), | 4301 SetLayerPropertiesForTesting(child.get(), |
4301 identity_matrix, | 4302 identity_matrix, |
4302 gfx::PointF(), | 4303 gfx::Point3F(), |
4303 gfx::PointF(), | 4304 gfx::PointF(), |
4304 gfx::Size(13, 13), | 4305 gfx::Size(13, 13), |
4305 false, | 4306 false, |
4306 true); | 4307 true); |
4307 | 4308 |
4308 scoped_refptr<NoScaleContentLayer> child_no_scale = | 4309 scoped_refptr<NoScaleContentLayer> child_no_scale = |
4309 CreateNoScaleDrawableContentLayer(&delegate); | 4310 CreateNoScaleDrawableContentLayer(&delegate); |
4310 SetLayerPropertiesForTesting(child_no_scale.get(), | 4311 SetLayerPropertiesForTesting(child_no_scale.get(), |
4311 identity_matrix, | 4312 identity_matrix, |
4312 gfx::PointF(), | 4313 gfx::Point3F(), |
4313 gfx::PointF(), | 4314 gfx::PointF(), |
4314 gfx::Size(13, 13), | 4315 gfx::Size(13, 13), |
4315 false, | 4316 false, |
4316 true); | 4317 true); |
4317 | 4318 |
4318 parent->AddChild(child); | 4319 parent->AddChild(child); |
4319 parent->AddChild(child_no_scale); | 4320 parent->AddChild(child_no_scale); |
4320 | 4321 |
4321 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 4322 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
4322 host->SetRootLayer(parent); | 4323 host->SetRootLayer(parent); |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4407 gfx::Transform child_scale_matrix; | 4408 gfx::Transform child_scale_matrix; |
4408 SkMScalar initial_child_scale = 1.25; | 4409 SkMScalar initial_child_scale = 1.25; |
4409 child_scale_matrix.Scale(initial_child_scale, initial_child_scale); | 4410 child_scale_matrix.Scale(initial_child_scale, initial_child_scale); |
4410 | 4411 |
4411 scoped_refptr<Layer> root = Layer::Create(); | 4412 scoped_refptr<Layer> root = Layer::Create(); |
4412 root->SetBounds(gfx::Size(100, 100)); | 4413 root->SetBounds(gfx::Size(100, 100)); |
4413 | 4414 |
4414 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); | 4415 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); |
4415 SetLayerPropertiesForTesting(parent.get(), | 4416 SetLayerPropertiesForTesting(parent.get(), |
4416 parent_scale_matrix, | 4417 parent_scale_matrix, |
4417 gfx::PointF(), | 4418 gfx::Point3F(), |
4418 gfx::PointF(), | 4419 gfx::PointF(), |
4419 gfx::Size(100, 100), | 4420 gfx::Size(100, 100), |
4420 false, | 4421 false, |
4421 true); | 4422 true); |
4422 | 4423 |
4423 scoped_refptr<ContentLayer> child_scale = | 4424 scoped_refptr<ContentLayer> child_scale = |
4424 CreateDrawableContentLayer(&delegate); | 4425 CreateDrawableContentLayer(&delegate); |
4425 SetLayerPropertiesForTesting(child_scale.get(), | 4426 SetLayerPropertiesForTesting(child_scale.get(), |
4426 child_scale_matrix, | 4427 child_scale_matrix, |
4427 gfx::PointF(), | 4428 gfx::Point3F(), |
4428 gfx::PointF(2.f, 2.f), | 4429 gfx::PointF(2.f, 2.f), |
4429 gfx::Size(10, 10), | 4430 gfx::Size(10, 10), |
4430 false, | 4431 false, |
4431 true); | 4432 true); |
4432 | 4433 |
4433 scoped_refptr<ContentLayer> child_empty = | 4434 scoped_refptr<ContentLayer> child_empty = |
4434 CreateDrawableContentLayer(&delegate); | 4435 CreateDrawableContentLayer(&delegate); |
4435 SetLayerPropertiesForTesting(child_empty.get(), | 4436 SetLayerPropertiesForTesting(child_empty.get(), |
4436 child_scale_matrix, | 4437 child_scale_matrix, |
4437 gfx::PointF(), | 4438 gfx::Point3F(), |
4438 gfx::PointF(2.f, 2.f), | 4439 gfx::PointF(2.f, 2.f), |
4439 gfx::Size(), | 4440 gfx::Size(), |
4440 false, | 4441 false, |
4441 true); | 4442 true); |
4442 | 4443 |
4443 scoped_refptr<NoScaleContentLayer> child_no_scale = | 4444 scoped_refptr<NoScaleContentLayer> child_no_scale = |
4444 CreateNoScaleDrawableContentLayer(&delegate); | 4445 CreateNoScaleDrawableContentLayer(&delegate); |
4445 SetLayerPropertiesForTesting(child_no_scale.get(), | 4446 SetLayerPropertiesForTesting(child_no_scale.get(), |
4446 child_scale_matrix, | 4447 child_scale_matrix, |
4447 gfx::PointF(), | 4448 gfx::Point3F(), |
4448 gfx::PointF(12.f, 12.f), | 4449 gfx::PointF(12.f, 12.f), |
4449 gfx::Size(10, 10), | 4450 gfx::Size(10, 10), |
4450 false, | 4451 false, |
4451 true); | 4452 true); |
4452 | 4453 |
4453 root->AddChild(parent); | 4454 root->AddChild(parent); |
4454 | 4455 |
4455 parent->AddChild(child_scale); | 4456 parent->AddChild(child_scale); |
4456 parent->AddChild(child_empty); | 4457 parent->AddChild(child_empty); |
4457 parent->AddChild(child_no_scale); | 4458 parent->AddChild(child_no_scale); |
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4591 gfx::Transform child_scale_matrix; | 4592 gfx::Transform child_scale_matrix; |
4592 SkMScalar initial_child_scale = 1.25; | 4593 SkMScalar initial_child_scale = 1.25; |
4593 child_scale_matrix.Scale(initial_child_scale, initial_child_scale); | 4594 child_scale_matrix.Scale(initial_child_scale, initial_child_scale); |
4594 | 4595 |
4595 scoped_refptr<Layer> root = Layer::Create(); | 4596 scoped_refptr<Layer> root = Layer::Create(); |
4596 root->SetBounds(gfx::Size(100, 100)); | 4597 root->SetBounds(gfx::Size(100, 100)); |
4597 | 4598 |
4598 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); | 4599 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); |
4599 SetLayerPropertiesForTesting(parent.get(), | 4600 SetLayerPropertiesForTesting(parent.get(), |
4600 parent_scale_matrix, | 4601 parent_scale_matrix, |
4601 gfx::PointF(), | 4602 gfx::Point3F(), |
4602 gfx::PointF(), | 4603 gfx::PointF(), |
4603 gfx::Size(100, 100), | 4604 gfx::Size(100, 100), |
4604 false, | 4605 false, |
4605 true); | 4606 true); |
4606 | 4607 |
4607 scoped_refptr<ContentLayer> child_scale = | 4608 scoped_refptr<ContentLayer> child_scale = |
4608 CreateDrawableContentLayer(&delegate); | 4609 CreateDrawableContentLayer(&delegate); |
4609 SetLayerPropertiesForTesting(child_scale.get(), | 4610 SetLayerPropertiesForTesting(child_scale.get(), |
4610 child_scale_matrix, | 4611 child_scale_matrix, |
4611 gfx::PointF(), | 4612 gfx::Point3F(), |
4612 gfx::PointF(2.f, 2.f), | 4613 gfx::PointF(2.f, 2.f), |
4613 gfx::Size(10, 10), | 4614 gfx::Size(10, 10), |
4614 false, | 4615 false, |
4615 true); | 4616 true); |
4616 | 4617 |
4617 scoped_refptr<ContentLayer> child_empty = | 4618 scoped_refptr<ContentLayer> child_empty = |
4618 CreateDrawableContentLayer(&delegate); | 4619 CreateDrawableContentLayer(&delegate); |
4619 SetLayerPropertiesForTesting(child_empty.get(), | 4620 SetLayerPropertiesForTesting(child_empty.get(), |
4620 child_scale_matrix, | 4621 child_scale_matrix, |
4621 gfx::PointF(), | 4622 gfx::Point3F(), |
4622 gfx::PointF(2.f, 2.f), | 4623 gfx::PointF(2.f, 2.f), |
4623 gfx::Size(), | 4624 gfx::Size(), |
4624 false, | 4625 false, |
4625 true); | 4626 true); |
4626 | 4627 |
4627 scoped_refptr<NoScaleContentLayer> child_no_scale = | 4628 scoped_refptr<NoScaleContentLayer> child_no_scale = |
4628 CreateNoScaleDrawableContentLayer(&delegate); | 4629 CreateNoScaleDrawableContentLayer(&delegate); |
4629 SetLayerPropertiesForTesting(child_no_scale.get(), | 4630 SetLayerPropertiesForTesting(child_no_scale.get(), |
4630 child_scale_matrix, | 4631 child_scale_matrix, |
4631 gfx::PointF(), | 4632 gfx::Point3F(), |
4632 gfx::PointF(12.f, 12.f), | 4633 gfx::PointF(12.f, 12.f), |
4633 gfx::Size(10, 10), | 4634 gfx::Size(10, 10), |
4634 false, | 4635 false, |
4635 true); | 4636 true); |
4636 | 4637 |
4637 root->AddChild(parent); | 4638 root->AddChild(parent); |
4638 | 4639 |
4639 parent->AddChild(child_scale); | 4640 parent->AddChild(child_scale); |
4640 parent->AddChild(child_empty); | 4641 parent->AddChild(child_empty); |
4641 parent->AddChild(child_no_scale); | 4642 parent->AddChild(child_no_scale); |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4695 gfx::Transform child_scale_matrix; | 4696 gfx::Transform child_scale_matrix; |
4696 SkMScalar initial_child_scale = 0.25; | 4697 SkMScalar initial_child_scale = 0.25; |
4697 child_scale_matrix.Scale(initial_child_scale, initial_child_scale); | 4698 child_scale_matrix.Scale(initial_child_scale, initial_child_scale); |
4698 | 4699 |
4699 scoped_refptr<Layer> root = Layer::Create(); | 4700 scoped_refptr<Layer> root = Layer::Create(); |
4700 root->SetBounds(gfx::Size(100, 100)); | 4701 root->SetBounds(gfx::Size(100, 100)); |
4701 | 4702 |
4702 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); | 4703 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); |
4703 SetLayerPropertiesForTesting(parent.get(), | 4704 SetLayerPropertiesForTesting(parent.get(), |
4704 parent_scale_matrix, | 4705 parent_scale_matrix, |
4705 gfx::PointF(), | 4706 gfx::Point3F(), |
4706 gfx::PointF(), | 4707 gfx::PointF(), |
4707 gfx::Size(100, 100), | 4708 gfx::Size(100, 100), |
4708 false, | 4709 false, |
4709 true); | 4710 true); |
4710 | 4711 |
4711 scoped_refptr<ContentLayer> child_scale = | 4712 scoped_refptr<ContentLayer> child_scale = |
4712 CreateDrawableContentLayer(&delegate); | 4713 CreateDrawableContentLayer(&delegate); |
4713 SetLayerPropertiesForTesting(child_scale.get(), | 4714 SetLayerPropertiesForTesting(child_scale.get(), |
4714 child_scale_matrix, | 4715 child_scale_matrix, |
4715 gfx::PointF(), | 4716 gfx::Point3F(), |
4716 gfx::PointF(2.f, 2.f), | 4717 gfx::PointF(2.f, 2.f), |
4717 gfx::Size(10, 10), | 4718 gfx::Size(10, 10), |
4718 false, | 4719 false, |
4719 true); | 4720 true); |
4720 | 4721 |
4721 root->AddChild(parent); | 4722 root->AddChild(parent); |
4722 | 4723 |
4723 parent->AddChild(child_scale); | 4724 parent->AddChild(child_scale); |
4724 | 4725 |
4725 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 4726 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4784 gfx::Transform child_scale_matrix; | 4785 gfx::Transform child_scale_matrix; |
4785 SkMScalar initial_child_scale = 3.0; | 4786 SkMScalar initial_child_scale = 3.0; |
4786 child_scale_matrix.Scale(initial_child_scale, initial_child_scale); | 4787 child_scale_matrix.Scale(initial_child_scale, initial_child_scale); |
4787 | 4788 |
4788 scoped_refptr<Layer> root = Layer::Create(); | 4789 scoped_refptr<Layer> root = Layer::Create(); |
4789 root->SetBounds(gfx::Size(100, 100)); | 4790 root->SetBounds(gfx::Size(100, 100)); |
4790 | 4791 |
4791 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); | 4792 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); |
4792 SetLayerPropertiesForTesting(parent.get(), | 4793 SetLayerPropertiesForTesting(parent.get(), |
4793 parent_scale_matrix, | 4794 parent_scale_matrix, |
4794 gfx::PointF(), | 4795 gfx::Point3F(), |
4795 gfx::PointF(), | 4796 gfx::PointF(), |
4796 gfx::Size(100, 100), | 4797 gfx::Size(100, 100), |
4797 false, | 4798 false, |
4798 true); | 4799 true); |
4799 | 4800 |
4800 scoped_refptr<ContentLayer> surface_scale = | 4801 scoped_refptr<ContentLayer> surface_scale = |
4801 CreateDrawableContentLayer(&delegate); | 4802 CreateDrawableContentLayer(&delegate); |
4802 SetLayerPropertiesForTesting(surface_scale.get(), | 4803 SetLayerPropertiesForTesting(surface_scale.get(), |
4803 child_scale_matrix, | 4804 child_scale_matrix, |
4804 gfx::PointF(), | 4805 gfx::Point3F(), |
4805 gfx::PointF(2.f, 2.f), | 4806 gfx::PointF(2.f, 2.f), |
4806 gfx::Size(10, 10), | 4807 gfx::Size(10, 10), |
4807 false, | 4808 false, |
4808 true); | 4809 true); |
4809 | 4810 |
4810 scoped_refptr<ContentLayer> surface_scale_child_scale = | 4811 scoped_refptr<ContentLayer> surface_scale_child_scale = |
4811 CreateDrawableContentLayer(&delegate); | 4812 CreateDrawableContentLayer(&delegate); |
4812 SetLayerPropertiesForTesting(surface_scale_child_scale.get(), | 4813 SetLayerPropertiesForTesting(surface_scale_child_scale.get(), |
4813 child_scale_matrix, | 4814 child_scale_matrix, |
4814 gfx::PointF(), | 4815 gfx::Point3F(), |
4815 gfx::PointF(), | 4816 gfx::PointF(), |
4816 gfx::Size(10, 10), | 4817 gfx::Size(10, 10), |
4817 false, | 4818 false, |
4818 true); | 4819 true); |
4819 | 4820 |
4820 scoped_refptr<NoScaleContentLayer> surface_scale_child_no_scale = | 4821 scoped_refptr<NoScaleContentLayer> surface_scale_child_no_scale = |
4821 CreateNoScaleDrawableContentLayer(&delegate); | 4822 CreateNoScaleDrawableContentLayer(&delegate); |
4822 SetLayerPropertiesForTesting(surface_scale_child_no_scale.get(), | 4823 SetLayerPropertiesForTesting(surface_scale_child_no_scale.get(), |
4823 child_scale_matrix, | 4824 child_scale_matrix, |
4824 gfx::PointF(), | 4825 gfx::Point3F(), |
4825 gfx::PointF(), | 4826 gfx::PointF(), |
4826 gfx::Size(10, 10), | 4827 gfx::Size(10, 10), |
4827 false, | 4828 false, |
4828 true); | 4829 true); |
4829 | 4830 |
4830 scoped_refptr<NoScaleContentLayer> surface_no_scale = | 4831 scoped_refptr<NoScaleContentLayer> surface_no_scale = |
4831 CreateNoScaleDrawableContentLayer(&delegate); | 4832 CreateNoScaleDrawableContentLayer(&delegate); |
4832 SetLayerPropertiesForTesting(surface_no_scale.get(), | 4833 SetLayerPropertiesForTesting(surface_no_scale.get(), |
4833 child_scale_matrix, | 4834 child_scale_matrix, |
4834 gfx::PointF(), | 4835 gfx::Point3F(), |
4835 gfx::PointF(12.f, 12.f), | 4836 gfx::PointF(12.f, 12.f), |
4836 gfx::Size(10, 10), | 4837 gfx::Size(10, 10), |
4837 false, | 4838 false, |
4838 true); | 4839 true); |
4839 | 4840 |
4840 scoped_refptr<ContentLayer> surface_no_scale_child_scale = | 4841 scoped_refptr<ContentLayer> surface_no_scale_child_scale = |
4841 CreateDrawableContentLayer(&delegate); | 4842 CreateDrawableContentLayer(&delegate); |
4842 SetLayerPropertiesForTesting(surface_no_scale_child_scale.get(), | 4843 SetLayerPropertiesForTesting(surface_no_scale_child_scale.get(), |
4843 child_scale_matrix, | 4844 child_scale_matrix, |
4844 gfx::PointF(), | 4845 gfx::Point3F(), |
4845 gfx::PointF(), | 4846 gfx::PointF(), |
4846 gfx::Size(10, 10), | 4847 gfx::Size(10, 10), |
4847 false, | 4848 false, |
4848 true); | 4849 true); |
4849 | 4850 |
4850 scoped_refptr<NoScaleContentLayer> surface_no_scale_child_no_scale = | 4851 scoped_refptr<NoScaleContentLayer> surface_no_scale_child_no_scale = |
4851 CreateNoScaleDrawableContentLayer(&delegate); | 4852 CreateNoScaleDrawableContentLayer(&delegate); |
4852 SetLayerPropertiesForTesting(surface_no_scale_child_no_scale.get(), | 4853 SetLayerPropertiesForTesting(surface_no_scale_child_no_scale.get(), |
4853 child_scale_matrix, | 4854 child_scale_matrix, |
4854 gfx::PointF(), | 4855 gfx::Point3F(), |
4855 gfx::PointF(), | 4856 gfx::PointF(), |
4856 gfx::Size(10, 10), | 4857 gfx::Size(10, 10), |
4857 false, | 4858 false, |
4858 true); | 4859 true); |
4859 | 4860 |
4860 root->AddChild(parent); | 4861 root->AddChild(parent); |
4861 | 4862 |
4862 parent->AddChild(surface_scale); | 4863 parent->AddChild(surface_scale); |
4863 parent->AddChild(surface_no_scale); | 4864 parent->AddChild(surface_no_scale); |
4864 | 4865 |
(...skipping 120 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4985 gfx::Transform child_scale_matrix; | 4986 gfx::Transform child_scale_matrix; |
4986 SkMScalar initial_child_scale = 3.0; | 4987 SkMScalar initial_child_scale = 3.0; |
4987 child_scale_matrix.Scale(initial_child_scale, initial_child_scale); | 4988 child_scale_matrix.Scale(initial_child_scale, initial_child_scale); |
4988 | 4989 |
4989 scoped_refptr<Layer> root = Layer::Create(); | 4990 scoped_refptr<Layer> root = Layer::Create(); |
4990 root->SetBounds(gfx::Size(100, 100)); | 4991 root->SetBounds(gfx::Size(100, 100)); |
4991 | 4992 |
4992 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); | 4993 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); |
4993 SetLayerPropertiesForTesting(parent.get(), | 4994 SetLayerPropertiesForTesting(parent.get(), |
4994 parent_scale_matrix, | 4995 parent_scale_matrix, |
4995 gfx::PointF(), | 4996 gfx::Point3F(), |
4996 gfx::PointF(), | 4997 gfx::PointF(), |
4997 gfx::Size(100, 100), | 4998 gfx::Size(100, 100), |
4998 false, | 4999 false, |
4999 true); | 5000 true); |
5000 | 5001 |
5001 scoped_refptr<ContentLayer> surface_scale = | 5002 scoped_refptr<ContentLayer> surface_scale = |
5002 CreateDrawableContentLayer(&delegate); | 5003 CreateDrawableContentLayer(&delegate); |
5003 SetLayerPropertiesForTesting(surface_scale.get(), | 5004 SetLayerPropertiesForTesting(surface_scale.get(), |
5004 child_scale_matrix, | 5005 child_scale_matrix, |
5005 gfx::PointF(), | 5006 gfx::Point3F(), |
5006 gfx::PointF(2.f, 2.f), | 5007 gfx::PointF(2.f, 2.f), |
5007 gfx::Size(10, 10), | 5008 gfx::Size(10, 10), |
5008 false, | 5009 false, |
5009 true); | 5010 true); |
5010 | 5011 |
5011 scoped_refptr<ContentLayer> surface_scale_child_scale = | 5012 scoped_refptr<ContentLayer> surface_scale_child_scale = |
5012 CreateDrawableContentLayer(&delegate); | 5013 CreateDrawableContentLayer(&delegate); |
5013 SetLayerPropertiesForTesting(surface_scale_child_scale.get(), | 5014 SetLayerPropertiesForTesting(surface_scale_child_scale.get(), |
5014 child_scale_matrix, | 5015 child_scale_matrix, |
5015 gfx::PointF(), | 5016 gfx::Point3F(), |
5016 gfx::PointF(), | 5017 gfx::PointF(), |
5017 gfx::Size(10, 10), | 5018 gfx::Size(10, 10), |
5018 false, | 5019 false, |
5019 true); | 5020 true); |
5020 | 5021 |
5021 scoped_refptr<NoScaleContentLayer> surface_scale_child_no_scale = | 5022 scoped_refptr<NoScaleContentLayer> surface_scale_child_no_scale = |
5022 CreateNoScaleDrawableContentLayer(&delegate); | 5023 CreateNoScaleDrawableContentLayer(&delegate); |
5023 SetLayerPropertiesForTesting(surface_scale_child_no_scale.get(), | 5024 SetLayerPropertiesForTesting(surface_scale_child_no_scale.get(), |
5024 child_scale_matrix, | 5025 child_scale_matrix, |
5025 gfx::PointF(), | 5026 gfx::Point3F(), |
5026 gfx::PointF(), | 5027 gfx::PointF(), |
5027 gfx::Size(10, 10), | 5028 gfx::Size(10, 10), |
5028 false, | 5029 false, |
5029 true); | 5030 true); |
5030 | 5031 |
5031 scoped_refptr<NoScaleContentLayer> surface_no_scale = | 5032 scoped_refptr<NoScaleContentLayer> surface_no_scale = |
5032 CreateNoScaleDrawableContentLayer(&delegate); | 5033 CreateNoScaleDrawableContentLayer(&delegate); |
5033 SetLayerPropertiesForTesting(surface_no_scale.get(), | 5034 SetLayerPropertiesForTesting(surface_no_scale.get(), |
5034 child_scale_matrix, | 5035 child_scale_matrix, |
5035 gfx::PointF(), | 5036 gfx::Point3F(), |
5036 gfx::PointF(12.f, 12.f), | 5037 gfx::PointF(12.f, 12.f), |
5037 gfx::Size(10, 10), | 5038 gfx::Size(10, 10), |
5038 false, | 5039 false, |
5039 true); | 5040 true); |
5040 | 5041 |
5041 scoped_refptr<ContentLayer> surface_no_scale_child_scale = | 5042 scoped_refptr<ContentLayer> surface_no_scale_child_scale = |
5042 CreateDrawableContentLayer(&delegate); | 5043 CreateDrawableContentLayer(&delegate); |
5043 SetLayerPropertiesForTesting(surface_no_scale_child_scale.get(), | 5044 SetLayerPropertiesForTesting(surface_no_scale_child_scale.get(), |
5044 child_scale_matrix, | 5045 child_scale_matrix, |
5045 gfx::PointF(), | 5046 gfx::Point3F(), |
5046 gfx::PointF(), | 5047 gfx::PointF(), |
5047 gfx::Size(10, 10), | 5048 gfx::Size(10, 10), |
5048 false, | 5049 false, |
5049 true); | 5050 true); |
5050 | 5051 |
5051 scoped_refptr<NoScaleContentLayer> surface_no_scale_child_no_scale = | 5052 scoped_refptr<NoScaleContentLayer> surface_no_scale_child_no_scale = |
5052 CreateNoScaleDrawableContentLayer(&delegate); | 5053 CreateNoScaleDrawableContentLayer(&delegate); |
5053 SetLayerPropertiesForTesting(surface_no_scale_child_no_scale.get(), | 5054 SetLayerPropertiesForTesting(surface_no_scale_child_no_scale.get(), |
5054 child_scale_matrix, | 5055 child_scale_matrix, |
5055 gfx::PointF(), | 5056 gfx::Point3F(), |
5056 gfx::PointF(), | 5057 gfx::PointF(), |
5057 gfx::Size(10, 10), | 5058 gfx::Size(10, 10), |
5058 false, | 5059 false, |
5059 true); | 5060 true); |
5060 | 5061 |
5061 root->AddChild(parent); | 5062 root->AddChild(parent); |
5062 | 5063 |
5063 parent->AddChild(surface_scale); | 5064 parent->AddChild(surface_scale); |
5064 parent->AddChild(surface_no_scale); | 5065 parent->AddChild(surface_no_scale); |
5065 | 5066 |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
5187 gfx::Transform child_scale_matrix; | 5188 gfx::Transform child_scale_matrix; |
5188 SkMScalar initial_child_scale = 1.25; | 5189 SkMScalar initial_child_scale = 1.25; |
5189 child_scale_matrix.Scale(initial_child_scale, initial_child_scale); | 5190 child_scale_matrix.Scale(initial_child_scale, initial_child_scale); |
5190 | 5191 |
5191 scoped_refptr<Layer> root = Layer::Create(); | 5192 scoped_refptr<Layer> root = Layer::Create(); |
5192 root->SetBounds(gfx::Size(100, 100)); | 5193 root->SetBounds(gfx::Size(100, 100)); |
5193 | 5194 |
5194 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); | 5195 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); |
5195 SetLayerPropertiesForTesting(parent.get(), | 5196 SetLayerPropertiesForTesting(parent.get(), |
5196 parent_scale_matrix, | 5197 parent_scale_matrix, |
5197 gfx::PointF(), | 5198 gfx::Point3F(), |
5198 gfx::PointF(), | 5199 gfx::PointF(), |
5199 gfx::Size(100, 100), | 5200 gfx::Size(100, 100), |
5200 false, | 5201 false, |
5201 true); | 5202 true); |
5202 | 5203 |
5203 scoped_refptr<ContentLayer> child_scale = | 5204 scoped_refptr<ContentLayer> child_scale = |
5204 CreateDrawableContentLayer(&delegate); | 5205 CreateDrawableContentLayer(&delegate); |
5205 SetLayerPropertiesForTesting(child_scale.get(), | 5206 SetLayerPropertiesForTesting(child_scale.get(), |
5206 child_scale_matrix, | 5207 child_scale_matrix, |
5207 gfx::PointF(), | 5208 gfx::Point3F(), |
5208 gfx::PointF(2.f, 2.f), | 5209 gfx::PointF(2.f, 2.f), |
5209 gfx::Size(10, 10), | 5210 gfx::Size(10, 10), |
5210 false, | 5211 false, |
5211 true); | 5212 true); |
5212 | 5213 |
5213 root->AddChild(parent); | 5214 root->AddChild(parent); |
5214 | 5215 |
5215 parent->AddChild(child_scale); | 5216 parent->AddChild(child_scale); |
5216 | 5217 |
5217 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 5218 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
5258 scoped_refptr<Layer> root = Layer::Create(); | 5259 scoped_refptr<Layer> root = Layer::Create(); |
5259 scoped_refptr<Layer> child = CreateDrawableContentLayer(&delegate); | 5260 scoped_refptr<Layer> child = CreateDrawableContentLayer(&delegate); |
5260 root->AddChild(child); | 5261 root->AddChild(child); |
5261 | 5262 |
5262 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 5263 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
5263 host->SetRootLayer(root); | 5264 host->SetRootLayer(root); |
5264 | 5265 |
5265 gfx::Transform identity_matrix; | 5266 gfx::Transform identity_matrix; |
5266 SetLayerPropertiesForTesting(root.get(), | 5267 SetLayerPropertiesForTesting(root.get(), |
5267 identity_matrix, | 5268 identity_matrix, |
5268 gfx::PointF(), | 5269 gfx::Point3F(), |
5269 gfx::PointF(), | 5270 gfx::PointF(), |
5270 gfx::Size(100, 100), | 5271 gfx::Size(100, 100), |
5271 true, | 5272 true, |
5272 false); | 5273 false); |
5273 SetLayerPropertiesForTesting(child.get(), | 5274 SetLayerPropertiesForTesting(child.get(), |
5274 identity_matrix, | 5275 identity_matrix, |
5275 gfx::PointF(), | 5276 gfx::Point3F(), |
5276 gfx::PointF(), | 5277 gfx::PointF(), |
5277 gfx::Size(100, 100), | 5278 gfx::Size(100, 100), |
5278 true, | 5279 true, |
5279 false); | 5280 false); |
5280 | 5281 |
5281 root->reset_needs_push_properties_for_testing(); | 5282 root->reset_needs_push_properties_for_testing(); |
5282 child->reset_needs_push_properties_for_testing(); | 5283 child->reset_needs_push_properties_for_testing(); |
5283 | 5284 |
5284 // This will change both layers' content bounds. | 5285 // This will change both layers' content bounds. |
5285 ExecuteCalculateDrawProperties(root.get()); | 5286 ExecuteCalculateDrawProperties(root.get()); |
(...skipping 18 matching lines...) Expand all Loading... | |
5304 EXPECT_FALSE(child->needs_push_properties()); | 5305 EXPECT_FALSE(child->needs_push_properties()); |
5305 } | 5306 } |
5306 | 5307 |
5307 TEST_F(LayerTreeHostCommonTest, RenderSurfaceTransformsInHighDPI) { | 5308 TEST_F(LayerTreeHostCommonTest, RenderSurfaceTransformsInHighDPI) { |
5308 MockContentLayerClient delegate; | 5309 MockContentLayerClient delegate; |
5309 gfx::Transform identity_matrix; | 5310 gfx::Transform identity_matrix; |
5310 | 5311 |
5311 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); | 5312 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); |
5312 SetLayerPropertiesForTesting(parent.get(), | 5313 SetLayerPropertiesForTesting(parent.get(), |
5313 identity_matrix, | 5314 identity_matrix, |
5314 gfx::PointF(), | 5315 gfx::Point3F(), |
5315 gfx::PointF(), | 5316 gfx::PointF(), |
5316 gfx::Size(30, 30), | 5317 gfx::Size(30, 30), |
5317 false, | 5318 false, |
5318 true); | 5319 true); |
5319 | 5320 |
5320 scoped_refptr<ContentLayer> child = CreateDrawableContentLayer(&delegate); | 5321 scoped_refptr<ContentLayer> child = CreateDrawableContentLayer(&delegate); |
5321 SetLayerPropertiesForTesting(child.get(), | 5322 SetLayerPropertiesForTesting(child.get(), |
5322 identity_matrix, | 5323 identity_matrix, |
5323 gfx::PointF(), | 5324 gfx::Point3F(), |
5324 gfx::PointF(2.f, 2.f), | 5325 gfx::PointF(2.f, 2.f), |
5325 gfx::Size(10, 10), | 5326 gfx::Size(10, 10), |
5326 false, | 5327 false, |
5327 true); | 5328 true); |
5328 | 5329 |
5329 gfx::Transform replica_transform; | 5330 gfx::Transform replica_transform; |
5330 replica_transform.Scale(1.0, -1.0); | 5331 replica_transform.Scale(1.0, -1.0); |
5331 scoped_refptr<ContentLayer> replica = CreateDrawableContentLayer(&delegate); | 5332 scoped_refptr<ContentLayer> replica = CreateDrawableContentLayer(&delegate); |
5332 SetLayerPropertiesForTesting(replica.get(), | 5333 SetLayerPropertiesForTesting(replica.get(), |
5333 replica_transform, | 5334 replica_transform, |
5334 gfx::PointF(), | 5335 gfx::Point3F(), |
5335 gfx::PointF(2.f, 2.f), | 5336 gfx::PointF(2.f, 2.f), |
5336 gfx::Size(10, 10), | 5337 gfx::Size(10, 10), |
5337 false, | 5338 false, |
5338 true); | 5339 true); |
5339 | 5340 |
5340 // This layer should end up in the same surface as child, with the same draw | 5341 // This layer should end up in the same surface as child, with the same draw |
5341 // and screen space transforms. | 5342 // and screen space transforms. |
5342 scoped_refptr<ContentLayer> duplicate_child_non_owner = | 5343 scoped_refptr<ContentLayer> duplicate_child_non_owner = |
5343 CreateDrawableContentLayer(&delegate); | 5344 CreateDrawableContentLayer(&delegate); |
5344 SetLayerPropertiesForTesting(duplicate_child_non_owner.get(), | 5345 SetLayerPropertiesForTesting(duplicate_child_non_owner.get(), |
5345 identity_matrix, | 5346 identity_matrix, |
5346 gfx::PointF(), | 5347 gfx::Point3F(), |
5347 gfx::PointF(), | 5348 gfx::PointF(), |
5348 gfx::Size(10, 10), | 5349 gfx::Size(10, 10), |
5349 false, | 5350 false, |
5350 true); | 5351 true); |
5351 | 5352 |
5352 parent->AddChild(child); | 5353 parent->AddChild(child); |
5353 child->AddChild(duplicate_child_non_owner); | 5354 child->AddChild(duplicate_child_non_owner); |
5354 child->SetReplicaLayer(replica.get()); | 5355 child->SetReplicaLayer(replica.get()); |
5355 | 5356 |
5356 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 5357 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
5439 } | 5440 } |
5440 | 5441 |
5441 TEST_F(LayerTreeHostCommonTest, | 5442 TEST_F(LayerTreeHostCommonTest, |
5442 RenderSurfaceTransformsInHighDPIAccurateScaleZeroPosition) { | 5443 RenderSurfaceTransformsInHighDPIAccurateScaleZeroPosition) { |
5443 MockContentLayerClient delegate; | 5444 MockContentLayerClient delegate; |
5444 gfx::Transform identity_matrix; | 5445 gfx::Transform identity_matrix; |
5445 | 5446 |
5446 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); | 5447 scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate); |
5447 SetLayerPropertiesForTesting(parent.get(), | 5448 SetLayerPropertiesForTesting(parent.get(), |
5448 identity_matrix, | 5449 identity_matrix, |
5449 gfx::PointF(), | 5450 gfx::Point3F(), |
5450 gfx::PointF(), | 5451 gfx::PointF(), |
5451 gfx::Size(33, 31), | 5452 gfx::Size(33, 31), |
5452 false, | 5453 false, |
5453 true); | 5454 true); |
5454 | 5455 |
5455 scoped_refptr<ContentLayer> child = CreateDrawableContentLayer(&delegate); | 5456 scoped_refptr<ContentLayer> child = CreateDrawableContentLayer(&delegate); |
5456 SetLayerPropertiesForTesting(child.get(), | 5457 SetLayerPropertiesForTesting(child.get(), |
5457 identity_matrix, | 5458 identity_matrix, |
5458 gfx::PointF(), | 5459 gfx::Point3F(), |
5459 gfx::PointF(), | 5460 gfx::PointF(), |
5460 gfx::Size(13, 11), | 5461 gfx::Size(13, 11), |
5461 false, | 5462 false, |
5462 true); | 5463 true); |
5463 | 5464 |
5464 gfx::Transform replica_transform; | 5465 gfx::Transform replica_transform; |
5465 replica_transform.Scale(1.0, -1.0); | 5466 replica_transform.Scale(1.0, -1.0); |
5466 scoped_refptr<ContentLayer> replica = CreateDrawableContentLayer(&delegate); | 5467 scoped_refptr<ContentLayer> replica = CreateDrawableContentLayer(&delegate); |
5467 SetLayerPropertiesForTesting(replica.get(), | 5468 SetLayerPropertiesForTesting(replica.get(), |
5468 replica_transform, | 5469 replica_transform, |
5469 gfx::PointF(), | 5470 gfx::Point3F(), |
5470 gfx::PointF(), | 5471 gfx::PointF(), |
5471 gfx::Size(13, 11), | 5472 gfx::Size(13, 11), |
5472 false, | 5473 false, |
5473 true); | 5474 true); |
5474 | 5475 |
5475 // This layer should end up in the same surface as child, with the same draw | 5476 // This layer should end up in the same surface as child, with the same draw |
5476 // and screen space transforms. | 5477 // and screen space transforms. |
5477 scoped_refptr<ContentLayer> duplicate_child_non_owner = | 5478 scoped_refptr<ContentLayer> duplicate_child_non_owner = |
5478 CreateDrawableContentLayer(&delegate); | 5479 CreateDrawableContentLayer(&delegate); |
5479 SetLayerPropertiesForTesting(duplicate_child_non_owner.get(), | 5480 SetLayerPropertiesForTesting(duplicate_child_non_owner.get(), |
5480 identity_matrix, | 5481 identity_matrix, |
5481 gfx::PointF(), | 5482 gfx::Point3F(), |
5482 gfx::PointF(), | 5483 gfx::PointF(), |
5483 gfx::Size(13, 11), | 5484 gfx::Size(13, 11), |
5484 false, | 5485 false, |
5485 true); | 5486 true); |
5486 | 5487 |
5487 parent->AddChild(child); | 5488 parent->AddChild(child); |
5488 child->AddChild(duplicate_child_non_owner); | 5489 child->AddChild(duplicate_child_non_owner); |
5489 child->SetReplicaLayer(replica.get()); | 5490 child->SetReplicaLayer(replica.get()); |
5490 | 5491 |
5491 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 5492 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
5576 | 5577 |
5577 TEST_F(LayerTreeHostCommonTest, TransparentChildRenderSurfaceCreation) { | 5578 TEST_F(LayerTreeHostCommonTest, TransparentChildRenderSurfaceCreation) { |
5578 scoped_refptr<Layer> root = Layer::Create(); | 5579 scoped_refptr<Layer> root = Layer::Create(); |
5579 scoped_refptr<Layer> child = Layer::Create(); | 5580 scoped_refptr<Layer> child = Layer::Create(); |
5580 scoped_refptr<LayerWithForcedDrawsContent> grand_child = | 5581 scoped_refptr<LayerWithForcedDrawsContent> grand_child = |
5581 make_scoped_refptr(new LayerWithForcedDrawsContent()); | 5582 make_scoped_refptr(new LayerWithForcedDrawsContent()); |
5582 | 5583 |
5583 const gfx::Transform identity_matrix; | 5584 const gfx::Transform identity_matrix; |
5584 SetLayerPropertiesForTesting(root.get(), | 5585 SetLayerPropertiesForTesting(root.get(), |
5585 identity_matrix, | 5586 identity_matrix, |
5586 gfx::PointF(), | 5587 gfx::Point3F(), |
5587 gfx::PointF(), | 5588 gfx::PointF(), |
5588 gfx::Size(100, 100), | 5589 gfx::Size(100, 100), |
5589 true, | 5590 true, |
5590 false); | 5591 false); |
5591 SetLayerPropertiesForTesting(child.get(), | 5592 SetLayerPropertiesForTesting(child.get(), |
5592 identity_matrix, | 5593 identity_matrix, |
5593 gfx::PointF(), | 5594 gfx::Point3F(), |
5594 gfx::PointF(), | 5595 gfx::PointF(), |
5595 gfx::Size(10, 10), | 5596 gfx::Size(10, 10), |
5596 true, | 5597 true, |
5597 false); | 5598 false); |
5598 SetLayerPropertiesForTesting(grand_child.get(), | 5599 SetLayerPropertiesForTesting(grand_child.get(), |
5599 identity_matrix, | 5600 identity_matrix, |
5600 gfx::PointF(), | 5601 gfx::Point3F(), |
5601 gfx::PointF(), | 5602 gfx::PointF(), |
5602 gfx::Size(10, 10), | 5603 gfx::Size(10, 10), |
5603 true, | 5604 true, |
5604 false); | 5605 false); |
5605 | 5606 |
5606 root->AddChild(child); | 5607 root->AddChild(child); |
5607 child->AddChild(grand_child); | 5608 child->AddChild(grand_child); |
5608 child->SetOpacity(0.5f); | 5609 child->SetOpacity(0.5f); |
5609 | 5610 |
5610 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 5611 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
5611 host->SetRootLayer(root); | 5612 host->SetRootLayer(root); |
5612 | 5613 |
5613 ExecuteCalculateDrawProperties(root.get()); | 5614 ExecuteCalculateDrawProperties(root.get()); |
5614 | 5615 |
5615 EXPECT_FALSE(child->render_surface()); | 5616 EXPECT_FALSE(child->render_surface()); |
5616 } | 5617 } |
5617 | 5618 |
5618 TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) { | 5619 TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) { |
5619 FakeImplProxy proxy; | 5620 FakeImplProxy proxy; |
5620 TestSharedBitmapManager shared_bitmap_manager; | 5621 TestSharedBitmapManager shared_bitmap_manager; |
5621 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); | 5622 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); |
5622 host_impl.CreatePendingTree(); | 5623 host_impl.CreatePendingTree(); |
5623 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1); | 5624 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1); |
5624 | 5625 |
5625 const gfx::Transform identity_matrix; | 5626 const gfx::Transform identity_matrix; |
5626 SetLayerPropertiesForTesting(root.get(), | 5627 SetLayerPropertiesForTesting(root.get(), |
5627 identity_matrix, | 5628 identity_matrix, |
5628 gfx::PointF(), | 5629 gfx::Point3F(), |
5629 gfx::PointF(), | 5630 gfx::PointF(), |
5630 gfx::Size(100, 100), | 5631 gfx::Size(100, 100), |
5631 true, | 5632 true, |
5632 false); | 5633 false); |
5633 root->SetDrawsContent(true); | 5634 root->SetDrawsContent(true); |
5634 | 5635 |
5635 scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.pending_tree(), 2); | 5636 scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.pending_tree(), 2); |
5636 SetLayerPropertiesForTesting(child.get(), | 5637 SetLayerPropertiesForTesting(child.get(), |
5637 identity_matrix, | 5638 identity_matrix, |
5638 gfx::PointF(), | 5639 gfx::Point3F(), |
5639 gfx::PointF(), | 5640 gfx::PointF(), |
5640 gfx::Size(50, 50), | 5641 gfx::Size(50, 50), |
5641 true, | 5642 true, |
5642 false); | 5643 false); |
5643 child->SetDrawsContent(true); | 5644 child->SetDrawsContent(true); |
5644 child->SetOpacity(0.0f); | 5645 child->SetOpacity(0.0f); |
5645 | 5646 |
5646 // Add opacity animation. | 5647 // Add opacity animation. |
5647 AddOpacityTransitionToController( | 5648 AddOpacityTransitionToController( |
5648 child->layer_animation_controller(), 10.0, 0.0f, 1.0f, false); | 5649 child->layer_animation_controller(), 10.0, 0.0f, 1.0f, false); |
(...skipping 22 matching lines...) Expand all Loading... | |
5671 | 5672 |
5672 root_ = Layer::Create(); | 5673 root_ = Layer::Create(); |
5673 child_ = Layer::Create(); | 5674 child_ = Layer::Create(); |
5674 grand_child_ = Layer::Create(); | 5675 grand_child_ = Layer::Create(); |
5675 child_->AddChild(grand_child_.get()); | 5676 child_->AddChild(grand_child_.get()); |
5676 root_->AddChild(child_.get()); | 5677 root_->AddChild(child_.get()); |
5677 | 5678 |
5678 gfx::Transform identity_matrix; | 5679 gfx::Transform identity_matrix; |
5679 SetLayerPropertiesForTesting(root_.get(), | 5680 SetLayerPropertiesForTesting(root_.get(), |
5680 identity_matrix, | 5681 identity_matrix, |
5681 gfx::PointF(), | 5682 gfx::Point3F(), |
5682 gfx::PointF(), | 5683 gfx::PointF(), |
5683 gfx::Size(1, 1), | 5684 gfx::Size(1, 1), |
5684 true, | 5685 true, |
5685 false); | 5686 false); |
5686 SetLayerPropertiesForTesting(child_.get(), | 5687 SetLayerPropertiesForTesting(child_.get(), |
5687 identity_matrix, | 5688 identity_matrix, |
5688 gfx::PointF(), | 5689 gfx::Point3F(), |
5689 gfx::PointF(), | 5690 gfx::PointF(), |
5690 gfx::Size(1, 1), | 5691 gfx::Size(1, 1), |
5691 true, | 5692 true, |
5692 false); | 5693 false); |
5693 SetLayerPropertiesForTesting(grand_child_.get(), | 5694 SetLayerPropertiesForTesting(grand_child_.get(), |
5694 identity_matrix, | 5695 identity_matrix, |
5695 gfx::PointF(), | 5696 gfx::Point3F(), |
5696 gfx::PointF(), | 5697 gfx::PointF(), |
5697 gfx::Size(1, 1), | 5698 gfx::Size(1, 1), |
5698 true, | 5699 true, |
5699 false); | 5700 false); |
5700 | 5701 |
5701 child_->SetForceRenderSurface(std::tr1::get<1>(GetParam())); | 5702 child_->SetForceRenderSurface(std::tr1::get<1>(GetParam())); |
5702 | 5703 |
5703 host_ = FakeLayerTreeHost::Create(); | 5704 host_ = FakeLayerTreeHost::Create(); |
5704 host_->SetRootLayer(root_); | 5705 host_->SetRootLayer(root_); |
5705 } | 5706 } |
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
5818 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayer) { | 5819 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayer) { |
5819 FakeImplProxy proxy; | 5820 FakeImplProxy proxy; |
5820 TestSharedBitmapManager shared_bitmap_manager; | 5821 TestSharedBitmapManager shared_bitmap_manager; |
5821 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); | 5822 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); |
5822 host_impl.CreatePendingTree(); | 5823 host_impl.CreatePendingTree(); |
5823 const gfx::Transform identity_matrix; | 5824 const gfx::Transform identity_matrix; |
5824 | 5825 |
5825 scoped_refptr<Layer> root = Layer::Create(); | 5826 scoped_refptr<Layer> root = Layer::Create(); |
5826 SetLayerPropertiesForTesting(root.get(), | 5827 SetLayerPropertiesForTesting(root.get(), |
5827 identity_matrix, | 5828 identity_matrix, |
5828 gfx::PointF(), | 5829 gfx::Point3F(), |
5829 gfx::PointF(), | 5830 gfx::PointF(), |
5830 gfx::Size(50, 50), | 5831 gfx::Size(50, 50), |
5831 true, | 5832 true, |
5832 false); | 5833 false); |
5833 root->SetIsDrawable(true); | 5834 root->SetIsDrawable(true); |
5834 | 5835 |
5835 scoped_refptr<Layer> child = Layer::Create(); | 5836 scoped_refptr<Layer> child = Layer::Create(); |
5836 SetLayerPropertiesForTesting(child.get(), | 5837 SetLayerPropertiesForTesting(child.get(), |
5837 identity_matrix, | 5838 identity_matrix, |
5838 gfx::PointF(), | 5839 gfx::Point3F(), |
5839 gfx::PointF(), | 5840 gfx::PointF(), |
5840 gfx::Size(40, 40), | 5841 gfx::Size(40, 40), |
5841 true, | 5842 true, |
5842 false); | 5843 false); |
5843 child->SetIsDrawable(true); | 5844 child->SetIsDrawable(true); |
5844 | 5845 |
5845 scoped_refptr<Layer> grand_child = Layer::Create(); | 5846 scoped_refptr<Layer> grand_child = Layer::Create(); |
5846 SetLayerPropertiesForTesting(grand_child.get(), | 5847 SetLayerPropertiesForTesting(grand_child.get(), |
5847 identity_matrix, | 5848 identity_matrix, |
5848 gfx::PointF(), | 5849 gfx::Point3F(), |
5849 gfx::PointF(), | 5850 gfx::PointF(), |
5850 gfx::Size(30, 30), | 5851 gfx::Size(30, 30), |
5851 true, | 5852 true, |
5852 false); | 5853 false); |
5853 grand_child->SetIsDrawable(true); | 5854 grand_child->SetIsDrawable(true); |
5854 grand_child->SetHideLayerAndSubtree(true); | 5855 grand_child->SetHideLayerAndSubtree(true); |
5855 | 5856 |
5856 child->AddChild(grand_child); | 5857 child->AddChild(grand_child); |
5857 root->AddChild(child); | 5858 root->AddChild(child); |
5858 | 5859 |
(...skipping 17 matching lines...) Expand all Loading... | |
5876 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayerImpl) { | 5877 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayerImpl) { |
5877 FakeImplProxy proxy; | 5878 FakeImplProxy proxy; |
5878 TestSharedBitmapManager shared_bitmap_manager; | 5879 TestSharedBitmapManager shared_bitmap_manager; |
5879 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); | 5880 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); |
5880 host_impl.CreatePendingTree(); | 5881 host_impl.CreatePendingTree(); |
5881 const gfx::Transform identity_matrix; | 5882 const gfx::Transform identity_matrix; |
5882 | 5883 |
5883 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1); | 5884 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1); |
5884 SetLayerPropertiesForTesting(root.get(), | 5885 SetLayerPropertiesForTesting(root.get(), |
5885 identity_matrix, | 5886 identity_matrix, |
5886 gfx::PointF(), | 5887 gfx::Point3F(), |
5887 gfx::PointF(), | 5888 gfx::PointF(), |
5888 gfx::Size(50, 50), | 5889 gfx::Size(50, 50), |
5889 true, | 5890 true, |
5890 false); | 5891 false); |
5891 root->SetDrawsContent(true); | 5892 root->SetDrawsContent(true); |
5892 | 5893 |
5893 scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.pending_tree(), 2); | 5894 scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.pending_tree(), 2); |
5894 SetLayerPropertiesForTesting(child.get(), | 5895 SetLayerPropertiesForTesting(child.get(), |
5895 identity_matrix, | 5896 identity_matrix, |
5896 gfx::PointF(), | 5897 gfx::Point3F(), |
5897 gfx::PointF(), | 5898 gfx::PointF(), |
5898 gfx::Size(40, 40), | 5899 gfx::Size(40, 40), |
5899 true, | 5900 true, |
5900 false); | 5901 false); |
5901 child->SetDrawsContent(true); | 5902 child->SetDrawsContent(true); |
5902 | 5903 |
5903 scoped_ptr<LayerImpl> grand_child = | 5904 scoped_ptr<LayerImpl> grand_child = |
5904 LayerImpl::Create(host_impl.pending_tree(), 3); | 5905 LayerImpl::Create(host_impl.pending_tree(), 3); |
5905 SetLayerPropertiesForTesting(grand_child.get(), | 5906 SetLayerPropertiesForTesting(grand_child.get(), |
5906 identity_matrix, | 5907 identity_matrix, |
5907 gfx::PointF(), | 5908 gfx::Point3F(), |
5908 gfx::PointF(), | 5909 gfx::PointF(), |
5909 gfx::Size(30, 30), | 5910 gfx::Size(30, 30), |
5910 true, | 5911 true, |
5911 false); | 5912 false); |
5912 grand_child->SetDrawsContent(true); | 5913 grand_child->SetDrawsContent(true); |
5913 grand_child->SetHideLayerAndSubtree(true); | 5914 grand_child->SetHideLayerAndSubtree(true); |
5914 | 5915 |
5915 child->AddChild(grand_child.Pass()); | 5916 child->AddChild(grand_child.Pass()); |
5916 root->AddChild(child.Pass()); | 5917 root->AddChild(child.Pass()); |
5917 | 5918 |
(...skipping 14 matching lines...) Expand all Loading... | |
5932 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayers) { | 5933 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayers) { |
5933 FakeImplProxy proxy; | 5934 FakeImplProxy proxy; |
5934 TestSharedBitmapManager shared_bitmap_manager; | 5935 TestSharedBitmapManager shared_bitmap_manager; |
5935 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); | 5936 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); |
5936 host_impl.CreatePendingTree(); | 5937 host_impl.CreatePendingTree(); |
5937 const gfx::Transform identity_matrix; | 5938 const gfx::Transform identity_matrix; |
5938 | 5939 |
5939 scoped_refptr<Layer> root = Layer::Create(); | 5940 scoped_refptr<Layer> root = Layer::Create(); |
5940 SetLayerPropertiesForTesting(root.get(), | 5941 SetLayerPropertiesForTesting(root.get(), |
5941 identity_matrix, | 5942 identity_matrix, |
5942 gfx::PointF(), | 5943 gfx::Point3F(), |
5943 gfx::PointF(), | 5944 gfx::PointF(), |
5944 gfx::Size(50, 50), | 5945 gfx::Size(50, 50), |
5945 true, | 5946 true, |
5946 false); | 5947 false); |
5947 root->SetIsDrawable(true); | 5948 root->SetIsDrawable(true); |
5948 | 5949 |
5949 scoped_refptr<Layer> child = Layer::Create(); | 5950 scoped_refptr<Layer> child = Layer::Create(); |
5950 SetLayerPropertiesForTesting(child.get(), | 5951 SetLayerPropertiesForTesting(child.get(), |
5951 identity_matrix, | 5952 identity_matrix, |
5952 gfx::PointF(), | 5953 gfx::Point3F(), |
5953 gfx::PointF(), | 5954 gfx::PointF(), |
5954 gfx::Size(40, 40), | 5955 gfx::Size(40, 40), |
5955 true, | 5956 true, |
5956 false); | 5957 false); |
5957 child->SetIsDrawable(true); | 5958 child->SetIsDrawable(true); |
5958 child->SetHideLayerAndSubtree(true); | 5959 child->SetHideLayerAndSubtree(true); |
5959 | 5960 |
5960 scoped_refptr<Layer> grand_child = Layer::Create(); | 5961 scoped_refptr<Layer> grand_child = Layer::Create(); |
5961 SetLayerPropertiesForTesting(grand_child.get(), | 5962 SetLayerPropertiesForTesting(grand_child.get(), |
5962 identity_matrix, | 5963 identity_matrix, |
5963 gfx::PointF(), | 5964 gfx::Point3F(), |
5964 gfx::PointF(), | 5965 gfx::PointF(), |
5965 gfx::Size(30, 30), | 5966 gfx::Size(30, 30), |
5966 true, | 5967 true, |
5967 false); | 5968 false); |
5968 grand_child->SetIsDrawable(true); | 5969 grand_child->SetIsDrawable(true); |
5969 | 5970 |
5970 child->AddChild(grand_child); | 5971 child->AddChild(grand_child); |
5971 root->AddChild(child); | 5972 root->AddChild(child); |
5972 | 5973 |
5973 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 5974 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
(...skipping 15 matching lines...) Expand all Loading... | |
5989 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) { | 5990 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) { |
5990 FakeImplProxy proxy; | 5991 FakeImplProxy proxy; |
5991 TestSharedBitmapManager shared_bitmap_manager; | 5992 TestSharedBitmapManager shared_bitmap_manager; |
5992 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); | 5993 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); |
5993 host_impl.CreatePendingTree(); | 5994 host_impl.CreatePendingTree(); |
5994 const gfx::Transform identity_matrix; | 5995 const gfx::Transform identity_matrix; |
5995 | 5996 |
5996 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1); | 5997 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1); |
5997 SetLayerPropertiesForTesting(root.get(), | 5998 SetLayerPropertiesForTesting(root.get(), |
5998 identity_matrix, | 5999 identity_matrix, |
5999 gfx::PointF(), | 6000 gfx::Point3F(), |
6000 gfx::PointF(), | 6001 gfx::PointF(), |
6001 gfx::Size(50, 50), | 6002 gfx::Size(50, 50), |
6002 true, | 6003 true, |
6003 false); | 6004 false); |
6004 root->SetDrawsContent(true); | 6005 root->SetDrawsContent(true); |
6005 | 6006 |
6006 scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.pending_tree(), 2); | 6007 scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.pending_tree(), 2); |
6007 SetLayerPropertiesForTesting(child.get(), | 6008 SetLayerPropertiesForTesting(child.get(), |
6008 identity_matrix, | 6009 identity_matrix, |
6009 gfx::PointF(), | 6010 gfx::Point3F(), |
6010 gfx::PointF(), | 6011 gfx::PointF(), |
6011 gfx::Size(40, 40), | 6012 gfx::Size(40, 40), |
6012 true, | 6013 true, |
6013 false); | 6014 false); |
6014 child->SetDrawsContent(true); | 6015 child->SetDrawsContent(true); |
6015 child->SetHideLayerAndSubtree(true); | 6016 child->SetHideLayerAndSubtree(true); |
6016 | 6017 |
6017 scoped_ptr<LayerImpl> grand_child = | 6018 scoped_ptr<LayerImpl> grand_child = |
6018 LayerImpl::Create(host_impl.pending_tree(), 3); | 6019 LayerImpl::Create(host_impl.pending_tree(), 3); |
6019 SetLayerPropertiesForTesting(grand_child.get(), | 6020 SetLayerPropertiesForTesting(grand_child.get(), |
6020 identity_matrix, | 6021 identity_matrix, |
6021 gfx::PointF(), | 6022 gfx::Point3F(), |
6022 gfx::PointF(), | 6023 gfx::PointF(), |
6023 gfx::Size(30, 30), | 6024 gfx::Size(30, 30), |
6024 true, | 6025 true, |
6025 false); | 6026 false); |
6026 grand_child->SetDrawsContent(true); | 6027 grand_child->SetDrawsContent(true); |
6027 | 6028 |
6028 child->AddChild(grand_child.Pass()); | 6029 child->AddChild(grand_child.Pass()); |
6029 root->AddChild(child.Pass()); | 6030 root->AddChild(child.Pass()); |
6030 | 6031 |
6031 LayerImplList render_surface_layer_list; | 6032 LayerImplList render_surface_layer_list; |
(...skipping 14 matching lines...) Expand all Loading... | |
6046 TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) { | 6047 TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) { |
6047 FakeImplProxy proxy; | 6048 FakeImplProxy proxy; |
6048 TestSharedBitmapManager shared_bitmap_manager; | 6049 TestSharedBitmapManager shared_bitmap_manager; |
6049 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); | 6050 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); |
6050 host_impl.CreatePendingTree(); | 6051 host_impl.CreatePendingTree(); |
6051 const gfx::Transform identity_matrix; | 6052 const gfx::Transform identity_matrix; |
6052 | 6053 |
6053 scoped_refptr<Layer> root = Layer::Create(); | 6054 scoped_refptr<Layer> root = Layer::Create(); |
6054 SetLayerPropertiesForTesting(root.get(), | 6055 SetLayerPropertiesForTesting(root.get(), |
6055 identity_matrix, | 6056 identity_matrix, |
6056 gfx::PointF(), | 6057 gfx::Point3F(), |
6057 gfx::PointF(), | 6058 gfx::PointF(), |
6058 gfx::Size(50, 50), | 6059 gfx::Size(50, 50), |
6059 true, | 6060 true, |
6060 false); | 6061 false); |
6061 root->SetIsDrawable(true); | 6062 root->SetIsDrawable(true); |
6062 | 6063 |
6063 scoped_refptr<Layer> copy_grand_parent = Layer::Create(); | 6064 scoped_refptr<Layer> copy_grand_parent = Layer::Create(); |
6064 SetLayerPropertiesForTesting(copy_grand_parent.get(), | 6065 SetLayerPropertiesForTesting(copy_grand_parent.get(), |
6065 identity_matrix, | 6066 identity_matrix, |
6066 gfx::PointF(), | 6067 gfx::Point3F(), |
6067 gfx::PointF(), | 6068 gfx::PointF(), |
6068 gfx::Size(40, 40), | 6069 gfx::Size(40, 40), |
6069 true, | 6070 true, |
6070 false); | 6071 false); |
6071 copy_grand_parent->SetIsDrawable(true); | 6072 copy_grand_parent->SetIsDrawable(true); |
6072 | 6073 |
6073 scoped_refptr<Layer> copy_parent = Layer::Create(); | 6074 scoped_refptr<Layer> copy_parent = Layer::Create(); |
6074 SetLayerPropertiesForTesting(copy_parent.get(), | 6075 SetLayerPropertiesForTesting(copy_parent.get(), |
6075 identity_matrix, | 6076 identity_matrix, |
6076 gfx::PointF(), | 6077 gfx::Point3F(), |
6077 gfx::PointF(), | 6078 gfx::PointF(), |
6078 gfx::Size(30, 30), | 6079 gfx::Size(30, 30), |
6079 true, | 6080 true, |
6080 false); | 6081 false); |
6081 copy_parent->SetIsDrawable(true); | 6082 copy_parent->SetIsDrawable(true); |
6082 copy_parent->SetForceRenderSurface(true); | 6083 copy_parent->SetForceRenderSurface(true); |
6083 | 6084 |
6084 scoped_refptr<Layer> copy_layer = Layer::Create(); | 6085 scoped_refptr<Layer> copy_layer = Layer::Create(); |
6085 SetLayerPropertiesForTesting(copy_layer.get(), | 6086 SetLayerPropertiesForTesting(copy_layer.get(), |
6086 identity_matrix, | 6087 identity_matrix, |
6087 gfx::PointF(), | 6088 gfx::Point3F(), |
6088 gfx::PointF(), | 6089 gfx::PointF(), |
6089 gfx::Size(20, 20), | 6090 gfx::Size(20, 20), |
6090 true, | 6091 true, |
6091 false); | 6092 false); |
6092 copy_layer->SetIsDrawable(true); | 6093 copy_layer->SetIsDrawable(true); |
6093 | 6094 |
6094 scoped_refptr<Layer> copy_child = Layer::Create(); | 6095 scoped_refptr<Layer> copy_child = Layer::Create(); |
6095 SetLayerPropertiesForTesting(copy_child.get(), | 6096 SetLayerPropertiesForTesting(copy_child.get(), |
6096 identity_matrix, | 6097 identity_matrix, |
6097 gfx::PointF(), | 6098 gfx::Point3F(), |
6098 gfx::PointF(), | 6099 gfx::PointF(), |
6099 gfx::Size(20, 20), | 6100 gfx::Size(20, 20), |
6100 true, | 6101 true, |
6101 false); | 6102 false); |
6102 copy_child->SetIsDrawable(true); | 6103 copy_child->SetIsDrawable(true); |
6103 | 6104 |
6104 scoped_refptr<Layer> copy_grand_parent_sibling_before = Layer::Create(); | 6105 scoped_refptr<Layer> copy_grand_parent_sibling_before = Layer::Create(); |
6105 SetLayerPropertiesForTesting(copy_grand_parent_sibling_before.get(), | 6106 SetLayerPropertiesForTesting(copy_grand_parent_sibling_before.get(), |
6106 identity_matrix, | 6107 identity_matrix, |
6107 gfx::PointF(), | 6108 gfx::Point3F(), |
6108 gfx::PointF(), | 6109 gfx::PointF(), |
6109 gfx::Size(40, 40), | 6110 gfx::Size(40, 40), |
6110 true, | 6111 true, |
6111 false); | 6112 false); |
6112 copy_grand_parent_sibling_before->SetIsDrawable(true); | 6113 copy_grand_parent_sibling_before->SetIsDrawable(true); |
6113 | 6114 |
6114 scoped_refptr<Layer> copy_grand_parent_sibling_after = Layer::Create(); | 6115 scoped_refptr<Layer> copy_grand_parent_sibling_after = Layer::Create(); |
6115 SetLayerPropertiesForTesting(copy_grand_parent_sibling_after.get(), | 6116 SetLayerPropertiesForTesting(copy_grand_parent_sibling_after.get(), |
6116 identity_matrix, | 6117 identity_matrix, |
6117 gfx::PointF(), | 6118 gfx::Point3F(), |
6118 gfx::PointF(), | 6119 gfx::PointF(), |
6119 gfx::Size(40, 40), | 6120 gfx::Size(40, 40), |
6120 true, | 6121 true, |
6121 false); | 6122 false); |
6122 copy_grand_parent_sibling_after->SetIsDrawable(true); | 6123 copy_grand_parent_sibling_after->SetIsDrawable(true); |
6123 | 6124 |
6124 copy_layer->AddChild(copy_child); | 6125 copy_layer->AddChild(copy_child); |
6125 copy_parent->AddChild(copy_layer); | 6126 copy_parent->AddChild(copy_layer); |
6126 copy_grand_parent->AddChild(copy_parent); | 6127 copy_grand_parent->AddChild(copy_parent); |
6127 root->AddChild(copy_grand_parent_sibling_before); | 6128 root->AddChild(copy_grand_parent_sibling_before); |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
6193 TEST_F(LayerTreeHostCommonTest, ClippedOutCopyRequest) { | 6194 TEST_F(LayerTreeHostCommonTest, ClippedOutCopyRequest) { |
6194 FakeImplProxy proxy; | 6195 FakeImplProxy proxy; |
6195 TestSharedBitmapManager shared_bitmap_manager; | 6196 TestSharedBitmapManager shared_bitmap_manager; |
6196 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); | 6197 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); |
6197 host_impl.CreatePendingTree(); | 6198 host_impl.CreatePendingTree(); |
6198 const gfx::Transform identity_matrix; | 6199 const gfx::Transform identity_matrix; |
6199 | 6200 |
6200 scoped_refptr<Layer> root = Layer::Create(); | 6201 scoped_refptr<Layer> root = Layer::Create(); |
6201 SetLayerPropertiesForTesting(root.get(), | 6202 SetLayerPropertiesForTesting(root.get(), |
6202 identity_matrix, | 6203 identity_matrix, |
6203 gfx::PointF(), | 6204 gfx::Point3F(), |
6204 gfx::PointF(), | 6205 gfx::PointF(), |
6205 gfx::Size(50, 50), | 6206 gfx::Size(50, 50), |
6206 true, | 6207 true, |
6207 false); | 6208 false); |
6208 root->SetIsDrawable(true); | 6209 root->SetIsDrawable(true); |
6209 | 6210 |
6210 scoped_refptr<Layer> copy_parent = Layer::Create(); | 6211 scoped_refptr<Layer> copy_parent = Layer::Create(); |
6211 SetLayerPropertiesForTesting(copy_parent.get(), | 6212 SetLayerPropertiesForTesting(copy_parent.get(), |
6212 identity_matrix, | 6213 identity_matrix, |
6213 gfx::PointF(), | 6214 gfx::Point3F(), |
6214 gfx::PointF(), | 6215 gfx::PointF(), |
6215 gfx::Size(), | 6216 gfx::Size(), |
6216 true, | 6217 true, |
6217 false); | 6218 false); |
6218 copy_parent->SetIsDrawable(true); | 6219 copy_parent->SetIsDrawable(true); |
6219 copy_parent->SetMasksToBounds(true); | 6220 copy_parent->SetMasksToBounds(true); |
6220 | 6221 |
6221 scoped_refptr<Layer> copy_layer = Layer::Create(); | 6222 scoped_refptr<Layer> copy_layer = Layer::Create(); |
6222 SetLayerPropertiesForTesting(copy_layer.get(), | 6223 SetLayerPropertiesForTesting(copy_layer.get(), |
6223 identity_matrix, | 6224 identity_matrix, |
6224 gfx::PointF(), | 6225 gfx::Point3F(), |
6225 gfx::PointF(), | 6226 gfx::PointF(), |
6226 gfx::Size(30, 30), | 6227 gfx::Size(30, 30), |
6227 true, | 6228 true, |
6228 false); | 6229 false); |
6229 copy_layer->SetIsDrawable(true); | 6230 copy_layer->SetIsDrawable(true); |
6230 | 6231 |
6231 scoped_refptr<Layer> copy_child = Layer::Create(); | 6232 scoped_refptr<Layer> copy_child = Layer::Create(); |
6232 SetLayerPropertiesForTesting(copy_child.get(), | 6233 SetLayerPropertiesForTesting(copy_child.get(), |
6233 identity_matrix, | 6234 identity_matrix, |
6234 gfx::PointF(), | 6235 gfx::Point3F(), |
6235 gfx::PointF(), | 6236 gfx::PointF(), |
6236 gfx::Size(20, 20), | 6237 gfx::Size(20, 20), |
6237 true, | 6238 true, |
6238 false); | 6239 false); |
6239 copy_child->SetIsDrawable(true); | 6240 copy_child->SetIsDrawable(true); |
6240 | 6241 |
6241 copy_layer->AddChild(copy_child); | 6242 copy_layer->AddChild(copy_child); |
6242 copy_parent->AddChild(copy_layer); | 6243 copy_parent->AddChild(copy_layer); |
6243 root->AddChild(copy_parent); | 6244 root->AddChild(copy_parent); |
6244 | 6245 |
(...skipping 23 matching lines...) Expand all Loading... | |
6268 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInsideSurface) { | 6269 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInsideSurface) { |
6269 FakeImplProxy proxy; | 6270 FakeImplProxy proxy; |
6270 TestSharedBitmapManager shared_bitmap_manager; | 6271 TestSharedBitmapManager shared_bitmap_manager; |
6271 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); | 6272 FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager); |
6272 host_impl.CreatePendingTree(); | 6273 host_impl.CreatePendingTree(); |
6273 const gfx::Transform identity_matrix; | 6274 const gfx::Transform identity_matrix; |
6274 | 6275 |
6275 scoped_refptr<Layer> root = Layer::Create(); | 6276 scoped_refptr<Layer> root = Layer::Create(); |
6276 SetLayerPropertiesForTesting(root.get(), | 6277 SetLayerPropertiesForTesting(root.get(), |
6277 identity_matrix, | 6278 identity_matrix, |
6278 gfx::PointF(), | 6279 gfx::Point3F(), |
6279 gfx::PointF(), | 6280 gfx::PointF(), |
6280 gfx::Size(50, 50), | 6281 gfx::Size(50, 50), |
6281 true, | 6282 true, |
6282 false); | 6283 false); |
6283 root->SetIsDrawable(true); | 6284 root->SetIsDrawable(true); |
6284 | 6285 |
6285 // The surface is moved slightly outside of the viewport. | 6286 // The surface is moved slightly outside of the viewport. |
6286 scoped_refptr<Layer> surface = Layer::Create(); | 6287 scoped_refptr<Layer> surface = Layer::Create(); |
6287 SetLayerPropertiesForTesting(surface.get(), | 6288 SetLayerPropertiesForTesting(surface.get(), |
6288 identity_matrix, | 6289 identity_matrix, |
6289 gfx::PointF(), | 6290 gfx::Point3F(), |
6290 gfx::PointF(-10, -20), | 6291 gfx::PointF(-10, -20), |
6291 gfx::Size(), | 6292 gfx::Size(), |
6292 true, | 6293 true, |
6293 false); | 6294 false); |
6294 surface->SetForceRenderSurface(true); | 6295 surface->SetForceRenderSurface(true); |
6295 | 6296 |
6296 scoped_refptr<Layer> surface_child = Layer::Create(); | 6297 scoped_refptr<Layer> surface_child = Layer::Create(); |
6297 SetLayerPropertiesForTesting(surface_child.get(), | 6298 SetLayerPropertiesForTesting(surface_child.get(), |
6298 identity_matrix, | 6299 identity_matrix, |
6299 gfx::PointF(), | 6300 gfx::Point3F(), |
6300 gfx::PointF(), | 6301 gfx::PointF(), |
6301 gfx::Size(50, 50), | 6302 gfx::Size(50, 50), |
6302 true, | 6303 true, |
6303 false); | 6304 false); |
6304 surface_child->SetIsDrawable(true); | 6305 surface_child->SetIsDrawable(true); |
6305 | 6306 |
6306 surface->AddChild(surface_child); | 6307 surface->AddChild(surface_child); |
6307 root->AddChild(surface); | 6308 root->AddChild(surface); |
6308 | 6309 |
6309 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 6310 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
6352 | 6353 |
6353 render_surface->SetForceRenderSurface(true); | 6354 render_surface->SetForceRenderSurface(true); |
6354 | 6355 |
6355 gfx::Transform scale_transform; | 6356 gfx::Transform scale_transform; |
6356 scale_transform.Scale(2, 2); | 6357 scale_transform.Scale(2, 2); |
6357 | 6358 |
6358 gfx::Transform identity_transform; | 6359 gfx::Transform identity_transform; |
6359 | 6360 |
6360 SetLayerPropertiesForTesting(root.get(), | 6361 SetLayerPropertiesForTesting(root.get(), |
6361 identity_transform, | 6362 identity_transform, |
6362 gfx::PointF(), | 6363 gfx::Point3F(), |
6363 gfx::PointF(), | 6364 gfx::PointF(), |
6364 gfx::Size(50, 50), | 6365 gfx::Size(50, 50), |
6365 true, | 6366 true, |
6366 false); | 6367 false); |
6367 SetLayerPropertiesForTesting(render_surface.get(), | 6368 SetLayerPropertiesForTesting(render_surface.get(), |
6368 identity_transform, | 6369 identity_transform, |
6369 gfx::PointF(), | 6370 gfx::Point3F(), |
6370 gfx::PointF(), | 6371 gfx::PointF(), |
6371 gfx::Size(10, 10), | 6372 gfx::Size(10, 10), |
6372 true, | 6373 true, |
6373 false); | 6374 false); |
6374 SetLayerPropertiesForTesting(clip_parent.get(), | 6375 SetLayerPropertiesForTesting(clip_parent.get(), |
6375 scale_transform, | 6376 scale_transform, |
6376 gfx::PointF(), | 6377 gfx::Point3F(), |
6377 gfx::PointF(1.f, 1.f), | 6378 gfx::PointF(1.f, 1.f), |
6378 gfx::Size(10, 10), | 6379 gfx::Size(10, 10), |
6379 true, | 6380 true, |
6380 false); | 6381 false); |
6381 SetLayerPropertiesForTesting(intervening.get(), | 6382 SetLayerPropertiesForTesting(intervening.get(), |
6382 identity_transform, | 6383 identity_transform, |
6383 gfx::PointF(), | 6384 gfx::Point3F(), |
6384 gfx::PointF(1.f, 1.f), | 6385 gfx::PointF(1.f, 1.f), |
6385 gfx::Size(5, 5), | 6386 gfx::Size(5, 5), |
6386 true, | 6387 true, |
6387 false); | 6388 false); |
6388 SetLayerPropertiesForTesting(clip_child.get(), | 6389 SetLayerPropertiesForTesting(clip_child.get(), |
6389 identity_transform, | 6390 identity_transform, |
6390 gfx::PointF(), | 6391 gfx::Point3F(), |
6391 gfx::PointF(1.f, 1.f), | 6392 gfx::PointF(1.f, 1.f), |
6392 gfx::Size(10, 10), | 6393 gfx::Size(10, 10), |
6393 true, | 6394 true, |
6394 false); | 6395 false); |
6395 | 6396 |
6396 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 6397 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
6397 host->SetRootLayer(root); | 6398 host->SetRootLayer(root); |
6398 | 6399 |
6399 ExecuteCalculateDrawProperties(root.get()); | 6400 ExecuteCalculateDrawProperties(root.get()); |
6400 | 6401 |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
6456 | 6457 |
6457 render_surface1->SetForceRenderSurface(true); | 6458 render_surface1->SetForceRenderSurface(true); |
6458 render_surface2->SetForceRenderSurface(true); | 6459 render_surface2->SetForceRenderSurface(true); |
6459 | 6460 |
6460 gfx::Transform translation_transform; | 6461 gfx::Transform translation_transform; |
6461 translation_transform.Translate(2, 2); | 6462 translation_transform.Translate(2, 2); |
6462 | 6463 |
6463 gfx::Transform identity_transform; | 6464 gfx::Transform identity_transform; |
6464 SetLayerPropertiesForTesting(root.get(), | 6465 SetLayerPropertiesForTesting(root.get(), |
6465 identity_transform, | 6466 identity_transform, |
6466 gfx::PointF(), | 6467 gfx::Point3F(), |
6467 gfx::PointF(), | 6468 gfx::PointF(), |
6468 gfx::Size(50, 50), | 6469 gfx::Size(50, 50), |
6469 true, | 6470 true, |
6470 false); | 6471 false); |
6471 SetLayerPropertiesForTesting(clip_parent.get(), | 6472 SetLayerPropertiesForTesting(clip_parent.get(), |
6472 translation_transform, | 6473 translation_transform, |
6473 gfx::PointF(), | 6474 gfx::Point3F(), |
6474 gfx::PointF(1.f, 1.f), | 6475 gfx::PointF(1.f, 1.f), |
6475 gfx::Size(40, 40), | 6476 gfx::Size(40, 40), |
6476 true, | 6477 true, |
6477 false); | 6478 false); |
6478 SetLayerPropertiesForTesting(render_surface1.get(), | 6479 SetLayerPropertiesForTesting(render_surface1.get(), |
6479 identity_transform, | 6480 identity_transform, |
6480 gfx::PointF(), | 6481 gfx::Point3F(), |
6481 gfx::PointF(), | 6482 gfx::PointF(), |
6482 gfx::Size(10, 10), | 6483 gfx::Size(10, 10), |
6483 true, | 6484 true, |
6484 false); | 6485 false); |
6485 SetLayerPropertiesForTesting(intervening.get(), | 6486 SetLayerPropertiesForTesting(intervening.get(), |
6486 identity_transform, | 6487 identity_transform, |
6487 gfx::PointF(), | 6488 gfx::Point3F(), |
6488 gfx::PointF(1.f, 1.f), | 6489 gfx::PointF(1.f, 1.f), |
6489 gfx::Size(5, 5), | 6490 gfx::Size(5, 5), |
6490 true, | 6491 true, |
6491 false); | 6492 false); |
6492 SetLayerPropertiesForTesting(render_surface2.get(), | 6493 SetLayerPropertiesForTesting(render_surface2.get(), |
6493 identity_transform, | 6494 identity_transform, |
6494 gfx::PointF(), | 6495 gfx::Point3F(), |
6495 gfx::PointF(), | 6496 gfx::PointF(), |
6496 gfx::Size(10, 10), | 6497 gfx::Size(10, 10), |
6497 true, | 6498 true, |
6498 false); | 6499 false); |
6499 SetLayerPropertiesForTesting(clip_child.get(), | 6500 SetLayerPropertiesForTesting(clip_child.get(), |
6500 identity_transform, | 6501 identity_transform, |
6501 gfx::PointF(), | 6502 gfx::Point3F(), |
6502 gfx::PointF(-10.f, -10.f), | 6503 gfx::PointF(-10.f, -10.f), |
6503 gfx::Size(60, 60), | 6504 gfx::Size(60, 60), |
6504 true, | 6505 true, |
6505 false); | 6506 false); |
6506 | 6507 |
6507 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 6508 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
6508 host->SetRootLayer(root); | 6509 host->SetRootLayer(root); |
6509 | 6510 |
6510 ExecuteCalculateDrawProperties(root.get()); | 6511 ExecuteCalculateDrawProperties(root.get()); |
6511 | 6512 |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
6585 | 6586 |
6586 render_surface1->SetForceRenderSurface(true); | 6587 render_surface1->SetForceRenderSurface(true); |
6587 render_surface2->SetForceRenderSurface(true); | 6588 render_surface2->SetForceRenderSurface(true); |
6588 | 6589 |
6589 gfx::Transform translation_transform; | 6590 gfx::Transform translation_transform; |
6590 translation_transform.Translate(2, 2); | 6591 translation_transform.Translate(2, 2); |
6591 | 6592 |
6592 gfx::Transform identity_transform; | 6593 gfx::Transform identity_transform; |
6593 SetLayerPropertiesForTesting(root.get(), | 6594 SetLayerPropertiesForTesting(root.get(), |
6594 identity_transform, | 6595 identity_transform, |
6595 gfx::PointF(), | 6596 gfx::Point3F(), |
6596 gfx::PointF(), | 6597 gfx::PointF(), |
6597 gfx::Size(50, 50), | 6598 gfx::Size(50, 50), |
6598 true, | 6599 true, |
6599 false); | 6600 false); |
6600 SetLayerPropertiesForTesting(clip_parent.get(), | 6601 SetLayerPropertiesForTesting(clip_parent.get(), |
6601 translation_transform, | 6602 translation_transform, |
6602 gfx::PointF(), | 6603 gfx::Point3F(), |
6603 gfx::PointF(1.f, 1.f), | 6604 gfx::PointF(1.f, 1.f), |
6604 gfx::Size(40, 40), | 6605 gfx::Size(40, 40), |
6605 true, | 6606 true, |
6606 false); | 6607 false); |
6607 SetLayerPropertiesForTesting(render_surface1.get(), | 6608 SetLayerPropertiesForTesting(render_surface1.get(), |
6608 identity_transform, | 6609 identity_transform, |
6609 gfx::PointF(), | 6610 gfx::Point3F(), |
6610 gfx::PointF(), | 6611 gfx::PointF(), |
6611 gfx::Size(10, 10), | 6612 gfx::Size(10, 10), |
6612 true, | 6613 true, |
6613 false); | 6614 false); |
6614 SetLayerPropertiesForTesting(intervening.get(), | 6615 SetLayerPropertiesForTesting(intervening.get(), |
6615 identity_transform, | 6616 identity_transform, |
6616 gfx::PointF(), | 6617 gfx::Point3F(), |
6617 gfx::PointF(1.f, 1.f), | 6618 gfx::PointF(1.f, 1.f), |
6618 gfx::Size(5, 5), | 6619 gfx::Size(5, 5), |
6619 true, | 6620 true, |
6620 false); | 6621 false); |
6621 SetLayerPropertiesForTesting(render_surface2.get(), | 6622 SetLayerPropertiesForTesting(render_surface2.get(), |
6622 identity_transform, | 6623 identity_transform, |
6623 gfx::PointF(), | 6624 gfx::Point3F(), |
6624 gfx::PointF(), | 6625 gfx::PointF(), |
6625 gfx::Size(10, 10), | 6626 gfx::Size(10, 10), |
6626 true, | 6627 true, |
6627 false); | 6628 false); |
6628 SetLayerPropertiesForTesting(clip_child.get(), | 6629 SetLayerPropertiesForTesting(clip_child.get(), |
6629 identity_transform, | 6630 identity_transform, |
6630 gfx::PointF(), | 6631 gfx::Point3F(), |
6631 gfx::PointF(-10.f, -10.f), | 6632 gfx::PointF(-10.f, -10.f), |
6632 gfx::Size(60, 60), | 6633 gfx::Size(60, 60), |
6633 true, | 6634 true, |
6634 false); | 6635 false); |
6635 | 6636 |
6636 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 6637 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
6637 host->SetRootLayer(root); | 6638 host->SetRootLayer(root); |
6638 | 6639 |
6639 ExecuteCalculateDrawProperties(root.get()); | 6640 ExecuteCalculateDrawProperties(root.get()); |
6640 | 6641 |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
6701 clip_child->AddChild(child); | 6702 clip_child->AddChild(child); |
6702 | 6703 |
6703 clip_child->SetClipParent(clip_parent.get()); | 6704 clip_child->SetClipParent(clip_parent.get()); |
6704 | 6705 |
6705 intervening->SetMasksToBounds(true); | 6706 intervening->SetMasksToBounds(true); |
6706 clip_parent->SetMasksToBounds(true); | 6707 clip_parent->SetMasksToBounds(true); |
6707 | 6708 |
6708 gfx::Transform identity_transform; | 6709 gfx::Transform identity_transform; |
6709 SetLayerPropertiesForTesting(root.get(), | 6710 SetLayerPropertiesForTesting(root.get(), |
6710 identity_transform, | 6711 identity_transform, |
6711 gfx::PointF(), | 6712 gfx::Point3F(), |
6712 gfx::PointF(), | 6713 gfx::PointF(), |
6713 gfx::Size(50, 50), | 6714 gfx::Size(50, 50), |
6714 true, | 6715 true, |
6715 false); | 6716 false); |
6716 SetLayerPropertiesForTesting(clip_parent.get(), | 6717 SetLayerPropertiesForTesting(clip_parent.get(), |
6717 identity_transform, | 6718 identity_transform, |
6718 gfx::PointF(), | 6719 gfx::Point3F(), |
6719 gfx::PointF(), | 6720 gfx::PointF(), |
6720 gfx::Size(40, 40), | 6721 gfx::Size(40, 40), |
6721 true, | 6722 true, |
6722 false); | 6723 false); |
6723 SetLayerPropertiesForTesting(intervening.get(), | 6724 SetLayerPropertiesForTesting(intervening.get(), |
6724 identity_transform, | 6725 identity_transform, |
6725 gfx::PointF(), | 6726 gfx::Point3F(), |
6726 gfx::PointF(), | 6727 gfx::PointF(), |
6727 gfx::Size(5, 5), | 6728 gfx::Size(5, 5), |
6728 true, | 6729 true, |
6729 false); | 6730 false); |
6730 SetLayerPropertiesForTesting(clip_child.get(), | 6731 SetLayerPropertiesForTesting(clip_child.get(), |
6731 identity_transform, | 6732 identity_transform, |
6732 gfx::PointF(), | 6733 gfx::Point3F(), |
6733 gfx::PointF(), | 6734 gfx::PointF(), |
6734 gfx::Size(60, 60), | 6735 gfx::Size(60, 60), |
6735 true, | 6736 true, |
6736 false); | 6737 false); |
6737 SetLayerPropertiesForTesting(child.get(), | 6738 SetLayerPropertiesForTesting(child.get(), |
6738 identity_transform, | 6739 identity_transform, |
6739 gfx::PointF(), | 6740 gfx::Point3F(), |
6740 gfx::PointF(), | 6741 gfx::PointF(), |
6741 gfx::Size(60, 60), | 6742 gfx::Size(60, 60), |
6742 true, | 6743 true, |
6743 false); | 6744 false); |
6744 | 6745 |
6745 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 6746 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
6746 host->SetRootLayer(root); | 6747 host->SetRootLayer(root); |
6747 | 6748 |
6748 ExecuteCalculateDrawProperties(root.get()); | 6749 ExecuteCalculateDrawProperties(root.get()); |
6749 | 6750 |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
6788 render_surface2->AddChild(non_clip_child); | 6789 render_surface2->AddChild(non_clip_child); |
6789 | 6790 |
6790 clip_child->SetClipParent(clip_parent.get()); | 6791 clip_child->SetClipParent(clip_parent.get()); |
6791 | 6792 |
6792 clip_parent->SetMasksToBounds(true); | 6793 clip_parent->SetMasksToBounds(true); |
6793 render_surface1->SetMasksToBounds(true); | 6794 render_surface1->SetMasksToBounds(true); |
6794 | 6795 |
6795 gfx::Transform identity_transform; | 6796 gfx::Transform identity_transform; |
6796 SetLayerPropertiesForTesting(root.get(), | 6797 SetLayerPropertiesForTesting(root.get(), |
6797 identity_transform, | 6798 identity_transform, |
6798 gfx::PointF(), | 6799 gfx::Point3F(), |
6799 gfx::PointF(), | 6800 gfx::PointF(), |
6800 gfx::Size(15, 15), | 6801 gfx::Size(15, 15), |
6801 true, | 6802 true, |
6802 false); | 6803 false); |
6803 SetLayerPropertiesForTesting(clip_parent.get(), | 6804 SetLayerPropertiesForTesting(clip_parent.get(), |
6804 identity_transform, | 6805 identity_transform, |
6805 gfx::PointF(), | 6806 gfx::Point3F(), |
6806 gfx::PointF(), | 6807 gfx::PointF(), |
6807 gfx::Size(10, 10), | 6808 gfx::Size(10, 10), |
6808 true, | 6809 true, |
6809 false); | 6810 false); |
6810 SetLayerPropertiesForTesting(render_surface1.get(), | 6811 SetLayerPropertiesForTesting(render_surface1.get(), |
6811 identity_transform, | 6812 identity_transform, |
6812 gfx::PointF(), | 6813 gfx::Point3F(), |
6813 gfx::PointF(5, 5), | 6814 gfx::PointF(5, 5), |
6814 gfx::Size(5, 5), | 6815 gfx::Size(5, 5), |
6815 true, | 6816 true, |
6816 false); | 6817 false); |
6817 SetLayerPropertiesForTesting(render_surface2.get(), | 6818 SetLayerPropertiesForTesting(render_surface2.get(), |
6818 identity_transform, | 6819 identity_transform, |
6819 gfx::PointF(), | 6820 gfx::Point3F(), |
6820 gfx::PointF(), | 6821 gfx::PointF(), |
6821 gfx::Size(5, 5), | 6822 gfx::Size(5, 5), |
6822 true, | 6823 true, |
6823 false); | 6824 false); |
6824 SetLayerPropertiesForTesting(clip_child.get(), | 6825 SetLayerPropertiesForTesting(clip_child.get(), |
6825 identity_transform, | 6826 identity_transform, |
6826 gfx::PointF(), | 6827 gfx::Point3F(), |
6827 gfx::PointF(-1, 1), | 6828 gfx::PointF(-1, 1), |
6828 gfx::Size(10, 10), | 6829 gfx::Size(10, 10), |
6829 true, | 6830 true, |
6830 false); | 6831 false); |
6831 SetLayerPropertiesForTesting(non_clip_child.get(), | 6832 SetLayerPropertiesForTesting(non_clip_child.get(), |
6832 identity_transform, | 6833 identity_transform, |
6833 gfx::PointF(), | 6834 gfx::Point3F(), |
6834 gfx::PointF(), | 6835 gfx::PointF(), |
6835 gfx::Size(5, 5), | 6836 gfx::Size(5, 5), |
6836 true, | 6837 true, |
6837 false); | 6838 false); |
6838 | 6839 |
6839 render_surface1->SetForceRenderSurface(true); | 6840 render_surface1->SetForceRenderSurface(true); |
6840 render_surface2->SetForceRenderSurface(true); | 6841 render_surface2->SetForceRenderSurface(true); |
6841 | 6842 |
6842 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 6843 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
6843 host->SetRootLayer(root); | 6844 host->SetRootLayer(root); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
6883 scoped_ptr<LayerImpl> root = | 6884 scoped_ptr<LayerImpl> root = |
6884 LayerImpl::Create(host_impl.active_tree(), 12345); | 6885 LayerImpl::Create(host_impl.active_tree(), 12345); |
6885 scoped_ptr<LayerImpl> child1 = | 6886 scoped_ptr<LayerImpl> child1 = |
6886 LayerImpl::Create(host_impl.active_tree(), 123456); | 6887 LayerImpl::Create(host_impl.active_tree(), 123456); |
6887 scoped_ptr<LayerImpl> child2 = | 6888 scoped_ptr<LayerImpl> child2 = |
6888 LayerImpl::Create(host_impl.active_tree(), 1234567); | 6889 LayerImpl::Create(host_impl.active_tree(), 1234567); |
6889 scoped_ptr<LayerImpl> child3 = | 6890 scoped_ptr<LayerImpl> child3 = |
6890 LayerImpl::Create(host_impl.active_tree(), 12345678); | 6891 LayerImpl::Create(host_impl.active_tree(), 12345678); |
6891 | 6892 |
6892 gfx::Transform identity_matrix; | 6893 gfx::Transform identity_matrix; |
6893 gfx::PointF anchor; | 6894 gfx::Point3F transform_origin; |
6894 gfx::PointF position; | 6895 gfx::PointF position; |
6895 gfx::Size bounds(100, 100); | 6896 gfx::Size bounds(100, 100); |
6896 SetLayerPropertiesForTesting(root.get(), | 6897 SetLayerPropertiesForTesting(root.get(), |
6897 identity_matrix, | 6898 identity_matrix, |
6898 anchor, | 6899 transform_origin, |
6899 position, | 6900 position, |
6900 bounds, | 6901 bounds, |
6901 true, | 6902 true, |
6902 false); | 6903 false); |
6903 root->SetDrawsContent(true); | 6904 root->SetDrawsContent(true); |
6904 | 6905 |
6905 // This layer structure normally forces render surface due to preserves3d | 6906 // This layer structure normally forces render surface due to preserves3d |
6906 // behavior. | 6907 // behavior. |
6907 SetLayerPropertiesForTesting(child1.get(), | 6908 SetLayerPropertiesForTesting(child1.get(), |
6908 identity_matrix, | 6909 identity_matrix, |
6909 anchor, | 6910 transform_origin, |
6910 position, | 6911 position, |
6911 bounds, | 6912 bounds, |
6912 false, | 6913 false, |
6913 true); | 6914 true); |
6914 child1->SetDrawsContent(true); | 6915 child1->SetDrawsContent(true); |
6915 SetLayerPropertiesForTesting(child2.get(), | 6916 SetLayerPropertiesForTesting(child2.get(), |
6916 identity_matrix, | 6917 identity_matrix, |
6917 anchor, | 6918 transform_origin, |
6918 position, | 6919 position, |
6919 bounds, | 6920 bounds, |
6920 true, | 6921 true, |
6921 false); | 6922 false); |
6922 child2->SetDrawsContent(true); | 6923 child2->SetDrawsContent(true); |
6923 SetLayerPropertiesForTesting(child3.get(), | 6924 SetLayerPropertiesForTesting(child3.get(), |
6924 identity_matrix, | 6925 identity_matrix, |
6925 anchor, | 6926 transform_origin, |
6926 position, | 6927 position, |
6927 bounds, | 6928 bounds, |
6928 true, | 6929 true, |
6929 false); | 6930 false); |
6930 child3->SetDrawsContent(true); | 6931 child3->SetDrawsContent(true); |
6931 | 6932 |
6932 child2->SetIs3dSorted(true); | 6933 child2->SetIs3dSorted(true); |
6933 child3->SetIs3dSorted(true); | 6934 child3->SetIs3dSorted(true); |
6934 | 6935 |
6935 child2->AddChild(child3.Pass()); | 6936 child2->AddChild(child3.Pass()); |
(...skipping 26 matching lines...) Expand all Loading... | |
6962 scoped_refptr<Layer> render_surface = Layer::Create(); | 6963 scoped_refptr<Layer> render_surface = Layer::Create(); |
6963 scoped_refptr<LayerWithForcedDrawsContent> child = | 6964 scoped_refptr<LayerWithForcedDrawsContent> child = |
6964 make_scoped_refptr(new LayerWithForcedDrawsContent); | 6965 make_scoped_refptr(new LayerWithForcedDrawsContent); |
6965 | 6966 |
6966 root->AddChild(render_surface); | 6967 root->AddChild(render_surface); |
6967 render_surface->AddChild(child); | 6968 render_surface->AddChild(child); |
6968 | 6969 |
6969 gfx::Transform identity_transform; | 6970 gfx::Transform identity_transform; |
6970 SetLayerPropertiesForTesting(root.get(), | 6971 SetLayerPropertiesForTesting(root.get(), |
6971 identity_transform, | 6972 identity_transform, |
6972 gfx::PointF(), | 6973 gfx::Point3F(), |
6973 gfx::PointF(), | 6974 gfx::PointF(), |
6974 gfx::Size(50, 50), | 6975 gfx::Size(50, 50), |
6975 true, | 6976 true, |
6976 false); | 6977 false); |
6977 SetLayerPropertiesForTesting(render_surface.get(), | 6978 SetLayerPropertiesForTesting(render_surface.get(), |
6978 identity_transform, | 6979 identity_transform, |
6979 gfx::PointF(), | 6980 gfx::Point3F(), |
6980 gfx::PointF(), | 6981 gfx::PointF(), |
6981 gfx::Size(30, 30), | 6982 gfx::Size(30, 30), |
6982 false, | 6983 false, |
6983 true); | 6984 true); |
6984 SetLayerPropertiesForTesting(child.get(), | 6985 SetLayerPropertiesForTesting(child.get(), |
6985 identity_transform, | 6986 identity_transform, |
6986 gfx::PointF(), | 6987 gfx::Point3F(), |
6987 gfx::PointF(), | 6988 gfx::PointF(), |
6988 gfx::Size(20, 20), | 6989 gfx::Size(20, 20), |
6989 true, | 6990 true, |
6990 false); | 6991 false); |
6991 | 6992 |
6992 root->SetShouldFlattenTransform(false); | 6993 root->SetShouldFlattenTransform(false); |
6993 root->SetIs3dSorted(true); | 6994 root->SetIs3dSorted(true); |
6994 render_surface->SetDoubleSided(false); | 6995 render_surface->SetDoubleSided(false); |
6995 render_surface->SetForceRenderSurface(true); | 6996 render_surface->SetForceRenderSurface(true); |
6996 | 6997 |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
7044 scroll_parent_border->AddChild(scroll_parent_clip); | 7045 scroll_parent_border->AddChild(scroll_parent_clip); |
7045 scroll_parent_clip->AddChild(scroll_parent); | 7046 scroll_parent_clip->AddChild(scroll_parent); |
7046 | 7047 |
7047 scroll_parent_clip->SetMasksToBounds(true); | 7048 scroll_parent_clip->SetMasksToBounds(true); |
7048 | 7049 |
7049 scroll_child->SetScrollParent(scroll_parent.get()); | 7050 scroll_child->SetScrollParent(scroll_parent.get()); |
7050 | 7051 |
7051 gfx::Transform identity_transform; | 7052 gfx::Transform identity_transform; |
7052 SetLayerPropertiesForTesting(root.get(), | 7053 SetLayerPropertiesForTesting(root.get(), |
7053 identity_transform, | 7054 identity_transform, |
7054 gfx::PointF(), | 7055 gfx::Point3F(), |
7055 gfx::PointF(), | 7056 gfx::PointF(), |
7056 gfx::Size(50, 50), | 7057 gfx::Size(50, 50), |
7057 true, | 7058 true, |
7058 false); | 7059 false); |
7059 SetLayerPropertiesForTesting(scroll_parent_border.get(), | 7060 SetLayerPropertiesForTesting(scroll_parent_border.get(), |
7060 identity_transform, | 7061 identity_transform, |
7061 gfx::PointF(), | 7062 gfx::Point3F(), |
7062 gfx::PointF(), | 7063 gfx::PointF(), |
7063 gfx::Size(40, 40), | 7064 gfx::Size(40, 40), |
7064 true, | 7065 true, |
7065 false); | 7066 false); |
7066 SetLayerPropertiesForTesting(scroll_parent_clip.get(), | 7067 SetLayerPropertiesForTesting(scroll_parent_clip.get(), |
7067 identity_transform, | 7068 identity_transform, |
7068 gfx::PointF(), | 7069 gfx::Point3F(), |
7069 gfx::PointF(), | 7070 gfx::PointF(), |
7070 gfx::Size(30, 30), | 7071 gfx::Size(30, 30), |
7071 true, | 7072 true, |
7072 false); | 7073 false); |
7073 SetLayerPropertiesForTesting(scroll_parent.get(), | 7074 SetLayerPropertiesForTesting(scroll_parent.get(), |
7074 identity_transform, | 7075 identity_transform, |
7075 gfx::PointF(), | 7076 gfx::Point3F(), |
7076 gfx::PointF(), | 7077 gfx::PointF(), |
7077 gfx::Size(50, 50), | 7078 gfx::Size(50, 50), |
7078 true, | 7079 true, |
7079 false); | 7080 false); |
7080 SetLayerPropertiesForTesting(scroll_child.get(), | 7081 SetLayerPropertiesForTesting(scroll_child.get(), |
7081 identity_transform, | 7082 identity_transform, |
7082 gfx::PointF(), | 7083 gfx::Point3F(), |
7083 gfx::PointF(), | 7084 gfx::PointF(), |
7084 gfx::Size(50, 50), | 7085 gfx::Size(50, 50), |
7085 true, | 7086 true, |
7086 false); | 7087 false); |
7087 | 7088 |
7088 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 7089 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
7089 host->SetRootLayer(root); | 7090 host->SetRootLayer(root); |
7090 | 7091 |
7091 ExecuteCalculateDrawProperties(root.get()); | 7092 ExecuteCalculateDrawProperties(root.get()); |
7092 | 7093 |
(...skipping 11 matching lines...) Expand all Loading... | |
7104 make_scoped_refptr(new LayerWithForcedDrawsContent); | 7105 make_scoped_refptr(new LayerWithForcedDrawsContent); |
7105 scoped_refptr<LayerWithForcedDrawsContent> child = | 7106 scoped_refptr<LayerWithForcedDrawsContent> child = |
7106 make_scoped_refptr(new LayerWithForcedDrawsContent); | 7107 make_scoped_refptr(new LayerWithForcedDrawsContent); |
7107 | 7108 |
7108 root->AddChild(parent); | 7109 root->AddChild(parent); |
7109 parent->AddChild(child); | 7110 parent->AddChild(child); |
7110 | 7111 |
7111 gfx::Transform identity_transform; | 7112 gfx::Transform identity_transform; |
7112 SetLayerPropertiesForTesting(root.get(), | 7113 SetLayerPropertiesForTesting(root.get(), |
7113 identity_transform, | 7114 identity_transform, |
7114 gfx::PointF(), | 7115 gfx::Point3F(), |
7115 gfx::PointF(), | 7116 gfx::PointF(), |
7116 gfx::Size(50, 50), | 7117 gfx::Size(50, 50), |
7117 true, | 7118 true, |
7118 true); | 7119 true); |
7119 root->SetForceRenderSurface(true); | 7120 root->SetForceRenderSurface(true); |
7120 SetLayerPropertiesForTesting(parent.get(), | 7121 SetLayerPropertiesForTesting(parent.get(), |
7121 identity_transform, | 7122 identity_transform, |
7122 gfx::PointF(), | 7123 gfx::Point3F(), |
7123 gfx::PointF(), | 7124 gfx::PointF(), |
7124 gfx::Size(30, 30), | 7125 gfx::Size(30, 30), |
7125 true, | 7126 true, |
7126 true); | 7127 true); |
7127 parent->SetForceRenderSurface(true); | 7128 parent->SetForceRenderSurface(true); |
7128 SetLayerPropertiesForTesting(child.get(), | 7129 SetLayerPropertiesForTesting(child.get(), |
7129 identity_transform, | 7130 identity_transform, |
7130 gfx::PointF(), | 7131 gfx::Point3F(), |
7131 gfx::PointF(), | 7132 gfx::PointF(), |
7132 gfx::Size(20, 20), | 7133 gfx::Size(20, 20), |
7133 true, | 7134 true, |
7134 true); | 7135 true); |
7135 child->SetForceRenderSurface(true); | 7136 child->SetForceRenderSurface(true); |
7136 | 7137 |
7137 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 7138 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
7138 host->SetRootLayer(root); | 7139 host->SetRootLayer(root); |
7139 | 7140 |
7140 ExecuteCalculateDrawProperties(root.get()); | 7141 ExecuteCalculateDrawProperties(root.get()); |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
7185 | 7186 |
7186 root->AddChild(scroll_child); | 7187 root->AddChild(scroll_child); |
7187 | 7188 |
7188 scroll_parent_clip->SetMasksToBounds(true); | 7189 scroll_parent_clip->SetMasksToBounds(true); |
7189 | 7190 |
7190 scroll_child->SetScrollParent(scroll_parent.get()); | 7191 scroll_child->SetScrollParent(scroll_parent.get()); |
7191 | 7192 |
7192 gfx::Transform identity_transform; | 7193 gfx::Transform identity_transform; |
7193 SetLayerPropertiesForTesting(root.get(), | 7194 SetLayerPropertiesForTesting(root.get(), |
7194 identity_transform, | 7195 identity_transform, |
7195 gfx::PointF(), | 7196 gfx::Point3F(), |
7196 gfx::PointF(), | 7197 gfx::PointF(), |
7197 gfx::Size(50, 50), | 7198 gfx::Size(50, 50), |
7198 true, | 7199 true, |
7199 false); | 7200 false); |
7200 SetLayerPropertiesForTesting(scroll_parent_border.get(), | 7201 SetLayerPropertiesForTesting(scroll_parent_border.get(), |
7201 identity_transform, | 7202 identity_transform, |
7202 gfx::PointF(), | 7203 gfx::Point3F(), |
7203 gfx::PointF(), | 7204 gfx::PointF(), |
7204 gfx::Size(40, 40), | 7205 gfx::Size(40, 40), |
7205 true, | 7206 true, |
7206 false); | 7207 false); |
7207 SetLayerPropertiesForTesting(scroll_parent_clip.get(), | 7208 SetLayerPropertiesForTesting(scroll_parent_clip.get(), |
7208 identity_transform, | 7209 identity_transform, |
7209 gfx::PointF(), | 7210 gfx::Point3F(), |
7210 gfx::PointF(), | 7211 gfx::PointF(), |
7211 gfx::Size(30, 30), | 7212 gfx::Size(30, 30), |
7212 true, | 7213 true, |
7213 false); | 7214 false); |
7214 SetLayerPropertiesForTesting(scroll_parent.get(), | 7215 SetLayerPropertiesForTesting(scroll_parent.get(), |
7215 identity_transform, | 7216 identity_transform, |
7216 gfx::PointF(), | 7217 gfx::Point3F(), |
7217 gfx::PointF(), | 7218 gfx::PointF(), |
7218 gfx::Size(50, 50), | 7219 gfx::Size(50, 50), |
7219 true, | 7220 true, |
7220 false); | 7221 false); |
7221 SetLayerPropertiesForTesting(scroll_child.get(), | 7222 SetLayerPropertiesForTesting(scroll_child.get(), |
7222 identity_transform, | 7223 identity_transform, |
7223 gfx::PointF(), | 7224 gfx::Point3F(), |
7224 gfx::PointF(), | 7225 gfx::PointF(), |
7225 gfx::Size(50, 50), | 7226 gfx::Size(50, 50), |
7226 true, | 7227 true, |
7227 false); | 7228 false); |
7228 | 7229 |
7229 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 7230 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
7230 host->SetRootLayer(root); | 7231 host->SetRootLayer(root); |
7231 | 7232 |
7232 ExecuteCalculateDrawProperties(root.get()); | 7233 ExecuteCalculateDrawProperties(root.get()); |
7233 | 7234 |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
7277 | 7278 |
7278 scroll_parent_clip->SetMasksToBounds(true); | 7279 scroll_parent_clip->SetMasksToBounds(true); |
7279 scroll_grandparent_clip->SetMasksToBounds(true); | 7280 scroll_grandparent_clip->SetMasksToBounds(true); |
7280 | 7281 |
7281 scroll_child->SetScrollParent(scroll_parent.get()); | 7282 scroll_child->SetScrollParent(scroll_parent.get()); |
7282 scroll_parent_border->SetScrollParent(scroll_grandparent.get()); | 7283 scroll_parent_border->SetScrollParent(scroll_grandparent.get()); |
7283 | 7284 |
7284 gfx::Transform identity_transform; | 7285 gfx::Transform identity_transform; |
7285 SetLayerPropertiesForTesting(root.get(), | 7286 SetLayerPropertiesForTesting(root.get(), |
7286 identity_transform, | 7287 identity_transform, |
7287 gfx::PointF(), | 7288 gfx::Point3F(), |
7288 gfx::PointF(), | 7289 gfx::PointF(), |
7289 gfx::Size(50, 50), | 7290 gfx::Size(50, 50), |
7290 true, | 7291 true, |
7291 false); | 7292 false); |
7292 SetLayerPropertiesForTesting(scroll_grandparent_border.get(), | 7293 SetLayerPropertiesForTesting(scroll_grandparent_border.get(), |
7293 identity_transform, | 7294 identity_transform, |
7294 gfx::PointF(), | 7295 gfx::Point3F(), |
7295 gfx::PointF(), | 7296 gfx::PointF(), |
7296 gfx::Size(40, 40), | 7297 gfx::Size(40, 40), |
7297 true, | 7298 true, |
7298 false); | 7299 false); |
7299 SetLayerPropertiesForTesting(scroll_grandparent_clip.get(), | 7300 SetLayerPropertiesForTesting(scroll_grandparent_clip.get(), |
7300 identity_transform, | 7301 identity_transform, |
7301 gfx::PointF(), | 7302 gfx::Point3F(), |
7302 gfx::PointF(), | 7303 gfx::PointF(), |
7303 gfx::Size(20, 20), | 7304 gfx::Size(20, 20), |
7304 true, | 7305 true, |
7305 false); | 7306 false); |
7306 SetLayerPropertiesForTesting(scroll_grandparent.get(), | 7307 SetLayerPropertiesForTesting(scroll_grandparent.get(), |
7307 identity_transform, | 7308 identity_transform, |
7308 gfx::PointF(), | 7309 gfx::Point3F(), |
7309 gfx::PointF(), | 7310 gfx::PointF(), |
7310 gfx::Size(50, 50), | 7311 gfx::Size(50, 50), |
7311 true, | 7312 true, |
7312 false); | 7313 false); |
7313 SetLayerPropertiesForTesting(scroll_parent_border.get(), | 7314 SetLayerPropertiesForTesting(scroll_parent_border.get(), |
7314 identity_transform, | 7315 identity_transform, |
7315 gfx::PointF(), | 7316 gfx::Point3F(), |
7316 gfx::PointF(), | 7317 gfx::PointF(), |
7317 gfx::Size(40, 40), | 7318 gfx::Size(40, 40), |
7318 true, | 7319 true, |
7319 false); | 7320 false); |
7320 SetLayerPropertiesForTesting(scroll_parent_clip.get(), | 7321 SetLayerPropertiesForTesting(scroll_parent_clip.get(), |
7321 identity_transform, | 7322 identity_transform, |
7322 gfx::PointF(), | 7323 gfx::Point3F(), |
7323 gfx::PointF(), | 7324 gfx::PointF(), |
7324 gfx::Size(30, 30), | 7325 gfx::Size(30, 30), |
7325 true, | 7326 true, |
7326 false); | 7327 false); |
7327 SetLayerPropertiesForTesting(scroll_parent.get(), | 7328 SetLayerPropertiesForTesting(scroll_parent.get(), |
7328 identity_transform, | 7329 identity_transform, |
7329 gfx::PointF(), | 7330 gfx::Point3F(), |
7330 gfx::PointF(), | 7331 gfx::PointF(), |
7331 gfx::Size(50, 50), | 7332 gfx::Size(50, 50), |
7332 true, | 7333 true, |
7333 false); | 7334 false); |
7334 SetLayerPropertiesForTesting(scroll_child.get(), | 7335 SetLayerPropertiesForTesting(scroll_child.get(), |
7335 identity_transform, | 7336 identity_transform, |
7336 gfx::PointF(), | 7337 gfx::Point3F(), |
7337 gfx::PointF(), | 7338 gfx::PointF(), |
7338 gfx::Size(50, 50), | 7339 gfx::Size(50, 50), |
7339 true, | 7340 true, |
7340 false); | 7341 false); |
7341 | 7342 |
7342 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 7343 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
7343 host->SetRootLayer(root); | 7344 host->SetRootLayer(root); |
7344 | 7345 |
7345 ExecuteCalculateDrawProperties(root.get()); | 7346 ExecuteCalculateDrawProperties(root.get()); |
7346 | 7347 |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
7412 | 7413 |
7413 scroll_child->SetScrollParent(scroll_parent.get()); | 7414 scroll_child->SetScrollParent(scroll_parent.get()); |
7414 scroll_parent_border->SetScrollParent(scroll_grandparent.get()); | 7415 scroll_parent_border->SetScrollParent(scroll_grandparent.get()); |
7415 | 7416 |
7416 render_surface1->SetForceRenderSurface(true); | 7417 render_surface1->SetForceRenderSurface(true); |
7417 render_surface2->SetForceRenderSurface(true); | 7418 render_surface2->SetForceRenderSurface(true); |
7418 | 7419 |
7419 gfx::Transform identity_transform; | 7420 gfx::Transform identity_transform; |
7420 SetLayerPropertiesForTesting(root.get(), | 7421 SetLayerPropertiesForTesting(root.get(), |
7421 identity_transform, | 7422 identity_transform, |
7422 gfx::PointF(), | 7423 gfx::Point3F(), |
7423 gfx::PointF(), | 7424 gfx::PointF(), |
7424 gfx::Size(50, 50), | 7425 gfx::Size(50, 50), |
7425 true, | 7426 true, |
7426 false); | 7427 false); |
7427 SetLayerPropertiesForTesting(scroll_grandparent_border.get(), | 7428 SetLayerPropertiesForTesting(scroll_grandparent_border.get(), |
7428 identity_transform, | 7429 identity_transform, |
7429 gfx::PointF(), | 7430 gfx::Point3F(), |
7430 gfx::PointF(), | 7431 gfx::PointF(), |
7431 gfx::Size(40, 40), | 7432 gfx::Size(40, 40), |
7432 true, | 7433 true, |
7433 false); | 7434 false); |
7434 SetLayerPropertiesForTesting(scroll_grandparent_clip.get(), | 7435 SetLayerPropertiesForTesting(scroll_grandparent_clip.get(), |
7435 identity_transform, | 7436 identity_transform, |
7436 gfx::PointF(), | 7437 gfx::Point3F(), |
7437 gfx::PointF(), | 7438 gfx::PointF(), |
7438 gfx::Size(20, 20), | 7439 gfx::Size(20, 20), |
7439 true, | 7440 true, |
7440 false); | 7441 false); |
7441 SetLayerPropertiesForTesting(scroll_grandparent.get(), | 7442 SetLayerPropertiesForTesting(scroll_grandparent.get(), |
7442 identity_transform, | 7443 identity_transform, |
7443 gfx::PointF(), | 7444 gfx::Point3F(), |
7444 gfx::PointF(), | 7445 gfx::PointF(), |
7445 gfx::Size(50, 50), | 7446 gfx::Size(50, 50), |
7446 true, | 7447 true, |
7447 false); | 7448 false); |
7448 SetLayerPropertiesForTesting(render_surface1.get(), | 7449 SetLayerPropertiesForTesting(render_surface1.get(), |
7449 identity_transform, | 7450 identity_transform, |
7450 gfx::PointF(), | 7451 gfx::Point3F(), |
7451 gfx::PointF(), | 7452 gfx::PointF(), |
7452 gfx::Size(50, 50), | 7453 gfx::Size(50, 50), |
7453 true, | 7454 true, |
7454 false); | 7455 false); |
7455 SetLayerPropertiesForTesting(scroll_parent_border.get(), | 7456 SetLayerPropertiesForTesting(scroll_parent_border.get(), |
7456 identity_transform, | 7457 identity_transform, |
7457 gfx::PointF(), | 7458 gfx::Point3F(), |
7458 gfx::PointF(), | 7459 gfx::PointF(), |
7459 gfx::Size(40, 40), | 7460 gfx::Size(40, 40), |
7460 true, | 7461 true, |
7461 false); | 7462 false); |
7462 SetLayerPropertiesForTesting(scroll_parent_clip.get(), | 7463 SetLayerPropertiesForTesting(scroll_parent_clip.get(), |
7463 identity_transform, | 7464 identity_transform, |
7464 gfx::PointF(), | 7465 gfx::Point3F(), |
7465 gfx::PointF(), | 7466 gfx::PointF(), |
7466 gfx::Size(30, 30), | 7467 gfx::Size(30, 30), |
7467 true, | 7468 true, |
7468 false); | 7469 false); |
7469 SetLayerPropertiesForTesting(scroll_parent.get(), | 7470 SetLayerPropertiesForTesting(scroll_parent.get(), |
7470 identity_transform, | 7471 identity_transform, |
7471 gfx::PointF(), | 7472 gfx::Point3F(), |
7472 gfx::PointF(), | 7473 gfx::PointF(), |
7473 gfx::Size(50, 50), | 7474 gfx::Size(50, 50), |
7474 true, | 7475 true, |
7475 false); | 7476 false); |
7476 SetLayerPropertiesForTesting(render_surface2.get(), | 7477 SetLayerPropertiesForTesting(render_surface2.get(), |
7477 identity_transform, | 7478 identity_transform, |
7478 gfx::PointF(), | 7479 gfx::Point3F(), |
7479 gfx::PointF(), | 7480 gfx::PointF(), |
7480 gfx::Size(50, 50), | 7481 gfx::Size(50, 50), |
7481 true, | 7482 true, |
7482 false); | 7483 false); |
7483 SetLayerPropertiesForTesting(scroll_child.get(), | 7484 SetLayerPropertiesForTesting(scroll_child.get(), |
7484 identity_transform, | 7485 identity_transform, |
7485 gfx::PointF(), | 7486 gfx::Point3F(), |
7486 gfx::PointF(), | 7487 gfx::PointF(), |
7487 gfx::Size(50, 50), | 7488 gfx::Size(50, 50), |
7488 true, | 7489 true, |
7489 false); | 7490 false); |
7490 | 7491 |
7491 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); | 7492 scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(); |
7492 host->SetRootLayer(root); | 7493 host->SetRootLayer(root); |
7493 | 7494 |
7494 RenderSurfaceLayerList render_surface_layer_list; | 7495 RenderSurfaceLayerList render_surface_layer_list; |
7495 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( | 7496 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
7562 bottom_content->SetDrawsContent(true); | 7563 bottom_content->SetDrawsContent(true); |
7563 | 7564 |
7564 gfx::Transform identity_transform; | 7565 gfx::Transform identity_transform; |
7565 gfx::Transform top_transform; | 7566 gfx::Transform top_transform; |
7566 top_transform.Translate3d(0.0, 0.0, 5.0); | 7567 top_transform.Translate3d(0.0, 0.0, 5.0); |
7567 gfx::Transform bottom_transform; | 7568 gfx::Transform bottom_transform; |
7568 bottom_transform.Translate3d(0.0, 0.0, 3.0); | 7569 bottom_transform.Translate3d(0.0, 0.0, 3.0); |
7569 | 7570 |
7570 SetLayerPropertiesForTesting(root.get(), | 7571 SetLayerPropertiesForTesting(root.get(), |
7571 identity_transform, | 7572 identity_transform, |
7572 gfx::PointF(), | 7573 gfx::Point3F(), |
7573 gfx::PointF(), | 7574 gfx::PointF(), |
7574 gfx::Size(50, 50), | 7575 gfx::Size(50, 50), |
7575 true, | 7576 true, |
7576 false); | 7577 false); |
7577 SetLayerPropertiesForTesting(scroll_parent_border.get(), | 7578 SetLayerPropertiesForTesting(scroll_parent_border.get(), |
7578 identity_transform, | 7579 identity_transform, |
7579 gfx::PointF(), | 7580 gfx::Point3F(), |
7580 gfx::PointF(), | 7581 gfx::PointF(), |
7581 gfx::Size(40, 40), | 7582 gfx::Size(40, 40), |
7582 true, | 7583 true, |
7583 false); | 7584 false); |
7584 SetLayerPropertiesForTesting(scroll_parent_clip.get(), | 7585 SetLayerPropertiesForTesting(scroll_parent_clip.get(), |
7585 identity_transform, | 7586 identity_transform, |
7586 gfx::PointF(), | 7587 gfx::Point3F(), |
7587 gfx::PointF(), | 7588 gfx::PointF(), |
7588 gfx::Size(30, 30), | 7589 gfx::Size(30, 30), |
7589 true, | 7590 true, |
7590 false); | 7591 false); |
7591 SetLayerPropertiesForTesting(scroll_parent.get(), | 7592 SetLayerPropertiesForTesting(scroll_parent.get(), |
7592 identity_transform, | 7593 identity_transform, |
7593 gfx::PointF(), | 7594 gfx::Point3F(), |
7594 gfx::PointF(), | 7595 gfx::PointF(), |
7595 gfx::Size(50, 50), | 7596 gfx::Size(50, 50), |
7596 true, | 7597 true, |
7597 false); | 7598 false); |
7598 SetLayerPropertiesForTesting(scroll_child.get(), | 7599 SetLayerPropertiesForTesting(scroll_child.get(), |
7599 identity_transform, | 7600 identity_transform, |
7600 gfx::PointF(), | 7601 gfx::Point3F(), |
7601 gfx::PointF(), | 7602 gfx::PointF(), |
7602 gfx::Size(50, 50), | 7603 gfx::Size(50, 50), |
7603 true, | 7604 true, |
7604 false); | 7605 false); |
7605 SetLayerPropertiesForTesting(top_content.get(), | 7606 SetLayerPropertiesForTesting(top_content.get(), |
7606 top_transform, | 7607 top_transform, |
7607 gfx::PointF(), | 7608 gfx::Point3F(), |
7608 gfx::PointF(), | 7609 gfx::PointF(), |
7609 gfx::Size(50, 50), | 7610 gfx::Size(50, 50), |
7610 false, | 7611 false, |
7611 true); | 7612 true); |
7612 SetLayerPropertiesForTesting(bottom_content.get(), | 7613 SetLayerPropertiesForTesting(bottom_content.get(), |
7613 bottom_transform, | 7614 bottom_transform, |
7614 gfx::PointF(), | 7615 gfx::Point3F(), |
7615 gfx::PointF(), | 7616 gfx::PointF(), |
7616 gfx::Size(50, 50), | 7617 gfx::Size(50, 50), |
7617 false, | 7618 false, |
7618 true); | 7619 true); |
7619 | 7620 |
7620 scroll_child->SetShouldFlattenTransform(false); | 7621 scroll_child->SetShouldFlattenTransform(false); |
7621 scroll_child->SetIs3dSorted(true); | 7622 scroll_child->SetIs3dSorted(true); |
7622 | 7623 |
7623 scroll_child->AddChild(top_content.Pass()); | 7624 scroll_child->AddChild(top_content.Pass()); |
7624 scroll_child->AddChild(bottom_content.Pass()); | 7625 scroll_child->AddChild(bottom_content.Pass()); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
7680 | 7681 |
7681 scroller->SetScrollClipLayer(container->id()); | 7682 scroller->SetScrollClipLayer(container->id()); |
7682 | 7683 |
7683 gfx::Transform identity_transform; | 7684 gfx::Transform identity_transform; |
7684 gfx::Transform container_transform; | 7685 gfx::Transform container_transform; |
7685 container_transform.Translate3d(10.0, 20.0, 0.0); | 7686 container_transform.Translate3d(10.0, 20.0, 0.0); |
7686 gfx::Vector2dF container_offset = container_transform.To2dTranslation(); | 7687 gfx::Vector2dF container_offset = container_transform.To2dTranslation(); |
7687 | 7688 |
7688 SetLayerPropertiesForTesting(root.get(), | 7689 SetLayerPropertiesForTesting(root.get(), |
7689 identity_transform, | 7690 identity_transform, |
7690 gfx::PointF(), | 7691 gfx::Point3F(), |
7691 gfx::PointF(), | 7692 gfx::PointF(), |
7692 gfx::Size(50, 50), | 7693 gfx::Size(50, 50), |
7693 true, | 7694 true, |
7694 false); | 7695 false); |
7695 SetLayerPropertiesForTesting(container.get(), | 7696 SetLayerPropertiesForTesting(container.get(), |
7696 container_transform, | 7697 container_transform, |
7697 gfx::PointF(), | 7698 gfx::Point3F(), |
7698 gfx::PointF(), | 7699 gfx::PointF(), |
7699 gfx::Size(40, 40), | 7700 gfx::Size(40, 40), |
7700 true, | 7701 true, |
7701 false); | 7702 false); |
7702 SetLayerPropertiesForTesting(scroller.get(), | 7703 SetLayerPropertiesForTesting(scroller.get(), |
7703 identity_transform, | 7704 identity_transform, |
7704 gfx::PointF(), | 7705 gfx::Point3F(), |
7705 gfx::PointF(), | 7706 gfx::PointF(), |
7706 gfx::Size(30, 30), | 7707 gfx::Size(30, 30), |
7707 true, | 7708 true, |
7708 false); | 7709 false); |
7709 SetLayerPropertiesForTesting(fixed.get(), | 7710 SetLayerPropertiesForTesting(fixed.get(), |
7710 identity_transform, | 7711 identity_transform, |
7711 gfx::PointF(), | 7712 gfx::Point3F(), |
7712 gfx::PointF(), | 7713 gfx::PointF(), |
7713 gfx::Size(50, 50), | 7714 gfx::Size(50, 50), |
7714 true, | 7715 true, |
7715 false); | 7716 false); |
7716 | 7717 |
7717 scroller->AddChild(fixed.Pass()); | 7718 scroller->AddChild(fixed.Pass()); |
7718 container->AddChild(scroller.Pass()); | 7719 container->AddChild(scroller.Pass()); |
7719 root->AddChild(container.Pass()); | 7720 root->AddChild(container.Pass()); |
7720 | 7721 |
7721 // Rounded to integers already. | 7722 // Rounded to integers already. |
(...skipping 147 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
7869 AnimationScaleFactorTrackingLayerImpl* parent_raw = parent.get(); | 7870 AnimationScaleFactorTrackingLayerImpl* parent_raw = parent.get(); |
7870 AnimationScaleFactorTrackingLayerImpl* child_raw = child.get(); | 7871 AnimationScaleFactorTrackingLayerImpl* child_raw = child.get(); |
7871 AnimationScaleFactorTrackingLayerImpl* grand_child_raw = grand_child.get(); | 7872 AnimationScaleFactorTrackingLayerImpl* grand_child_raw = grand_child.get(); |
7872 | 7873 |
7873 child->AddChild(grand_child.PassAs<LayerImpl>()); | 7874 child->AddChild(grand_child.PassAs<LayerImpl>()); |
7874 parent->AddChild(child.PassAs<LayerImpl>()); | 7875 parent->AddChild(child.PassAs<LayerImpl>()); |
7875 grand_parent->AddChild(parent.PassAs<LayerImpl>()); | 7876 grand_parent->AddChild(parent.PassAs<LayerImpl>()); |
7876 | 7877 |
7877 SetLayerPropertiesForTesting(grand_parent.get(), | 7878 SetLayerPropertiesForTesting(grand_parent.get(), |
7878 identity_matrix, | 7879 identity_matrix, |
7879 gfx::PointF(), | 7880 gfx::Point3F(), |
7880 gfx::PointF(), | 7881 gfx::PointF(), |
7881 gfx::Size(1, 2), | 7882 gfx::Size(1, 2), |
7882 true, | 7883 true, |
7883 false); | 7884 false); |
7884 SetLayerPropertiesForTesting(parent_raw, | 7885 SetLayerPropertiesForTesting(parent_raw, |
7885 identity_matrix, | 7886 identity_matrix, |
7886 gfx::PointF(), | 7887 gfx::Point3F(), |
7887 gfx::PointF(), | 7888 gfx::PointF(), |
7888 gfx::Size(1, 2), | 7889 gfx::Size(1, 2), |
7889 true, | 7890 true, |
7890 false); | 7891 false); |
7891 SetLayerPropertiesForTesting(child_raw, | 7892 SetLayerPropertiesForTesting(child_raw, |
7892 identity_matrix, | 7893 identity_matrix, |
7893 gfx::PointF(), | 7894 gfx::Point3F(), |
7894 gfx::PointF(), | 7895 gfx::PointF(), |
7895 gfx::Size(1, 2), | 7896 gfx::Size(1, 2), |
7896 true, | 7897 true, |
7897 false); | 7898 false); |
7898 SetLayerPropertiesForTesting(grand_child_raw, | 7899 SetLayerPropertiesForTesting(grand_child_raw, |
7899 identity_matrix, | 7900 identity_matrix, |
7900 gfx::PointF(), | 7901 gfx::Point3F(), |
7901 gfx::PointF(), | 7902 gfx::PointF(), |
7902 gfx::Size(1, 2), | 7903 gfx::Size(1, 2), |
7903 true, | 7904 true, |
7904 false); | 7905 false); |
7905 | 7906 |
7906 ExecuteCalculateDrawProperties(grand_parent.get()); | 7907 ExecuteCalculateDrawProperties(grand_parent.get()); |
7907 | 7908 |
7908 // No layers have animations. | 7909 // No layers have animations. |
7909 EXPECT_EQ(0.f, grand_parent->last_maximum_animation_contents_scale()); | 7910 EXPECT_EQ(0.f, grand_parent->last_maximum_animation_contents_scale()); |
7910 EXPECT_EQ(0.f, parent_raw->last_maximum_animation_contents_scale()); | 7911 EXPECT_EQ(0.f, parent_raw->last_maximum_animation_contents_scale()); |
(...skipping 162 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
8073 LayerImpl* grand_child1_raw = grand_child1.get(); | 8074 LayerImpl* grand_child1_raw = grand_child1.get(); |
8074 LayerImpl* grand_child2_raw = grand_child2.get(); | 8075 LayerImpl* grand_child2_raw = grand_child2.get(); |
8075 | 8076 |
8076 child->AddChild(grand_child1.Pass()); | 8077 child->AddChild(grand_child1.Pass()); |
8077 child->AddChild(grand_child2.Pass()); | 8078 child->AddChild(grand_child2.Pass()); |
8078 parent->AddChild(child.Pass()); | 8079 parent->AddChild(child.Pass()); |
8079 grand_parent->AddChild(parent.Pass()); | 8080 grand_parent->AddChild(parent.Pass()); |
8080 | 8081 |
8081 SetLayerPropertiesForTesting(grand_parent_raw, | 8082 SetLayerPropertiesForTesting(grand_parent_raw, |
8082 identity_matrix, | 8083 identity_matrix, |
8083 gfx::PointF(), | 8084 gfx::Point3F(), |
8084 gfx::PointF(), | 8085 gfx::PointF(), |
8085 gfx::Size(1, 2), | 8086 gfx::Size(1, 2), |
8086 true, | 8087 true, |
8087 false); | 8088 false); |
8088 SetLayerPropertiesForTesting(parent_raw, | 8089 SetLayerPropertiesForTesting(parent_raw, |
8089 identity_matrix, | 8090 identity_matrix, |
8090 gfx::PointF(), | 8091 gfx::Point3F(), |
8091 gfx::PointF(), | 8092 gfx::PointF(), |
8092 gfx::Size(1, 2), | 8093 gfx::Size(1, 2), |
8093 true, | 8094 true, |
8094 false); | 8095 false); |
8095 SetLayerPropertiesForTesting(child_raw, | 8096 SetLayerPropertiesForTesting(child_raw, |
8096 identity_matrix, | 8097 identity_matrix, |
8097 gfx::PointF(), | 8098 gfx::Point3F(), |
8098 gfx::PointF(), | 8099 gfx::PointF(), |
8099 gfx::Size(1, 2), | 8100 gfx::Size(1, 2), |
8100 true, | 8101 true, |
8101 false); | 8102 false); |
8102 SetLayerPropertiesForTesting(grand_child1_raw, | 8103 SetLayerPropertiesForTesting(grand_child1_raw, |
8103 identity_matrix, | 8104 identity_matrix, |
8104 gfx::PointF(), | 8105 gfx::Point3F(), |
8105 gfx::PointF(), | 8106 gfx::PointF(), |
8106 gfx::Size(1, 2), | 8107 gfx::Size(1, 2), |
8107 true, | 8108 true, |
8108 false); | 8109 false); |
8109 SetLayerPropertiesForTesting(grand_child2_raw, | 8110 SetLayerPropertiesForTesting(grand_child2_raw, |
8110 identity_matrix, | 8111 identity_matrix, |
8111 gfx::PointF(), | 8112 gfx::Point3F(), |
8112 gfx::PointF(), | 8113 gfx::PointF(), |
8113 gfx::Size(1, 2), | 8114 gfx::Size(1, 2), |
8114 true, | 8115 true, |
8115 false); | 8116 false); |
8116 | 8117 |
8117 // Start with nothing being drawn. | 8118 // Start with nothing being drawn. |
8118 ExecuteCalculateDrawProperties(grand_parent_raw); | 8119 ExecuteCalculateDrawProperties(grand_parent_raw); |
8119 int member_id = render_surface_layer_list_count(); | 8120 int member_id = render_surface_layer_list_count(); |
8120 | 8121 |
8121 EXPECT_NE(member_id, membership_id(grand_parent_raw)); | 8122 EXPECT_NE(member_id, membership_id(grand_parent_raw)); |
(...skipping 184 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
8306 expected.insert(child_raw); | 8307 expected.insert(child_raw); |
8307 expected.insert(grand_child1_raw); | 8308 expected.insert(grand_child1_raw); |
8308 expected.insert(grand_child2_raw); | 8309 expected.insert(grand_child2_raw); |
8309 | 8310 |
8310 actual.clear(); | 8311 actual.clear(); |
8311 GatherDrawnLayers(render_surface_layer_list_impl(), &actual); | 8312 GatherDrawnLayers(render_surface_layer_list_impl(), &actual); |
8312 EXPECT_EQ(expected, actual); | 8313 EXPECT_EQ(expected, actual); |
8313 } | 8314 } |
8314 } // namespace | 8315 } // namespace |
8315 } // namespace cc | 8316 } // namespace cc |
OLD | NEW |