1 // Copyright 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "cc/trees/occlusion_tracker.h" 6 7 #include "cc/animation/layer_animation_controller.h" 8 #include "cc/base/math_util.h" 9 #include "cc/debug/overdraw_metrics.h" 10 #include "cc/layers/layer.h" 11 #include "cc/layers/layer_impl.h" 12 #include "cc/output/copy_output_request.h" 13 #include "cc/output/copy_output_result.h" 14 #include "cc/output/filter_operation.h" 15 #include "cc/output/filter_operations.h" 16 #include "cc/test/animation_test_common.h" 17 #include "cc/test/fake_impl_proxy.h" 18 #include "cc/test/fake_layer_tree_host.h" 19 #include "cc/test/fake_layer_tree_host_impl.h" 20 #include "cc/test/geometry_test_utils.h" 21 #include "cc/test/occlusion_tracker_test_common.h" 22 #include "cc/trees/layer_tree_host_common.h" 23 #include "cc/trees/single_thread_proxy.h" 24 #include "testing/gmock/include/gmock/gmock.h" 25 #include "testing/gtest/include/gtest/gtest.h" 26 #include "ui/gfx/transform.h" 27 28 namespace cc { 29 namespace { 30 31 class TestContentLayer : public Layer { 32 public: 33 TestContentLayer() : Layer(), override_opaque_contents_rect_(false) { 34 SetIsDrawable(true); 35 } 36 37 virtual Region VisibleContentOpaqueRegion() const OVERRIDE { 38 if (override_opaque_contents_rect_) 39 return gfx::IntersectRects(opaque_contents_rect_, visible_content_rect()); 40 return Layer::VisibleContentOpaqueRegion(); 41 } 42 void SetOpaqueContentsRect(gfx::Rect opaque_contents_rect) { 43 override_opaque_contents_rect_ = true; 44 opaque_contents_rect_ = opaque_contents_rect; 45 } 46 47 private: 48 virtual ~TestContentLayer() {} 49 50 bool override_opaque_contents_rect_; 51 gfx::Rect opaque_contents_rect_; 52 }; 53 54 class TestContentLayerImpl : public LayerImpl { 55 public: 56 TestContentLayerImpl(LayerTreeImpl* tree_impl, int id) 57 : LayerImpl(tree_impl, id), override_opaque_contents_rect_(false) { 58 SetDrawsContent(true); 59 } 60 61 virtual Region VisibleContentOpaqueRegion() const OVERRIDE { 62 if (override_opaque_contents_rect_) 63 return gfx::IntersectRects(opaque_contents_rect_, visible_content_rect()); 64 return LayerImpl::VisibleContentOpaqueRegion(); 65 } 66 void SetOpaqueContentsRect(gfx::Rect opaque_contents_rect) { 67 override_opaque_contents_rect_ = true; 68 opaque_contents_rect_ = opaque_contents_rect; 69 } 70 71 private: 72 bool override_opaque_contents_rect_; 73 gfx::Rect opaque_contents_rect_; 74 }; 75 76 static inline bool LayerImplDrawTransformIsUnknown(const Layer* layer) { 77 return layer->draw_transform_is_animating(); 78 } 79 static inline bool LayerImplDrawTransformIsUnknown(const LayerImpl* layer) { 80 return false; 81 } 82 83 template <typename LayerType, typename RenderSurfaceType> 84 class TestOcclusionTrackerWithClip 85 : public TestOcclusionTrackerBase<LayerType, RenderSurfaceType> { 86 public: 87 TestOcclusionTrackerWithClip(gfx::Rect viewport_rect, 88 bool record_metrics_for_frame) 89 : TestOcclusionTrackerBase<LayerType, RenderSurfaceType>( 90 viewport_rect, 91 record_metrics_for_frame) {} 92 explicit TestOcclusionTrackerWithClip(gfx::Rect viewport_rect) 93 : TestOcclusionTrackerBase<LayerType, RenderSurfaceType>(viewport_rect, 94 false) {} 95 96 bool OccludedLayer(const LayerType* layer, 97 gfx::Rect content_rect) const { 98 DCHECK(layer->visible_content_rect().Contains(content_rect)); 99 return this->Occluded(layer->render_target(), 100 content_rect, 101 layer->draw_transform(), 102 LayerImplDrawTransformIsUnknown(layer)); 103 } 104 105 // Gives an unoccluded sub-rect of |content_rect| in the content space of the 106 // layer. Simple wrapper around UnoccludedContentRect. 107 gfx::Rect UnoccludedLayerContentRect(const LayerType* layer, 108 gfx::Rect content_rect) const { 109 DCHECK(layer->visible_content_rect().Contains(content_rect)); 110 return this->UnoccludedContentRect( 111 layer->render_target(), 112 content_rect, 113 layer->draw_transform(), 114 LayerImplDrawTransformIsUnknown(layer)); 115 } 116 }; 117 118 struct OcclusionTrackerTestMainThreadTypes { 119 typedef Layer LayerType; 120 typedef FakeLayerTreeHost HostType; 121 typedef RenderSurface RenderSurfaceType; 122 typedef TestContentLayer ContentLayerType; 123 typedef scoped_refptr<Layer> LayerPtrType; 124 typedef scoped_refptr<ContentLayerType> ContentLayerPtrType; 125 typedef LayerIterator<Layer, 126 RenderSurfaceLayerList, 127 RenderSurface, 128 LayerIteratorActions::FrontToBack> TestLayerIterator; 129 typedef OcclusionTracker OcclusionTrackerType; 130 131 static LayerPtrType CreateLayer(HostType* host) { return Layer::Create(); } 132 static ContentLayerPtrType CreateContentLayer(HostType* host) { 133 return make_scoped_refptr(new ContentLayerType()); 134 } 135 136 static LayerPtrType PassLayerPtr(ContentLayerPtrType* layer) { 137 LayerPtrType ref(*layer); 138 *layer = NULL; 139 return ref; 140 } 141 142 static LayerPtrType PassLayerPtr(LayerPtrType* layer) { 143 LayerPtrType ref(*layer); 144 *layer = NULL; 145 return ref; 146 } 147 148 static void DestroyLayer(LayerPtrType* layer) { *layer = NULL; } 149 }; 150 151 struct OcclusionTrackerTestImplThreadTypes { 152 typedef LayerImpl LayerType; 153 typedef LayerTreeImpl HostType; 154 typedef RenderSurfaceImpl RenderSurfaceType; 155 typedef TestContentLayerImpl ContentLayerType; 156 typedef scoped_ptr<LayerImpl> LayerPtrType; 157 typedef scoped_ptr<ContentLayerType> ContentLayerPtrType; 158 typedef LayerIterator<LayerImpl, 159 LayerImplList, 160 RenderSurfaceImpl, 161 LayerIteratorActions::FrontToBack> TestLayerIterator; 162 typedef OcclusionTrackerImpl OcclusionTrackerType; 163 164 static LayerPtrType CreateLayer(HostType* host) { 165 return LayerImpl::Create(host, next_layer_impl_id++); 166 } 167 static ContentLayerPtrType CreateContentLayer(HostType* host) { 168 return make_scoped_ptr(new ContentLayerType(host, next_layer_impl_id++)); 169 } 170 static int next_layer_impl_id; 171 172 static LayerPtrType PassLayerPtr(LayerPtrType* layer) { 173 return layer->Pass(); 174 } 175 176 static LayerPtrType PassLayerPtr(ContentLayerPtrType* layer) { 177 return layer->PassAs<LayerType>(); 178 } 179 180 static void DestroyLayer(LayerPtrType* layer) { layer->reset(); } 181 }; 182 183 int OcclusionTrackerTestImplThreadTypes::next_layer_impl_id = 1; 184 185 template <typename Types> class OcclusionTrackerTest : public testing::Test { 186 protected: 187 explicit OcclusionTrackerTest(bool opaque_layers) 188 : opaque_layers_(opaque_layers), host_(FakeLayerTreeHost::Create()) {} 189 190 virtual void RunMyTest() = 0; 191 192 virtual void TearDown() { 193 Types::DestroyLayer(&root_); 194 render_surface_layer_list_.reset(); 195 render_surface_layer_list_impl_.clear(); 196 replica_layers_.clear(); 197 mask_layers_.clear(); 198 } 199 200 typename Types::HostType* GetHost(); 201 202 typename Types::ContentLayerType* CreateRoot(const gfx::Transform& transform, 203 gfx::PointF position, 204 gfx::Size bounds) { 205 typename Types::ContentLayerPtrType layer( 206 Types::CreateContentLayer(GetHost())); 207 typename Types::ContentLayerType* layer_ptr = layer.get(); 208 SetProperties(layer_ptr, transform, position, bounds); 209 210 DCHECK(!root_.get()); 211 root_ = Types::PassLayerPtr(&layer); 212 213 SetRootLayerOnMainThread(layer_ptr); 214 215 return layer_ptr; 216 } 217 218 typename Types::LayerType* CreateLayer(typename Types::LayerType* parent, 219 const gfx::Transform& transform, 220 gfx::PointF position, 221 gfx::Size bounds) { 222 typename Types::LayerPtrType layer(Types::CreateLayer(GetHost())); 223 typename Types::LayerType* layer_ptr = layer.get(); 224 SetProperties(layer_ptr, transform, position, bounds); 225 parent->AddChild(Types::PassLayerPtr(&layer)); 226 return layer_ptr; 227 } 228 229 typename Types::LayerType* CreateSurface(typename Types::LayerType* parent, 230 const gfx::Transform& transform, 231 gfx::PointF position, 232 gfx::Size bounds) { 233 typename Types::LayerType* layer = 234 CreateLayer(parent, transform, position, bounds); 235 layer->SetForceRenderSurface(true); 236 return layer; 237 } 238 239 typename Types::ContentLayerType* CreateDrawingLayer( 240 typename Types::LayerType* parent, 241 const gfx::Transform& transform, 242 gfx::PointF position, 243 gfx::Size bounds, 244 bool opaque) { 245 typename Types::ContentLayerPtrType layer( 246 Types::CreateContentLayer(GetHost())); 247 typename Types::ContentLayerType* layer_ptr = layer.get(); 248 SetProperties(layer_ptr, transform, position, bounds); 249 250 if (opaque_layers_) { 251 layer_ptr->SetContentsOpaque(opaque); 252 } else { 253 layer_ptr->SetContentsOpaque(false); 254 if (opaque) 255 layer_ptr->SetOpaqueContentsRect(gfx::Rect(bounds)); 256 else 257 layer_ptr->SetOpaqueContentsRect(gfx::Rect()); 258 } 259 260 parent->AddChild(Types::PassLayerPtr(&layer)); 261 return layer_ptr; 262 } 263 264 typename Types::LayerType* CreateReplicaLayer( 265 typename Types::LayerType* owning_layer, 266 const gfx::Transform& transform, 267 gfx::PointF position, 268 gfx::Size bounds) { 269 typename Types::ContentLayerPtrType layer( 270 Types::CreateContentLayer(GetHost())); 271 typename Types::ContentLayerType* layer_ptr = layer.get(); 272 SetProperties(layer_ptr, transform, position, bounds); 273 SetReplica(owning_layer, Types::PassLayerPtr(&layer)); 274 return layer_ptr; 275 } 276 277 typename Types::LayerType* CreateMaskLayer( 278 typename Types::LayerType* owning_layer, 279 gfx::Size bounds) { 280 typename Types::ContentLayerPtrType layer( 281 Types::CreateContentLayer(GetHost())); 282 typename Types::ContentLayerType* layer_ptr = layer.get(); 283 SetProperties(layer_ptr, identity_matrix, gfx::PointF(), bounds); 284 SetMask(owning_layer, Types::PassLayerPtr(&layer)); 285 return layer_ptr; 286 } 287 288 typename Types::ContentLayerType* CreateDrawingSurface( 289 typename Types::LayerType* parent, 290 const gfx::Transform& transform, 291 gfx::PointF position, 292 gfx::Size bounds, 293 bool opaque) { 294 typename Types::ContentLayerType* layer = 295 CreateDrawingLayer(parent, transform, position, bounds, opaque); 296 layer->SetForceRenderSurface(true); 297 return layer; 298 } 299 300 301 void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {} 302 303 void AddCopyRequest(Layer* layer) { 304 layer->RequestCopyOfOutput( 305 CopyOutputRequest::CreateBitmapRequest(base::Bind( 306 &OcclusionTrackerTest<Types>::CopyOutputCallback, 307 base::Unretained(this)))); 308 } 309 310 void AddCopyRequest(LayerImpl* layer) { 311 ScopedPtrVector<CopyOutputRequest> requests; 312 requests.push_back( 313 CopyOutputRequest::CreateBitmapRequest(base::Bind( 314 &OcclusionTrackerTest<Types>::CopyOutputCallback, 315 base::Unretained(this)))); 316 layer->PassCopyRequests(&requests); 317 } 318 319 void CalcDrawEtc(TestContentLayerImpl* root) { 320 DCHECK(root == root_.get()); 321 DCHECK(!root->render_surface()); 322 323 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( 324 root, root->bounds(), &render_surface_layer_list_impl_); 325 inputs.can_adjust_raster_scales = true; 326 LayerTreeHostCommon::CalculateDrawProperties(&inputs); 327 328 layer_iterator_ = layer_iterator_begin_ = 329 Types::TestLayerIterator::Begin(&render_surface_layer_list_impl_); 330 } 331 332 void CalcDrawEtc(TestContentLayer* root) { 333 DCHECK(root == root_.get()); 334 DCHECK(!root->render_surface()); 335 336 render_surface_layer_list_.reset(new RenderSurfaceLayerList); 337 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( 338 root, root->bounds(), render_surface_layer_list_.get()); 339 inputs.can_adjust_raster_scales = true; 340 LayerTreeHostCommon::CalculateDrawProperties(&inputs); 341 342 layer_iterator_ = layer_iterator_begin_ = 343 Types::TestLayerIterator::Begin(render_surface_layer_list_.get()); 344 } 345 346 void SetDrawsContent(LayerImpl* layer_impl, bool draws_content) { 347 layer_impl->SetDrawsContent(draws_content); 348 } 349 350 void SetDrawsContent(Layer* layer, bool draws_content) { 351 layer->SetIsDrawable(draws_content); 352 } 353 354 void EnterLayer(typename Types::LayerType* layer, 355 typename Types::OcclusionTrackerType* occlusion) { 356 ASSERT_EQ(layer, *layer_iterator_); 357 ASSERT_TRUE(layer_iterator_.represents_itself()); 358 occlusion->EnterLayer(layer_iterator_); 359 } 360 361 void LeaveLayer(typename Types::LayerType* layer, 362 typename Types::OcclusionTrackerType* occlusion) { 363 ASSERT_EQ(layer, *layer_iterator_); 364 ASSERT_TRUE(layer_iterator_.represents_itself()); 365 occlusion->LeaveLayer(layer_iterator_); 366 ++layer_iterator_; 367 } 368 369 void VisitLayer(typename Types::LayerType* layer, 370 typename Types::OcclusionTrackerType* occlusion) { 371 EnterLayer(layer, occlusion); 372 LeaveLayer(layer, occlusion); 373 } 374 375 void EnterContributingSurface( 376 typename Types::LayerType* layer, 377 typename Types::OcclusionTrackerType* occlusion) { 378 ASSERT_EQ(layer, *layer_iterator_); 379 ASSERT_TRUE(layer_iterator_.represents_target_render_surface()); 380 occlusion->EnterLayer(layer_iterator_); 381 occlusion->LeaveLayer(layer_iterator_); 382 ++layer_iterator_; 383 ASSERT_TRUE(layer_iterator_.represents_contributing_render_surface()); 384 occlusion->EnterLayer(layer_iterator_); 385 } 386 387 void LeaveContributingSurface( 388 typename Types::LayerType* layer, 389 typename Types::OcclusionTrackerType* occlusion) { 390 ASSERT_EQ(layer, *layer_iterator_); 391 ASSERT_TRUE(layer_iterator_.represents_contributing_render_surface()); 392 occlusion->LeaveLayer(layer_iterator_); 393 ++layer_iterator_; 394 } 395 396 void VisitContributingSurface( 397 typename Types::LayerType* layer, 398 typename Types::OcclusionTrackerType* occlusion) { 399 EnterContributingSurface(layer, occlusion); 400 LeaveContributingSurface(layer, occlusion); 401 } 402 403 void ResetLayerIterator() { layer_iterator_ = layer_iterator_begin_; } 404 405 const gfx::Transform identity_matrix; 406 407 private: 408 void SetRootLayerOnMainThread(Layer* root) { 409 host_->SetRootLayer(scoped_refptr<Layer>(root)); 410 } 411 412 void SetRootLayerOnMainThread(LayerImpl* root) {} 413 414 void SetBaseProperties(typename Types::LayerType* layer, 415 const gfx::Transform& transform, 416 gfx::PointF position, 417 gfx::Size bounds) { 418 layer->SetTransform(transform); 419 layer->SetSublayerTransform(gfx::Transform()); 420 layer->SetAnchorPoint(gfx::PointF()); 421 layer->SetPosition(position); 422 layer->SetBounds(bounds); 423 } 424 425 void SetProperties(Layer* layer, 426 const gfx::Transform& transform, 427 gfx::PointF position, 428 gfx::Size bounds) { 429 SetBaseProperties(layer, transform, position, bounds); 430 } 431 432 void SetProperties(LayerImpl* layer, 433 const gfx::Transform& transform, 434 gfx::PointF position, 435 gfx::Size bounds) { 436 SetBaseProperties(layer, transform, position, bounds); 437 438 layer->SetContentBounds(layer->bounds()); 439 } 440 441 void SetReplica(Layer* owning_layer, scoped_refptr<Layer> layer) { 442 owning_layer->SetReplicaLayer(layer.get()); 443 replica_layers_.push_back(layer); 444 } 445 446 void SetReplica(LayerImpl* owning_layer, scoped_ptr<LayerImpl> layer) { 447 owning_layer->SetReplicaLayer(layer.Pass()); 448 } 449 450 void SetMask(Layer* owning_layer, scoped_refptr<Layer> layer) { 451 owning_layer->SetMaskLayer(layer.get()); 452 mask_layers_.push_back(layer); 453 } 454 455 void SetMask(LayerImpl* owning_layer, scoped_ptr<LayerImpl> layer) { 456 owning_layer->SetMaskLayer(layer.Pass()); 457 } 458 459 bool opaque_layers_; 460 scoped_ptr<FakeLayerTreeHost> host_; 461 // These hold ownership of the layers for the duration of the test. 462 typename Types::LayerPtrType root_; 463 scoped_ptr<RenderSurfaceLayerList> render_surface_layer_list_; 464 LayerImplList render_surface_layer_list_impl_; 465 typename Types::TestLayerIterator layer_iterator_begin_; 466 typename Types::TestLayerIterator layer_iterator_; 467 typename Types::LayerType* last_layer_visited_; 468 LayerList replica_layers_; 469 LayerList mask_layers_; 470 }; 471 472 template <> 473 FakeLayerTreeHost* 474 OcclusionTrackerTest<OcclusionTrackerTestMainThreadTypes>::GetHost() { 475 return host_.get(); 476 } 477 478 template <> 479 LayerTreeImpl* 480 OcclusionTrackerTest<OcclusionTrackerTestImplThreadTypes>::GetHost() { 481 return host_->host_impl()->active_tree(); 482 } 483 484 #define RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) \ 485 class ClassName##MainThreadOpaqueLayers \ 486 : public ClassName<OcclusionTrackerTestMainThreadTypes> { \ 487 public: /* NOLINT(whitespace/indent) */ \ 488 ClassName##MainThreadOpaqueLayers() \ 489 : ClassName<OcclusionTrackerTestMainThreadTypes>(true) {} \ 490 }; \ 491 TEST_F(ClassName##MainThreadOpaqueLayers, RunTest) { RunMyTest(); } 492 #define RUN_TEST_MAIN_THREAD_OPAQUE_PAINTS(ClassName) \ 493 class ClassName##MainThreadOpaquePaints \ 494 : public ClassName<OcclusionTrackerTestMainThreadTypes> { \ 495 public: /* NOLINT(whitespace/indent) */ \ 496 ClassName##MainThreadOpaquePaints() \ 497 : ClassName<OcclusionTrackerTestMainThreadTypes>(false) {} \ 498 }; \ 499 TEST_F(ClassName##MainThreadOpaquePaints, RunTest) { RunMyTest(); } 500 501 #define RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName) \ 502 class ClassName##ImplThreadOpaqueLayers \ 503 : public ClassName<OcclusionTrackerTestImplThreadTypes> { \ 504 public: /* NOLINT(whitespace/indent) */ \ 505 ClassName##ImplThreadOpaqueLayers() \ 506 : ClassName<OcclusionTrackerTestImplThreadTypes>(true) {} \ 507 }; \ 508 TEST_F(ClassName##ImplThreadOpaqueLayers, RunTest) { RunMyTest(); } 509 #define RUN_TEST_IMPL_THREAD_OPAQUE_PAINTS(ClassName) \ 510 class ClassName##ImplThreadOpaquePaints \ 511 : public ClassName<OcclusionTrackerTestImplThreadTypes> { \ 512 public: /* NOLINT(whitespace/indent) */ \ 513 ClassName##ImplThreadOpaquePaints() \ 514 : ClassName<OcclusionTrackerTestImplThreadTypes>(false) {} \ 515 }; \ 516 TEST_F(ClassName##ImplThreadOpaquePaints, RunTest) { RunMyTest(); } 517 518 #define ALL_OCCLUSIONTRACKER_TEST(ClassName) \ 519 RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) \ 520 RUN_TEST_MAIN_THREAD_OPAQUE_PAINTS(ClassName) \ 521 RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName) \ 522 RUN_TEST_IMPL_THREAD_OPAQUE_PAINTS(ClassName) 523 524 #define MAIN_THREAD_TEST(ClassName) \ 525 RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) 526 527 #define IMPL_THREAD_TEST(ClassName) \ 528 RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName) 529 530 #define MAIN_AND_IMPL_THREAD_TEST(ClassName) \ 531 RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) \ 532 RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName) 533 534 template <class Types> 535 class OcclusionTrackerTestIdentityTransforms 536 : public OcclusionTrackerTest<Types> { 537 protected: 538 explicit OcclusionTrackerTestIdentityTransforms(bool opaque_layers) 539 : OcclusionTrackerTest<Types>(opaque_layers) {} 540 541 void RunMyTest() { 542 typename Types::ContentLayerType* root = this->CreateRoot( 543 this->identity_matrix, gfx::PointF(), gfx::Size(200, 200)); 544 typename Types::ContentLayerType* parent = this->CreateDrawingLayer( 545 root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true); 546 typename Types::ContentLayerType* layer = 547 this->CreateDrawingLayer(parent, 548 this->identity_matrix, 549 gfx::PointF(30.f, 30.f), 550 gfx::Size(500, 500), 551 true); 552 parent->SetMasksToBounds(true); 553 this->CalcDrawEtc(root); 554 555 TestOcclusionTrackerWithClip<typename Types::LayerType, 556 typename Types::RenderSurfaceType> occlusion( 557 gfx::Rect(0, 0, 1000, 1000), false); 558 559 this->VisitLayer(layer, &occlusion); 560 this->EnterLayer(parent, &occlusion); 561 562 EXPECT_EQ(gfx::Rect().ToString(), 563 occlusion.occlusion_from_outside_target().ToString()); 564 EXPECT_EQ(gfx::Rect(30, 30, 70, 70).ToString(), 565 occlusion.occlusion_from_inside_target().ToString()); 566 567 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 30, 70, 70))); 568 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 30, 70, 70))); 569 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 29, 70, 70))); 570 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(31, 30, 69, 70))); 571 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 31, 70, 69))); 572 573 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect( 574 parent, gfx::Rect(30, 30, 70, 70)).IsEmpty()); 575 EXPECT_RECT_EQ(gfx::Rect(29, 30, 1, 70), 576 occlusion.UnoccludedLayerContentRect( 577 parent, gfx::Rect(29, 30, 70, 70))); 578 EXPECT_RECT_EQ(gfx::Rect(29, 29, 70, 70), 579 occlusion.UnoccludedLayerContentRect( 580 parent, gfx::Rect(29, 29, 70, 70))); 581 EXPECT_RECT_EQ(gfx::Rect(30, 29, 70, 1), 582 occlusion.UnoccludedLayerContentRect( 583 parent, gfx::Rect(30, 29, 70, 70))); 584 EXPECT_RECT_EQ(gfx::Rect(31, 29, 69, 1), 585 occlusion.UnoccludedLayerContentRect( 586 parent, gfx::Rect(31, 29, 69, 70))); 587 EXPECT_RECT_EQ(gfx::Rect(), 588 occlusion.UnoccludedLayerContentRect( 589 parent, gfx::Rect(31, 30, 69, 70))); 590 EXPECT_RECT_EQ(gfx::Rect(), 591 occlusion.UnoccludedLayerContentRect( 592 parent, gfx::Rect(31, 31, 69, 69))); 593 EXPECT_RECT_EQ(gfx::Rect(), 594 occlusion.UnoccludedLayerContentRect( 595 parent, gfx::Rect(30, 31, 70, 69))); 596 EXPECT_RECT_EQ(gfx::Rect(29, 31, 1, 69), 597 occlusion.UnoccludedLayerContentRect( 598 parent, gfx::Rect(29, 31, 70, 69))); 599 } 600 }; 601 602 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestIdentityTransforms); 603 604 template <class Types> 605 class OcclusionTrackerTestQuadsMismatchLayer 606 : public OcclusionTrackerTest<Types> { 607 protected: 608 explicit OcclusionTrackerTestQuadsMismatchLayer(bool opaque_layers) 609 : OcclusionTrackerTest<Types>(opaque_layers) {} 610 void RunMyTest() { 611 gfx::Transform layer_transform; 612 layer_transform.Translate(10.0, 10.0); 613 614 typename Types::ContentLayerType* parent = this->CreateRoot( 615 this->identity_matrix, gfx::Point(0, 0), gfx::Size(100, 100)); 616 typename Types::ContentLayerType* layer1 = this->CreateDrawingLayer( 617 parent, layer_transform, gfx::PointF(), gfx::Size(90, 90), true); 618 typename Types::ContentLayerType* layer2 = this->CreateDrawingLayer( 619 layer1, layer_transform, gfx::PointF(), gfx::Size(50, 50), true); 620 this->CalcDrawEtc(parent); 621 622 TestOcclusionTrackerWithClip<typename Types::LayerType, 623 typename Types::RenderSurfaceType> occlusion( 624 gfx::Rect(0, 0, 1000, 1000)); 625 626 this->VisitLayer(layer2, &occlusion); 627 this->EnterLayer(layer1, &occlusion); 628 629 EXPECT_EQ(gfx::Rect().ToString(), 630 occlusion.occlusion_from_outside_target().ToString()); 631 EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(), 632 occlusion.occlusion_from_inside_target().ToString()); 633 634 // This checks cases where the quads don't match their "containing" 635 // layers, e.g. in terms of transforms or clip rect. This is typical for 636 // DelegatedRendererLayer. 637 638 gfx::Transform quad_transform; 639 quad_transform.Translate(30.0, 30.0); 640 641 EXPECT_TRUE(occlusion.UnoccludedContentRect(parent, 642 gfx::Rect(0, 0, 10, 10), 643 quad_transform, 644 false).IsEmpty()); 645 EXPECT_RECT_EQ(gfx::Rect(0, 0, 10, 10), 646 occlusion.UnoccludedContentRect(parent, 647 gfx::Rect(0, 0, 10, 10), 648 quad_transform, 649 true)); 650 EXPECT_RECT_EQ(gfx::Rect(40, 40, 10, 10), 651 occlusion.UnoccludedContentRect(parent, 652 gfx::Rect(40, 40, 10, 10), 653 quad_transform, 654 false)); 655 EXPECT_RECT_EQ(gfx::Rect(40, 30, 5, 10), 656 occlusion.UnoccludedContentRect(parent, 657 gfx::Rect(35, 30, 10, 10), 658 quad_transform, 659 false)); 660 } 661 }; 662 663 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestQuadsMismatchLayer); 664 665 template <class Types> 666 class OcclusionTrackerTestRotatedChild : public OcclusionTrackerTest<Types> { 667 protected: 668 explicit OcclusionTrackerTestRotatedChild(bool opaque_layers) 669 : OcclusionTrackerTest<Types>(opaque_layers) {} 670 void RunMyTest() { 671 gfx::Transform layer_transform; 672 layer_transform.Translate(250.0, 250.0); 673 layer_transform.Rotate(90.0); 674 layer_transform.Translate(-250.0, -250.0); 675 676 typename Types::ContentLayerType* root = this->CreateRoot( 677 this->identity_matrix, gfx::Point(0, 0), gfx::Size(200, 200)); 678 typename Types::ContentLayerType* parent = this->CreateDrawingLayer( 679 root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true); 680 typename Types::ContentLayerType* layer = 681 this->CreateDrawingLayer(parent, 682 layer_transform, 683 gfx::PointF(30.f, 30.f), 684 gfx::Size(500, 500), 685 true); 686 parent->SetMasksToBounds(true); 687 this->CalcDrawEtc(root); 688 689 TestOcclusionTrackerWithClip<typename Types::LayerType, 690 typename Types::RenderSurfaceType> occlusion( 691 gfx::Rect(0, 0, 1000, 1000)); 692 693 this->VisitLayer(layer, &occlusion); 694 this->EnterLayer(parent, &occlusion); 695 696 EXPECT_EQ(gfx::Rect().ToString(), 697 occlusion.occlusion_from_outside_target().ToString()); 698 EXPECT_EQ(gfx::Rect(30, 30, 70, 70).ToString(), 699 occlusion.occlusion_from_inside_target().ToString()); 700 701 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 30, 70, 70))); 702 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 30, 70, 70))); 703 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 29, 70, 70))); 704 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(31, 30, 69, 70))); 705 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 31, 70, 69))); 706 707 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect( 708 parent, gfx::Rect(30, 30, 70, 70)).IsEmpty()); 709 EXPECT_RECT_EQ(gfx::Rect(29, 30, 1, 70), 710 occlusion.UnoccludedLayerContentRect( 711 parent, gfx::Rect(29, 30, 69, 70))); 712 EXPECT_RECT_EQ(gfx::Rect(29, 29, 70, 70), 713 occlusion.UnoccludedLayerContentRect( 714 parent, gfx::Rect(29, 29, 70, 70))); 715 EXPECT_RECT_EQ(gfx::Rect(30, 29, 70, 1), 716 occlusion.UnoccludedLayerContentRect( 717 parent, gfx::Rect(30, 29, 70, 70))); 718 EXPECT_RECT_EQ(gfx::Rect(31, 29, 69, 1), 719 occlusion.UnoccludedLayerContentRect( 720 parent, gfx::Rect(31, 29, 69, 70))); 721 EXPECT_RECT_EQ(gfx::Rect(), 722 occlusion.UnoccludedLayerContentRect( 723 parent, gfx::Rect(31, 30, 69, 70))); 724 EXPECT_RECT_EQ(gfx::Rect(), 725 occlusion.UnoccludedLayerContentRect( 726 parent, gfx::Rect(31, 31, 69, 69))); 727 EXPECT_RECT_EQ(gfx::Rect(), 728 occlusion.UnoccludedLayerContentRect( 729 parent, gfx::Rect(30, 31, 70, 69))); 730 EXPECT_RECT_EQ(gfx::Rect(29, 31, 1, 69), 731 occlusion.UnoccludedLayerContentRect( 732 parent, gfx::Rect(29, 31, 70, 69))); 733 } 734 }; 735 736 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestRotatedChild); 737 738 template <class Types> 739 class OcclusionTrackerTestTranslatedChild : public OcclusionTrackerTest<Types> { 740 protected: 741 explicit OcclusionTrackerTestTranslatedChild(bool opaque_layers) 742 : OcclusionTrackerTest<Types>(opaque_layers) {} 743 void RunMyTest() { 744 gfx::Transform layer_transform; 745 layer_transform.Translate(20.0, 20.0); 746 747 typename Types::ContentLayerType* root = this->CreateRoot( 748 this->identity_matrix, gfx::PointF(), gfx::Size(200, 200)); 749 typename Types::ContentLayerType* parent = this->CreateDrawingLayer( 750 root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true); 751 typename Types::ContentLayerType* layer = 752 this->CreateDrawingLayer(parent, 753 layer_transform, 754 gfx::PointF(30.f, 30.f), 755 gfx::Size(500, 500), 756 true); 757 parent->SetMasksToBounds(true); 758 this->CalcDrawEtc(root); 759 760 TestOcclusionTrackerWithClip<typename Types::LayerType, 761 typename Types::RenderSurfaceType> occlusion( 762 gfx::Rect(0, 0, 1000, 1000)); 763 764 this->VisitLayer(layer, &occlusion); 765 this->EnterLayer(parent, &occlusion); 766 767 EXPECT_EQ(gfx::Rect().ToString(), 768 occlusion.occlusion_from_outside_target().ToString()); 769 EXPECT_EQ(gfx::Rect(50, 50, 50, 50).ToString(), 770 occlusion.occlusion_from_inside_target().ToString()); 771 772 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(50, 50, 50, 50))); 773 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(49, 50, 50, 50))); 774 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(50, 49, 50, 50))); 775 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(51, 50, 49, 50))); 776 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(50, 51, 50, 49))); 777 778 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect( 779 parent, gfx::Rect(50, 50, 50, 50)).IsEmpty()); 780 EXPECT_RECT_EQ(gfx::Rect(49, 50, 1, 50), 781 occlusion.UnoccludedLayerContentRect( 782 parent, gfx::Rect(49, 50, 50, 50))); 783 EXPECT_RECT_EQ(gfx::Rect(49, 49, 50, 50), 784 occlusion.UnoccludedLayerContentRect( 785 parent, gfx::Rect(49, 49, 50, 50))); 786 EXPECT_RECT_EQ(gfx::Rect(50, 49, 50, 1), 787 occlusion.UnoccludedLayerContentRect( 788 parent, gfx::Rect(50, 49, 50, 50))); 789 EXPECT_RECT_EQ(gfx::Rect(51, 49, 49, 1), 790 occlusion.UnoccludedLayerContentRect( 791 parent, gfx::Rect(51, 49, 49, 50))); 792 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect( 793 parent, gfx::Rect(51, 50, 49, 50)).IsEmpty()); 794 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect( 795 parent, gfx::Rect(51, 51, 49, 49)).IsEmpty()); 796 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect( 797 parent, gfx::Rect(50, 51, 50, 49)).IsEmpty()); 798 EXPECT_RECT_EQ(gfx::Rect(49, 51, 1, 49), 799 occlusion.UnoccludedLayerContentRect( 800 parent, gfx::Rect(49, 51, 50, 49))); 801 } 802 }; 803 804 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestTranslatedChild); 805 806 template <class Types> 807 class OcclusionTrackerTestChildInRotatedChild 808 : public OcclusionTrackerTest<Types> { 809 protected: 810 explicit OcclusionTrackerTestChildInRotatedChild(bool opaque_layers) 811 : OcclusionTrackerTest<Types>(opaque_layers) {} 812 void RunMyTest() { 813 gfx::Transform child_transform; 814 child_transform.Translate(250.0, 250.0); 815 child_transform.Rotate(90.0); 816 child_transform.Translate(-250.0, -250.0); 817 818 typename Types::ContentLayerType* parent = this->CreateRoot( 819 this->identity_matrix, gfx::PointF(), gfx::Size(100, 100)); 820 parent->SetMasksToBounds(true); 821 typename Types::LayerType* child = this->CreateSurface( 822 parent, child_transform, gfx::PointF(30.f, 30.f), gfx::Size(500, 500)); 823 child->SetMasksToBounds(true); 824 typename Types::ContentLayerType* layer = 825 this->CreateDrawingLayer(child, 826 this->identity_matrix, 827 gfx::PointF(10.f, 10.f), 828 gfx::Size(500, 500), 829 true); 830 this->CalcDrawEtc(parent); 831 832 TestOcclusionTrackerWithClip<typename Types::LayerType, 833 typename Types::RenderSurfaceType> occlusion( 834 gfx::Rect(0, 0, 1000, 1000)); 835 836 this->VisitLayer(layer, &occlusion); 837 this->EnterContributingSurface(child, &occlusion); 838 839 EXPECT_EQ(gfx::Rect().ToString(), 840 occlusion.occlusion_from_outside_target().ToString()); 841 EXPECT_EQ(gfx::Rect(10, 430, 60, 70).ToString(), 842 occlusion.occlusion_from_inside_target().ToString()); 843 844 this->LeaveContributingSurface(child, &occlusion); 845 this->EnterLayer(parent, &occlusion); 846 847 EXPECT_EQ(gfx::Rect().ToString(), 848 occlusion.occlusion_from_outside_target().ToString()); 849 EXPECT_EQ(gfx::Rect(30, 40, 70, 60).ToString(), 850 occlusion.occlusion_from_inside_target().ToString()); 851 852 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 40, 70, 60))); 853 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 40, 70, 60))); 854 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 39, 70, 60))); 855 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(31, 40, 69, 60))); 856 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 41, 70, 59))); 857 858 /* Justification for the above occlusion from |layer|: 859 100 860 +---------------------+ 861 | | 862 | 30 | rotate(90) 863 | 30 + ---------------------------------+ 864 100 | | 10 | | ==> 865 | |10+---------------------------------+ 866 | | | | | | 867 | | | | | | 868 | | | | | | 869 +----|--|-------------+ | | 870 | | | | 871 | | | | 872 | | | |500 873 | | | | 874 | | | | 875 | | | | 876 | | | | 877 +--|-------------------------------+ | 878 | | 879 +---------------------------------+ 880 500 881 882 +---------------------+ 883 | |30 Visible region of |layer|: ///// 884 | | 885 | +---------------------------------+ 886 100| | |10 | 887 | +---------------------------------+ | 888 | | |///////////////| 420 | | 889 | | |///////////////|60 | | 890 | | |///////////////| | | 891 +--|--|---------------+ | | 892 20|10| 70 | | 893 | | | | 894 | | | | 895 | | | | 896 | | | | 897 | | | | 898 | | |10| 899 | +------------------------------|--+ 900 | 490 | 901 +---------------------------------+ 902 500 903 904 */ 905 } 906 }; 907 908 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestChildInRotatedChild); 909 910 template <class Types> 911 class OcclusionTrackerTestScaledRenderSurface 912 : public OcclusionTrackerTest<Types> { 913 protected: 914 explicit OcclusionTrackerTestScaledRenderSurface(bool opaque_layers) 915 : OcclusionTrackerTest<Types>(opaque_layers) {} 916 917 void RunMyTest() { 918 typename Types::ContentLayerType* parent = this->CreateRoot( 919 this->identity_matrix, gfx::PointF(), gfx::Size(200, 200)); 920 921 gfx::Transform layer1_matrix; 922 layer1_matrix.Scale(2.0, 2.0); 923 typename Types::ContentLayerType* layer1 = this->CreateDrawingLayer( 924 parent, layer1_matrix, gfx::PointF(), gfx::Size(100, 100), true); 925 layer1->SetForceRenderSurface(true); 926 927 gfx::Transform layer2_matrix; 928 layer2_matrix.Translate(25.0, 25.0); 929 typename Types::ContentLayerType* layer2 = this->CreateDrawingLayer( 930 layer1, layer2_matrix, gfx::PointF(), gfx::Size(50, 50), true); 931 typename Types::ContentLayerType* occluder = 932 this->CreateDrawingLayer(parent, 933 this->identity_matrix, 934 gfx::PointF(100.f, 100.f), 935 gfx::Size(500, 500), 936 true); 937 this->CalcDrawEtc(parent); 938 939 TestOcclusionTrackerWithClip<typename Types::LayerType, 940 typename Types::RenderSurfaceType> occlusion( 941 gfx::Rect(0, 0, 1000, 1000)); 942 943 this->VisitLayer(occluder, &occlusion); 944 this->EnterLayer(layer2, &occlusion); 945 946 EXPECT_EQ(gfx::Rect(100, 100, 100, 100).ToString(), 947 occlusion.occlusion_from_outside_target().ToString()); 948 EXPECT_EQ(gfx::Rect().ToString(), 949 occlusion.occlusion_from_inside_target().ToString()); 950 951 EXPECT_RECT_EQ( 952 gfx::Rect(0, 0, 25, 25), 953 occlusion.UnoccludedLayerContentRect(layer2, gfx::Rect(0, 0, 25, 25))); 954 EXPECT_RECT_EQ(gfx::Rect(10, 25, 15, 25), 955 occlusion.UnoccludedLayerContentRect( 956 layer2, gfx::Rect(10, 25, 25, 25))); 957 EXPECT_RECT_EQ(gfx::Rect(25, 10, 25, 15), 958 occlusion.UnoccludedLayerContentRect( 959 layer2, gfx::Rect(25, 10, 25, 25))); 960 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect( 961 layer2, gfx::Rect(25, 25, 25, 25)).IsEmpty()); 962 } 963 }; 964 965 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestScaledRenderSurface); 966 967 template <class Types> 968 class OcclusionTrackerTestVisitTargetTwoTimes 969 : public OcclusionTrackerTest<Types> { 970 protected: 971 explicit OcclusionTrackerTestVisitTargetTwoTimes(bool opaque_layers) 972 : OcclusionTrackerTest<Types>(opaque_layers) {} 973 void RunMyTest() { 974 gfx::Transform child_transform; 975 child_transform.Translate(250.0, 250.0); 976 child_transform.Rotate(90.0); 977 child_transform.Translate(-250.0, -250.0); 978 979 typename Types::ContentLayerType* root = this->CreateRoot( 980 this->identity_matrix, gfx::PointF(), gfx::Size(200, 200)); 981 typename Types::ContentLayerType* parent = this->CreateDrawingLayer( 982 root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true); 983 parent->SetMasksToBounds(true); 984 typename Types::LayerType* child = this->CreateSurface( 985 parent, child_transform, gfx::PointF(30.f, 30.f), gfx::Size(500, 500)); 986 child->SetMasksToBounds(true); 987 typename Types::ContentLayerType* layer = 988 this->CreateDrawingLayer(child, 989 this->identity_matrix, 990 gfx::PointF(10.f, 10.f), 991 gfx::Size(500, 500), 992 true); 993 // |child2| makes |parent|'s surface get considered by OcclusionTracker 994 // first, instead of |child|'s. This exercises different code in 995 // LeaveToRenderTarget, as the target surface has already been seen. 996 typename Types::ContentLayerType* child2 = 997 this->CreateDrawingLayer(parent, 998 this->identity_matrix, 999 gfx::PointF(30.f, 30.f), 1000 gfx::Size(60, 20), 1001 true); 1002 this->CalcDrawEtc(root); 1003 1004 TestOcclusionTrackerWithClip<typename Types::LayerType, 1005 typename Types::RenderSurfaceType> occlusion( 1006 gfx::Rect(0, 0, 1000, 1000)); 1007 1008 this->VisitLayer(child2, &occlusion); 1009 1010 EXPECT_EQ(gfx::Rect().ToString(), 1011 occlusion.occlusion_from_outside_target().ToString()); 1012 EXPECT_EQ(gfx::Rect(30, 30, 60, 20).ToString(), 1013 occlusion.occlusion_from_inside_target().ToString()); 1014 1015 this->VisitLayer(layer, &occlusion); 1016 1017 EXPECT_EQ(gfx::Rect(0, 440, 20, 60).ToString(), 1018 occlusion.occlusion_from_outside_target().ToString()); 1019 EXPECT_EQ(gfx::Rect(10, 430, 60, 70).ToString(), 1020 occlusion.occlusion_from_inside_target().ToString()); 1021 1022 this->EnterContributingSurface(child, &occlusion); 1023 1024 EXPECT_EQ(gfx::Rect(0, 440, 20, 60).ToString(), 1025 occlusion.occlusion_from_outside_target().ToString()); 1026 EXPECT_EQ(gfx::Rect(10, 430, 60, 70).ToString(), 1027 occlusion.occlusion_from_inside_target().ToString()); 1028 1029 // Occlusion in |child2| should get merged with the |child| surface we are 1030 // leaving now. 1031 this->LeaveContributingSurface(child, &occlusion); 1032 this->EnterLayer(parent, &occlusion); 1033 1034 EXPECT_EQ(gfx::Rect().ToString(), 1035 occlusion.occlusion_from_outside_target().ToString()); 1036 EXPECT_EQ(UnionRegions(gfx::Rect(30, 30, 60, 10), gfx::Rect(30, 40, 70, 60)) 1037 .ToString(), 1038 occlusion.occlusion_from_inside_target().ToString()); 1039 1040 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 30, 70, 70))); 1041 EXPECT_RECT_EQ(gfx::Rect(90, 30, 10, 10), 1042 occlusion.UnoccludedLayerContentRect( 1043 parent, gfx::Rect(30, 30, 70, 70))); 1044 1045 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 30, 60, 10))); 1046 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 30, 60, 10))); 1047 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 29, 60, 10))); 1048 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(31, 30, 60, 10))); 1049 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 31, 60, 10))); 1050 1051 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 40, 70, 60))); 1052 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 40, 70, 60))); 1053 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 39, 70, 60))); 1054 1055 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect( 1056 parent, gfx::Rect(30, 30, 60, 10)).IsEmpty()); 1057 EXPECT_RECT_EQ(gfx::Rect(29, 30, 1, 10), 1058 occlusion.UnoccludedLayerContentRect( 1059 parent, gfx::Rect(29, 30, 60, 10))); 1060 EXPECT_RECT_EQ(gfx::Rect(30, 29, 60, 1), 1061 occlusion.UnoccludedLayerContentRect( 1062 parent, gfx::Rect(30, 29, 60, 10))); 1063 EXPECT_RECT_EQ(gfx::Rect(90, 30, 1, 10), 1064 occlusion.UnoccludedLayerContentRect( 1065 parent, gfx::Rect(31, 30, 60, 10))); 1066 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect( 1067 parent, gfx::Rect(30, 31, 60, 10)).IsEmpty()); 1068 1069 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect( 1070 parent, gfx::Rect(30, 40, 70, 60)).IsEmpty()); 1071 EXPECT_RECT_EQ(gfx::Rect(29, 40, 1, 60), 1072 occlusion.UnoccludedLayerContentRect( 1073 parent, gfx::Rect(29, 40, 70, 60))); 1074 // This rect is mostly occluded by |child2|. 1075 EXPECT_RECT_EQ(gfx::Rect(90, 39, 10, 1), 1076 occlusion.UnoccludedLayerContentRect( 1077 parent, gfx::Rect(30, 39, 70, 60))); 1078 // This rect extends past top/right ends of |child2|. 1079 EXPECT_RECT_EQ(gfx::Rect(30, 29, 70, 11), 1080 occlusion.UnoccludedLayerContentRect( 1081 parent, gfx::Rect(30, 29, 70, 70))); 1082 // This rect extends past left/right ends of |child2|. 1083 EXPECT_RECT_EQ(gfx::Rect(20, 39, 80, 60), 1084 occlusion.UnoccludedLayerContentRect( 1085 parent, gfx::Rect(20, 39, 80, 60))); 1086 EXPECT_RECT_EQ(gfx::Rect(), 1087 occlusion.UnoccludedLayerContentRect( 1088 parent, gfx::Rect(31, 40, 69, 60))); 1089 EXPECT_RECT_EQ(gfx::Rect(), 1090 occlusion.UnoccludedLayerContentRect( 1091 parent, gfx::Rect(30, 41, 70, 59))); 1092 1093 /* Justification for the above occlusion from |layer|: 1094 100 1095 +---------------------+ 1096 | | 1097 | 30 | rotate(90) 1098 | 30 + ------------+--------------------+ 1099 100 | | 10 | | | ==> 1100 | |10+----------|----------------------+ 1101 | + ------------+ | | | 1102 | | | | | | 1103 | | | | | | 1104 +----|--|-------------+ | | 1105 | | | | 1106 | | | | 1107 | | | |500 1108 | | | | 1109 | | | | 1110 | | | | 1111 | | | | 1112 +--|-------------------------------+ | 1113 | | 1114 +---------------------------------+ 1115 500 1116 1117 1118 +---------------------+ 1119 | |30 Visible region of |layer|: ///// 1120 | 30 60 | |child2|: \\\\\ 1121 | 30 +------------+--------------------+ 1122 | |\\\\\\\\\\\\| |10 | 1123 | +--|\\\\\\\\\\\\|-----------------+ | 1124 | | +------------+//| 420 | | 1125 | | |///////////////|60 | | 1126 | | |///////////////| | | 1127 +--|--|---------------+ | | 1128 20|10| 70 | | 1129 | | | | 1130 | | | | 1131 | | | | 1132 | | | | 1133 | | | | 1134 | | |10| 1135 | +------------------------------|--+ 1136 | 490 | 1137 +---------------------------------+ 1138 500 1139 */ 1140 } 1141 }; 1142 1143 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestVisitTargetTwoTimes); 1144 1145 template <class Types> 1146 class OcclusionTrackerTestSurfaceRotatedOffAxis 1147 : public OcclusionTrackerTest<Types> { 1148 protected: 1149 explicit OcclusionTrackerTestSurfaceRotatedOffAxis(bool opaque_layers) 1150 : OcclusionTrackerTest<Types>(opaque_layers) {} 1151 void RunMyTest() { 1152 gfx::Transform child_transform; 1153 child_transform.Translate(250.0, 250.0); 1154 child_transform.Rotate(95.0); 1155 child_transform.Translate(-250.0, -250.0); 1156 1157 gfx::Transform layer_transform; 1158 layer_transform.Translate(10.0, 10.0); 1159 1160 typename Types::ContentLayerType* root = this->CreateRoot( 1161 this->identity_matrix, gfx::PointF(), gfx::Size(1000, 1000)); 1162 typename Types::ContentLayerType* parent = this->CreateDrawingLayer( 1163 root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true); 1164 typename Types::LayerType* child = this->CreateLayer( 1165 parent, child_transform, gfx::PointF(30.f, 30.f), gfx::Size(500, 500)); 1166 child->SetMasksToBounds(true); 1167 typename Types::ContentLayerType* layer = this->CreateDrawingLayer( 1168 child, layer_transform, gfx::PointF(), gfx::Size(500, 500), true); 1169 this->CalcDrawEtc(root); 1170 1171 TestOcclusionTrackerWithClip<typename Types::LayerType, 1172 typename Types::RenderSurfaceType> occlusion( 1173 gfx::Rect(0, 0, 1000, 1000)); 1174 1175 gfx::Rect clipped_layer_in_child = MathUtil::MapClippedRect( 1176 layer_transform, layer->visible_content_rect()); 1177 1178 this->VisitLayer(layer, &occlusion); 1179 this->EnterContributingSurface(child, &occlusion); 1180 1181 EXPECT_EQ(gfx::Rect().ToString(), 1182 occlusion.occlusion_from_outside_target().ToString()); 1183 EXPECT_EQ(clipped_layer_in_child.ToString(), 1184 occlusion.occlusion_from_inside_target().ToString()); 1185 1186 this->LeaveContributingSurface(child, &occlusion); 1187 this->EnterLayer(parent, &occlusion); 1188 1189 EXPECT_EQ(gfx::Rect().ToString(), 1190 occlusion.occlusion_from_outside_target().ToString()); 1191 EXPECT_EQ(gfx::Rect().ToString(), 1192 occlusion.occlusion_from_inside_target().ToString()); 1193 1194 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(75, 55, 1, 1))); 1195 EXPECT_RECT_EQ( 1196 gfx::Rect(75, 55, 1, 1), 1197 occlusion.UnoccludedLayerContentRect(parent, gfx::Rect(75, 55, 1, 1))); 1198 } 1199 }; 1200 1201 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceRotatedOffAxis); 1202 1203 template <class Types> 1204 class OcclusionTrackerTestSurfaceWithTwoOpaqueChildren 1205 : public OcclusionTrackerTest<Types> { 1206 protected: 1207 explicit OcclusionTrackerTestSurfaceWithTwoOpaqueChildren(bool opaque_layers) 1208 : OcclusionTrackerTest<Types>(opaque_layers) {} 1209 void RunMyTest() { 1210 gfx::Transform child_transform; 1211 child_transform.Translate(250.0, 250.0); 1212 child_transform.Rotate(90.0); 1213 child_transform.Translate(-250.0, -250.0); 1214 1215 typename Types::ContentLayerType* root = this->CreateRoot( 1216 this->identity_matrix, gfx::PointF(), gfx::Size(1000, 1000)); 1217 typename Types::ContentLayerType* parent = this->CreateDrawingLayer( 1218 root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true); 1219 parent->SetMasksToBounds(true); 1220 typename Types::ContentLayerType* child = 1221 this->CreateDrawingSurface(parent, 1222 child_transform, 1223 gfx::PointF(30.f, 30.f), 1224 gfx::Size(500, 500), 1225 false); 1226 child->SetMasksToBounds(true); 1227 typename Types::ContentLayerType* layer1 = 1228 this->CreateDrawingLayer(child, 1229 this->identity_matrix, 1230 gfx::PointF(10.f, 10.f), 1231 gfx::Size(500, 500), 1232 true); 1233 typename Types::ContentLayerType* layer2 = 1234 this->CreateDrawingLayer(child, 1235 this->identity_matrix, 1236 gfx::PointF(10.f, 450.f), 1237 gfx::Size(500, 60), 1238 true); 1239 this->CalcDrawEtc(root); 1240 1241 TestOcclusionTrackerWithClip<typename Types::LayerType, 1242 typename Types::RenderSurfaceType> occlusion( 1243 gfx::Rect(0, 0, 1000, 1000)); 1244 1245 this->VisitLayer(layer2, &occlusion); 1246 this->VisitLayer(layer1, &occlusion); 1247 this->VisitLayer(child, &occlusion); 1248 this->EnterContributingSurface(child, &occlusion); 1249 1250 EXPECT_EQ(gfx::Rect().ToString(), 1251 occlusion.occlusion_from_outside_target().ToString()); 1252 EXPECT_EQ(gfx::Rect(10, 430, 60, 70).ToString(), 1253 occlusion.occlusion_from_inside_target().ToString()); 1254 1255 EXPECT_TRUE(occlusion.OccludedLayer(child, gfx::Rect(10, 430, 60, 70))); 1256 EXPECT_FALSE(occlusion.OccludedLayer(child, gfx::Rect(9, 430, 60, 70))); 1257 EXPECT_TRUE(occlusion.OccludedLayer(child, gfx::Rect(11, 430, 59, 70))); 1258 EXPECT_TRUE(occlusion.OccludedLayer(child, gfx::Rect(10, 431, 60, 69))); 1259 1260 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect( 1261 child, gfx::Rect(10, 430, 60, 70)).IsEmpty()); 1262 EXPECT_RECT_EQ( 1263 gfx::Rect(9, 430, 1, 70), 1264 occlusion.UnoccludedLayerContentRect(child, gfx::Rect(9, 430, 60, 70))); 1265 EXPECT_RECT_EQ(gfx::Rect(), 1266 occlusion.UnoccludedLayerContentRect( 1267 child, gfx::Rect(11, 430, 59, 70))); 1268 EXPECT_RECT_EQ(gfx::Rect(), 1269 occlusion.UnoccludedLayerContentRect( 1270 child, gfx::Rect(10, 431, 60, 69))); 1271 1272 this->LeaveContributingSurface(child, &occlusion); 1273 this->EnterLayer(parent, &occlusion); 1274 1275 EXPECT_EQ(gfx::Rect().ToString(), 1276 occlusion.occlusion_from_outside_target().ToString()); 1277 EXPECT_EQ(gfx::Rect(30, 40, 70, 60).ToString(), 1278 occlusion.occlusion_from_inside_target().ToString()); 1279 1280 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 40, 70, 60))); 1281 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 40, 70, 60))); 1282 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 39, 70, 60))); 1283 1284 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect( 1285 parent, gfx::Rect(30, 40, 70, 60)).IsEmpty()); 1286 EXPECT_RECT_EQ(gfx::Rect(29, 40, 1, 60), 1287 occlusion.UnoccludedLayerContentRect( 1288 parent, gfx::Rect(29, 40, 70, 60))); 1289 EXPECT_RECT_EQ(gfx::Rect(30, 39, 70, 1), 1290 occlusion.UnoccludedLayerContentRect( 1291 parent, gfx::Rect(30, 39, 70, 60))); 1292 EXPECT_RECT_EQ(gfx::Rect(), 1293 occlusion.UnoccludedLayerContentRect( 1294 parent, gfx::Rect(31, 40, 69, 60))); 1295 EXPECT_RECT_EQ(gfx::Rect(), 1296 occlusion.UnoccludedLayerContentRect( 1297 parent, gfx::Rect(30, 41, 70, 59))); 1298 1299 /* Justification for the above occlusion from |layer1| and |layer2|: 1300 1301 +---------------------+ 1302 | |30 Visible region of |layer1|: ///// 1303 | | Visible region of |layer2|: \\\\\ 1304 | +---------------------------------+ 1305 | | |10 | 1306 | +---------------+-----------------+ | 1307 | | |\\\\\\\\\\\\|//| 420 | | 1308 | | |\\\\\\\\\\\\|//|60 | | 1309 | | |\\\\\\\\\\\\|//| | | 1310 +--|--|------------|--+ | | 1311 20|10| 70 | | | 1312 | | | | | 1313 | | | | | 1314 | | | | | 1315 | | | | | 1316 | | | | | 1317 | | | |10| 1318 | +------------|-----------------|--+ 1319 | | 490 | 1320 +---------------+-----------------+ 1321 60 440 1322 */ 1323 } 1324 }; 1325 1326 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceWithTwoOpaqueChildren); 1327 1328 template <class Types> 1329 class OcclusionTrackerTestOverlappingSurfaceSiblings 1330 : public OcclusionTrackerTest<Types> { 1331 protected: 1332 explicit OcclusionTrackerTestOverlappingSurfaceSiblings(bool opaque_layers) 1333 : OcclusionTrackerTest<Types>(opaque_layers) {} 1334 void RunMyTest() { 1335 gfx::Transform child_transform; 1336 child_transform.Translate(250.0, 250.0); 1337 child_transform.Rotate(90.0); 1338 child_transform.Translate(-250.0, -250.0); 1339 1340 typename Types::ContentLayerType* parent = this->CreateRoot( 1341 this->identity_matrix, gfx::PointF(), gfx::Size(100, 100)); 1342 parent->SetMasksToBounds(true); 1343 typename Types::LayerType* child1 = this->CreateSurface( 1344 parent, child_transform, gfx::PointF(30.f, 30.f), gfx::Size(10, 10)); 1345 typename Types::LayerType* child2 = this->CreateSurface( 1346 parent, child_transform, gfx::PointF(20.f, 40.f), gfx::Size(10, 10)); 1347 typename Types::ContentLayerType* layer1 = 1348 this->CreateDrawingLayer(child1, 1349 this->identity_matrix, 1350 gfx::PointF(-10.f, -10.f), 1351 gfx::Size(510, 510), 1352 true); 1353 typename Types::ContentLayerType* layer2 = 1354 this->CreateDrawingLayer(child2, 1355 this->identity_matrix, 1356 gfx::PointF(-10.f, -10.f), 1357 gfx::Size(510, 510), 1358 true); 1359 this->CalcDrawEtc(parent); 1360 1361 TestOcclusionTrackerWithClip<typename Types::LayerType, 1362 typename Types::RenderSurfaceType> occlusion( 1363 gfx::Rect(0, 0, 1000, 1000)); 1364 1365 this->VisitLayer(layer2, &occlusion); 1366 this->EnterContributingSurface(child2, &occlusion); 1367 1368 EXPECT_EQ(gfx::Rect().ToString(), 1369 occlusion.occlusion_from_outside_target().ToString()); 1370 EXPECT_EQ(gfx::Rect(-10, 420, 70, 80).ToString(), 1371 occlusion.occlusion_from_inside_target().ToString()); 1372 1373 // There is nothing above child2's surface in the z-order. 1374 EXPECT_RECT_EQ(gfx::Rect(-10, 420, 70, 80), 1375 occlusion.UnoccludedContributingSurfaceContentRect( 1376 child2, false, gfx::Rect(-10, 420, 70, 80))); 1377 1378 this->LeaveContributingSurface(child2, &occlusion); 1379 this->VisitLayer(layer1, &occlusion); 1380 this->EnterContributingSurface(child1, &occlusion); 1381 1382 EXPECT_EQ(gfx::Rect(0, 430, 70, 80).ToString(), 1383 occlusion.occlusion_from_outside_target().ToString()); 1384 EXPECT_EQ(gfx::Rect(-10, 430, 80, 70).ToString(), 1385 occlusion.occlusion_from_inside_target().ToString()); 1386 1387 // child2's contents will occlude child1 below it. 1388 EXPECT_RECT_EQ(gfx::Rect(-10, 430, 10, 70), 1389 occlusion.UnoccludedContributingSurfaceContentRect( 1390 child1, false, gfx::Rect(-10, 430, 80, 70))); 1391 1392 this->LeaveContributingSurface(child1, &occlusion); 1393 this->EnterLayer(parent, &occlusion); 1394 1395 EXPECT_EQ(gfx::Rect().ToString(), 1396 occlusion.occlusion_from_outside_target().ToString()); 1397 EXPECT_EQ(UnionRegions(gfx::Rect(30, 20, 70, 10), gfx::Rect(20, 30, 80, 70)) 1398 .ToString(), 1399 occlusion.occlusion_from_inside_target().ToString()); 1400 1401 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(20, 20, 80, 80))); 1402 1403 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 20, 70, 80))); 1404 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 20, 70, 80))); 1405 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 19, 70, 80))); 1406 1407 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(20, 30, 80, 70))); 1408 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(19, 30, 80, 70))); 1409 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(20, 29, 80, 70))); 1410 1411 /* Justification for the above occlusion: 1412 100 1413 +---------------------+ 1414 | 20 | layer1 1415 | 30+ ---------------------------------+ 1416 100 | 30| | layer2 | 1417 |20+----------------------------------+ | 1418 | | | | | | 1419 | | | | | | 1420 | | | | | | 1421 +--|-|----------------+ | | 1422 | | | | 510 1423 | | | | 1424 | | | | 1425 | | | | 1426 | | | | 1427 | | | | 1428 | | | | 1429 | +--------------------------------|-+ 1430 | | 1431 +----------------------------------+ 1432 510 1433 */ 1434 } 1435 }; 1436 1437 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestOverlappingSurfaceSiblings); 1438 1439 template <class Types> 1440 class OcclusionTrackerTestOverlappingSurfaceSiblingsWithTwoTransforms 1441 : public OcclusionTrackerTest<Types> { 1442 protected: 1443 explicit OcclusionTrackerTestOverlappingSurfaceSiblingsWithTwoTransforms( 1444 bool opaque_layers) 1445 : OcclusionTrackerTest<Types>(opaque_layers) {} 1446 void RunMyTest() { 1447 gfx::Transform child1_transform; 1448 child1_transform.Translate(250.0, 250.0); 1449 child1_transform.Rotate(-90.0); 1450 child1_transform.Translate(-250.0, -250.0); 1451 1452 gfx::Transform child2_transform; 1453 child2_transform.Translate(250.0, 250.0); 1454 child2_transform.Rotate(90.0); 1455 child2_transform.Translate(-250.0, -250.0); 1456 1457 typename Types::ContentLayerType* parent = this->CreateRoot( 1458 this->identity_matrix, gfx::PointF(), gfx::Size(100, 100)); 1459 parent->SetMasksToBounds(true); 1460 typename Types::LayerType* child1 = this->CreateSurface( 1461 parent, child1_transform, gfx::PointF(30.f, 20.f), gfx::Size(10, 10)); 1462 typename Types::LayerType* child2 = 1463 this->CreateDrawingSurface(parent, 1464 child2_transform, 1465 gfx::PointF(20.f, 40.f), 1466 gfx::Size(10, 10), 1467 false); 1468 typename Types::ContentLayerType* layer1 = 1469 this->CreateDrawingLayer(child1, 1470 this->identity_matrix, 1471 gfx::PointF(-10.f, -20.f), 1472 gfx::Size(510, 510), 1473 true); 1474 typename Types::ContentLayerType* layer2 = 1475 this->CreateDrawingLayer(child2, 1476 this->identity_matrix, 1477 gfx::PointF(-10.f, -10.f), 1478 gfx::Size(510, 510), 1479 true); 1480 this->CalcDrawEtc(parent); 1481 1482 TestOcclusionTrackerWithClip<typename Types::LayerType, 1483 typename Types::RenderSurfaceType> occlusion( 1484 gfx::Rect(0, 0, 1000, 1000)); 1485 1486 this->VisitLayer(layer2, &occlusion); 1487 this->EnterLayer(child2, &occlusion); 1488 1489 EXPECT_EQ(gfx::Rect().ToString(), 1490 occlusion.occlusion_from_outside_target().ToString()); 1491 EXPECT_EQ(gfx::Rect(-10, 420, 70, 80).ToString(), 1492 occlusion.occlusion_from_inside_target().ToString()); 1493 1494 this->LeaveLayer(child2, &occlusion); 1495 this->EnterContributingSurface(child2, &occlusion); 1496 1497 // There is nothing above child2's surface in the z-order. 1498 EXPECT_RECT_EQ(gfx::Rect(-10, 420, 70, 80), 1499 occlusion.UnoccludedContributingSurfaceContentRect( 1500 child2, false, gfx::Rect(-10, 420, 70, 80))); 1501 1502 this->LeaveContributingSurface(child2, &occlusion); 1503 this->VisitLayer(layer1, &occlusion); 1504 this->EnterContributingSurface(child1, &occlusion); 1505 1506 EXPECT_EQ(gfx::Rect(420, -10, 70, 80).ToString(), 1507 occlusion.occlusion_from_outside_target().ToString()); 1508 EXPECT_EQ(gfx::Rect(420, -20, 80, 90).ToString(), 1509 occlusion.occlusion_from_inside_target().ToString()); 1510 1511 // child2's contents will occlude child1 below it. 1512 EXPECT_RECT_EQ(gfx::Rect(420, -20, 80, 90), 1513 occlusion.UnoccludedContributingSurfaceContentRect( 1514 child1, false, gfx::Rect(420, -20, 80, 90))); 1515 EXPECT_RECT_EQ(gfx::Rect(490, -10, 10, 80), 1516 occlusion.UnoccludedContributingSurfaceContentRect( 1517 child1, false, gfx::Rect(420, -10, 80, 90))); 1518 EXPECT_RECT_EQ(gfx::Rect(420, -20, 70, 10), 1519 occlusion.UnoccludedContributingSurfaceContentRect( 1520 child1, false, gfx::Rect(420, -20, 70, 90))); 1521 1522 this->LeaveContributingSurface(child1, &occlusion); 1523 this->EnterLayer(parent, &occlusion); 1524 1525 EXPECT_EQ(gfx::Rect().ToString(), 1526 occlusion.occlusion_from_outside_target().ToString()); 1527 EXPECT_EQ(gfx::Rect(10, 20, 90, 80).ToString(), 1528 occlusion.occlusion_from_inside_target().ToString()); 1529 1530 /* Justification for the above occlusion: 1531 100 1532 +---------------------+ 1533 |20 | layer1 1534 10+----------------------------------+ 1535 100 || 30 | layer2 | 1536 |20+----------------------------------+ 1537 || | | | | 1538 || | | | | 1539 || | | | | 1540 +|-|------------------+ | | 1541 | | | | 510 1542 | | 510 | | 1543 | | | | 1544 | | | | 1545 | | | | 1546 | | | | 1547 | | 520 | | 1548 +----------------------------------+ | 1549 | | 1550 +----------------------------------+ 1551 510 1552 */ 1553 } 1554 }; 1555 1556 ALL_OCCLUSIONTRACKER_TEST( 1557 OcclusionTrackerTestOverlappingSurfaceSiblingsWithTwoTransforms); 1558 1559 template <class Types> 1560 class OcclusionTrackerTestFilters : public OcclusionTrackerTest<Types> { 1561 protected: 1562 explicit OcclusionTrackerTestFilters(bool opaque_layers) 1563 : OcclusionTrackerTest<Types>(opaque_layers) {} 1564 void RunMyTest() { 1565 gfx::Transform layer_transform; 1566 layer_transform.Translate(250.0, 250.0); 1567 layer_transform.Rotate(90.0); 1568 layer_transform.Translate(-250.0, -250.0); 1569 1570 typename Types::ContentLayerType* parent = this->CreateRoot( 1571 this->identity_matrix, gfx::PointF(), gfx::Size(100, 100)); 1572 parent->SetMasksToBounds(true); 1573 typename Types::ContentLayerType* blur_layer = 1574 this->CreateDrawingLayer(parent, 1575 layer_transform, 1576 gfx::PointF(30.f, 30.f), 1577 gfx::Size(500, 500), 1578 true); 1579 typename Types::ContentLayerType* opaque_layer = 1580 this->CreateDrawingLayer(parent, 1581 layer_transform, 1582 gfx::PointF(30.f, 30.f), 1583 gfx::Size(500, 500), 1584 true); 1585 typename Types::ContentLayerType* opacity_layer = 1586 this->CreateDrawingLayer(parent, 1587 layer_transform, 1588 gfx::PointF(30.f, 30.f), 1589 gfx::Size(500, 500), 1590 true); 1591 1592 FilterOperations filters; 1593 filters.Append(FilterOperation::CreateBlurFilter(10.f)); 1594 blur_layer->SetFilters(filters); 1595 1596 filters.Clear(); 1597 filters.Append(FilterOperation::CreateGrayscaleFilter(0.5f)); 1598 opaque_layer->SetFilters(filters); 1599 1600 filters.Clear(); 1601 filters.Append(FilterOperation::CreateOpacityFilter(0.5f)); 1602 opacity_layer->SetFilters(filters); 1603 1604 this->CalcDrawEtc(parent); 1605 1606 TestOcclusionTrackerWithClip<typename Types::LayerType, 1607 typename Types::RenderSurfaceType> occlusion( 1608 gfx::Rect(0, 0, 1000, 1000)); 1609 1610 // Opacity layer won't contribute to occlusion. 1611 this->VisitLayer(opacity_layer, &occlusion); 1612 this->EnterContributingSurface(opacity_layer, &occlusion); 1613 1614 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty()); 1615 EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty()); 1616 1617 // And has nothing to contribute to its parent surface. 1618 this->LeaveContributingSurface(opacity_layer, &occlusion); 1619 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty()); 1620 EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty()); 1621 1622 // Opaque layer will contribute to occlusion. 1623 this->VisitLayer(opaque_layer, &occlusion); 1624 this->EnterContributingSurface(opaque_layer, &occlusion); 1625 1626 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty()); 1627 EXPECT_EQ(gfx::Rect(0, 430, 70, 70).ToString(), 1628 occlusion.occlusion_from_inside_target().ToString()); 1629 1630 // And it gets translated to the parent surface. 1631 this->LeaveContributingSurface(opaque_layer, &occlusion); 1632 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty()); 1633 EXPECT_EQ(gfx::Rect(30, 30, 70, 70).ToString(), 1634 occlusion.occlusion_from_inside_target().ToString()); 1635 1636 // The blur layer needs to throw away any occlusion from outside its 1637 // subtree. 1638 this->EnterLayer(blur_layer, &occlusion); 1639 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty()); 1640 EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty()); 1641 1642 // And it won't contribute to occlusion. 1643 this->LeaveLayer(blur_layer, &occlusion); 1644 this->EnterContributingSurface(blur_layer, &occlusion); 1645 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty()); 1646 EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty()); 1647 1648 // But the opaque layer's occlusion is preserved on the parent. 1649 this->LeaveContributingSurface(blur_layer, &occlusion); 1650 this->EnterLayer(parent, &occlusion); 1651 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty()); 1652 EXPECT_EQ(gfx::Rect(30, 30, 70, 70).ToString(), 1653 occlusion.occlusion_from_inside_target().ToString()); 1654 } 1655 }; 1656 1657 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestFilters); 1658 1659 template <class Types> 1660 class OcclusionTrackerTestReplicaDoesOcclude 1661 : public OcclusionTrackerTest<Types> { 1662 protected: 1663 explicit OcclusionTrackerTestReplicaDoesOcclude(bool opaque_layers) 1664 : OcclusionTrackerTest<Types>(opaque_layers) {} 1665 void RunMyTest() { 1666 typename Types::ContentLayerType* parent = this->CreateRoot( 1667 this->identity_matrix, gfx::PointF(), gfx::Size(100, 200)); 1668 typename Types::LayerType* surface = 1669 this->CreateDrawingSurface(parent, 1670 this->identity_matrix, 1671 gfx::PointF(0.f, 100.f), 1672 gfx::Size(50, 50), 1673 true); 1674 this->CreateReplicaLayer( 1675 surface, this->identity_matrix, gfx::PointF(50.f, 50.f), gfx::Size()); 1676 this->CalcDrawEtc(parent); 1677 1678 TestOcclusionTrackerWithClip<typename Types::LayerType, 1679 typename Types::RenderSurfaceType> occlusion( 1680 gfx::Rect(0, 0, 1000, 1000)); 1681 1682 this->VisitLayer(surface, &occlusion); 1683 1684 EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(), 1685 occlusion.occlusion_from_inside_target().ToString()); 1686 1687 this->VisitContributingSurface(surface, &occlusion); 1688 this->EnterLayer(parent, &occlusion); 1689 1690 // The surface and replica should both be occluding the parent. 1691 EXPECT_EQ( 1692 UnionRegions(gfx::Rect(0, 100, 50, 50), 1693 gfx::Rect(50, 150, 50, 50)).ToString(), 1694 occlusion.occlusion_from_inside_target().ToString()); 1695 } 1696 }; 1697 1698 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaDoesOcclude); 1699 1700 template <class Types> 1701 class OcclusionTrackerTestReplicaWithClipping 1702 : public OcclusionTrackerTest<Types> { 1703 protected: 1704 explicit OcclusionTrackerTestReplicaWithClipping(bool opaque_layers) 1705 : OcclusionTrackerTest<Types>(opaque_layers) {} 1706 void RunMyTest() { 1707 typename Types::ContentLayerType* parent = this->CreateRoot( 1708 this->identity_matrix, gfx::PointF(), gfx::Size(100, 170)); 1709 parent->SetMasksToBounds(true); 1710 typename Types::LayerType* surface = 1711 this->CreateDrawingSurface(parent, 1712 this->identity_matrix, 1713 gfx::PointF(0.f, 100.f), 1714 gfx::Size(50, 50), 1715 true); 1716 this->CreateReplicaLayer( 1717 surface, this->identity_matrix, gfx::PointF(50.f, 50.f), gfx::Size()); 1718 this->CalcDrawEtc(parent); 1719 1720 TestOcclusionTrackerWithClip<typename Types::LayerType, 1721 typename Types::RenderSurfaceType> occlusion( 1722 gfx::Rect(0, 0, 1000, 1000)); 1723 1724 this->VisitLayer(surface, &occlusion); 1725 1726 EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(), 1727 occlusion.occlusion_from_inside_target().ToString()); 1728 1729 this->VisitContributingSurface(surface, &occlusion); 1730 this->EnterLayer(parent, &occlusion); 1731 1732 // The surface and replica should both be occluding the parent. 1733 EXPECT_EQ( 1734 UnionRegions(gfx::Rect(0, 100, 50, 50), 1735 gfx::Rect(50, 150, 50, 20)).ToString(), 1736 occlusion.occlusion_from_inside_target().ToString()); 1737 } 1738 }; 1739 1740 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaWithClipping); 1741 1742 template <class Types> 1743 class OcclusionTrackerTestReplicaWithMask : public OcclusionTrackerTest<Types> { 1744 protected: 1745 explicit OcclusionTrackerTestReplicaWithMask(bool opaque_layers) 1746 : OcclusionTrackerTest<Types>(opaque_layers) {} 1747 void RunMyTest() { 1748 typename Types::ContentLayerType* parent = this->CreateRoot( 1749 this->identity_matrix, gfx::PointF(), gfx::Size(100, 200)); 1750 typename Types::LayerType* surface = 1751 this->CreateDrawingSurface(parent, 1752 this->identity_matrix, 1753 gfx::PointF(0.f, 100.f), 1754 gfx::Size(50, 50), 1755 true); 1756 typename Types::LayerType* replica = this->CreateReplicaLayer( 1757 surface, this->identity_matrix, gfx::PointF(50.f, 50.f), gfx::Size()); 1758 this->CreateMaskLayer(replica, gfx::Size(10, 10)); 1759 this->CalcDrawEtc(parent); 1760 1761 TestOcclusionTrackerWithClip<typename Types::LayerType, 1762 typename Types::RenderSurfaceType> occlusion( 1763 gfx::Rect(0, 0, 1000, 1000)); 1764 1765 this->VisitLayer(surface, &occlusion); 1766 1767 EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(), 1768 occlusion.occlusion_from_inside_target().ToString()); 1769 1770 this->VisitContributingSurface(surface, &occlusion); 1771 this->EnterLayer(parent, &occlusion); 1772 1773 // The replica should not be occluding the parent, since it has a mask 1774 // applied to it. 1775 EXPECT_EQ(gfx::Rect(0, 100, 50, 50).ToString(), 1776 occlusion.occlusion_from_inside_target().ToString()); 1777 } 1778 }; 1779 1780 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaWithMask); 1781 1782 template <class Types> 1783 class OcclusionTrackerTestOpaqueContentsRegionEmpty 1784 : public OcclusionTrackerTest<Types> { 1785 protected: 1786 explicit OcclusionTrackerTestOpaqueContentsRegionEmpty(bool opaque_layers) 1787 : OcclusionTrackerTest<Types>(opaque_layers) {} 1788 void RunMyTest() { 1789 typename Types::ContentLayerType* parent = this->CreateRoot( 1790 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300)); 1791 typename Types::ContentLayerType* layer = 1792 this->CreateDrawingSurface(parent, 1793 this->identity_matrix, 1794 gfx::PointF(), 1795 gfx::Size(200, 200), 1796 false); 1797 this->CalcDrawEtc(parent); 1798 1799 TestOcclusionTrackerWithClip<typename Types::LayerType, 1800 typename Types::RenderSurfaceType> occlusion( 1801 gfx::Rect(0, 0, 1000, 1000)); 1802 this->EnterLayer(layer, &occlusion); 1803 1804 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100))); 1805 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100))); 1806 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100))); 1807 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100))); 1808 1809 this->LeaveLayer(layer, &occlusion); 1810 this->VisitContributingSurface(layer, &occlusion); 1811 this->EnterLayer(parent, &occlusion); 1812 1813 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty()); 1814 } 1815 }; 1816 1817 MAIN_AND_IMPL_THREAD_TEST(OcclusionTrackerTestOpaqueContentsRegionEmpty); 1818 1819 template <class Types> 1820 class OcclusionTrackerTestOpaqueContentsRegionNonEmpty 1821 : public OcclusionTrackerTest<Types> { 1822 protected: 1823 explicit OcclusionTrackerTestOpaqueContentsRegionNonEmpty(bool opaque_layers) 1824 : OcclusionTrackerTest<Types>(opaque_layers) {} 1825 void RunMyTest() { 1826 typename Types::ContentLayerType* parent = this->CreateRoot( 1827 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300)); 1828 typename Types::ContentLayerType* layer = 1829 this->CreateDrawingLayer(parent, 1830 this->identity_matrix, 1831 gfx::PointF(100.f, 100.f), 1832 gfx::Size(200, 200), 1833 false); 1834 this->CalcDrawEtc(parent); 1835 { 1836 TestOcclusionTrackerWithClip<typename Types::LayerType, 1837 typename Types::RenderSurfaceType> occlusion( 1838 gfx::Rect(0, 0, 1000, 1000)); 1839 layer->SetOpaqueContentsRect(gfx::Rect(0, 0, 100, 100)); 1840 1841 this->ResetLayerIterator(); 1842 this->VisitLayer(layer, &occlusion); 1843 this->EnterLayer(parent, &occlusion); 1844 1845 EXPECT_EQ(gfx::Rect(100, 100, 100, 100).ToString(), 1846 occlusion.occlusion_from_inside_target().ToString()); 1847 1848 EXPECT_FALSE( 1849 occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100))); 1850 EXPECT_TRUE( 1851 occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100))); 1852 EXPECT_FALSE( 1853 occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100))); 1854 } 1855 { 1856 TestOcclusionTrackerWithClip<typename Types::LayerType, 1857 typename Types::RenderSurfaceType> occlusion( 1858 gfx::Rect(0, 0, 1000, 1000)); 1859 layer->SetOpaqueContentsRect(gfx::Rect(20, 20, 180, 180)); 1860 1861 this->ResetLayerIterator(); 1862 this->VisitLayer(layer, &occlusion); 1863 this->EnterLayer(parent, &occlusion); 1864 1865 EXPECT_EQ(gfx::Rect(120, 120, 180, 180).ToString(), 1866 occlusion.occlusion_from_inside_target().ToString()); 1867 1868 EXPECT_FALSE( 1869 occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100))); 1870 EXPECT_FALSE( 1871 occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100))); 1872 EXPECT_TRUE( 1873 occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100))); 1874 } 1875 { 1876 TestOcclusionTrackerWithClip<typename Types::LayerType, 1877 typename Types::RenderSurfaceType> occlusion( 1878 gfx::Rect(0, 0, 1000, 1000)); 1879 layer->SetOpaqueContentsRect(gfx::Rect(150, 150, 100, 100)); 1880 1881 this->ResetLayerIterator(); 1882 this->VisitLayer(layer, &occlusion); 1883 this->EnterLayer(parent, &occlusion); 1884 1885 EXPECT_EQ(gfx::Rect(250, 250, 50, 50).ToString(), 1886 occlusion.occlusion_from_inside_target().ToString()); 1887 1888 EXPECT_FALSE( 1889 occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100))); 1890 EXPECT_FALSE( 1891 occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100))); 1892 EXPECT_FALSE( 1893 occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100))); 1894 } 1895 } 1896 }; 1897 1898 MAIN_AND_IMPL_THREAD_TEST(OcclusionTrackerTestOpaqueContentsRegionNonEmpty); 1899 1900 template <class Types> 1901 class OcclusionTrackerTest3dTransform : public OcclusionTrackerTest<Types> { 1902 protected: 1903 explicit OcclusionTrackerTest3dTransform(bool opaque_layers) 1904 : OcclusionTrackerTest<Types>(opaque_layers) {} 1905 void RunMyTest() { 1906 gfx::Transform transform; 1907 transform.RotateAboutYAxis(30.0); 1908 1909 typename Types::ContentLayerType* parent = this->CreateRoot( 1910 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300)); 1911 typename Types::LayerType* container = this->CreateLayer( 1912 parent, this->identity_matrix, gfx::PointF(), gfx::Size(300, 300)); 1913 typename Types::ContentLayerType* layer = 1914 this->CreateDrawingLayer(container, 1915 transform, 1916 gfx::PointF(100.f, 100.f), 1917 gfx::Size(200, 200), 1918 true); 1919 this->CalcDrawEtc(parent); 1920 1921 TestOcclusionTrackerWithClip<typename Types::LayerType, 1922 typename Types::RenderSurfaceType> occlusion( 1923 gfx::Rect(0, 0, 1000, 1000)); 1924 this->EnterLayer(layer, &occlusion); 1925 1926 // The layer is rotated in 3d but without preserving 3d, so it only gets 1927 // resized. 1928 EXPECT_RECT_EQ( 1929 gfx::Rect(0, 0, 200, 200), 1930 occlusion.UnoccludedLayerContentRect(layer, gfx::Rect(0, 0, 200, 200))); 1931 } 1932 }; 1933 1934 MAIN_AND_IMPL_THREAD_TEST(OcclusionTrackerTest3dTransform); 1935 1936 template <class Types> 1937 class OcclusionTrackerTestUnsorted3dLayers 1938 : public OcclusionTrackerTest<Types> { 1939 protected: 1940 explicit OcclusionTrackerTestUnsorted3dLayers(bool opaque_layers) 1941 : OcclusionTrackerTest<Types>(opaque_layers) {} 1942 void RunMyTest() { 1943 // Currently, The main thread layer iterator does not iterate over 3d items 1944 // in sorted order, because layer sorting is not performed on the main 1945 // thread. Because of this, the occlusion tracker cannot assume that a 3d 1946 // layer occludes other layers that have not yet been iterated over. For 1947 // now, the expected behavior is that a 3d layer simply does not add any 1948 // occlusion to the occlusion tracker. 1949 1950 gfx::Transform translation_to_front; 1951 translation_to_front.Translate3d(0.0, 0.0, -10.0); 1952 gfx::Transform translation_to_back; 1953 translation_to_front.Translate3d(0.0, 0.0, -100.0); 1954 1955 typename Types::ContentLayerType* parent = this->CreateRoot( 1956 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300)); 1957 typename Types::ContentLayerType* child1 = this->CreateDrawingLayer( 1958 parent, translation_to_back, gfx::PointF(), gfx::Size(100, 100), true); 1959 typename Types::ContentLayerType* child2 = 1960 this->CreateDrawingLayer(parent, 1961 translation_to_front, 1962 gfx::PointF(50.f, 50.f), 1963 gfx::Size(100, 100), 1964 true); 1965 parent->SetPreserves3d(true); 1966 1967 this->CalcDrawEtc(parent); 1968 1969 TestOcclusionTrackerWithClip<typename Types::LayerType, 1970 typename Types::RenderSurfaceType> occlusion( 1971 gfx::Rect(0, 0, 1000, 1000)); 1972 this->VisitLayer(child2, &occlusion); 1973 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty()); 1974 EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty()); 1975 1976 this->VisitLayer(child1, &occlusion); 1977 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty()); 1978 EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty()); 1979 } 1980 }; 1981 1982 // This test will have different layer ordering on the impl thread; the test 1983 // will only work on the main thread. 1984 MAIN_THREAD_TEST(OcclusionTrackerTestUnsorted3dLayers); 1985 1986 template <class Types> 1987 class OcclusionTrackerTestPerspectiveTransform 1988 : public OcclusionTrackerTest<Types> { 1989 protected: 1990 explicit OcclusionTrackerTestPerspectiveTransform(bool opaque_layers) 1991 : OcclusionTrackerTest<Types>(opaque_layers) {} 1992 void RunMyTest() { 1993 gfx::Transform transform; 1994 transform.Translate(150.0, 150.0); 1995 transform.ApplyPerspectiveDepth(400.0); 1996 transform.RotateAboutXAxis(-30.0); 1997 transform.Translate(-150.0, -150.0); 1998 1999 typename Types::ContentLayerType* parent = this->CreateRoot( 2000 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300)); 2001 typename Types::LayerType* container = this->CreateLayer( 2002 parent, this->identity_matrix, gfx::PointF(), gfx::Size(300, 300)); 2003 typename Types::ContentLayerType* layer = 2004 this->CreateDrawingLayer(container, 2005 transform, 2006 gfx::PointF(100.f, 100.f), 2007 gfx::Size(200, 200), 2008 true); 2009 container->SetPreserves3d(true); 2010 layer->SetPreserves3d(true); 2011 this->CalcDrawEtc(parent); 2012 2013 TestOcclusionTrackerWithClip<typename Types::LayerType, 2014 typename Types::RenderSurfaceType> occlusion( 2015 gfx::Rect(0, 0, 1000, 1000)); 2016 this->EnterLayer(layer, &occlusion); 2017 2018 EXPECT_RECT_EQ( 2019 gfx::Rect(0, 0, 200, 200), 2020 occlusion.UnoccludedLayerContentRect(layer, gfx::Rect(0, 0, 200, 200))); 2021 } 2022 }; 2023 2024 // This test requires accumulating occlusion of 3d layers, which are skipped by 2025 // the occlusion tracker on the main thread. So this test should run on the impl 2026 // thread. 2027 IMPL_THREAD_TEST(OcclusionTrackerTestPerspectiveTransform); 2028 2029 template <class Types> 2030 class OcclusionTrackerTestPerspectiveTransformBehindCamera 2031 : public OcclusionTrackerTest<Types> { 2032 protected: 2033 explicit OcclusionTrackerTestPerspectiveTransformBehindCamera( 2034 bool opaque_layers) 2035 : OcclusionTrackerTest<Types>(opaque_layers) {} 2036 void RunMyTest() { 2037 // This test is based on the platform/chromium/compositing/3d-corners.html 2038 // layout test. 2039 gfx::Transform transform; 2040 transform.Translate(250.0, 50.0); 2041 transform.ApplyPerspectiveDepth(10.0); 2042 transform.Translate(-250.0, -50.0); 2043 transform.Translate(250.0, 50.0); 2044 transform.RotateAboutXAxis(-167.0); 2045 transform.Translate(-250.0, -50.0); 2046 2047 typename Types::ContentLayerType* parent = this->CreateRoot( 2048 this->identity_matrix, gfx::PointF(), gfx::Size(500, 100)); 2049 typename Types::LayerType* container = this->CreateLayer( 2050 parent, this->identity_matrix, gfx::PointF(), gfx::Size(500, 500)); 2051 typename Types::ContentLayerType* layer = this->CreateDrawingLayer( 2052 container, transform, gfx::PointF(), gfx::Size(500, 500), true); 2053 container->SetPreserves3d(true); 2054 layer->SetPreserves3d(true); 2055 this->CalcDrawEtc(parent); 2056 2057 TestOcclusionTrackerWithClip<typename Types::LayerType, 2058 typename Types::RenderSurfaceType> occlusion( 2059 gfx::Rect(0, 0, 1000, 1000)); 2060 this->EnterLayer(layer, &occlusion); 2061 2062 // The bottom 11 pixel rows of this layer remain visible inside the 2063 // container, after translation to the target surface. When translated back, 2064 // this will include many more pixels but must include at least the bottom 2065 // 11 rows. 2066 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect( 2067 layer, gfx::Rect(0, 26, 500, 474)). 2068 Contains(gfx::Rect(0, 489, 500, 11))); 2069 } 2070 }; 2071 2072 // This test requires accumulating occlusion of 3d layers, which are skipped by 2073 // the occlusion tracker on the main thread. So this test should run on the impl 2074 // thread. 2075 IMPL_THREAD_TEST(OcclusionTrackerTestPerspectiveTransformBehindCamera); 2076 2077 template <class Types> 2078 class OcclusionTrackerTestLayerBehindCameraDoesNotOcclude 2079 : public OcclusionTrackerTest<Types> { 2080 protected: 2081 explicit OcclusionTrackerTestLayerBehindCameraDoesNotOcclude( 2082 bool opaque_layers) 2083 : OcclusionTrackerTest<Types>(opaque_layers) {} 2084 void RunMyTest() { 2085 gfx::Transform transform; 2086 transform.Translate(50.0, 50.0); 2087 transform.ApplyPerspectiveDepth(100.0); 2088 transform.Translate3d(0.0, 0.0, 110.0); 2089 transform.Translate(-50.0, -50.0); 2090 2091 typename Types::ContentLayerType* parent = this->CreateRoot( 2092 this->identity_matrix, gfx::PointF(), gfx::Size(100, 100)); 2093 typename Types::ContentLayerType* layer = this->CreateDrawingLayer( 2094 parent, transform, gfx::PointF(), gfx::Size(100, 100), true); 2095 parent->SetPreserves3d(true); 2096 layer->SetPreserves3d(true); 2097 this->CalcDrawEtc(parent); 2098 2099 TestOcclusionTrackerWithClip<typename Types::LayerType, 2100 typename Types::RenderSurfaceType> occlusion( 2101 gfx::Rect(0, 0, 1000, 1000)); 2102 2103 // The |layer| is entirely behind the camera and should not occlude. 2104 this->VisitLayer(layer, &occlusion); 2105 this->EnterLayer(parent, &occlusion); 2106 EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty()); 2107 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty()); 2108 } 2109 }; 2110 2111 // This test requires accumulating occlusion of 3d layers, which are skipped by 2112 // the occlusion tracker on the main thread. So this test should run on the impl 2113 // thread. 2114 IMPL_THREAD_TEST(OcclusionTrackerTestLayerBehindCameraDoesNotOcclude); 2115 2116 template <class Types> 2117 class OcclusionTrackerTestLargePixelsOccludeInsideClipRect 2118 : public OcclusionTrackerTest<Types> { 2119 protected: 2120 explicit OcclusionTrackerTestLargePixelsOccludeInsideClipRect( 2121 bool opaque_layers) 2122 : OcclusionTrackerTest<Types>(opaque_layers) {} 2123 void RunMyTest() { 2124 gfx::Transform transform; 2125 transform.Translate(50.0, 50.0); 2126 transform.ApplyPerspectiveDepth(100.0); 2127 transform.Translate3d(0.0, 0.0, 99.0); 2128 transform.Translate(-50.0, -50.0); 2129 2130 typename Types::ContentLayerType* parent = this->CreateRoot( 2131 this->identity_matrix, gfx::PointF(), gfx::Size(100, 100)); 2132 parent->SetMasksToBounds(true); 2133 typename Types::ContentLayerType* layer = this->CreateDrawingLayer( 2134 parent, transform, gfx::PointF(), gfx::Size(100, 100), true); 2135 parent->SetPreserves3d(true); 2136 layer->SetPreserves3d(true); 2137 this->CalcDrawEtc(parent); 2138 2139 TestOcclusionTrackerWithClip<typename Types::LayerType, 2140 typename Types::RenderSurfaceType> occlusion( 2141 gfx::Rect(0, 0, 1000, 1000)); 2142 2143 // This is very close to the camera, so pixels in its visible_content_rect() 2144 // will actually go outside of the layer's clip rect. Ensure that those 2145 // pixels don't occlude things outside the clip rect. 2146 this->VisitLayer(layer, &occlusion); 2147 this->EnterLayer(parent, &occlusion); 2148 EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), 2149 occlusion.occlusion_from_inside_target().ToString()); 2150 EXPECT_EQ(gfx::Rect().ToString(), 2151 occlusion.occlusion_from_outside_target().ToString()); 2152 } 2153 }; 2154 2155 // This test requires accumulating occlusion of 3d layers, which are skipped by 2156 // the occlusion tracker on the main thread. So this test should run on the impl 2157 // thread. 2158 IMPL_THREAD_TEST(OcclusionTrackerTestLargePixelsOccludeInsideClipRect); 2159 2160 template <class Types> 2161 class OcclusionTrackerTestAnimationOpacity1OnMainThread 2162 : public OcclusionTrackerTest<Types> { 2163 protected: 2164 explicit OcclusionTrackerTestAnimationOpacity1OnMainThread(bool opaque_layers) 2165 : OcclusionTrackerTest<Types>(opaque_layers) {} 2166 void RunMyTest() { 2167 // parent 2168 // +--layer 2169 // +--surface 2170 // | +--surface_child 2171 // | +--surface_child2 2172 // +--parent2 2173 // +--topmost 2174 2175 typename Types::ContentLayerType* parent = this->CreateRoot( 2176 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300)); 2177 typename Types::ContentLayerType* layer = 2178 this->CreateDrawingLayer(parent, 2179 this->identity_matrix, 2180 gfx::PointF(), 2181 gfx::Size(300, 300), 2182 true); 2183 typename Types::ContentLayerType* surface = 2184 this->CreateDrawingSurface(parent, 2185 this->identity_matrix, 2186 gfx::PointF(), 2187 gfx::Size(300, 300), 2188 true); 2189 typename Types::ContentLayerType* surface_child = 2190 this->CreateDrawingLayer(surface, 2191 this->identity_matrix, 2192 gfx::PointF(), 2193 gfx::Size(200, 300), 2194 true); 2195 typename Types::ContentLayerType* surface_child2 = 2196 this->CreateDrawingLayer(surface, 2197 this->identity_matrix, 2198 gfx::PointF(), 2199 gfx::Size(100, 300), 2200 true); 2201 typename Types::ContentLayerType* parent2 = 2202 this->CreateDrawingLayer(parent, 2203 this->identity_matrix, 2204 gfx::PointF(), 2205 gfx::Size(300, 300), 2206 false); 2207 typename Types::ContentLayerType* topmost = 2208 this->CreateDrawingLayer(parent, 2209 this->identity_matrix, 2210 gfx::PointF(250.f, 0.f), 2211 gfx::Size(50, 300), 2212 true); 2213 2214 AddOpacityTransitionToController( 2215 layer->layer_animation_controller(), 10.0, 0.f, 1.f, false); 2216 AddOpacityTransitionToController( 2217 surface->layer_animation_controller(), 10.0, 0.f, 1.f, false); 2218 this->CalcDrawEtc(parent); 2219 2220 EXPECT_TRUE(layer->draw_opacity_is_animating()); 2221 EXPECT_FALSE(surface->draw_opacity_is_animating()); 2222 EXPECT_TRUE(surface->render_surface()->draw_opacity_is_animating()); 2223 2224 TestOcclusionTrackerWithClip<typename Types::LayerType, 2225 typename Types::RenderSurfaceType> occlusion( 2226 gfx::Rect(0, 0, 1000, 1000)); 2227 2228 this->VisitLayer(topmost, &occlusion); 2229 this->EnterLayer(parent2, &occlusion); 2230 // This occlusion will affect all surfaces. 2231 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(), 2232 occlusion.occlusion_from_inside_target().ToString()); 2233 EXPECT_EQ(gfx::Rect().ToString(), 2234 occlusion.occlusion_from_outside_target().ToString()); 2235 EXPECT_EQ(gfx::Rect(0, 0, 250, 300).ToString(), 2236 occlusion.UnoccludedLayerContentRect( 2237 parent2, gfx::Rect(0, 0, 300, 300)).ToString()); 2238 this->LeaveLayer(parent2, &occlusion); 2239 2240 this->VisitLayer(surface_child2, &occlusion); 2241 this->EnterLayer(surface_child, &occlusion); 2242 EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(), 2243 occlusion.occlusion_from_inside_target().ToString()); 2244 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(), 2245 occlusion.occlusion_from_outside_target().ToString()); 2246 EXPECT_RECT_EQ(gfx::Rect(100, 0, 100, 300), 2247 occlusion.UnoccludedLayerContentRect( 2248 surface_child, gfx::Rect(0, 0, 200, 300))); 2249 this->LeaveLayer(surface_child, &occlusion); 2250 this->EnterLayer(surface, &occlusion); 2251 EXPECT_EQ(gfx::Rect(0, 0, 200, 300).ToString(), 2252 occlusion.occlusion_from_inside_target().ToString()); 2253 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(), 2254 occlusion.occlusion_from_outside_target().ToString()); 2255 EXPECT_RECT_EQ(gfx::Rect(200, 0, 50, 300), 2256 occlusion.UnoccludedLayerContentRect( 2257 surface, gfx::Rect(0, 0, 300, 300))); 2258 this->LeaveLayer(surface, &occlusion); 2259 2260 this->EnterContributingSurface(surface, &occlusion); 2261 // Occlusion within the surface is lost when leaving the animating surface. 2262 EXPECT_EQ(gfx::Rect().ToString(), 2263 occlusion.occlusion_from_inside_target().ToString()); 2264 EXPECT_EQ(gfx::Rect().ToString(), 2265 occlusion.occlusion_from_outside_target().ToString()); 2266 EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300), 2267 occlusion.UnoccludedContributingSurfaceContentRect( 2268 surface, false, gfx::Rect(0, 0, 300, 300))); 2269 this->LeaveContributingSurface(surface, &occlusion); 2270 2271 // Occlusion from outside the animating surface still exists. 2272 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(), 2273 occlusion.occlusion_from_inside_target().ToString()); 2274 EXPECT_EQ(gfx::Rect().ToString(), 2275 occlusion.occlusion_from_outside_target().ToString()); 2276 2277 this->VisitLayer(layer, &occlusion); 2278 this->EnterLayer(parent, &occlusion); 2279 2280 // Occlusion is not added for the animating |layer|. 2281 EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300), 2282 occlusion.UnoccludedLayerContentRect( 2283 parent, gfx::Rect(0, 0, 300, 300))); 2284 } 2285 }; 2286 2287 MAIN_THREAD_TEST(OcclusionTrackerTestAnimationOpacity1OnMainThread); 2288 2289 template <class Types> 2290 class OcclusionTrackerTestAnimationOpacity0OnMainThread 2291 : public OcclusionTrackerTest<Types> { 2292 protected: 2293 explicit OcclusionTrackerTestAnimationOpacity0OnMainThread(bool opaque_layers) 2294 : OcclusionTrackerTest<Types>(opaque_layers) {} 2295 void RunMyTest() { 2296 typename Types::ContentLayerType* parent = this->CreateRoot( 2297 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300)); 2298 typename Types::ContentLayerType* layer = 2299 this->CreateDrawingLayer(parent, 2300 this->identity_matrix, 2301 gfx::PointF(), 2302 gfx::Size(300, 300), 2303 true); 2304 typename Types::ContentLayerType* surface = 2305 this->CreateDrawingSurface(parent, 2306 this->identity_matrix, 2307 gfx::PointF(), 2308 gfx::Size(300, 300), 2309 true); 2310 typename Types::ContentLayerType* surface_child = 2311 this->CreateDrawingLayer(surface, 2312 this->identity_matrix, 2313 gfx::PointF(), 2314 gfx::Size(200, 300), 2315 true); 2316 typename Types::ContentLayerType* surface_child2 = 2317 this->CreateDrawingLayer(surface, 2318 this->identity_matrix, 2319 gfx::PointF(), 2320 gfx::Size(100, 300), 2321 true); 2322 typename Types::ContentLayerType* parent2 = 2323 this->CreateDrawingLayer(parent, 2324 this->identity_matrix, 2325 gfx::PointF(), 2326 gfx::Size(300, 300), 2327 false); 2328 typename Types::ContentLayerType* topmost = 2329 this->CreateDrawingLayer(parent, 2330 this->identity_matrix, 2331 gfx::PointF(250.f, 0.f), 2332 gfx::Size(50, 300), 2333 true); 2334 2335 AddOpacityTransitionToController( 2336 layer->layer_animation_controller(), 10.0, 1.f, 0.f, false); 2337 AddOpacityTransitionToController( 2338 surface->layer_animation_controller(), 10.0, 1.f, 0.f, false); 2339 this->CalcDrawEtc(parent); 2340 2341 EXPECT_TRUE(layer->draw_opacity_is_animating()); 2342 EXPECT_FALSE(surface->draw_opacity_is_animating()); 2343 EXPECT_TRUE(surface->render_surface()->draw_opacity_is_animating()); 2344 2345 TestOcclusionTrackerWithClip<typename Types::LayerType, 2346 typename Types::RenderSurfaceType> occlusion( 2347 gfx::Rect(0, 0, 1000, 1000)); 2348 2349 this->VisitLayer(topmost, &occlusion); 2350 this->EnterLayer(parent2, &occlusion); 2351 // This occlusion will affect all surfaces. 2352 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(), 2353 occlusion.occlusion_from_inside_target().ToString()); 2354 EXPECT_EQ(gfx::Rect().ToString(), 2355 occlusion.occlusion_from_outside_target().ToString()); 2356 EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300), 2357 occlusion.UnoccludedLayerContentRect( 2358 parent, gfx::Rect(0, 0, 300, 300))); 2359 this->LeaveLayer(parent2, &occlusion); 2360 2361 this->VisitLayer(surface_child2, &occlusion); 2362 this->EnterLayer(surface_child, &occlusion); 2363 EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(), 2364 occlusion.occlusion_from_inside_target().ToString()); 2365 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(), 2366 occlusion.occlusion_from_outside_target().ToString()); 2367 EXPECT_RECT_EQ(gfx::Rect(100, 0, 100, 300), 2368 occlusion.UnoccludedLayerContentRect( 2369 surface_child, gfx::Rect(0, 0, 200, 300))); 2370 this->LeaveLayer(surface_child, &occlusion); 2371 this->EnterLayer(surface, &occlusion); 2372 EXPECT_EQ(gfx::Rect(0, 0, 200, 300).ToString(), 2373 occlusion.occlusion_from_inside_target().ToString()); 2374 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(), 2375 occlusion.occlusion_from_outside_target().ToString()); 2376 EXPECT_RECT_EQ(gfx::Rect(200, 0, 50, 300), 2377 occlusion.UnoccludedLayerContentRect( 2378 surface, gfx::Rect(0, 0, 300, 300))); 2379 this->LeaveLayer(surface, &occlusion); 2380 2381 this->EnterContributingSurface(surface, &occlusion); 2382 // Occlusion within the surface is lost when leaving the animating surface. 2383 EXPECT_EQ(gfx::Rect().ToString(), 2384 occlusion.occlusion_from_inside_target().ToString()); 2385 EXPECT_EQ(gfx::Rect().ToString(), 2386 occlusion.occlusion_from_outside_target().ToString()); 2387 EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300), 2388 occlusion.UnoccludedContributingSurfaceContentRect( 2389 surface, false, gfx::Rect(0, 0, 300, 300))); 2390 this->LeaveContributingSurface(surface, &occlusion); 2391 2392 // Occlusion from outside the animating surface still exists. 2393 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(), 2394 occlusion.occlusion_from_inside_target().ToString()); 2395 EXPECT_EQ(gfx::Rect().ToString(), 2396 occlusion.occlusion_from_outside_target().ToString()); 2397 2398 this->VisitLayer(layer, &occlusion); 2399 this->EnterLayer(parent, &occlusion); 2400 2401 // Occlusion is not added for the animating |layer|. 2402 EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300), 2403 occlusion.UnoccludedLayerContentRect( 2404 parent, gfx::Rect(0, 0, 300, 300))); 2405 } 2406 }; 2407 2408 MAIN_THREAD_TEST(OcclusionTrackerTestAnimationOpacity0OnMainThread); 2409 2410 template <class Types> 2411 class OcclusionTrackerTestAnimationTranslateOnMainThread 2412 : public OcclusionTrackerTest<Types> { 2413 protected: 2414 explicit OcclusionTrackerTestAnimationTranslateOnMainThread( 2415 bool opaque_layers) 2416 : OcclusionTrackerTest<Types>(opaque_layers) {} 2417 void RunMyTest() { 2418 typename Types::ContentLayerType* parent = this->CreateRoot( 2419 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300)); 2420 typename Types::ContentLayerType* layer = 2421 this->CreateDrawingLayer(parent, 2422 this->identity_matrix, 2423 gfx::PointF(), 2424 gfx::Size(300, 300), 2425 true); 2426 typename Types::ContentLayerType* surface = 2427 this->CreateDrawingSurface(parent, 2428 this->identity_matrix, 2429 gfx::PointF(), 2430 gfx::Size(300, 300), 2431 true); 2432 typename Types::ContentLayerType* surface_child = 2433 this->CreateDrawingLayer(surface, 2434 this->identity_matrix, 2435 gfx::PointF(), 2436 gfx::Size(200, 300), 2437 true); 2438 typename Types::ContentLayerType* surface_child2 = 2439 this->CreateDrawingLayer(surface, 2440 this->identity_matrix, 2441 gfx::PointF(), 2442 gfx::Size(100, 300), 2443 true); 2444 typename Types::ContentLayerType* surface2 = this->CreateDrawingSurface( 2445 parent, this->identity_matrix, gfx::PointF(), gfx::Size(50, 300), true); 2446 2447 AddAnimatedTransformToController( 2448 layer->layer_animation_controller(), 10.0, 30, 0); 2449 AddAnimatedTransformToController( 2450 surface->layer_animation_controller(), 10.0, 30, 0); 2451 AddAnimatedTransformToController( 2452 surface_child->layer_animation_controller(), 10.0, 30, 0); 2453 this->CalcDrawEtc(parent); 2454 2455 EXPECT_TRUE(layer->draw_transform_is_animating()); 2456 EXPECT_TRUE(layer->screen_space_transform_is_animating()); 2457 EXPECT_TRUE( 2458 surface->render_surface()->target_surface_transforms_are_animating()); 2459 EXPECT_TRUE( 2460 surface->render_surface()->screen_space_transforms_are_animating()); 2461 // The surface owning layer doesn't animate against its own surface. 2462 EXPECT_FALSE(surface->draw_transform_is_animating()); 2463 EXPECT_TRUE(surface->screen_space_transform_is_animating()); 2464 EXPECT_TRUE(surface_child->draw_transform_is_animating()); 2465 EXPECT_TRUE(surface_child->screen_space_transform_is_animating()); 2466 2467 TestOcclusionTrackerWithClip<typename Types::LayerType, 2468 typename Types::RenderSurfaceType> occlusion( 2469 gfx::Rect(0, 0, 1000, 1000)); 2470 2471 this->VisitLayer(surface2, &occlusion); 2472 this->EnterContributingSurface(surface2, &occlusion); 2473 2474 EXPECT_EQ(gfx::Rect(0, 0, 50, 300).ToString(), 2475 occlusion.occlusion_from_inside_target().ToString()); 2476 2477 this->LeaveContributingSurface(surface2, &occlusion); 2478 this->EnterLayer(surface_child2, &occlusion); 2479 2480 // surface_child2 is moving in screen space but not relative to its target, 2481 // so occlusion should happen in its target space only. It also means that 2482 // things occluding from outside the target (e.g. surface2) cannot occlude 2483 // this layer. 2484 EXPECT_EQ(gfx::Rect().ToString(), 2485 occlusion.occlusion_from_outside_target().ToString()); 2486 2487 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 300), 2488 occlusion.UnoccludedLayerContentRect( 2489 surface_child2, gfx::Rect(0, 0, 100, 300))); 2490 EXPECT_FALSE( 2491 occlusion.OccludedLayer(surface_child, gfx::Rect(0, 0, 50, 300))); 2492 2493 this->LeaveLayer(surface_child2, &occlusion); 2494 this->EnterLayer(surface_child, &occlusion); 2495 EXPECT_FALSE( 2496 occlusion.OccludedLayer(surface_child, gfx::Rect(0, 0, 100, 300))); 2497 EXPECT_EQ(gfx::Rect().ToString(), 2498 occlusion.occlusion_from_outside_target().ToString()); 2499 EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(), 2500 occlusion.occlusion_from_inside_target().ToString()); 2501 EXPECT_RECT_EQ(gfx::Rect(100, 0, 200, 300), 2502 occlusion.UnoccludedLayerContentRect( 2503 surface, gfx::Rect(0, 0, 300, 300))); 2504 2505 // The surface_child is occluded by the surface_child2, but is moving 2506 // relative its target, so it can't be occluded. 2507 EXPECT_RECT_EQ(gfx::Rect(0, 0, 200, 300), 2508 occlusion.UnoccludedLayerContentRect( 2509 surface_child, gfx::Rect(0, 0, 200, 300))); 2510 EXPECT_FALSE( 2511 occlusion.OccludedLayer(surface_child, gfx::Rect(0, 0, 50, 300))); 2512 2513 this->LeaveLayer(surface_child, &occlusion); 2514 this->EnterLayer(surface, &occlusion); 2515 // The surface_child is moving in screen space but not relative to its 2516 // target, so occlusion should happen from within the target only. 2517 EXPECT_EQ(gfx::Rect().ToString(), 2518 occlusion.occlusion_from_outside_target().ToString()); 2519 EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(), 2520 occlusion.occlusion_from_inside_target().ToString()); 2521 EXPECT_RECT_EQ(gfx::Rect(100, 0, 200, 300), 2522 occlusion.UnoccludedLayerContentRect( 2523 surface, gfx::Rect(0, 0, 300, 300))); 2524 2525 this->LeaveLayer(surface, &occlusion); 2526 // The surface's owning layer is moving in screen space but not relative to 2527 // its target, so occlusion should happen within the target only. 2528 EXPECT_EQ(gfx::Rect().ToString(), 2529 occlusion.occlusion_from_outside_target().ToString()); 2530 EXPECT_EQ(gfx::Rect(0, 0, 300, 300).ToString(), 2531 occlusion.occlusion_from_inside_target().ToString()); 2532 EXPECT_RECT_EQ(gfx::Rect(0, 0, 0, 0), 2533 occlusion.UnoccludedLayerContentRect( 2534 surface, gfx::Rect(0, 0, 300, 300))); 2535 2536 this->EnterContributingSurface(surface, &occlusion); 2537 // The contributing |surface| is animating so it can't be occluded. 2538 EXPECT_RECT_EQ(gfx::Rect(0, 0, 300, 300), 2539 occlusion.UnoccludedContributingSurfaceContentRect( 2540 surface, false, gfx::Rect(0, 0, 300, 300))); 2541 this->LeaveContributingSurface(surface, &occlusion); 2542 2543 this->EnterLayer(layer, &occlusion); 2544 // The |surface| is moving in the screen and in its target, so all occlusion 2545 // within the surface is lost when leaving it. 2546 EXPECT_RECT_EQ(gfx::Rect(50, 0, 250, 300), 2547 occlusion.UnoccludedLayerContentRect( 2548 parent, gfx::Rect(0, 0, 300, 300))); 2549 this->LeaveLayer(layer, &occlusion); 2550 2551 this->EnterLayer(parent, &occlusion); 2552 // The |layer| is animating in the screen and in its target, so no occlusion 2553 // is added. 2554 EXPECT_RECT_EQ(gfx::Rect(50, 0, 250, 300), 2555 occlusion.UnoccludedLayerContentRect( 2556 parent, gfx::Rect(0, 0, 300, 300))); 2557 } 2558 }; 2559 2560 MAIN_THREAD_TEST(OcclusionTrackerTestAnimationTranslateOnMainThread); 2561 2562 template <class Types> 2563 class OcclusionTrackerTestSurfaceOcclusionTranslatesToParent 2564 : public OcclusionTrackerTest<Types> { 2565 protected: 2566 explicit OcclusionTrackerTestSurfaceOcclusionTranslatesToParent( 2567 bool opaque_layers) 2568 : OcclusionTrackerTest<Types>(opaque_layers) {} 2569 void RunMyTest() { 2570 gfx::Transform surface_transform; 2571 surface_transform.Translate(300.0, 300.0); 2572 surface_transform.Scale(2.0, 2.0); 2573 surface_transform.Translate(-150.0, -150.0); 2574 2575 typename Types::ContentLayerType* parent = this->CreateRoot( 2576 this->identity_matrix, gfx::PointF(), gfx::Size(500, 500)); 2577 typename Types::ContentLayerType* surface = this->CreateDrawingSurface( 2578 parent, surface_transform, gfx::PointF(), gfx::Size(300, 300), false); 2579 typename Types::ContentLayerType* surface2 = 2580 this->CreateDrawingSurface(parent, 2581 this->identity_matrix, 2582 gfx::PointF(50.f, 50.f), 2583 gfx::Size(300, 300), 2584 false); 2585 surface->SetOpaqueContentsRect(gfx::Rect(0, 0, 200, 200)); 2586 surface2->SetOpaqueContentsRect(gfx::Rect(0, 0, 200, 200)); 2587 this->CalcDrawEtc(parent); 2588 2589 TestOcclusionTrackerWithClip<typename Types::LayerType, 2590 typename Types::RenderSurfaceType> occlusion( 2591 gfx::Rect(0, 0, 1000, 1000)); 2592 2593 this->VisitLayer(surface2, &occlusion); 2594 this->VisitContributingSurface(surface2, &occlusion); 2595 2596 EXPECT_EQ(gfx::Rect().ToString(), 2597 occlusion.occlusion_from_outside_target().ToString()); 2598 EXPECT_EQ(gfx::Rect(50, 50, 200, 200).ToString(), 2599 occlusion.occlusion_from_inside_target().ToString()); 2600 2601 // Clear any stored occlusion. 2602 occlusion.set_occlusion_from_outside_target(Region()); 2603 occlusion.set_occlusion_from_inside_target(Region()); 2604 2605 this->VisitLayer(surface, &occlusion); 2606 this->VisitContributingSurface(surface, &occlusion); 2607 2608 EXPECT_EQ(gfx::Rect().ToString(), 2609 occlusion.occlusion_from_outside_target().ToString()); 2610 EXPECT_EQ(gfx::Rect(0, 0, 400, 400).ToString(), 2611 occlusion.occlusion_from_inside_target().ToString()); 2612 } 2613 }; 2614 2615 MAIN_AND_IMPL_THREAD_TEST( 2616 OcclusionTrackerTestSurfaceOcclusionTranslatesToParent); 2617 2618 template <class Types> 2619 class OcclusionTrackerTestSurfaceOcclusionTranslatesWithClipping 2620 : public OcclusionTrackerTest<Types> { 2621 protected: 2622 explicit OcclusionTrackerTestSurfaceOcclusionTranslatesWithClipping( 2623 bool opaque_layers) 2624 : OcclusionTrackerTest<Types>(opaque_layers) {} 2625 void RunMyTest() { 2626 typename Types::ContentLayerType* parent = this->CreateRoot( 2627 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300)); 2628 parent->SetMasksToBounds(true); 2629 typename Types::ContentLayerType* surface = 2630 this->CreateDrawingSurface(parent, 2631 this->identity_matrix, 2632 gfx::PointF(), 2633 gfx::Size(500, 300), 2634 false); 2635 surface->SetOpaqueContentsRect(gfx::Rect(0, 0, 400, 200)); 2636 this->CalcDrawEtc(parent); 2637 2638 TestOcclusionTrackerWithClip<typename Types::LayerType, 2639 typename Types::RenderSurfaceType> occlusion( 2640 gfx::Rect(0, 0, 1000, 1000)); 2641 2642 this->VisitLayer(surface, &occlusion); 2643 this->VisitContributingSurface(surface, &occlusion); 2644 2645 EXPECT_EQ(gfx::Rect().ToString(), 2646 occlusion.occlusion_from_outside_target().ToString()); 2647 EXPECT_EQ(gfx::Rect(0, 0, 300, 200).ToString(), 2648 occlusion.occlusion_from_inside_target().ToString()); 2649 } 2650 }; 2651 2652 MAIN_AND_IMPL_THREAD_TEST( 2653 OcclusionTrackerTestSurfaceOcclusionTranslatesWithClipping); 2654 2655 template <class Types> 2656 class OcclusionTrackerTestReplicaOccluded : public OcclusionTrackerTest<Types> { 2657 protected: 2658 explicit OcclusionTrackerTestReplicaOccluded(bool opaque_layers) 2659 : OcclusionTrackerTest<Types>(opaque_layers) {} 2660 void RunMyTest() { 2661 typename Types::ContentLayerType* parent = this->CreateRoot( 2662 this->identity_matrix, gfx::PointF(), gfx::Size(100, 200)); 2663 typename Types::LayerType* surface = 2664 this->CreateDrawingSurface(parent, 2665 this->identity_matrix, 2666 gfx::PointF(), 2667 gfx::Size(100, 100), 2668 true); 2669 this->CreateReplicaLayer(surface, 2670 this->identity_matrix, 2671 gfx::PointF(0.f, 100.f), 2672 gfx::Size(100, 100)); 2673 typename Types::LayerType* topmost = 2674 this->CreateDrawingLayer(parent, 2675 this->identity_matrix, 2676 gfx::PointF(0.f, 100.f), 2677 gfx::Size(100, 100), 2678 true); 2679 this->CalcDrawEtc(parent); 2680 2681 TestOcclusionTrackerWithClip<typename Types::LayerType, 2682 typename Types::RenderSurfaceType> occlusion( 2683 gfx::Rect(0, 0, 1000, 1000)); 2684 2685 // |topmost| occludes the replica, but not the surface itself. 2686 this->VisitLayer(topmost, &occlusion); 2687 2688 EXPECT_EQ(gfx::Rect().ToString(), 2689 occlusion.occlusion_from_outside_target().ToString()); 2690 EXPECT_EQ(gfx::Rect(0, 100, 100, 100).ToString(), 2691 occlusion.occlusion_from_inside_target().ToString()); 2692 2693 this->VisitLayer(surface, &occlusion); 2694 2695 // Render target with replica ignores occlusion from outside. 2696 EXPECT_EQ(gfx::Rect().ToString(), 2697 occlusion.occlusion_from_outside_target().ToString()); 2698 EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), 2699 occlusion.occlusion_from_inside_target().ToString()); 2700 2701 this->EnterContributingSurface(surface, &occlusion); 2702 2703 // Surface is not occluded so it shouldn't think it is. 2704 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), 2705 occlusion.UnoccludedContributingSurfaceContentRect( 2706 surface, false, gfx::Rect(0, 0, 100, 100))); 2707 } 2708 }; 2709 2710 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaOccluded); 2711 2712 template <class Types> 2713 class OcclusionTrackerTestSurfaceWithReplicaUnoccluded 2714 : public OcclusionTrackerTest<Types> { 2715 protected: 2716 explicit OcclusionTrackerTestSurfaceWithReplicaUnoccluded(bool opaque_layers) 2717 : OcclusionTrackerTest<Types>(opaque_layers) {} 2718 void RunMyTest() { 2719 typename Types::ContentLayerType* parent = this->CreateRoot( 2720 this->identity_matrix, gfx::PointF(), gfx::Size(100, 200)); 2721 typename Types::LayerType* surface = 2722 this->CreateDrawingSurface(parent, 2723 this->identity_matrix, 2724 gfx::PointF(), 2725 gfx::Size(100, 100), 2726 true); 2727 this->CreateReplicaLayer(surface, 2728 this->identity_matrix, 2729 gfx::PointF(0.f, 100.f), 2730 gfx::Size(100, 100)); 2731 typename Types::LayerType* topmost = 2732 this->CreateDrawingLayer(parent, 2733 this->identity_matrix, 2734 gfx::PointF(), 2735 gfx::Size(100, 110), 2736 true); 2737 this->CalcDrawEtc(parent); 2738 2739 TestOcclusionTrackerWithClip<typename Types::LayerType, 2740 typename Types::RenderSurfaceType> occlusion( 2741 gfx::Rect(0, 0, 1000, 1000)); 2742 2743 // |topmost| occludes the surface, but not the entire surface's replica. 2744 this->VisitLayer(topmost, &occlusion); 2745 2746 EXPECT_EQ(gfx::Rect().ToString(), 2747 occlusion.occlusion_from_outside_target().ToString()); 2748 EXPECT_EQ(gfx::Rect(0, 0, 100, 110).ToString(), 2749 occlusion.occlusion_from_inside_target().ToString()); 2750 2751 this->VisitLayer(surface, &occlusion); 2752 2753 // Render target with replica ignores occlusion from outside. 2754 EXPECT_EQ(gfx::Rect().ToString(), 2755 occlusion.occlusion_from_outside_target().ToString()); 2756 EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), 2757 occlusion.occlusion_from_inside_target().ToString()); 2758 2759 this->EnterContributingSurface(surface, &occlusion); 2760 2761 // Surface is occluded, but only the top 10px of the replica. 2762 EXPECT_RECT_EQ(gfx::Rect(0, 0, 0, 0), 2763 occlusion.UnoccludedContributingSurfaceContentRect( 2764 surface, false, gfx::Rect(0, 0, 100, 100))); 2765 EXPECT_RECT_EQ(gfx::Rect(0, 10, 100, 90), 2766 occlusion.UnoccludedContributingSurfaceContentRect( 2767 surface, true, gfx::Rect(0, 0, 100, 100))); 2768 } 2769 }; 2770 2771 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceWithReplicaUnoccluded); 2772 2773 template <class Types> 2774 class OcclusionTrackerTestSurfaceAndReplicaOccludedDifferently 2775 : public OcclusionTrackerTest<Types> { 2776 protected: 2777 explicit OcclusionTrackerTestSurfaceAndReplicaOccludedDifferently( 2778 bool opaque_layers) 2779 : OcclusionTrackerTest<Types>(opaque_layers) {} 2780 void RunMyTest() { 2781 typename Types::ContentLayerType* parent = this->CreateRoot( 2782 this->identity_matrix, gfx::PointF(), gfx::Size(100, 200)); 2783 typename Types::LayerType* surface = 2784 this->CreateDrawingSurface(parent, 2785 this->identity_matrix, 2786 gfx::PointF(), 2787 gfx::Size(100, 100), 2788 true); 2789 this->CreateReplicaLayer(surface, 2790 this->identity_matrix, 2791 gfx::PointF(0.f, 100.f), 2792 gfx::Size(100, 100)); 2793 typename Types::LayerType* over_surface = this->CreateDrawingLayer( 2794 parent, this->identity_matrix, gfx::PointF(), gfx::Size(40, 100), true); 2795 typename Types::LayerType* over_replica = 2796 this->CreateDrawingLayer(parent, 2797 this->identity_matrix, 2798 gfx::PointF(0.f, 100.f), 2799 gfx::Size(50, 100), 2800 true); 2801 this->CalcDrawEtc(parent); 2802 2803 TestOcclusionTrackerWithClip<typename Types::LayerType, 2804 typename Types::RenderSurfaceType> occlusion( 2805 gfx::Rect(0, 0, 1000, 1000)); 2806 2807 // These occlude the surface and replica differently, so we can test each 2808 // one. 2809 this->VisitLayer(over_replica, &occlusion); 2810 this->VisitLayer(over_surface, &occlusion); 2811 2812 EXPECT_EQ(gfx::Rect().ToString(), 2813 occlusion.occlusion_from_outside_target().ToString()); 2814 EXPECT_EQ(UnionRegions(gfx::Rect(0, 0, 40, 100), gfx::Rect(0, 100, 50, 100)) 2815 .ToString(), 2816 occlusion.occlusion_from_inside_target().ToString()); 2817 2818 this->VisitLayer(surface, &occlusion); 2819 2820 // Render target with replica ignores occlusion from outside. 2821 EXPECT_EQ(gfx::Rect().ToString(), 2822 occlusion.occlusion_from_outside_target().ToString()); 2823 EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), 2824 occlusion.occlusion_from_inside_target().ToString()); 2825 2826 this->EnterContributingSurface(surface, &occlusion); 2827 2828 // Surface and replica are occluded different amounts. 2829 EXPECT_RECT_EQ(gfx::Rect(40, 0, 60, 100), 2830 occlusion.UnoccludedContributingSurfaceContentRect( 2831 surface, false, gfx::Rect(0, 0, 100, 100))); 2832 EXPECT_RECT_EQ(gfx::Rect(50, 0, 50, 100), 2833 occlusion.UnoccludedContributingSurfaceContentRect( 2834 surface, true, gfx::Rect(0, 0, 100, 100))); 2835 } 2836 }; 2837 2838 ALL_OCCLUSIONTRACKER_TEST( 2839 OcclusionTrackerTestSurfaceAndReplicaOccludedDifferently); 2840 2841 template <class Types> 2842 class OcclusionTrackerTestSurfaceChildOfSurface 2843 : public OcclusionTrackerTest<Types> { 2844 protected: 2845 explicit OcclusionTrackerTestSurfaceChildOfSurface(bool opaque_layers) 2846 : OcclusionTrackerTest<Types>(opaque_layers) {} 2847 void RunMyTest() { 2848 // This test verifies that the surface cliprect does not end up empty and 2849 // clip away the entire unoccluded rect. 2850 2851 typename Types::ContentLayerType* parent = this->CreateRoot( 2852 this->identity_matrix, gfx::PointF(), gfx::Size(100, 200)); 2853 typename Types::LayerType* surface = 2854 this->CreateDrawingSurface(parent, 2855 this->identity_matrix, 2856 gfx::PointF(), 2857 gfx::Size(100, 100), 2858 true); 2859 typename Types::LayerType* surface_child = 2860 this->CreateDrawingSurface(surface, 2861 this->identity_matrix, 2862 gfx::PointF(0.f, 10.f), 2863 gfx::Size(100, 50), 2864 true); 2865 typename Types::LayerType* topmost = this->CreateDrawingLayer( 2866 parent, this->identity_matrix, gfx::PointF(), gfx::Size(100, 50), true); 2867 this->CalcDrawEtc(parent); 2868 2869 TestOcclusionTrackerWithClip<typename Types::LayerType, 2870 typename Types::RenderSurfaceType> occlusion( 2871 gfx::Rect(-100, -100, 1000, 1000)); 2872 2873 // |topmost| occludes everything partially so we know occlusion is happening 2874 // at all. 2875 this->VisitLayer(topmost, &occlusion); 2876 2877 EXPECT_EQ(gfx::Rect().ToString(), 2878 occlusion.occlusion_from_outside_target().ToString()); 2879 EXPECT_EQ(gfx::Rect(0, 0, 100, 50).ToString(), 2880 occlusion.occlusion_from_inside_target().ToString()); 2881 2882 this->VisitLayer(surface_child, &occlusion); 2883 2884 // surface_child increases the occlusion in the screen by a narrow sliver. 2885 EXPECT_EQ(gfx::Rect(0, -10, 100, 50).ToString(), 2886 occlusion.occlusion_from_outside_target().ToString()); 2887 // In its own surface, surface_child is at 0,0 as is its occlusion. 2888 EXPECT_EQ(gfx::Rect(0, 0, 100, 50).ToString(), 2889 occlusion.occlusion_from_inside_target().ToString()); 2890 2891 // The root layer always has a clip rect. So the parent of |surface| has a 2892 // clip rect. However, the owning layer for |surface| does not mask to 2893 // bounds, so it doesn't have a clip rect of its own. Thus the parent of 2894 // |surface_child| exercises different code paths as its parent does not 2895 // have a clip rect. 2896 2897 this->EnterContributingSurface(surface_child, &occlusion); 2898 // The surface_child's parent does not have a clip rect as it owns a render 2899 // surface. Make sure the unoccluded rect does not get clipped away 2900 // inappropriately. 2901 EXPECT_RECT_EQ(gfx::Rect(0, 40, 100, 10), 2902 occlusion.UnoccludedContributingSurfaceContentRect( 2903 surface_child, false, gfx::Rect(0, 0, 100, 50))); 2904 this->LeaveContributingSurface(surface_child, &occlusion); 2905 2906 // When the surface_child's occlusion is transformed up to its parent, make 2907 // sure it is not clipped away inappropriately also. 2908 this->EnterLayer(surface, &occlusion); 2909 EXPECT_EQ(gfx::Rect(0, 0, 100, 50).ToString(), 2910 occlusion.occlusion_from_outside_target().ToString()); 2911 EXPECT_EQ(gfx::Rect(0, 10, 100, 50).ToString(), 2912 occlusion.occlusion_from_inside_target().ToString()); 2913 this->LeaveLayer(surface, &occlusion); 2914 2915 this->EnterContributingSurface(surface, &occlusion); 2916 // The surface's parent does have a clip rect as it is the root layer. 2917 EXPECT_RECT_EQ(gfx::Rect(0, 50, 100, 50), 2918 occlusion.UnoccludedContributingSurfaceContentRect( 2919 surface, false, gfx::Rect(0, 0, 100, 100))); 2920 } 2921 }; 2922 2923 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceChildOfSurface); 2924 2925 template <class Types> 2926 class OcclusionTrackerTestTopmostSurfaceIsClippedToViewport 2927 : public OcclusionTrackerTest<Types> { 2928 protected: 2929 explicit OcclusionTrackerTestTopmostSurfaceIsClippedToViewport( 2930 bool opaque_layers) 2931 : OcclusionTrackerTest<Types>(opaque_layers) {} 2932 void RunMyTest() { 2933 // This test verifies that the top-most surface is considered occluded 2934 // outside of its target's clip rect and outside the viewport rect. 2935 2936 typename Types::ContentLayerType* parent = this->CreateRoot( 2937 this->identity_matrix, gfx::PointF(), gfx::Size(100, 200)); 2938 typename Types::LayerType* surface = 2939 this->CreateDrawingSurface(parent, 2940 this->identity_matrix, 2941 gfx::PointF(), 2942 gfx::Size(100, 300), 2943 true); 2944 this->CalcDrawEtc(parent); 2945 { 2946 // Make a viewport rect that is larger than the root layer. 2947 TestOcclusionTrackerWithClip<typename Types::LayerType, 2948 typename Types::RenderSurfaceType> occlusion( 2949 gfx::Rect(0, 0, 1000, 1000)); 2950 2951 this->VisitLayer(surface, &occlusion); 2952 2953 // The root layer always has a clip rect. So the parent of |surface| has a 2954 // clip rect giving the surface itself a clip rect. 2955 this->EnterContributingSurface(surface, &occlusion); 2956 // Make sure the parent's clip rect clips the unoccluded region of the 2957 // child surface. 2958 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 200), 2959 occlusion.UnoccludedContributingSurfaceContentRect( 2960 surface, false, gfx::Rect(0, 0, 100, 300))); 2961 } 2962 this->ResetLayerIterator(); 2963 { 2964 // Make a viewport rect that is smaller than the root layer. 2965 TestOcclusionTrackerWithClip<typename Types::LayerType, 2966 typename Types::RenderSurfaceType> occlusion( 2967 gfx::Rect(0, 0, 100, 100)); 2968 2969 this->VisitLayer(surface, &occlusion); 2970 2971 // The root layer always has a clip rect. So the parent of |surface| has a 2972 // clip rect giving the surface itself a clip rect. 2973 this->EnterContributingSurface(surface, &occlusion); 2974 // Make sure the viewport rect clips the unoccluded region of the child 2975 // surface. 2976 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), 2977 occlusion.UnoccludedContributingSurfaceContentRect( 2978 surface, false, gfx::Rect(0, 0, 100, 300))); 2979 } 2980 } 2981 }; 2982 2983 ALL_OCCLUSIONTRACKER_TEST( 2984 OcclusionTrackerTestTopmostSurfaceIsClippedToViewport); 2985 2986 template <class Types> 2987 class OcclusionTrackerTestSurfaceChildOfClippingSurface 2988 : public OcclusionTrackerTest<Types> { 2989 protected: 2990 explicit OcclusionTrackerTestSurfaceChildOfClippingSurface(bool opaque_layers) 2991 : OcclusionTrackerTest<Types>(opaque_layers) {} 2992 void RunMyTest() { 2993 // This test verifies that the surface cliprect does not end up empty and 2994 // clip away the entire unoccluded rect. 2995 2996 typename Types::ContentLayerType* parent = this->CreateRoot( 2997 this->identity_matrix, gfx::PointF(), gfx::Size(80, 200)); 2998 parent->SetMasksToBounds(true); 2999 typename Types::LayerType* surface = 3000 this->CreateDrawingSurface(parent, 3001 this->identity_matrix, 3002 gfx::PointF(), 3003 gfx::Size(100, 100), 3004 true); 3005 typename Types::LayerType* surface_child = 3006 this->CreateDrawingSurface(surface, 3007 this->identity_matrix, 3008 gfx::PointF(), 3009 gfx::Size(100, 100), 3010 false); 3011 typename Types::LayerType* topmost = this->CreateDrawingLayer( 3012 parent, this->identity_matrix, gfx::PointF(), gfx::Size(100, 50), true); 3013 this->CalcDrawEtc(parent); 3014 3015 TestOcclusionTrackerWithClip<typename Types::LayerType, 3016 typename Types::RenderSurfaceType> occlusion( 3017 gfx::Rect(0, 0, 1000, 1000)); 3018 3019 // |topmost| occludes everything partially so we know occlusion is happening 3020 // at all. 3021 this->VisitLayer(topmost, &occlusion); 3022 3023 EXPECT_EQ(gfx::Rect().ToString(), 3024 occlusion.occlusion_from_outside_target().ToString()); 3025 EXPECT_EQ(gfx::Rect(0, 0, 80, 50).ToString(), 3026 occlusion.occlusion_from_inside_target().ToString()); 3027 3028 // surface_child is not opaque and does not occlude, so we have a non-empty 3029 // unoccluded area on surface. 3030 this->VisitLayer(surface_child, &occlusion); 3031 3032 EXPECT_EQ(gfx::Rect(0, 0, 80, 50).ToString(), 3033 occlusion.occlusion_from_outside_target().ToString()); 3034 EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(), 3035 occlusion.occlusion_from_inside_target().ToString()); 3036 3037 // The root layer always has a clip rect. So the parent of |surface| has a 3038 // clip rect. However, the owning layer for |surface| does not mask to 3039 // bounds, so it doesn't have a clip rect of its own. Thus the parent of 3040 // |surface_child| exercises different code paths as its parent does not 3041 // have a clip rect. 3042 3043 this->EnterContributingSurface(surface_child, &occlusion); 3044 // The surface_child's parent does not have a clip rect as it owns a render 3045 // surface. 3046 EXPECT_EQ( 3047 gfx::Rect(0, 50, 80, 50).ToString(), 3048 occlusion.UnoccludedContributingSurfaceContentRect( 3049 surface_child, false, gfx::Rect(0, 0, 100, 100)).ToString()); 3050 this->LeaveContributingSurface(surface_child, &occlusion); 3051 3052 this->VisitLayer(surface, &occlusion); 3053 this->EnterContributingSurface(surface, &occlusion); 3054 // The surface's parent does have a clip rect as it is the root layer. 3055 EXPECT_EQ(gfx::Rect(0, 50, 80, 50).ToString(), 3056 occlusion.UnoccludedContributingSurfaceContentRect( 3057 surface, false, gfx::Rect(0, 0, 100, 100)).ToString()); 3058 } 3059 }; 3060 3061 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceChildOfClippingSurface); 3062 3063 template <class Types> 3064 class OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter 3065 : public OcclusionTrackerTest<Types> { 3066 protected: 3067 explicit OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter( 3068 bool opaque_layers) 3069 : OcclusionTrackerTest<Types>(opaque_layers) {} 3070 void RunMyTest() { 3071 gfx::Transform scale_by_half; 3072 scale_by_half.Scale(0.5, 0.5); 3073 3074 // Make a 50x50 filtered surface that is completely surrounded by opaque 3075 // layers which are above it in the z-order. The surface is scaled to test 3076 // that the pixel moving is done in the target space, where the background 3077 // filter is applied. 3078 typename Types::ContentLayerType* parent = this->CreateRoot( 3079 this->identity_matrix, gfx::PointF(), gfx::Size(200, 150)); 3080 typename Types::LayerType* filtered_surface = 3081 this->CreateDrawingLayer(parent, 3082 scale_by_half, 3083 gfx::PointF(50.f, 50.f), 3084 gfx::Size(100, 100), 3085 false); 3086 typename Types::LayerType* occluding_layer1 = this->CreateDrawingLayer( 3087 parent, this->identity_matrix, gfx::PointF(), gfx::Size(200, 50), true); 3088 typename Types::LayerType* occluding_layer2 = 3089 this->CreateDrawingLayer(parent, 3090 this->identity_matrix, 3091 gfx::PointF(0.f, 100.f), 3092 gfx::Size(200, 50), 3093 true); 3094 typename Types::LayerType* occluding_layer3 = 3095 this->CreateDrawingLayer(parent, 3096 this->identity_matrix, 3097 gfx::PointF(0.f, 50.f), 3098 gfx::Size(50, 50), 3099 true); 3100 typename Types::LayerType* occluding_layer4 = 3101 this->CreateDrawingLayer(parent, 3102 this->identity_matrix, 3103 gfx::PointF(100.f, 50.f), 3104 gfx::Size(100, 50), 3105 true); 3106 3107 // Filters make the layer own a surface. 3108 FilterOperations filters; 3109 filters.Append(FilterOperation::CreateBlurFilter(10.f)); 3110 filtered_surface->SetBackgroundFilters(filters); 3111 3112 // Save the distance of influence for the blur effect. 3113 int outset_top, outset_right, outset_bottom, outset_left; 3114 filters.GetOutsets( 3115 &outset_top, &outset_right, &outset_bottom, &outset_left); 3116 3117 this->CalcDrawEtc(parent); 3118 3119 TestOcclusionTrackerWithClip<typename Types::LayerType, 3120 typename Types::RenderSurfaceType> occlusion( 3121 gfx::Rect(0, 0, 1000, 1000)); 3122 3123 // These layers occlude pixels directly beside the filtered_surface. Because 3124 // filtered surface blends pixels in a radius, it will need to see some of 3125 // the pixels (up to radius far) underneath the occluding layers. 3126 this->VisitLayer(occluding_layer4, &occlusion); 3127 this->VisitLayer(occluding_layer3, &occlusion); 3128 this->VisitLayer(occluding_layer2, &occlusion); 3129 this->VisitLayer(occluding_layer1, &occlusion); 3130 3131 Region expected_occlusion; 3132 expected_occlusion.Union(gfx::Rect(0, 0, 200, 50)); 3133 expected_occlusion.Union(gfx::Rect(0, 50, 50, 50)); 3134 expected_occlusion.Union(gfx::Rect(100, 50, 100, 50)); 3135 expected_occlusion.Union(gfx::Rect(0, 100, 200, 50)); 3136 3137 EXPECT_EQ(expected_occlusion.ToString(), 3138 occlusion.occlusion_from_inside_target().ToString()); 3139 EXPECT_EQ(gfx::Rect().ToString(), 3140 occlusion.occlusion_from_outside_target().ToString()); 3141 3142 this->VisitLayer(filtered_surface, &occlusion); 3143 3144 // The filtered layer does not occlude. 3145 Region expected_occlusion_outside_surface; 3146 expected_occlusion_outside_surface.Union(gfx::Rect(-50, -50, 200, 50)); 3147 expected_occlusion_outside_surface.Union(gfx::Rect(-50, 0, 50, 50)); 3148 expected_occlusion_outside_surface.Union(gfx::Rect(50, 0, 100, 50)); 3149 expected_occlusion_outside_surface.Union(gfx::Rect(-50, 50, 200, 50)); 3150 3151 EXPECT_EQ(expected_occlusion_outside_surface.ToString(), 3152 occlusion.occlusion_from_outside_target().ToString()); 3153 EXPECT_EQ(gfx::Rect().ToString(), 3154 occlusion.occlusion_from_inside_target().ToString()); 3155 3156 // The surface has a background blur, so it needs pixels that are currently 3157 // considered occluded in order to be drawn. So the pixels it needs should 3158 // be removed some the occluded area so that when we get to the parent they 3159 // are drawn. 3160 this->VisitContributingSurface(filtered_surface, &occlusion); 3161 3162 this->EnterLayer(parent, &occlusion); 3163 3164 Region expected_blurred_occlusion; 3165 expected_blurred_occlusion.Union(gfx::Rect(0, 0, 200, 50 - outset_top)); 3166 expected_blurred_occlusion.Union(gfx::Rect( 3167 0, 50 - outset_top, 50 - outset_left, 50 + outset_top + outset_bottom)); 3168 expected_blurred_occlusion.Union( 3169 gfx::Rect(100 + outset_right, 3170 50 - outset_top, 3171 100 - outset_right, 3172 50 + outset_top + outset_bottom)); 3173 expected_blurred_occlusion.Union( 3174 gfx::Rect(0, 100 + outset_bottom, 200, 50 - outset_bottom)); 3175 3176 EXPECT_EQ(expected_blurred_occlusion.ToString(), 3177 occlusion.occlusion_from_inside_target().ToString()); 3178 EXPECT_EQ(gfx::Rect().ToString(), 3179 occlusion.occlusion_from_outside_target().ToString()); 3180 3181 gfx::Rect outset_rect; 3182 gfx::Rect test_rect; 3183 3184 // Nothing in the blur outsets for the filtered_surface is occluded. 3185 outset_rect = gfx::Rect(50 - outset_left, 3186 50 - outset_top, 3187 50 + outset_left + outset_right, 3188 50 + outset_top + outset_bottom); 3189 test_rect = outset_rect; 3190 EXPECT_EQ( 3191 outset_rect.ToString(), 3192 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString()); 3193 3194 // Stuff outside the blur outsets is still occluded though. 3195 test_rect = outset_rect; 3196 test_rect.Inset(0, 0, -1, 0); 3197 EXPECT_EQ( 3198 outset_rect.ToString(), 3199 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString()); 3200 test_rect = outset_rect; 3201 test_rect.Inset(0, 0, 0, -1); 3202 EXPECT_EQ( 3203 outset_rect.ToString(), 3204 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString()); 3205 test_rect = outset_rect; 3206 test_rect.Inset(-1, 0, 0, 0); 3207 EXPECT_EQ( 3208 outset_rect.ToString(), 3209 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString()); 3210 test_rect = outset_rect; 3211 test_rect.Inset(0, -1, 0, 0); 3212 EXPECT_EQ( 3213 outset_rect.ToString(), 3214 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString()); 3215 } 3216 }; 3217 3218 ALL_OCCLUSIONTRACKER_TEST( 3219 OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter); 3220 3221 template <class Types> 3222 class OcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice 3223 : public OcclusionTrackerTest<Types> { 3224 protected: 3225 explicit OcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice( 3226 bool opaque_layers) 3227 : OcclusionTrackerTest<Types>(opaque_layers) {} 3228 void RunMyTest() { 3229 gfx::Transform scale_by_half; 3230 scale_by_half.Scale(0.5, 0.5); 3231 3232 // Makes two surfaces that completely cover |parent|. The occlusion both 3233 // above and below the filters will be reduced by each of them. 3234 typename Types::ContentLayerType* root = this->CreateRoot( 3235 this->identity_matrix, gfx::PointF(), gfx::Size(75, 75)); 3236 typename Types::LayerType* parent = this->CreateSurface( 3237 root, scale_by_half, gfx::PointF(), gfx::Size(150, 150)); 3238 parent->SetMasksToBounds(true); 3239 typename Types::LayerType* filtered_surface1 = this->CreateDrawingLayer( 3240 parent, scale_by_half, gfx::PointF(), gfx::Size(300, 300), false); 3241 typename Types::LayerType* filtered_surface2 = this->CreateDrawingLayer( 3242 parent, scale_by_half, gfx::PointF(), gfx::Size(300, 300), false); 3243 typename Types::LayerType* occluding_layer_above = 3244 this->CreateDrawingLayer(parent, 3245 this->identity_matrix, 3246 gfx::PointF(100.f, 100.f), 3247 gfx::Size(50, 50), 3248 true); 3249 3250 // Filters make the layers own surfaces. 3251 FilterOperations filters; 3252 filters.Append(FilterOperation::CreateBlurFilter(1.f)); 3253 filtered_surface1->SetBackgroundFilters(filters); 3254 filtered_surface2->SetBackgroundFilters(filters); 3255 3256 // Save the distance of influence for the blur effect. 3257 int outset_top, outset_right, outset_bottom, outset_left; 3258 filters.GetOutsets( 3259 &outset_top, &outset_right, &outset_bottom, &outset_left); 3260 3261 this->CalcDrawEtc(root); 3262 3263 TestOcclusionTrackerWithClip<typename Types::LayerType, 3264 typename Types::RenderSurfaceType> occlusion( 3265 gfx::Rect(0, 0, 1000, 1000)); 3266 3267 this->VisitLayer(occluding_layer_above, &occlusion); 3268 EXPECT_EQ(gfx::Rect().ToString(), 3269 occlusion.occlusion_from_outside_target().ToString()); 3270 EXPECT_EQ(gfx::Rect(100 / 2, 100 / 2, 50 / 2, 50 / 2).ToString(), 3271 occlusion.occlusion_from_inside_target().ToString()); 3272 3273 this->VisitLayer(filtered_surface2, &occlusion); 3274 this->VisitContributingSurface(filtered_surface2, &occlusion); 3275 this->VisitLayer(filtered_surface1, &occlusion); 3276 this->VisitContributingSurface(filtered_surface1, &occlusion); 3277 3278 // Test expectations in the target. 3279 gfx::Rect expected_occlusion = 3280 gfx::Rect(100 / 2 + outset_right * 2, 3281 100 / 2 + outset_bottom * 2, 3282 50 / 2 - (outset_left + outset_right) * 2, 3283 50 / 2 - (outset_top + outset_bottom) * 2); 3284 EXPECT_EQ(expected_occlusion.ToString(), 3285 occlusion.occlusion_from_inside_target().ToString()); 3286 3287 // Test expectations in the screen are the same as in the target, as the 3288 // render surface is 1:1 with the screen. 3289 EXPECT_EQ(expected_occlusion.ToString(), 3290 occlusion.occlusion_from_outside_target().ToString()); 3291 } 3292 }; 3293 3294 ALL_OCCLUSIONTRACKER_TEST( 3295 OcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice); 3296 3297 template <class Types> 3298 class OcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter 3299 : public OcclusionTrackerTest<Types> { 3300 protected: 3301 explicit OcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter( 3302 bool opaque_layers) 3303 : OcclusionTrackerTest<Types>(opaque_layers) {} 3304 void RunMyTest() { 3305 gfx::Transform scale_by_half; 3306 scale_by_half.Scale(0.5, 0.5); 3307 3308 // Make a surface and its replica, each 50x50, with a smaller 30x30 layer 3309 // centered below each. The surface is scaled to test that the pixel moving 3310 // is done in the target space, where the background filter is applied, but 3311 // the surface appears at 50, 50 and the replica at 200, 50. 3312 typename Types::ContentLayerType* parent = this->CreateRoot( 3313 this->identity_matrix, gfx::PointF(), gfx::Size(300, 150)); 3314 typename Types::LayerType* behind_surface_layer = 3315 this->CreateDrawingLayer(parent, 3316 this->identity_matrix, 3317 gfx::PointF(60.f, 60.f), 3318 gfx::Size(30, 30), 3319 true); 3320 typename Types::LayerType* behind_replica_layer = 3321 this->CreateDrawingLayer(parent, 3322 this->identity_matrix, 3323 gfx::PointF(210.f, 60.f), 3324 gfx::Size(30, 30), 3325 true); 3326 typename Types::LayerType* filtered_surface = 3327 this->CreateDrawingLayer(parent, 3328 scale_by_half, 3329 gfx::PointF(50.f, 50.f), 3330 gfx::Size(100, 100), 3331 false); 3332 this->CreateReplicaLayer(filtered_surface, 3333 this->identity_matrix, 3334 gfx::PointF(300.f, 0.f), 3335 gfx::Size()); 3336 3337 // Filters make the layer own a surface. 3338 FilterOperations filters; 3339 filters.Append(FilterOperation::CreateBlurFilter(3.f)); 3340 filtered_surface->SetBackgroundFilters(filters); 3341 3342 this->CalcDrawEtc(parent); 3343 3344 TestOcclusionTrackerWithClip<typename Types::LayerType, 3345 typename Types::RenderSurfaceType> occlusion( 3346 gfx::Rect(0, 0, 1000, 1000)); 3347 3348 // The surface has a background blur, so it blurs non-opaque pixels below 3349 // it. 3350 this->VisitLayer(filtered_surface, &occlusion); 3351 this->VisitContributingSurface(filtered_surface, &occlusion); 3352 3353 this->VisitLayer(behind_replica_layer, &occlusion); 3354 this->VisitLayer(behind_surface_layer, &occlusion); 3355 3356 // The layers behind the surface are not blurred, and their occlusion does 3357 // not change, until we leave the surface. So it should not be modified by 3358 // the filter here. 3359 gfx::Rect occlusion_behind_surface = gfx::Rect(60, 60, 30, 30); 3360 gfx::Rect occlusion_behind_replica = gfx::Rect(210, 60, 30, 30); 3361 3362 Region expected_opaque_bounds = 3363 UnionRegions(occlusion_behind_surface, occlusion_behind_replica); 3364 EXPECT_EQ(expected_opaque_bounds.ToString(), 3365 occlusion.occlusion_from_inside_target().ToString()); 3366 3367 EXPECT_EQ(gfx::Rect().ToString(), 3368 occlusion.occlusion_from_outside_target().ToString()); 3369 } 3370 }; 3371 3372 ALL_OCCLUSIONTRACKER_TEST( 3373 OcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter); 3374 3375 template <class Types> 3376 class OcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded 3377 : public OcclusionTrackerTest<Types> { 3378 protected: 3379 explicit OcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded( 3380 bool opaque_layers) 3381 : OcclusionTrackerTest<Types>(opaque_layers) {} 3382 void RunMyTest() { 3383 gfx::Transform scale_by_half; 3384 scale_by_half.Scale(0.5, 0.5); 3385 3386 // Make a 50x50 filtered surface that is completely occluded by an opaque 3387 // layer which is above it in the z-order. The surface is 3388 // scaled to test that the pixel moving is done in the target space, where 3389 // the background filter is applied, but the surface appears at 50, 50. 3390 typename Types::ContentLayerType* parent = this->CreateRoot( 3391 this->identity_matrix, gfx::PointF(), gfx::Size(200, 150)); 3392 typename Types::LayerType* filtered_surface = 3393 this->CreateDrawingLayer(parent, 3394 scale_by_half, 3395 gfx::PointF(50.f, 50.f), 3396 gfx::Size(100, 100), 3397 false); 3398 typename Types::LayerType* occluding_layer = 3399 this->CreateDrawingLayer(parent, 3400 this->identity_matrix, 3401 gfx::PointF(50.f, 50.f), 3402 gfx::Size(50, 50), 3403 true); 3404 3405 // Filters make the layer own a surface. 3406 FilterOperations filters; 3407 filters.Append(FilterOperation::CreateBlurFilter(3.f)); 3408 filtered_surface->SetBackgroundFilters(filters); 3409 3410 this->CalcDrawEtc(parent); 3411 3412 TestOcclusionTrackerWithClip<typename Types::LayerType, 3413 typename Types::RenderSurfaceType> occlusion( 3414 gfx::Rect(0, 0, 1000, 1000)); 3415 3416 this->VisitLayer(occluding_layer, &occlusion); 3417 3418 this->VisitLayer(filtered_surface, &occlusion); 3419 { 3420 // The layers above the filtered surface occlude from outside. 3421 gfx::Rect occlusion_above_surface = gfx::Rect(0, 0, 50, 50); 3422 3423 EXPECT_EQ(gfx::Rect().ToString(), 3424 occlusion.occlusion_from_inside_target().ToString()); 3425 EXPECT_EQ(occlusion_above_surface.ToString(), 3426 occlusion.occlusion_from_outside_target().ToString()); 3427 } 3428 3429 // The surface has a background blur, so it blurs non-opaque pixels below 3430 // it. 3431 this->VisitContributingSurface(filtered_surface, &occlusion); 3432 { 3433 // The filter is completely occluded, so it should not blur anything and 3434 // reduce any occlusion. 3435 gfx::Rect occlusion_above_surface = gfx::Rect(50, 50, 50, 50); 3436 3437 EXPECT_EQ(occlusion_above_surface.ToString(), 3438 occlusion.occlusion_from_inside_target().ToString()); 3439 EXPECT_EQ(gfx::Rect().ToString(), 3440 occlusion.occlusion_from_outside_target().ToString()); 3441 } 3442 } 3443 }; 3444 3445 ALL_OCCLUSIONTRACKER_TEST( 3446 OcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded); 3447 3448 template <class Types> 3449 class OcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded 3450 : public OcclusionTrackerTest<Types> { 3451 protected: 3452 explicit 3453 OcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded( 3454 bool opaque_layers) 3455 : OcclusionTrackerTest<Types>(opaque_layers) {} 3456 void RunMyTest() { 3457 gfx::Transform scale_by_half; 3458 scale_by_half.Scale(0.5, 0.5); 3459 3460 // Make a surface and its replica, each 50x50, that are partially occluded 3461 // by opaque layers which are above them in the z-order. The surface is 3462 // scaled to test that the pixel moving is done in the target space, where 3463 // the background filter is applied, but the surface appears at 50, 50 and 3464 // the replica at 200, 50. 3465 typename Types::ContentLayerType* parent = this->CreateRoot( 3466 this->identity_matrix, gfx::PointF(), gfx::Size(300, 150)); 3467 typename Types::LayerType* filtered_surface = 3468 this->CreateDrawingLayer(parent, 3469 scale_by_half, 3470 gfx::PointF(50.f, 50.f), 3471 gfx::Size(100, 100), 3472 false); 3473 this->CreateReplicaLayer(filtered_surface, 3474 this->identity_matrix, 3475 gfx::PointF(300.f, 0.f), 3476 gfx::Size()); 3477 typename Types::LayerType* above_surface_layer = 3478 this->CreateDrawingLayer(parent, 3479 this->identity_matrix, 3480 gfx::PointF(70.f, 50.f), 3481 gfx::Size(30, 50), 3482 true); 3483 typename Types::LayerType* above_replica_layer = 3484 this->CreateDrawingLayer(parent, 3485 this->identity_matrix, 3486 gfx::PointF(200.f, 50.f), 3487 gfx::Size(30, 50), 3488 true); 3489 typename Types::LayerType* beside_surface_layer = 3490 this->CreateDrawingLayer(parent, 3491 this->identity_matrix, 3492 gfx::PointF(90.f, 40.f), 3493 gfx::Size(10, 10), 3494 true); 3495 typename Types::LayerType* beside_replica_layer = 3496 this->CreateDrawingLayer(parent, 3497 this->identity_matrix, 3498 gfx::PointF(200.f, 40.f), 3499 gfx::Size(10, 10), 3500 true); 3501 3502 // Filters make the layer own a surface. 3503 FilterOperations filters; 3504 filters.Append(FilterOperation::CreateBlurFilter(3.f)); 3505 filtered_surface->SetBackgroundFilters(filters); 3506 3507 // Save the distance of influence for the blur effect. 3508 int outset_top, outset_right, outset_bottom, outset_left; 3509 filters.GetOutsets( 3510 &outset_top, &outset_right, &outset_bottom, &outset_left); 3511 3512 this->CalcDrawEtc(parent); 3513 3514 TestOcclusionTrackerWithClip<typename Types::LayerType, 3515 typename Types::RenderSurfaceType> occlusion( 3516 gfx::Rect(0, 0, 1000, 1000)); 3517 3518 this->VisitLayer(beside_replica_layer, &occlusion); 3519 this->VisitLayer(beside_surface_layer, &occlusion); 3520 this->VisitLayer(above_replica_layer, &occlusion); 3521 this->VisitLayer(above_surface_layer, &occlusion); 3522 3523 // The surface has a background blur, so it blurs non-opaque pixels below 3524 // it. 3525 this->VisitLayer(filtered_surface, &occlusion); 3526 this->VisitContributingSurface(filtered_surface, &occlusion); 3527 3528 // The filter in the surface and replica are partially unoccluded. Only the 3529 // unoccluded parts should reduce occlusion. This means it will push back 3530 // the occlusion that touches the unoccluded part (occlusion_above___), but 3531 // it will not touch occlusion_beside____ since that is not beside the 3532 // unoccluded part of the surface, even though it is beside the occluded 3533 // part of the surface. 3534 gfx::Rect occlusion_above_surface = 3535 gfx::Rect(70 + outset_right, 50, 30 - outset_right, 50); 3536 gfx::Rect occlusion_above_replica = 3537 gfx::Rect(200, 50, 30 - outset_left, 50); 3538 gfx::Rect occlusion_beside_surface = gfx::Rect(90, 40, 10, 10); 3539 gfx::Rect occlusion_beside_replica = gfx::Rect(200, 40, 10, 10); 3540 3541 Region expected_occlusion; 3542 expected_occlusion.Union(occlusion_above_surface); 3543 expected_occlusion.Union(occlusion_above_replica); 3544 expected_occlusion.Union(occlusion_beside_surface); 3545 expected_occlusion.Union(occlusion_beside_replica); 3546 3547 ASSERT_EQ(expected_occlusion.ToString(), 3548 occlusion.occlusion_from_inside_target().ToString()); 3549 EXPECT_EQ(gfx::Rect().ToString(), 3550 occlusion.occlusion_from_outside_target().ToString()); 3551 3552 Region::Iterator expected_rects(expected_occlusion); 3553 Region::Iterator target_surface_rects( 3554 occlusion.occlusion_from_inside_target()); 3555 for (; expected_rects.has_rect(); 3556 expected_rects.next(), target_surface_rects.next()) { 3557 ASSERT_TRUE(target_surface_rects.has_rect()); 3558 EXPECT_EQ(expected_rects.rect(), target_surface_rects.rect()); 3559 } 3560 } 3561 }; 3562 3563 ALL_OCCLUSIONTRACKER_TEST( 3564 OcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded); 3565 3566 template <class Types> 3567 class OcclusionTrackerTestMinimumTrackingSize 3568 : public OcclusionTrackerTest<Types> { 3569 protected: 3570 explicit OcclusionTrackerTestMinimumTrackingSize(bool opaque_layers) 3571 : OcclusionTrackerTest<Types>(opaque_layers) {} 3572 void RunMyTest() { 3573 gfx::Size tracking_size(100, 100); 3574 gfx::Size below_tracking_size(99, 99); 3575 3576 typename Types::ContentLayerType* parent = this->CreateRoot( 3577 this->identity_matrix, gfx::PointF(), gfx::Size(400, 400)); 3578 typename Types::LayerType* large = this->CreateDrawingLayer( 3579 parent, this->identity_matrix, gfx::PointF(), tracking_size, true); 3580 typename Types::LayerType* small = 3581 this->CreateDrawingLayer(parent, 3582 this->identity_matrix, 3583 gfx::PointF(), 3584 below_tracking_size, 3585 true); 3586 this->CalcDrawEtc(parent); 3587 3588 TestOcclusionTrackerWithClip<typename Types::LayerType, 3589 typename Types::RenderSurfaceType> occlusion( 3590 gfx::Rect(0, 0, 1000, 1000)); 3591 occlusion.set_minimum_tracking_size(tracking_size); 3592 3593 // The small layer is not tracked because it is too small. 3594 this->VisitLayer(small, &occlusion); 3595 3596 EXPECT_EQ(gfx::Rect().ToString(), 3597 occlusion.occlusion_from_outside_target().ToString()); 3598 EXPECT_EQ(gfx::Rect().ToString(), 3599 occlusion.occlusion_from_inside_target().ToString()); 3600 3601 // The large layer is tracked as it is large enough. 3602 this->VisitLayer(large, &occlusion); 3603 3604 EXPECT_EQ(gfx::Rect().ToString(), 3605 occlusion.occlusion_from_outside_target().ToString()); 3606 EXPECT_EQ(gfx::Rect(tracking_size).ToString(), 3607 occlusion.occlusion_from_inside_target().ToString()); 3608 } 3609 }; 3610 3611 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestMinimumTrackingSize); 3612 3613 template <class Types> 3614 class OcclusionTrackerTestScaledLayerIsClipped 3615 : public OcclusionTrackerTest<Types> { 3616 protected: 3617 explicit OcclusionTrackerTestScaledLayerIsClipped(bool opaque_layers) 3618 : OcclusionTrackerTest<Types>(opaque_layers) {} 3619 void RunMyTest() { 3620 gfx::Transform scale_transform; 3621 scale_transform.Scale(512.0, 512.0); 3622 3623 typename Types::ContentLayerType* parent = this->CreateRoot( 3624 this->identity_matrix, gfx::PointF(), gfx::Size(400, 400)); 3625 typename Types::LayerType* clip = this->CreateLayer(parent, 3626 this->identity_matrix, 3627 gfx::PointF(10.f, 10.f), 3628 gfx::Size(50, 50)); 3629 clip->SetMasksToBounds(true); 3630 typename Types::LayerType* scale = this->CreateLayer( 3631 clip, scale_transform, gfx::PointF(), gfx::Size(1, 1)); 3632 typename Types::LayerType* scaled = this->CreateDrawingLayer( 3633 scale, this->identity_matrix, gfx::PointF(), gfx::Size(500, 500), true); 3634 this->CalcDrawEtc(parent); 3635 3636 TestOcclusionTrackerWithClip<typename Types::LayerType, 3637 typename Types::RenderSurfaceType> occlusion( 3638 gfx::Rect(0, 0, 1000, 1000)); 3639 3640 this->VisitLayer(scaled, &occlusion); 3641 3642 EXPECT_EQ(gfx::Rect().ToString(), 3643 occlusion.occlusion_from_outside_target().ToString()); 3644 EXPECT_EQ(gfx::Rect(10, 10, 50, 50).ToString(), 3645 occlusion.occlusion_from_inside_target().ToString()); 3646 } 3647 }; 3648 3649 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestScaledLayerIsClipped) 3650 3651 template <class Types> 3652 class OcclusionTrackerTestScaledLayerInSurfaceIsClipped 3653 : public OcclusionTrackerTest<Types> { 3654 protected: 3655 explicit OcclusionTrackerTestScaledLayerInSurfaceIsClipped(bool opaque_layers) 3656 : OcclusionTrackerTest<Types>(opaque_layers) {} 3657 void RunMyTest() { 3658 gfx::Transform scale_transform; 3659 scale_transform.Scale(512.0, 512.0); 3660 3661 typename Types::ContentLayerType* parent = this->CreateRoot( 3662 this->identity_matrix, gfx::PointF(), gfx::Size(400, 400)); 3663 typename Types::LayerType* clip = this->CreateLayer(parent, 3664 this->identity_matrix, 3665 gfx::PointF(10.f, 10.f), 3666 gfx::Size(50, 50)); 3667 clip->SetMasksToBounds(true); 3668 typename Types::LayerType* surface = this->CreateDrawingSurface( 3669 clip, this->identity_matrix, gfx::PointF(), gfx::Size(400, 30), false); 3670 typename Types::LayerType* scale = this->CreateLayer( 3671 surface, scale_transform, gfx::PointF(), gfx::Size(1, 1)); 3672 typename Types::LayerType* scaled = this->CreateDrawingLayer( 3673 scale, this->identity_matrix, gfx::PointF(), gfx::Size(500, 500), true); 3674 this->CalcDrawEtc(parent); 3675 3676 TestOcclusionTrackerWithClip<typename Types::LayerType, 3677 typename Types::RenderSurfaceType> occlusion( 3678 gfx::Rect(0, 0, 1000, 1000)); 3679 3680 this->VisitLayer(scaled, &occlusion); 3681 this->VisitLayer(surface, &occlusion); 3682 this->VisitContributingSurface(surface, &occlusion); 3683 3684 EXPECT_EQ(gfx::Rect().ToString(), 3685 occlusion.occlusion_from_outside_target().ToString()); 3686 EXPECT_EQ(gfx::Rect(10, 10, 50, 50).ToString(), 3687 occlusion.occlusion_from_inside_target().ToString()); 3688 } 3689 }; 3690 3691 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestScaledLayerInSurfaceIsClipped) 3692 3693 template <class Types> 3694 class OcclusionTrackerTestCopyRequestDoesOcclude 3695 : public OcclusionTrackerTest<Types> { 3696 protected: 3697 explicit OcclusionTrackerTestCopyRequestDoesOcclude(bool opaque_layers) 3698 : OcclusionTrackerTest<Types>(opaque_layers) {} 3699 void RunMyTest() { 3700 typename Types::ContentLayerType* root = this->CreateRoot( 3701 this->identity_matrix, gfx::Point(), gfx::Size(400, 400)); 3702 typename Types::ContentLayerType* parent = this->CreateDrawingLayer( 3703 root, this->identity_matrix, gfx::Point(), gfx::Size(400, 400), true); 3704 typename Types::LayerType* copy = this->CreateLayer(parent, 3705 this->identity_matrix, 3706 gfx::Point(100, 0), 3707 gfx::Size(200, 400)); 3708 this->AddCopyRequest(copy); 3709 typename Types::LayerType* copy_child = this->CreateDrawingLayer( 3710 copy, 3711 this->identity_matrix, 3712 gfx::PointF(), 3713 gfx::Size(200, 400), 3714 true); 3715 this->CalcDrawEtc(root); 3716 3717 TestOcclusionTrackerWithClip<typename Types::LayerType, 3718 typename Types::RenderSurfaceType> occlusion( 3719 gfx::Rect(0, 0, 1000, 1000)); 3720 3721 this->VisitLayer(copy_child, &occlusion); 3722 EXPECT_EQ(gfx::Rect().ToString(), 3723 occlusion.occlusion_from_outside_target().ToString()); 3724 EXPECT_EQ(gfx::Rect(200, 400).ToString(), 3725 occlusion.occlusion_from_inside_target().ToString()); 3726 3727 // CopyRequests cause the layer to own a surface. 3728 this->VisitContributingSurface(copy, &occlusion); 3729 3730 // The occlusion from the copy should be kept. 3731 EXPECT_EQ(gfx::Rect().ToString(), 3732 occlusion.occlusion_from_outside_target().ToString()); 3733 EXPECT_EQ(gfx::Rect(100, 0, 200, 400).ToString(), 3734 occlusion.occlusion_from_inside_target().ToString()); 3735 } 3736 }; 3737 3738 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestCopyRequestDoesOcclude) 3739 3740 template <class Types> 3741 class OcclusionTrackerTestHiddenCopyRequestDoesNotOcclude 3742 : public OcclusionTrackerTest<Types> { 3743 protected: 3744 explicit OcclusionTrackerTestHiddenCopyRequestDoesNotOcclude( 3745 bool opaque_layers) 3746 : OcclusionTrackerTest<Types>(opaque_layers) {} 3747 void RunMyTest() { 3748 typename Types::ContentLayerType* root = this->CreateRoot( 3749 this->identity_matrix, gfx::Point(), gfx::Size(400, 400)); 3750 typename Types::ContentLayerType* parent = this->CreateDrawingLayer( 3751 root, this->identity_matrix, gfx::Point(), gfx::Size(400, 400), true); 3752 typename Types::LayerType* hide = this->CreateLayer( 3753 parent, this->identity_matrix, gfx::Point(), gfx::Size()); 3754 typename Types::LayerType* copy = this->CreateLayer( 3755 hide, this->identity_matrix, gfx::Point(100, 0), gfx::Size(200, 400)); 3756 this->AddCopyRequest(copy); 3757 typename Types::LayerType* copy_child = this->CreateDrawingLayer( 3758 copy, this->identity_matrix, gfx::PointF(), gfx::Size(200, 400), true); 3759 3760 // The |copy| layer is hidden but since it is being copied, it will be 3761 // drawn. 3762 hide->SetHideLayerAndSubtree(true); 3763 3764 this->CalcDrawEtc(root); 3765 3766 TestOcclusionTrackerWithClip<typename Types::LayerType, 3767 typename Types::RenderSurfaceType> occlusion( 3768 gfx::Rect(0, 0, 1000, 1000)); 3769 3770 this->VisitLayer(copy_child, &occlusion); 3771 EXPECT_EQ(gfx::Rect().ToString(), 3772 occlusion.occlusion_from_outside_target().ToString()); 3773 EXPECT_EQ(gfx::Rect(200, 400).ToString(), 3774 occlusion.occlusion_from_inside_target().ToString()); 3775 3776 // CopyRequests cause the layer to own a surface. 3777 this->VisitContributingSurface(copy, &occlusion); 3778 3779 // The occlusion from the copy should be dropped since it is hidden. 3780 EXPECT_EQ(gfx::Rect().ToString(), 3781 occlusion.occlusion_from_outside_target().ToString()); 3782 EXPECT_EQ(gfx::Rect().ToString(), 3783 occlusion.occlusion_from_inside_target().ToString()); 3784 } 3785 }; 3786 3787 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestHiddenCopyRequestDoesNotOcclude) 3788 3789 template <class Types> 3790 class OcclusionTrackerTestEmptyEventLayerDoesNotOcclude 3791 : public OcclusionTrackerTest<Types> { 3792 protected: 3793 explicit OcclusionTrackerTestEmptyEventLayerDoesNotOcclude( 3794 bool opaque_layers) 3795 : OcclusionTrackerTest<Types>(opaque_layers) {} 3796 void RunMyTest() { 3797 typename Types::ContentLayerType* root = this->CreateRoot( 3798 this->identity_matrix, gfx::Point(), gfx::Size(400, 400)); 3799 typename Types::ContentLayerType* empty_layer = this->CreateDrawingLayer( 3800 root, this->identity_matrix, gfx::Point(), gfx::Size(200, 200), true); 3801 this->SetDrawsContent(empty_layer, false); 3802 empty_layer->SetTouchEventHandlerRegion(gfx::Rect(10, 10, 10, 10)); 3803 3804 this->CalcDrawEtc(root); 3805 3806 TestOcclusionTrackerWithClip<typename Types::LayerType, 3807 typename Types::RenderSurfaceType> occlusion( 3808 gfx::Rect(0, 0, 1000, 1000), false); 3809 3810 this->VisitLayer(empty_layer, &occlusion); 3811 3812 EXPECT_EQ(gfx::Rect().ToString(), 3813 occlusion.occlusion_from_outside_target().ToString()); 3814 EXPECT_EQ(gfx::Rect().ToString(), 3815 occlusion.occlusion_from_inside_target().ToString()); 3816 } 3817 }; 3818 3819 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestEmptyEventLayerDoesNotOcclude) 3820 3821 } // namespace 3822 } // namespace cc 3823
