?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Move prefs::kLastPolicyStatisticsUpdate to the policy component.
[chromium-blink-merge.git] / cc / trees / occlusion_tracker_unittest.cc
blob469d65a4cb24d6772e3652525344d485f1271354
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
35 virtual bool DrawsContent() const OVERRIDE { return true; }
36 virtual Region VisibleContentOpaqueRegion() const OVERRIDE {
37 if (override_opaque_contents_rect_)
38 return gfx::IntersectRects(opaque_contents_rect_, visible_content_rect());
39 return Layer::VisibleContentOpaqueRegion();
40 }
41 void SetOpaqueContentsRect(gfx::Rect opaque_contents_rect) {
42 override_opaque_contents_rect_ = true;
43 opaque_contents_rect_ = opaque_contents_rect;
44 }
45
46 private:
47 virtual ~TestContentLayer() {}
48
49 bool override_opaque_contents_rect_;
50 gfx::Rect opaque_contents_rect_;
51 };
52
53 class TestContentLayerImpl : public LayerImpl {
54 public:
55 TestContentLayerImpl(LayerTreeImpl* tree_impl, int id)
56 : LayerImpl(tree_impl, id), override_opaque_contents_rect_(false) {
57 SetDrawsContent(true);
58 }
59
60 virtual Region VisibleContentOpaqueRegion() const OVERRIDE {
61 if (override_opaque_contents_rect_)
62 return gfx::IntersectRects(opaque_contents_rect_, visible_content_rect());
63 return LayerImpl::VisibleContentOpaqueRegion();
64 }
65 void SetOpaqueContentsRect(gfx::Rect opaque_contents_rect) {
66 override_opaque_contents_rect_ = true;
67 opaque_contents_rect_ = opaque_contents_rect;
68 }
69
70 private:
71 bool override_opaque_contents_rect_;
72 gfx::Rect opaque_contents_rect_;
73 };
74
75 static inline bool LayerImplDrawTransformIsUnknown(const Layer* layer) {
76 return layer->draw_transform_is_animating();
77 }
78 static inline bool LayerImplDrawTransformIsUnknown(const LayerImpl* layer) {
79 return false;
80 }
81
82 template <typename LayerType, typename RenderSurfaceType>
83 class TestOcclusionTrackerWithClip
84 : public TestOcclusionTrackerBase<LayerType, RenderSurfaceType> {
85 public:
86 TestOcclusionTrackerWithClip(gfx::Rect viewport_rect,
87 bool record_metrics_for_frame)
88 : TestOcclusionTrackerBase<LayerType, RenderSurfaceType>(
89 viewport_rect,
90 record_metrics_for_frame) {}
91 explicit TestOcclusionTrackerWithClip(gfx::Rect viewport_rect)
92 : TestOcclusionTrackerBase<LayerType, RenderSurfaceType>(viewport_rect,
93 false) {}
94
95 bool OccludedLayer(const LayerType* layer, gfx::Rect content_rect) {
96 bool temp;
97 return OccludedLayer(layer, content_rect, &temp);
98 }
99
100 bool OccludedLayer(const LayerType* layer,
101 gfx::Rect content_rect,
102 bool* has_occlusion_from_outside_target_surface) const {
103 return this->Occluded(layer->render_target(),
104 content_rect,
105 layer->draw_transform(),
106 LayerImplDrawTransformIsUnknown(layer),
107 layer->is_clipped(),
108 layer->clip_rect(),
109 has_occlusion_from_outside_target_surface);
110 }
111 // Gives an unoccluded sub-rect of |content_rect| in the content space of the
112 // layer. Simple wrapper around UnoccludedContentRect.
113 gfx::Rect UnoccludedLayerContentRect(const LayerType* layer,
114 gfx::Rect content_rect) const {
115 bool temp;
116 return UnoccludedLayerContentRect(layer, content_rect, &temp);
117 }
118
119 gfx::Rect UnoccludedLayerContentRect(
120 const LayerType* layer,
121 gfx::Rect content_rect,
122 bool* has_occlusion_from_outside_target_surface) const {
123 return this->UnoccludedContentRect(
124 layer->render_target(),
125 content_rect,
126 layer->draw_transform(),
127 LayerImplDrawTransformIsUnknown(layer),
128 layer->is_clipped(),
129 layer->clip_rect(),
130 has_occlusion_from_outside_target_surface);
131 }
132 };
133
134 struct OcclusionTrackerTestMainThreadTypes {
135 typedef Layer LayerType;
136 typedef FakeLayerTreeHost HostType;
137 typedef RenderSurface RenderSurfaceType;
138 typedef TestContentLayer ContentLayerType;
139 typedef scoped_refptr<Layer> LayerPtrType;
140 typedef scoped_refptr<ContentLayerType> ContentLayerPtrType;
141 typedef LayerIterator<Layer,
142 RenderSurfaceLayerList,
143 RenderSurface,
144 LayerIteratorActions::FrontToBack> TestLayerIterator;
145 typedef OcclusionTracker OcclusionTrackerType;
146
147 static LayerPtrType CreateLayer(HostType* host) { return Layer::Create(); }
148 static ContentLayerPtrType CreateContentLayer(HostType* host) {
149 return make_scoped_refptr(new ContentLayerType());
150 }
151
152 static LayerPtrType PassLayerPtr(ContentLayerPtrType* layer) {
153 LayerPtrType ref(*layer);
154 *layer = NULL;
155 return ref;
156 }
157
158 static LayerPtrType PassLayerPtr(LayerPtrType* layer) {
159 LayerPtrType ref(*layer);
160 *layer = NULL;
161 return ref;
162 }
163
164 static void DestroyLayer(LayerPtrType* layer) { *layer = NULL; }
165 };
166
167 struct OcclusionTrackerTestImplThreadTypes {
168 typedef LayerImpl LayerType;
169 typedef LayerTreeImpl HostType;
170 typedef RenderSurfaceImpl RenderSurfaceType;
171 typedef TestContentLayerImpl ContentLayerType;
172 typedef scoped_ptr<LayerImpl> LayerPtrType;
173 typedef scoped_ptr<ContentLayerType> ContentLayerPtrType;
174 typedef LayerIterator<LayerImpl,
175 LayerImplList,
176 RenderSurfaceImpl,
177 LayerIteratorActions::FrontToBack> TestLayerIterator;
178 typedef OcclusionTrackerImpl OcclusionTrackerType;
179
180 static LayerPtrType CreateLayer(HostType* host) {
181 return LayerImpl::Create(host, next_layer_impl_id++);
182 }
183 static ContentLayerPtrType CreateContentLayer(HostType* host) {
184 return make_scoped_ptr(new ContentLayerType(host, next_layer_impl_id++));
185 }
186 static int next_layer_impl_id;
187
188 static LayerPtrType PassLayerPtr(LayerPtrType* layer) {
189 return layer->Pass();
190 }
191
192 static LayerPtrType PassLayerPtr(ContentLayerPtrType* layer) {
193 return layer->PassAs<LayerType>();
194 }
195
196 static void DestroyLayer(LayerPtrType* layer) { layer->reset(); }
197 };
198
199 int OcclusionTrackerTestImplThreadTypes::next_layer_impl_id = 1;
200
201 template <typename Types> class OcclusionTrackerTest : public testing::Test {
202 protected:
203 explicit OcclusionTrackerTest(bool opaque_layers)
204 : opaque_layers_(opaque_layers), host_(FakeLayerTreeHost::Create()) {}
205
206 virtual void RunMyTest() = 0;
207
208 virtual void TearDown() {
209 Types::DestroyLayer(&root_);
210 render_surface_layer_list_.reset();
211 render_surface_layer_list_impl_.clear();
212 replica_layers_.clear();
213 mask_layers_.clear();
214 }
215
216 typename Types::HostType* GetHost();
217
218 typename Types::ContentLayerType* CreateRoot(const gfx::Transform& transform,
219 gfx::PointF position,
220 gfx::Size bounds) {
221 typename Types::ContentLayerPtrType layer(
222 Types::CreateContentLayer(GetHost()));
223 typename Types::ContentLayerType* layer_ptr = layer.get();
224 SetProperties(layer_ptr, transform, position, bounds);
225
226 DCHECK(!root_.get());
227 root_ = Types::PassLayerPtr(&layer);
228
229 SetRootLayerOnMainThread(layer_ptr);
230
231 return layer_ptr;
232 }
233
234 typename Types::LayerType* CreateLayer(typename Types::LayerType* parent,
235 const gfx::Transform& transform,
236 gfx::PointF position,
237 gfx::Size bounds) {
238 typename Types::LayerPtrType layer(Types::CreateLayer(GetHost()));
239 typename Types::LayerType* layer_ptr = layer.get();
240 SetProperties(layer_ptr, transform, position, bounds);
241 parent->AddChild(Types::PassLayerPtr(&layer));
242 return layer_ptr;
243 }
244
245 typename Types::LayerType* CreateSurface(typename Types::LayerType* parent,
246 const gfx::Transform& transform,
247 gfx::PointF position,
248 gfx::Size bounds) {
249 typename Types::LayerType* layer =
250 CreateLayer(parent, transform, position, bounds);
251 layer->SetForceRenderSurface(true);
252 return layer;
253 }
254
255 typename Types::ContentLayerType* CreateDrawingLayer(
256 typename Types::LayerType* parent,
257 const gfx::Transform& transform,
258 gfx::PointF position,
259 gfx::Size bounds,
260 bool opaque) {
261 typename Types::ContentLayerPtrType layer(
262 Types::CreateContentLayer(GetHost()));
263 typename Types::ContentLayerType* layer_ptr = layer.get();
264 SetProperties(layer_ptr, transform, position, bounds);
265
266 if (opaque_layers_) {
267 layer_ptr->SetContentsOpaque(opaque);
268 } else {
269 layer_ptr->SetContentsOpaque(false);
270 if (opaque)
271 layer_ptr->SetOpaqueContentsRect(gfx::Rect(bounds));
272 else
273 layer_ptr->SetOpaqueContentsRect(gfx::Rect());
274 }
275
276 parent->AddChild(Types::PassLayerPtr(&layer));
277 return layer_ptr;
278 }
279
280 typename Types::LayerType* CreateReplicaLayer(
281 typename Types::LayerType* owning_layer,
282 const gfx::Transform& transform,
283 gfx::PointF position,
284 gfx::Size bounds) {
285 typename Types::ContentLayerPtrType layer(
286 Types::CreateContentLayer(GetHost()));
287 typename Types::ContentLayerType* layer_ptr = layer.get();
288 SetProperties(layer_ptr, transform, position, bounds);
289 SetReplica(owning_layer, Types::PassLayerPtr(&layer));
290 return layer_ptr;
291 }
292
293 typename Types::LayerType* CreateMaskLayer(
294 typename Types::LayerType* owning_layer,
295 gfx::Size bounds) {
296 typename Types::ContentLayerPtrType layer(
297 Types::CreateContentLayer(GetHost()));
298 typename Types::ContentLayerType* layer_ptr = layer.get();
299 SetProperties(layer_ptr, identity_matrix, gfx::PointF(), bounds);
300 SetMask(owning_layer, Types::PassLayerPtr(&layer));
301 return layer_ptr;
302 }
303
304 typename Types::ContentLayerType* CreateDrawingSurface(
305 typename Types::LayerType* parent,
306 const gfx::Transform& transform,
307 gfx::PointF position,
308 gfx::Size bounds,
309 bool opaque) {
310 typename Types::ContentLayerType* layer =
311 CreateDrawingLayer(parent, transform, position, bounds, opaque);
312 layer->SetForceRenderSurface(true);
313 return layer;
314 }
315
316
317 void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {}
318
319 void AddCopyRequest(Layer* layer) {
320 layer->RequestCopyOfOutput(
321 CopyOutputRequest::CreateBitmapRequest(base::Bind(
322 &OcclusionTrackerTest<Types>::CopyOutputCallback,
323 base::Unretained(this))));
324 }
325
326 void AddCopyRequest(LayerImpl* layer) {
327 ScopedPtrVector<CopyOutputRequest> requests;
328 requests.push_back(
329 CopyOutputRequest::CreateBitmapRequest(base::Bind(
330 &OcclusionTrackerTest<Types>::CopyOutputCallback,
331 base::Unretained(this))));
332 layer->PassCopyRequests(&requests);
333 }
334
335 void CalcDrawEtc(TestContentLayerImpl* root) {
336 DCHECK(root == root_.get());
337 DCHECK(!root->render_surface());
338
339 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
340 root, root->bounds(), &render_surface_layer_list_impl_);
341 inputs.can_adjust_raster_scales = true;
342 LayerTreeHostCommon::CalculateDrawProperties(&inputs);
343
344 layer_iterator_ = layer_iterator_begin_ =
345 Types::TestLayerIterator::Begin(&render_surface_layer_list_impl_);
346 }
347
348 void CalcDrawEtc(TestContentLayer* root) {
349 DCHECK(root == root_.get());
350 DCHECK(!root->render_surface());
351
352 render_surface_layer_list_.reset(new RenderSurfaceLayerList);
353 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
354 root, root->bounds(), render_surface_layer_list_.get());
355 inputs.can_adjust_raster_scales = true;
356 LayerTreeHostCommon::CalculateDrawProperties(&inputs);
357
358 layer_iterator_ = layer_iterator_begin_ =
359 Types::TestLayerIterator::Begin(render_surface_layer_list_.get());
360 }
361
362 void EnterLayer(typename Types::LayerType* layer,
363 typename Types::OcclusionTrackerType* occlusion,
364 bool prevent_occlusion) {
365 ASSERT_EQ(layer, *layer_iterator_);
366 ASSERT_TRUE(layer_iterator_.represents_itself());
367 occlusion->EnterLayer(layer_iterator_, prevent_occlusion);
368 }
369
370 void LeaveLayer(typename Types::LayerType* layer,
371 typename Types::OcclusionTrackerType* occlusion) {
372 ASSERT_EQ(layer, *layer_iterator_);
373 ASSERT_TRUE(layer_iterator_.represents_itself());
374 occlusion->LeaveLayer(layer_iterator_);
375 ++layer_iterator_;
376 }
377
378 void VisitLayer(typename Types::LayerType* layer,
379 typename Types::OcclusionTrackerType* occlusion) {
380 EnterLayer(layer, occlusion, false);
381 LeaveLayer(layer, occlusion);
382 }
383
384 void EnterContributingSurface(
385 typename Types::LayerType* layer,
386 typename Types::OcclusionTrackerType* occlusion,
387 bool prevent_occlusion) {
388 ASSERT_EQ(layer, *layer_iterator_);
389 ASSERT_TRUE(layer_iterator_.represents_target_render_surface());
390 occlusion->EnterLayer(layer_iterator_, false);
391 occlusion->LeaveLayer(layer_iterator_);
392 ++layer_iterator_;
393 ASSERT_TRUE(layer_iterator_.represents_contributing_render_surface());
394 occlusion->EnterLayer(layer_iterator_, prevent_occlusion);
395 }
396
397 void LeaveContributingSurface(
398 typename Types::LayerType* layer,
399 typename Types::OcclusionTrackerType* occlusion) {
400 ASSERT_EQ(layer, *layer_iterator_);
401 ASSERT_TRUE(layer_iterator_.represents_contributing_render_surface());
402 occlusion->LeaveLayer(layer_iterator_);
403 ++layer_iterator_;
404 }
405
406 void VisitContributingSurface(
407 typename Types::LayerType* layer,
408 typename Types::OcclusionTrackerType* occlusion) {
409 EnterContributingSurface(layer, occlusion, false);
410 LeaveContributingSurface(layer, occlusion);
411 }
412
413 void ResetLayerIterator() { layer_iterator_ = layer_iterator_begin_; }
414
415 const gfx::Transform identity_matrix;
416
417 private:
418 void SetRootLayerOnMainThread(Layer* root) {
419 host_->SetRootLayer(scoped_refptr<Layer>(root));
420 }
421
422 void SetRootLayerOnMainThread(LayerImpl* root) {}
423
424 void SetBaseProperties(typename Types::LayerType* layer,
425 const gfx::Transform& transform,
426 gfx::PointF position,
427 gfx::Size bounds) {
428 layer->SetTransform(transform);
429 layer->SetSublayerTransform(gfx::Transform());
430 layer->SetAnchorPoint(gfx::PointF());
431 layer->SetPosition(position);
432 layer->SetBounds(bounds);
433 }
434
435 void SetProperties(Layer* layer,
436 const gfx::Transform& transform,
437 gfx::PointF position,
438 gfx::Size bounds) {
439 SetBaseProperties(layer, transform, position, bounds);
440 }
441
442 void SetProperties(LayerImpl* layer,
443 const gfx::Transform& transform,
444 gfx::PointF position,
445 gfx::Size bounds) {
446 SetBaseProperties(layer, transform, position, bounds);
447
448 layer->SetContentBounds(layer->bounds());
449 }
450
451 void SetReplica(Layer* owning_layer, scoped_refptr<Layer> layer) {
452 owning_layer->SetReplicaLayer(layer.get());
453 replica_layers_.push_back(layer);
454 }
455
456 void SetReplica(LayerImpl* owning_layer, scoped_ptr<LayerImpl> layer) {
457 owning_layer->SetReplicaLayer(layer.Pass());
458 }
459
460 void SetMask(Layer* owning_layer, scoped_refptr<Layer> layer) {
461 owning_layer->SetMaskLayer(layer.get());
462 mask_layers_.push_back(layer);
463 }
464
465 void SetMask(LayerImpl* owning_layer, scoped_ptr<LayerImpl> layer) {
466 owning_layer->SetMaskLayer(layer.Pass());
467 }
468
469 bool opaque_layers_;
470 scoped_ptr<FakeLayerTreeHost> host_;
471 // These hold ownership of the layers for the duration of the test.
472 typename Types::LayerPtrType root_;
473 scoped_ptr<RenderSurfaceLayerList> render_surface_layer_list_;
474 LayerImplList render_surface_layer_list_impl_;
475 typename Types::TestLayerIterator layer_iterator_begin_;
476 typename Types::TestLayerIterator layer_iterator_;
477 typename Types::LayerType* last_layer_visited_;
478 LayerList replica_layers_;
479 LayerList mask_layers_;
480 };
481
482 template <>
483 FakeLayerTreeHost*
484 OcclusionTrackerTest<OcclusionTrackerTestMainThreadTypes>::GetHost() {
485 return host_.get();
486 }
487
488 template <>
489 LayerTreeImpl*
490 OcclusionTrackerTest<OcclusionTrackerTestImplThreadTypes>::GetHost() {
491 return host_->host_impl()->active_tree();
492 }
493
494 #define RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) \
495 class ClassName##MainThreadOpaqueLayers \
496 : public ClassName<OcclusionTrackerTestMainThreadTypes> { \
497 public: /* NOLINT(whitespace/indent) */ \
498 ClassName##MainThreadOpaqueLayers() \
499 : ClassName<OcclusionTrackerTestMainThreadTypes>(true) {} \
500 }; \
501 TEST_F(ClassName##MainThreadOpaqueLayers, RunTest) { RunMyTest(); }
502 #define RUN_TEST_MAIN_THREAD_OPAQUE_PAINTS(ClassName) \
503 class ClassName##MainThreadOpaquePaints \
504 : public ClassName<OcclusionTrackerTestMainThreadTypes> { \
505 public: /* NOLINT(whitespace/indent) */ \
506 ClassName##MainThreadOpaquePaints() \
507 : ClassName<OcclusionTrackerTestMainThreadTypes>(false) {} \
508 }; \
509 TEST_F(ClassName##MainThreadOpaquePaints, RunTest) { RunMyTest(); }
510
511 #define RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName) \
512 class ClassName##ImplThreadOpaqueLayers \
513 : public ClassName<OcclusionTrackerTestImplThreadTypes> { \
514 public: /* NOLINT(whitespace/indent) */ \
515 ClassName##ImplThreadOpaqueLayers() \
516 : ClassName<OcclusionTrackerTestImplThreadTypes>(true) {} \
517 }; \
518 TEST_F(ClassName##ImplThreadOpaqueLayers, RunTest) { RunMyTest(); }
519 #define RUN_TEST_IMPL_THREAD_OPAQUE_PAINTS(ClassName) \
520 class ClassName##ImplThreadOpaquePaints \
521 : public ClassName<OcclusionTrackerTestImplThreadTypes> { \
522 public: /* NOLINT(whitespace/indent) */ \
523 ClassName##ImplThreadOpaquePaints() \
524 : ClassName<OcclusionTrackerTestImplThreadTypes>(false) {} \
525 }; \
526 TEST_F(ClassName##ImplThreadOpaquePaints, RunTest) { RunMyTest(); }
527
528 #define ALL_OCCLUSIONTRACKER_TEST(ClassName) \
529 RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) \
530 RUN_TEST_MAIN_THREAD_OPAQUE_PAINTS(ClassName) \
531 RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName) \
532 RUN_TEST_IMPL_THREAD_OPAQUE_PAINTS(ClassName)
533
534 #define MAIN_THREAD_TEST(ClassName) \
535 RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName)
536
537 #define IMPL_THREAD_TEST(ClassName) \
538 RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName)
539
540 #define MAIN_AND_IMPL_THREAD_TEST(ClassName) \
541 RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) \
542 RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName)
543
544 template <class Types>
545 class OcclusionTrackerTestIdentityTransforms
546 : public OcclusionTrackerTest<Types> {
547 protected:
548 explicit OcclusionTrackerTestIdentityTransforms(bool opaque_layers)
549 : OcclusionTrackerTest<Types>(opaque_layers) {}
550
551 void RunMyTest() {
552 typename Types::ContentLayerType* root = this->CreateRoot(
553 this->identity_matrix, gfx::PointF(), gfx::Size(200, 200));
554 typename Types::ContentLayerType* parent = this->CreateDrawingLayer(
555 root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true);
556 typename Types::ContentLayerType* layer =
557 this->CreateDrawingLayer(parent,
558 this->identity_matrix,
559 gfx::PointF(30.f, 30.f),
560 gfx::Size(500, 500),
561 true);
562 parent->SetMasksToBounds(true);
563 this->CalcDrawEtc(root);
564
565 TestOcclusionTrackerWithClip<typename Types::LayerType,
566 typename Types::RenderSurfaceType> occlusion(
567 gfx::Rect(0, 0, 1000, 1000), false);
568
569 this->VisitLayer(layer, &occlusion);
570 this->EnterLayer(parent, &occlusion, false);
571
572 EXPECT_EQ(gfx::Rect().ToString(),
573 occlusion.occlusion_from_outside_target().ToString());
574 EXPECT_EQ(gfx::Rect(30, 30, 70, 70).ToString(),
575 occlusion.occlusion_from_inside_target().ToString());
576
577 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 30, 70, 70)));
578 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 30, 70, 70)));
579 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 29, 70, 70)));
580 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(31, 30, 70, 70)));
581 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 31, 70, 70)));
582
583 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
584 parent, gfx::Rect(30, 30, 70, 70)).IsEmpty());
585 EXPECT_RECT_EQ(gfx::Rect(29, 30, 1, 70),
586 occlusion.UnoccludedLayerContentRect(
587 parent, gfx::Rect(29, 30, 70, 70)));
588 EXPECT_RECT_EQ(gfx::Rect(29, 29, 70, 70),
589 occlusion.UnoccludedLayerContentRect(
590 parent, gfx::Rect(29, 29, 70, 70)));
591 EXPECT_RECT_EQ(gfx::Rect(30, 29, 70, 1),
592 occlusion.UnoccludedLayerContentRect(
593 parent, gfx::Rect(30, 29, 70, 70)));
594 EXPECT_RECT_EQ(gfx::Rect(31, 29, 69, 1),
595 occlusion.UnoccludedLayerContentRect(
596 parent, gfx::Rect(31, 29, 70, 70)));
597 EXPECT_RECT_EQ(gfx::Rect(),
598 occlusion.UnoccludedLayerContentRect(
599 parent, gfx::Rect(31, 30, 70, 70)));
600 EXPECT_RECT_EQ(gfx::Rect(),
601 occlusion.UnoccludedLayerContentRect(
602 parent, gfx::Rect(31, 31, 70, 70)));
603 EXPECT_RECT_EQ(gfx::Rect(),
604 occlusion.UnoccludedLayerContentRect(
605 parent, gfx::Rect(30, 31, 70, 70)));
606 EXPECT_RECT_EQ(gfx::Rect(29, 31, 1, 69),
607 occlusion.UnoccludedLayerContentRect(
608 parent, gfx::Rect(29, 31, 70, 70)));
609 }
610 };
611
612 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestIdentityTransforms);
613
614 template <class Types>
615 class OcclusionTrackerTestQuadsMismatchLayer
616 : public OcclusionTrackerTest<Types> {
617 protected:
618 explicit OcclusionTrackerTestQuadsMismatchLayer(bool opaque_layers)
619 : OcclusionTrackerTest<Types>(opaque_layers) {}
620 void RunMyTest() {
621 gfx::Transform layer_transform;
622 layer_transform.Translate(10.0, 10.0);
623
624 typename Types::ContentLayerType* parent = this->CreateRoot(
625 this->identity_matrix, gfx::Point(0, 0), gfx::Size(100, 100));
626 typename Types::ContentLayerType* layer1 = this->CreateDrawingLayer(
627 parent, layer_transform, gfx::PointF(), gfx::Size(90, 90), true);
628 typename Types::ContentLayerType* layer2 = this->CreateDrawingLayer(
629 layer1, layer_transform, gfx::PointF(), gfx::Size(50, 50), true);
630 this->CalcDrawEtc(parent);
631
632 TestOcclusionTrackerWithClip<typename Types::LayerType,
633 typename Types::RenderSurfaceType> occlusion(
634 gfx::Rect(0, 0, 1000, 1000));
635
636 this->VisitLayer(layer2, &occlusion);
637 this->EnterLayer(layer1, &occlusion, false);
638
639 EXPECT_EQ(gfx::Rect().ToString(),
640 occlusion.occlusion_from_outside_target().ToString());
641 EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(),
642 occlusion.occlusion_from_inside_target().ToString());
643
644 // This checks cases where the quads don't match their "containing"
645 // layers, e.g. in terms of transforms or clip rect. This is typical for
646 // DelegatedRendererLayer.
647
648 gfx::Transform quad_transform;
649 quad_transform.Translate(30.0, 30.0);
650 gfx::Rect clip_rect_in_target(0, 0, 100, 100);
651
652 EXPECT_TRUE(occlusion.UnoccludedContentRect(parent,
653 gfx::Rect(0, 0, 10, 10),
654 quad_transform,
655 false,
656 true,
657 clip_rect_in_target,
658 NULL).IsEmpty());
659 EXPECT_RECT_EQ(gfx::Rect(0, 0, 10, 10),
660 occlusion.UnoccludedContentRect(parent,
661 gfx::Rect(0, 0, 10, 10),
662 quad_transform,
663 true,
664 true,
665 clip_rect_in_target,
666 NULL));
667 EXPECT_RECT_EQ(gfx::Rect(40, 40, 10, 10),
668 occlusion.UnoccludedContentRect(parent,
669 gfx::Rect(40, 40, 10, 10),
670 quad_transform,
671 false,
672 true,
673 clip_rect_in_target,
674 NULL));
675 EXPECT_RECT_EQ(gfx::Rect(40, 30, 5, 10),
676 occlusion.UnoccludedContentRect(parent,
677 gfx::Rect(35, 30, 10, 10),
678 quad_transform,
679 false,
680 true,
681 clip_rect_in_target,
682 NULL));
683 EXPECT_RECT_EQ(gfx::Rect(40, 40, 5, 5),
684 occlusion.UnoccludedContentRect(parent,
685 gfx::Rect(40, 40, 10, 10),
686 quad_transform,
687 false,
688 true,
689 gfx::Rect(0, 0, 75, 75),
690 NULL));
691 }
692 };
693
694 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestQuadsMismatchLayer);
695
696 template <class Types>
697 class OcclusionTrackerTestRotatedChild : public OcclusionTrackerTest<Types> {
698 protected:
699 explicit OcclusionTrackerTestRotatedChild(bool opaque_layers)
700 : OcclusionTrackerTest<Types>(opaque_layers) {}
701 void RunMyTest() {
702 gfx::Transform layer_transform;
703 layer_transform.Translate(250.0, 250.0);
704 layer_transform.Rotate(90.0);
705 layer_transform.Translate(-250.0, -250.0);
706
707 typename Types::ContentLayerType* root = this->CreateRoot(
708 this->identity_matrix, gfx::Point(0, 0), gfx::Size(200, 200));
709 typename Types::ContentLayerType* parent = this->CreateDrawingLayer(
710 root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true);
711 typename Types::ContentLayerType* layer =
712 this->CreateDrawingLayer(parent,
713 layer_transform,
714 gfx::PointF(30.f, 30.f),
715 gfx::Size(500, 500),
716 true);
717 parent->SetMasksToBounds(true);
718 this->CalcDrawEtc(root);
719
720 TestOcclusionTrackerWithClip<typename Types::LayerType,
721 typename Types::RenderSurfaceType> occlusion(
722 gfx::Rect(0, 0, 1000, 1000));
723
724 this->VisitLayer(layer, &occlusion);
725 this->EnterLayer(parent, &occlusion, false);
726
727 EXPECT_EQ(gfx::Rect().ToString(),
728 occlusion.occlusion_from_outside_target().ToString());
729 EXPECT_EQ(gfx::Rect(30, 30, 70, 70).ToString(),
730 occlusion.occlusion_from_inside_target().ToString());
731
732 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 30, 70, 70)));
733 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 30, 70, 70)));
734 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 29, 70, 70)));
735 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(31, 30, 70, 70)));
736 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 31, 70, 70)));
737
738 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
739 parent, gfx::Rect(30, 30, 70, 70)).IsEmpty());
740 EXPECT_RECT_EQ(gfx::Rect(29, 30, 1, 70),
741 occlusion.UnoccludedLayerContentRect(
742 parent, gfx::Rect(29, 30, 70, 70)));
743 EXPECT_RECT_EQ(gfx::Rect(29, 29, 70, 70),
744 occlusion.UnoccludedLayerContentRect(
745 parent, gfx::Rect(29, 29, 70, 70)));
746 EXPECT_RECT_EQ(gfx::Rect(30, 29, 70, 1),
747 occlusion.UnoccludedLayerContentRect(
748 parent, gfx::Rect(30, 29, 70, 70)));
749 EXPECT_RECT_EQ(gfx::Rect(31, 29, 69, 1),
750 occlusion.UnoccludedLayerContentRect(
751 parent, gfx::Rect(31, 29, 70, 70)));
752 EXPECT_RECT_EQ(gfx::Rect(),
753 occlusion.UnoccludedLayerContentRect(
754 parent, gfx::Rect(31, 30, 70, 70)));
755 EXPECT_RECT_EQ(gfx::Rect(),
756 occlusion.UnoccludedLayerContentRect(
757 parent, gfx::Rect(31, 31, 70, 70)));
758 EXPECT_RECT_EQ(gfx::Rect(),
759 occlusion.UnoccludedLayerContentRect(
760 parent, gfx::Rect(30, 31, 70, 70)));
761 EXPECT_RECT_EQ(gfx::Rect(29, 31, 1, 69),
762 occlusion.UnoccludedLayerContentRect(
763 parent, gfx::Rect(29, 31, 70, 70)));
764 }
765 };
766
767 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestRotatedChild);
768
769 template <class Types>
770 class OcclusionTrackerTestTranslatedChild : public OcclusionTrackerTest<Types> {
771 protected:
772 explicit OcclusionTrackerTestTranslatedChild(bool opaque_layers)
773 : OcclusionTrackerTest<Types>(opaque_layers) {}
774 void RunMyTest() {
775 gfx::Transform layer_transform;
776 layer_transform.Translate(20.0, 20.0);
777
778 typename Types::ContentLayerType* root = this->CreateRoot(
779 this->identity_matrix, gfx::PointF(), gfx::Size(200, 200));
780 typename Types::ContentLayerType* parent = this->CreateDrawingLayer(
781 root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true);
782 typename Types::ContentLayerType* layer =
783 this->CreateDrawingLayer(parent,
784 layer_transform,
785 gfx::PointF(30.f, 30.f),
786 gfx::Size(500, 500),
787 true);
788 parent->SetMasksToBounds(true);
789 this->CalcDrawEtc(root);
790
791 TestOcclusionTrackerWithClip<typename Types::LayerType,
792 typename Types::RenderSurfaceType> occlusion(
793 gfx::Rect(0, 0, 1000, 1000));
794
795 this->VisitLayer(layer, &occlusion);
796 this->EnterLayer(parent, &occlusion, false);
797
798 EXPECT_EQ(gfx::Rect().ToString(),
799 occlusion.occlusion_from_outside_target().ToString());
800 EXPECT_EQ(gfx::Rect(50, 50, 50, 50).ToString(),
801 occlusion.occlusion_from_inside_target().ToString());
802
803 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(50, 50, 50, 50)));
804 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(49, 50, 50, 50)));
805 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(50, 49, 50, 50)));
806 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(51, 50, 50, 50)));
807 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(50, 51, 50, 50)));
808
809 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
810 parent, gfx::Rect(50, 50, 50, 50)).IsEmpty());
811 EXPECT_RECT_EQ(gfx::Rect(49, 50, 1, 50),
812 occlusion.UnoccludedLayerContentRect(
813 parent, gfx::Rect(49, 50, 50, 50)));
814 EXPECT_RECT_EQ(gfx::Rect(49, 49, 50, 50),
815 occlusion.UnoccludedLayerContentRect(
816 parent, gfx::Rect(49, 49, 50, 50)));
817 EXPECT_RECT_EQ(gfx::Rect(50, 49, 50, 1),
818 occlusion.UnoccludedLayerContentRect(
819 parent, gfx::Rect(50, 49, 50, 50)));
820 EXPECT_RECT_EQ(gfx::Rect(51, 49, 49, 1),
821 occlusion.UnoccludedLayerContentRect(
822 parent, gfx::Rect(51, 49, 50, 50)));
823 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
824 parent, gfx::Rect(51, 50, 50, 50)).IsEmpty());
825 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
826 parent, gfx::Rect(51, 51, 50, 50)).IsEmpty());
827 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
828 parent, gfx::Rect(50, 51, 50, 50)).IsEmpty());
829 EXPECT_RECT_EQ(gfx::Rect(49, 51, 1, 49),
830 occlusion.UnoccludedLayerContentRect(
831 parent, gfx::Rect(49, 51, 50, 50)));
832 }
833 };
834
835 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestTranslatedChild);
836
837 template <class Types>
838 class OcclusionTrackerTestChildInRotatedChild
839 : public OcclusionTrackerTest<Types> {
840 protected:
841 explicit OcclusionTrackerTestChildInRotatedChild(bool opaque_layers)
842 : OcclusionTrackerTest<Types>(opaque_layers) {}
843 void RunMyTest() {
844 gfx::Transform child_transform;
845 child_transform.Translate(250.0, 250.0);
846 child_transform.Rotate(90.0);
847 child_transform.Translate(-250.0, -250.0);
848
849 typename Types::ContentLayerType* parent = this->CreateRoot(
850 this->identity_matrix, gfx::PointF(), gfx::Size(100, 100));
851 parent->SetMasksToBounds(true);
852 typename Types::LayerType* child = this->CreateSurface(
853 parent, child_transform, gfx::PointF(30.f, 30.f), gfx::Size(500, 500));
854 child->SetMasksToBounds(true);
855 typename Types::ContentLayerType* layer =
856 this->CreateDrawingLayer(child,
857 this->identity_matrix,
858 gfx::PointF(10.f, 10.f),
859 gfx::Size(500, 500),
860 true);
861 this->CalcDrawEtc(parent);
862
863 TestOcclusionTrackerWithClip<typename Types::LayerType,
864 typename Types::RenderSurfaceType> occlusion(
865 gfx::Rect(0, 0, 1000, 1000));
866
867 this->VisitLayer(layer, &occlusion);
868 this->EnterContributingSurface(child, &occlusion, false);
869
870 EXPECT_EQ(gfx::Rect().ToString(),
871 occlusion.occlusion_from_outside_target().ToString());
872 EXPECT_EQ(gfx::Rect(10, 430, 60, 70).ToString(),
873 occlusion.occlusion_from_inside_target().ToString());
874
875 this->LeaveContributingSurface(child, &occlusion);
876 this->EnterLayer(parent, &occlusion, false);
877
878 EXPECT_EQ(gfx::Rect().ToString(),
879 occlusion.occlusion_from_outside_target().ToString());
880 EXPECT_EQ(gfx::Rect(30, 40, 70, 60).ToString(),
881 occlusion.occlusion_from_inside_target().ToString());
882
883 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 40, 70, 60)));
884 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 40, 70, 60)));
885 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 39, 70, 60)));
886 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(31, 40, 70, 60)));
887 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 41, 70, 60)));
888
889 /* Justification for the above occlusion from |layer|:
890 100
891 +---------------------+
892 | |
893 | 30 | rotate(90)
894 | 30 + ---------------------------------+
895 100 | | 10 | | ==>
896 | |10+---------------------------------+
897 | | | | | |
898 | | | | | |
899 | | | | | |
900 +----|--|-------------+ | |
901 | | | |
902 | | | |
903 | | | |500
904 | | | |
905 | | | |
906 | | | |
907 | | | |
908 +--|-------------------------------+ |
909 | |
910 +---------------------------------+
911 500
912
913 +---------------------+
914 | |30 Visible region of |layer|: /////
915 | |
916 | +---------------------------------+
917 100| | |10 |
918 | +---------------------------------+ |
919 | | |///////////////| 420 | |
920 | | |///////////////|60 | |
921 | | |///////////////| | |
922 +--|--|---------------+ | |
923 20|10| 70 | |
924 | | | |
925 | | | |
926 | | | |
927 | | | |
928 | | | |
929 | | |10|
930 | +------------------------------|--+
931 | 490 |
932 +---------------------------------+
933 500
934
935 */
936 }
937 };
938
939 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestChildInRotatedChild);
940
941 template <class Types>
942 class OcclusionTrackerTestScaledRenderSurface
943 : public OcclusionTrackerTest<Types> {
944 protected:
945 explicit OcclusionTrackerTestScaledRenderSurface(bool opaque_layers)
946 : OcclusionTrackerTest<Types>(opaque_layers) {}
947
948 void RunMyTest() {
949 typename Types::ContentLayerType* parent = this->CreateRoot(
950 this->identity_matrix, gfx::PointF(), gfx::Size(200, 200));
951
952 gfx::Transform layer1_matrix;
953 layer1_matrix.Scale(2.0, 2.0);
954 typename Types::ContentLayerType* layer1 = this->CreateDrawingLayer(
955 parent, layer1_matrix, gfx::PointF(), gfx::Size(100, 100), true);
956 layer1->SetForceRenderSurface(true);
957
958 gfx::Transform layer2_matrix;
959 layer2_matrix.Translate(25.0, 25.0);
960 typename Types::ContentLayerType* layer2 = this->CreateDrawingLayer(
961 layer1, layer2_matrix, gfx::PointF(), gfx::Size(50, 50), true);
962 typename Types::ContentLayerType* occluder =
963 this->CreateDrawingLayer(parent,
964 this->identity_matrix,
965 gfx::PointF(100.f, 100.f),
966 gfx::Size(500, 500),
967 true);
968 this->CalcDrawEtc(parent);
969
970 TestOcclusionTrackerWithClip<typename Types::LayerType,
971 typename Types::RenderSurfaceType> occlusion(
972 gfx::Rect(0, 0, 1000, 1000));
973
974 this->VisitLayer(occluder, &occlusion);
975 this->EnterLayer(layer2, &occlusion, false);
976
977 EXPECT_EQ(gfx::Rect(100, 100, 100, 100).ToString(),
978 occlusion.occlusion_from_outside_target().ToString());
979 EXPECT_EQ(gfx::Rect().ToString(),
980 occlusion.occlusion_from_inside_target().ToString());
981
982 EXPECT_RECT_EQ(
983 gfx::Rect(0, 0, 25, 25),
984 occlusion.UnoccludedLayerContentRect(layer2, gfx::Rect(0, 0, 25, 25)));
985 EXPECT_RECT_EQ(gfx::Rect(10, 25, 15, 25),
986 occlusion.UnoccludedLayerContentRect(
987 layer2, gfx::Rect(10, 25, 25, 25)));
988 EXPECT_RECT_EQ(gfx::Rect(25, 10, 25, 15),
989 occlusion.UnoccludedLayerContentRect(
990 layer2, gfx::Rect(25, 10, 25, 25)));
991 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
992 layer2, gfx::Rect(25, 25, 25, 25)).IsEmpty());
993 }
994 };
995
996 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestScaledRenderSurface);
997
998 template <class Types>
999 class OcclusionTrackerTestVisitTargetTwoTimes
1000 : public OcclusionTrackerTest<Types> {
1001 protected:
1002 explicit OcclusionTrackerTestVisitTargetTwoTimes(bool opaque_layers)
1003 : OcclusionTrackerTest<Types>(opaque_layers) {}
1004 void RunMyTest() {
1005 gfx::Transform child_transform;
1006 child_transform.Translate(250.0, 250.0);
1007 child_transform.Rotate(90.0);
1008 child_transform.Translate(-250.0, -250.0);
1009
1010 typename Types::ContentLayerType* root = this->CreateRoot(
1011 this->identity_matrix, gfx::PointF(), gfx::Size(200, 200));
1012 typename Types::ContentLayerType* parent = this->CreateDrawingLayer(
1013 root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true);
1014 parent->SetMasksToBounds(true);
1015 typename Types::LayerType* child = this->CreateSurface(
1016 parent, child_transform, gfx::PointF(30.f, 30.f), gfx::Size(500, 500));
1017 child->SetMasksToBounds(true);
1018 typename Types::ContentLayerType* layer =
1019 this->CreateDrawingLayer(child,
1020 this->identity_matrix,
1021 gfx::PointF(10.f, 10.f),
1022 gfx::Size(500, 500),
1023 true);
1024 // |child2| makes |parent|'s surface get considered by OcclusionTracker
1025 // first, instead of |child|'s. This exercises different code in
1026 // LeaveToRenderTarget, as the target surface has already been seen.
1027 typename Types::ContentLayerType* child2 =
1028 this->CreateDrawingLayer(parent,
1029 this->identity_matrix,
1030 gfx::PointF(30.f, 30.f),
1031 gfx::Size(60, 20),
1032 true);
1033 this->CalcDrawEtc(root);
1034
1035 TestOcclusionTrackerWithClip<typename Types::LayerType,
1036 typename Types::RenderSurfaceType> occlusion(
1037 gfx::Rect(0, 0, 1000, 1000));
1038
1039 this->VisitLayer(child2, &occlusion);
1040
1041 EXPECT_EQ(gfx::Rect().ToString(),
1042 occlusion.occlusion_from_outside_target().ToString());
1043 EXPECT_EQ(gfx::Rect(30, 30, 60, 20).ToString(),
1044 occlusion.occlusion_from_inside_target().ToString());
1045
1046 this->VisitLayer(layer, &occlusion);
1047
1048 EXPECT_EQ(gfx::Rect(0, 440, 20, 60).ToString(),
1049 occlusion.occlusion_from_outside_target().ToString());
1050 EXPECT_EQ(gfx::Rect(10, 430, 60, 70).ToString(),
1051 occlusion.occlusion_from_inside_target().ToString());
1052
1053 this->EnterContributingSurface(child, &occlusion, false);
1054
1055 EXPECT_EQ(gfx::Rect(0, 440, 20, 60).ToString(),
1056 occlusion.occlusion_from_outside_target().ToString());
1057 EXPECT_EQ(gfx::Rect(10, 430, 60, 70).ToString(),
1058 occlusion.occlusion_from_inside_target().ToString());
1059
1060 // Occlusion in |child2| should get merged with the |child| surface we are
1061 // leaving now.
1062 this->LeaveContributingSurface(child, &occlusion);
1063 this->EnterLayer(parent, &occlusion, false);
1064
1065 EXPECT_EQ(gfx::Rect().ToString(),
1066 occlusion.occlusion_from_outside_target().ToString());
1067 EXPECT_EQ(UnionRegions(gfx::Rect(30, 30, 60, 10), gfx::Rect(30, 40, 70, 60))
1068 .ToString(),
1069 occlusion.occlusion_from_inside_target().ToString());
1070
1071 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 30, 70, 70)));
1072 EXPECT_RECT_EQ(gfx::Rect(90, 30, 10, 10),
1073 occlusion.UnoccludedLayerContentRect(
1074 parent, gfx::Rect(30, 30, 70, 70)));
1075
1076 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 30, 60, 10)));
1077 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 30, 60, 10)));
1078 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 29, 60, 10)));
1079 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(31, 30, 60, 10)));
1080 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 31, 60, 10)));
1081
1082 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 40, 70, 60)));
1083 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 40, 70, 60)));
1084 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 39, 70, 60)));
1085
1086 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
1087 parent, gfx::Rect(30, 30, 60, 10)).IsEmpty());
1088 EXPECT_RECT_EQ(gfx::Rect(29, 30, 1, 10),
1089 occlusion.UnoccludedLayerContentRect(
1090 parent, gfx::Rect(29, 30, 60, 10)));
1091 EXPECT_RECT_EQ(gfx::Rect(30, 29, 60, 1),
1092 occlusion.UnoccludedLayerContentRect(
1093 parent, gfx::Rect(30, 29, 60, 10)));
1094 EXPECT_RECT_EQ(gfx::Rect(90, 30, 1, 10),
1095 occlusion.UnoccludedLayerContentRect(
1096 parent, gfx::Rect(31, 30, 60, 10)));
1097 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
1098 parent, gfx::Rect(30, 31, 60, 10)).IsEmpty());
1099
1100 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
1101 parent, gfx::Rect(30, 40, 70, 60)).IsEmpty());
1102 EXPECT_RECT_EQ(gfx::Rect(29, 40, 1, 60),
1103 occlusion.UnoccludedLayerContentRect(
1104 parent, gfx::Rect(29, 40, 70, 60)));
1105 // This rect is mostly occluded by |child2|.
1106 EXPECT_RECT_EQ(gfx::Rect(90, 39, 10, 1),
1107 occlusion.UnoccludedLayerContentRect(
1108 parent, gfx::Rect(30, 39, 70, 60)));
1109 // This rect extends past top/right ends of |child2|.
1110 EXPECT_RECT_EQ(gfx::Rect(30, 29, 70, 11),
1111 occlusion.UnoccludedLayerContentRect(
1112 parent, gfx::Rect(30, 29, 70, 70)));
1113 // This rect extends past left/right ends of |child2|.
1114 EXPECT_RECT_EQ(gfx::Rect(20, 39, 80, 60),
1115 occlusion.UnoccludedLayerContentRect(
1116 parent, gfx::Rect(20, 39, 80, 60)));
1117 EXPECT_RECT_EQ(gfx::Rect(),
1118 occlusion.UnoccludedLayerContentRect(
1119 parent, gfx::Rect(31, 40, 70, 60)));
1120 EXPECT_RECT_EQ(gfx::Rect(),
1121 occlusion.UnoccludedLayerContentRect(
1122 parent, gfx::Rect(30, 41, 70, 60)));
1123
1124 /* Justification for the above occlusion from |layer|:
1125 100
1126 +---------------------+
1127 | |
1128 | 30 | rotate(90)
1129 | 30 + ------------+--------------------+
1130 100 | | 10 | | | ==>
1131 | |10+----------|----------------------+
1132 | + ------------+ | | |
1133 | | | | | |
1134 | | | | | |
1135 +----|--|-------------+ | |
1136 | | | |
1137 | | | |
1138 | | | |500
1139 | | | |
1140 | | | |
1141 | | | |
1142 | | | |
1143 +--|-------------------------------+ |
1144 | |
1145 +---------------------------------+
1146 500
1147
1148
1149 +---------------------+
1150 | |30 Visible region of |layer|: /////
1151 | 30 60 | |child2|: \\\\\
1152 | 30 +------------+--------------------+
1153 | |\\\\\\\\\\\\| |10 |
1154 | +--|\\\\\\\\\\\\|-----------------+ |
1155 | | +------------+//| 420 | |
1156 | | |///////////////|60 | |
1157 | | |///////////////| | |
1158 +--|--|---------------+ | |
1159 20|10| 70 | |
1160 | | | |
1161 | | | |
1162 | | | |
1163 | | | |
1164 | | | |
1165 | | |10|
1166 | +------------------------------|--+
1167 | 490 |
1168 +---------------------------------+
1169 500
1170 */
1171 }
1172 };
1173
1174 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestVisitTargetTwoTimes);
1175
1176 template <class Types>
1177 class OcclusionTrackerTestSurfaceRotatedOffAxis
1178 : public OcclusionTrackerTest<Types> {
1179 protected:
1180 explicit OcclusionTrackerTestSurfaceRotatedOffAxis(bool opaque_layers)
1181 : OcclusionTrackerTest<Types>(opaque_layers) {}
1182 void RunMyTest() {
1183 gfx::Transform child_transform;
1184 child_transform.Translate(250.0, 250.0);
1185 child_transform.Rotate(95.0);
1186 child_transform.Translate(-250.0, -250.0);
1187
1188 gfx::Transform layer_transform;
1189 layer_transform.Translate(10.0, 10.0);
1190
1191 typename Types::ContentLayerType* root = this->CreateRoot(
1192 this->identity_matrix, gfx::PointF(), gfx::Size(1000, 1000));
1193 typename Types::ContentLayerType* parent = this->CreateDrawingLayer(
1194 root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true);
1195 typename Types::LayerType* child = this->CreateLayer(
1196 parent, child_transform, gfx::PointF(30.f, 30.f), gfx::Size(500, 500));
1197 child->SetMasksToBounds(true);
1198 typename Types::ContentLayerType* layer = this->CreateDrawingLayer(
1199 child, layer_transform, gfx::PointF(), gfx::Size(500, 500), true);
1200 this->CalcDrawEtc(root);
1201
1202 TestOcclusionTrackerWithClip<typename Types::LayerType,
1203 typename Types::RenderSurfaceType> occlusion(
1204 gfx::Rect(0, 0, 1000, 1000));
1205
1206 gfx::Rect clipped_layer_in_child = MathUtil::MapClippedRect(
1207 layer_transform, layer->visible_content_rect());
1208
1209 this->VisitLayer(layer, &occlusion);
1210 this->EnterContributingSurface(child, &occlusion, false);
1211
1212 EXPECT_EQ(gfx::Rect().ToString(),
1213 occlusion.occlusion_from_outside_target().ToString());
1214 EXPECT_EQ(clipped_layer_in_child.ToString(),
1215 occlusion.occlusion_from_inside_target().ToString());
1216
1217 this->LeaveContributingSurface(child, &occlusion);
1218 this->EnterLayer(parent, &occlusion, false);
1219
1220 EXPECT_EQ(gfx::Rect().ToString(),
1221 occlusion.occlusion_from_outside_target().ToString());
1222 EXPECT_EQ(gfx::Rect().ToString(),
1223 occlusion.occlusion_from_inside_target().ToString());
1224
1225 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(75, 55, 1, 1)));
1226 EXPECT_RECT_EQ(
1227 gfx::Rect(75, 55, 1, 1),
1228 occlusion.UnoccludedLayerContentRect(parent, gfx::Rect(75, 55, 1, 1)));
1229 }
1230 };
1231
1232 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceRotatedOffAxis);
1233
1234 template <class Types>
1235 class OcclusionTrackerTestSurfaceWithTwoOpaqueChildren
1236 : public OcclusionTrackerTest<Types> {
1237 protected:
1238 explicit OcclusionTrackerTestSurfaceWithTwoOpaqueChildren(bool opaque_layers)
1239 : OcclusionTrackerTest<Types>(opaque_layers) {}
1240 void RunMyTest() {
1241 gfx::Transform child_transform;
1242 child_transform.Translate(250.0, 250.0);
1243 child_transform.Rotate(90.0);
1244 child_transform.Translate(-250.0, -250.0);
1245
1246 typename Types::ContentLayerType* root = this->CreateRoot(
1247 this->identity_matrix, gfx::PointF(), gfx::Size(1000, 1000));
1248 typename Types::ContentLayerType* parent = this->CreateDrawingLayer(
1249 root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true);
1250 parent->SetMasksToBounds(true);
1251 typename Types::ContentLayerType* child =
1252 this->CreateDrawingSurface(parent,
1253 child_transform,
1254 gfx::PointF(30.f, 30.f),
1255 gfx::Size(500, 500),
1256 false);
1257 child->SetMasksToBounds(true);
1258 typename Types::ContentLayerType* layer1 =
1259 this->CreateDrawingLayer(child,
1260 this->identity_matrix,
1261 gfx::PointF(10.f, 10.f),
1262 gfx::Size(500, 500),
1263 true);
1264 typename Types::ContentLayerType* layer2 =
1265 this->CreateDrawingLayer(child,
1266 this->identity_matrix,
1267 gfx::PointF(10.f, 450.f),
1268 gfx::Size(500, 60),
1269 true);
1270 this->CalcDrawEtc(root);
1271
1272 TestOcclusionTrackerWithClip<typename Types::LayerType,
1273 typename Types::RenderSurfaceType> occlusion(
1274 gfx::Rect(0, 0, 1000, 1000));
1275
1276 this->VisitLayer(layer2, &occlusion);
1277 this->VisitLayer(layer1, &occlusion);
1278 this->VisitLayer(child, &occlusion);
1279 this->EnterContributingSurface(child, &occlusion, false);
1280
1281 EXPECT_EQ(gfx::Rect().ToString(),
1282 occlusion.occlusion_from_outside_target().ToString());
1283 EXPECT_EQ(gfx::Rect(10, 430, 60, 70).ToString(),
1284 occlusion.occlusion_from_inside_target().ToString());
1285
1286 EXPECT_TRUE(occlusion.OccludedLayer(child, gfx::Rect(10, 430, 60, 70)));
1287 EXPECT_FALSE(occlusion.OccludedLayer(child, gfx::Rect(9, 430, 60, 70)));
1288 // These rects are occluded except for the part outside the bounds of the
1289 // target surface.
1290 EXPECT_TRUE(occlusion.OccludedLayer(child, gfx::Rect(10, 429, 60, 70)));
1291 EXPECT_TRUE(occlusion.OccludedLayer(child, gfx::Rect(11, 430, 60, 70)));
1292 EXPECT_TRUE(occlusion.OccludedLayer(child, gfx::Rect(10, 431, 60, 70)));
1293
1294 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
1295 child, gfx::Rect(10, 430, 60, 70)).IsEmpty());
1296 EXPECT_RECT_EQ(
1297 gfx::Rect(9, 430, 1, 70),
1298 occlusion.UnoccludedLayerContentRect(child, gfx::Rect(9, 430, 60, 70)));
1299 // These rects are occluded except for the part outside the bounds of the
1300 // target surface.
1301 EXPECT_RECT_EQ(gfx::Rect(),
1302 occlusion.UnoccludedLayerContentRect(
1303 child, gfx::Rect(10, 429, 60, 70)));
1304 EXPECT_RECT_EQ(gfx::Rect(),
1305 occlusion.UnoccludedLayerContentRect(
1306 child, gfx::Rect(11, 430, 60, 70)));
1307 EXPECT_RECT_EQ(gfx::Rect(),
1308 occlusion.UnoccludedLayerContentRect(
1309 child, gfx::Rect(10, 431, 60, 70)));
1310
1311 this->LeaveContributingSurface(child, &occlusion);
1312 this->EnterLayer(parent, &occlusion, false);
1313
1314 EXPECT_EQ(gfx::Rect().ToString(),
1315 occlusion.occlusion_from_outside_target().ToString());
1316 EXPECT_EQ(gfx::Rect(30, 40, 70, 60).ToString(),
1317 occlusion.occlusion_from_inside_target().ToString());
1318
1319 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 40, 70, 60)));
1320 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 40, 70, 60)));
1321 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 39, 70, 60)));
1322
1323 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
1324 parent, gfx::Rect(30, 40, 70, 60)).IsEmpty());
1325 EXPECT_RECT_EQ(gfx::Rect(29, 40, 1, 60),
1326 occlusion.UnoccludedLayerContentRect(
1327 parent, gfx::Rect(29, 40, 70, 60)));
1328 EXPECT_RECT_EQ(gfx::Rect(30, 39, 70, 1),
1329 occlusion.UnoccludedLayerContentRect(
1330 parent, gfx::Rect(30, 39, 70, 60)));
1331 EXPECT_RECT_EQ(gfx::Rect(),
1332 occlusion.UnoccludedLayerContentRect(
1333 parent, gfx::Rect(31, 40, 70, 60)));
1334 EXPECT_RECT_EQ(gfx::Rect(),
1335 occlusion.UnoccludedLayerContentRect(
1336 parent, gfx::Rect(30, 41, 70, 60)));
1337
1338 /* Justification for the above occlusion from |layer1| and |layer2|:
1339
1340 +---------------------+
1341 | |30 Visible region of |layer1|: /////
1342 | | Visible region of |layer2|: \\\\\
1343 | +---------------------------------+
1344 | | |10 |
1345 | +---------------+-----------------+ |
1346 | | |\\\\\\\\\\\\|//| 420 | |
1347 | | |\\\\\\\\\\\\|//|60 | |
1348 | | |\\\\\\\\\\\\|//| | |
1349 +--|--|------------|--+ | |
1350 20|10| 70 | | |
1351 | | | | |
1352 | | | | |
1353 | | | | |
1354 | | | | |
1355 | | | | |
1356 | | | |10|
1357 | +------------|-----------------|--+
1358 | | 490 |
1359 +---------------+-----------------+
1360 60 440
1361 */
1362 }
1363 };
1364
1365 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceWithTwoOpaqueChildren);
1366
1367 template <class Types>
1368 class OcclusionTrackerTestOverlappingSurfaceSiblings
1369 : public OcclusionTrackerTest<Types> {
1370 protected:
1371 explicit OcclusionTrackerTestOverlappingSurfaceSiblings(bool opaque_layers)
1372 : OcclusionTrackerTest<Types>(opaque_layers) {}
1373 void RunMyTest() {
1374 gfx::Transform child_transform;
1375 child_transform.Translate(250.0, 250.0);
1376 child_transform.Rotate(90.0);
1377 child_transform.Translate(-250.0, -250.0);
1378
1379 typename Types::ContentLayerType* parent = this->CreateRoot(
1380 this->identity_matrix, gfx::PointF(), gfx::Size(100, 100));
1381 parent->SetMasksToBounds(true);
1382 typename Types::LayerType* child1 = this->CreateSurface(
1383 parent, child_transform, gfx::PointF(30.f, 30.f), gfx::Size(10, 10));
1384 typename Types::LayerType* child2 = this->CreateSurface(
1385 parent, child_transform, gfx::PointF(20.f, 40.f), gfx::Size(10, 10));
1386 typename Types::ContentLayerType* layer1 =
1387 this->CreateDrawingLayer(child1,
1388 this->identity_matrix,
1389 gfx::PointF(-10.f, -10.f),
1390 gfx::Size(510, 510),
1391 true);
1392 typename Types::ContentLayerType* layer2 =
1393 this->CreateDrawingLayer(child2,
1394 this->identity_matrix,
1395 gfx::PointF(-10.f, -10.f),
1396 gfx::Size(510, 510),
1397 true);
1398 this->CalcDrawEtc(parent);
1399
1400 TestOcclusionTrackerWithClip<typename Types::LayerType,
1401 typename Types::RenderSurfaceType> occlusion(
1402 gfx::Rect(0, 0, 1000, 1000));
1403
1404 this->VisitLayer(layer2, &occlusion);
1405 this->EnterContributingSurface(child2, &occlusion, false);
1406
1407 EXPECT_EQ(gfx::Rect().ToString(),
1408 occlusion.occlusion_from_outside_target().ToString());
1409 EXPECT_EQ(gfx::Rect(-10, 420, 70, 80).ToString(),
1410 occlusion.occlusion_from_inside_target().ToString());
1411
1412 EXPECT_TRUE(occlusion.OccludedLayer(child2, gfx::Rect(-10, 420, 70, 80)));
1413 EXPECT_TRUE(occlusion.OccludedLayer(child2, gfx::Rect(-11, 420, 70, 80)));
1414 EXPECT_TRUE(occlusion.OccludedLayer(child2, gfx::Rect(-10, 419, 70, 80)));
1415 EXPECT_TRUE(occlusion.OccludedLayer(child2, gfx::Rect(-10, 420, 71, 80)));
1416 EXPECT_TRUE(occlusion.OccludedLayer(child2, gfx::Rect(-10, 420, 70, 81)));
1417
1418 // There is nothing above child2's surface in the z-order.
1419 EXPECT_RECT_EQ(gfx::Rect(-10, 420, 70, 80),
1420 occlusion.UnoccludedContributingSurfaceContentRect(
1421 child2, false, gfx::Rect(-10, 420, 70, 80), NULL));
1422
1423 this->LeaveContributingSurface(child2, &occlusion);
1424 this->VisitLayer(layer1, &occlusion);
1425 this->EnterContributingSurface(child1, &occlusion, false);
1426
1427 EXPECT_EQ(gfx::Rect(0, 430, 70, 80).ToString(),
1428 occlusion.occlusion_from_outside_target().ToString());
1429 EXPECT_EQ(gfx::Rect(-10, 430, 80, 70).ToString(),
1430 occlusion.occlusion_from_inside_target().ToString());
1431
1432 // child2's contents will occlude child1 below it.
1433 EXPECT_RECT_EQ(gfx::Rect(-10, 430, 10, 70),
1434 occlusion.UnoccludedContributingSurfaceContentRect(
1435 child1, false, gfx::Rect(-10, 430, 80, 70), NULL));
1436
1437 this->LeaveContributingSurface(child1, &occlusion);
1438 this->EnterLayer(parent, &occlusion, false);
1439
1440 EXPECT_EQ(gfx::Rect().ToString(),
1441 occlusion.occlusion_from_outside_target().ToString());
1442 EXPECT_EQ(UnionRegions(gfx::Rect(30, 20, 70, 10), gfx::Rect(20, 30, 80, 70))
1443 .ToString(),
1444 occlusion.occlusion_from_inside_target().ToString());
1445
1446 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(20, 20, 80, 80)));
1447
1448 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 20, 70, 80)));
1449 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 20, 70, 80)));
1450 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 19, 70, 80)));
1451
1452 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(20, 30, 80, 70)));
1453 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(19, 30, 80, 70)));
1454 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(20, 29, 80, 70)));
1455
1456 /* Justification for the above occlusion:
1457 100
1458 +---------------------+
1459 | 20 | layer1
1460 | 30+ ---------------------------------+
1461 100 | 30| | layer2 |
1462 |20+----------------------------------+ |
1463 | | | | | |
1464 | | | | | |
1465 | | | | | |
1466 +--|-|----------------+ | |
1467 | | | | 510
1468 | | | |
1469 | | | |
1470 | | | |
1471 | | | |
1472 | | | |
1473 | | | |
1474 | +--------------------------------|-+
1475 | |
1476 +----------------------------------+
1477 510
1478 */
1479 }
1480 };
1481
1482 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestOverlappingSurfaceSiblings);
1483
1484 template <class Types>
1485 class OcclusionTrackerTestOverlappingSurfaceSiblingsWithTwoTransforms
1486 : public OcclusionTrackerTest<Types> {
1487 protected:
1488 explicit OcclusionTrackerTestOverlappingSurfaceSiblingsWithTwoTransforms(
1489 bool opaque_layers)
1490 : OcclusionTrackerTest<Types>(opaque_layers) {}
1491 void RunMyTest() {
1492 gfx::Transform child1_transform;
1493 child1_transform.Translate(250.0, 250.0);
1494 child1_transform.Rotate(-90.0);
1495 child1_transform.Translate(-250.0, -250.0);
1496
1497 gfx::Transform child2_transform;
1498 child2_transform.Translate(250.0, 250.0);
1499 child2_transform.Rotate(90.0);
1500 child2_transform.Translate(-250.0, -250.0);
1501
1502 typename Types::ContentLayerType* parent = this->CreateRoot(
1503 this->identity_matrix, gfx::PointF(), gfx::Size(100, 100));
1504 parent->SetMasksToBounds(true);
1505 typename Types::LayerType* child1 = this->CreateSurface(
1506 parent, child1_transform, gfx::PointF(30.f, 20.f), gfx::Size(10, 10));
1507 typename Types::LayerType* child2 =
1508 this->CreateDrawingSurface(parent,
1509 child2_transform,
1510 gfx::PointF(20.f, 40.f),
1511 gfx::Size(10, 10),
1512 false);
1513 typename Types::ContentLayerType* layer1 =
1514 this->CreateDrawingLayer(child1,
1515 this->identity_matrix,
1516 gfx::PointF(-10.f, -20.f),
1517 gfx::Size(510, 510),
1518 true);
1519 typename Types::ContentLayerType* layer2 =
1520 this->CreateDrawingLayer(child2,
1521 this->identity_matrix,
1522 gfx::PointF(-10.f, -10.f),
1523 gfx::Size(510, 510),
1524 true);
1525 this->CalcDrawEtc(parent);
1526
1527 TestOcclusionTrackerWithClip<typename Types::LayerType,
1528 typename Types::RenderSurfaceType> occlusion(
1529 gfx::Rect(0, 0, 1000, 1000));
1530
1531 this->VisitLayer(layer2, &occlusion);
1532 this->EnterLayer(child2, &occlusion, false);
1533
1534 EXPECT_EQ(gfx::Rect().ToString(),
1535 occlusion.occlusion_from_outside_target().ToString());
1536 EXPECT_EQ(gfx::Rect(-10, 420, 70, 80).ToString(),
1537 occlusion.occlusion_from_inside_target().ToString());
1538
1539 this->LeaveLayer(child2, &occlusion);
1540 this->EnterContributingSurface(child2, &occlusion, false);
1541
1542 // There is nothing above child2's surface in the z-order.
1543 EXPECT_RECT_EQ(gfx::Rect(-10, 420, 70, 80),
1544 occlusion.UnoccludedContributingSurfaceContentRect(
1545 child2, false, gfx::Rect(-10, 420, 70, 80), NULL));
1546
1547 this->LeaveContributingSurface(child2, &occlusion);
1548 this->VisitLayer(layer1, &occlusion);
1549 this->EnterContributingSurface(child1, &occlusion, false);
1550
1551 EXPECT_EQ(gfx::Rect(420, -10, 70, 80).ToString(),
1552 occlusion.occlusion_from_outside_target().ToString());
1553 EXPECT_EQ(gfx::Rect(420, -20, 80, 90).ToString(),
1554 occlusion.occlusion_from_inside_target().ToString());
1555
1556 // child2's contents will occlude child1 below it.
1557 EXPECT_RECT_EQ(gfx::Rect(420, -20, 80, 90),
1558 occlusion.UnoccludedContributingSurfaceContentRect(
1559 child1, false, gfx::Rect(420, -20, 80, 90), NULL));
1560 EXPECT_RECT_EQ(gfx::Rect(490, -10, 10, 80),
1561 occlusion.UnoccludedContributingSurfaceContentRect(
1562 child1, false, gfx::Rect(420, -10, 80, 90), NULL));
1563 EXPECT_RECT_EQ(gfx::Rect(420, -20, 70, 10),
1564 occlusion.UnoccludedContributingSurfaceContentRect(
1565 child1, false, gfx::Rect(420, -20, 70, 90), NULL));
1566
1567 this->LeaveContributingSurface(child1, &occlusion);
1568 this->EnterLayer(parent, &occlusion, false);
1569
1570 EXPECT_EQ(gfx::Rect().ToString(),
1571 occlusion.occlusion_from_outside_target().ToString());
1572 EXPECT_EQ(gfx::Rect(10, 20, 90, 80).ToString(),
1573 occlusion.occlusion_from_inside_target().ToString());
1574
1575 /* Justification for the above occlusion:
1576 100
1577 +---------------------+
1578 |20 | layer1
1579 10+----------------------------------+
1580 100 || 30 | layer2 |
1581 |20+----------------------------------+
1582 || | | | |
1583 || | | | |
1584 || | | | |
1585 +|-|------------------+ | |
1586 | | | | 510
1587 | | 510 | |
1588 | | | |
1589 | | | |
1590 | | | |
1591 | | | |
1592 | | 520 | |
1593 +----------------------------------+ |
1594 | |
1595 +----------------------------------+
1596 510
1597 */
1598 }
1599 };
1600
1601 ALL_OCCLUSIONTRACKER_TEST(
1602 OcclusionTrackerTestOverlappingSurfaceSiblingsWithTwoTransforms);
1603
1604 template <class Types>
1605 class OcclusionTrackerTestFilters : public OcclusionTrackerTest<Types> {
1606 protected:
1607 explicit OcclusionTrackerTestFilters(bool opaque_layers)
1608 : OcclusionTrackerTest<Types>(opaque_layers) {}
1609 void RunMyTest() {
1610 gfx::Transform layer_transform;
1611 layer_transform.Translate(250.0, 250.0);
1612 layer_transform.Rotate(90.0);
1613 layer_transform.Translate(-250.0, -250.0);
1614
1615 typename Types::ContentLayerType* parent = this->CreateRoot(
1616 this->identity_matrix, gfx::PointF(), gfx::Size(100, 100));
1617 parent->SetMasksToBounds(true);
1618 typename Types::ContentLayerType* blur_layer =
1619 this->CreateDrawingLayer(parent,
1620 layer_transform,
1621 gfx::PointF(30.f, 30.f),
1622 gfx::Size(500, 500),
1623 true);
1624 typename Types::ContentLayerType* opaque_layer =
1625 this->CreateDrawingLayer(parent,
1626 layer_transform,
1627 gfx::PointF(30.f, 30.f),
1628 gfx::Size(500, 500),
1629 true);
1630 typename Types::ContentLayerType* opacity_layer =
1631 this->CreateDrawingLayer(parent,
1632 layer_transform,
1633 gfx::PointF(30.f, 30.f),
1634 gfx::Size(500, 500),
1635 true);
1636
1637 FilterOperations filters;
1638 filters.Append(FilterOperation::CreateBlurFilter(10.f));
1639 blur_layer->SetFilters(filters);
1640
1641 filters.Clear();
1642 filters.Append(FilterOperation::CreateGrayscaleFilter(0.5f));
1643 opaque_layer->SetFilters(filters);
1644
1645 filters.Clear();
1646 filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
1647 opacity_layer->SetFilters(filters);
1648
1649 this->CalcDrawEtc(parent);
1650
1651 TestOcclusionTrackerWithClip<typename Types::LayerType,
1652 typename Types::RenderSurfaceType> occlusion(
1653 gfx::Rect(0, 0, 1000, 1000));
1654
1655 // Opacity layer won't contribute to occlusion.
1656 this->VisitLayer(opacity_layer, &occlusion);
1657 this->EnterContributingSurface(opacity_layer, &occlusion, false);
1658
1659 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
1660 EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
1661
1662 // And has nothing to contribute to its parent surface.
1663 this->LeaveContributingSurface(opacity_layer, &occlusion);
1664 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
1665 EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
1666
1667 // Opaque layer will contribute to occlusion.
1668 this->VisitLayer(opaque_layer, &occlusion);
1669 this->EnterContributingSurface(opaque_layer, &occlusion, false);
1670
1671 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
1672 EXPECT_EQ(gfx::Rect(0, 430, 70, 70).ToString(),
1673 occlusion.occlusion_from_inside_target().ToString());
1674
1675 // And it gets translated to the parent surface.
1676 this->LeaveContributingSurface(opaque_layer, &occlusion);
1677 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
1678 EXPECT_EQ(gfx::Rect(30, 30, 70, 70).ToString(),
1679 occlusion.occlusion_from_inside_target().ToString());
1680
1681 // The blur layer needs to throw away any occlusion from outside its
1682 // subtree.
1683 this->EnterLayer(blur_layer, &occlusion, false);
1684 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
1685 EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
1686
1687 // And it won't contribute to occlusion.
1688 this->LeaveLayer(blur_layer, &occlusion);
1689 this->EnterContributingSurface(blur_layer, &occlusion, false);
1690 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
1691 EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
1692
1693 // But the opaque layer's occlusion is preserved on the parent.
1694 this->LeaveContributingSurface(blur_layer, &occlusion);
1695 this->EnterLayer(parent, &occlusion, false);
1696 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
1697 EXPECT_EQ(gfx::Rect(30, 30, 70, 70).ToString(),
1698 occlusion.occlusion_from_inside_target().ToString());
1699 }
1700 };
1701
1702 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestFilters);
1703
1704 template <class Types>
1705 class OcclusionTrackerTestReplicaDoesOcclude
1706 : public OcclusionTrackerTest<Types> {
1707 protected:
1708 explicit OcclusionTrackerTestReplicaDoesOcclude(bool opaque_layers)
1709 : OcclusionTrackerTest<Types>(opaque_layers) {}
1710 void RunMyTest() {
1711 typename Types::ContentLayerType* parent = this->CreateRoot(
1712 this->identity_matrix, gfx::PointF(), gfx::Size(100, 200));
1713 typename Types::LayerType* surface =
1714 this->CreateDrawingSurface(parent,
1715 this->identity_matrix,
1716 gfx::PointF(0.f, 100.f),
1717 gfx::Size(50, 50),
1718 true);
1719 this->CreateReplicaLayer(
1720 surface, this->identity_matrix, gfx::PointF(50.f, 50.f), gfx::Size());
1721 this->CalcDrawEtc(parent);
1722
1723 TestOcclusionTrackerWithClip<typename Types::LayerType,
1724 typename Types::RenderSurfaceType> occlusion(
1725 gfx::Rect(0, 0, 1000, 1000));
1726
1727 this->VisitLayer(surface, &occlusion);
1728
1729 EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(),
1730 occlusion.occlusion_from_inside_target().ToString());
1731
1732 this->VisitContributingSurface(surface, &occlusion);
1733 this->EnterLayer(parent, &occlusion, false);
1734
1735 // The surface and replica should both be occluding the parent.
1736 EXPECT_EQ(
1737 UnionRegions(gfx::Rect(0, 100, 50, 50),
1738 gfx::Rect(50, 150, 50, 50)).ToString(),
1739 occlusion.occlusion_from_inside_target().ToString());
1740 }
1741 };
1742
1743 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaDoesOcclude);
1744
1745 template <class Types>
1746 class OcclusionTrackerTestReplicaWithClipping
1747 : public OcclusionTrackerTest<Types> {
1748 protected:
1749 explicit OcclusionTrackerTestReplicaWithClipping(bool opaque_layers)
1750 : OcclusionTrackerTest<Types>(opaque_layers) {}
1751 void RunMyTest() {
1752 typename Types::ContentLayerType* parent = this->CreateRoot(
1753 this->identity_matrix, gfx::PointF(), gfx::Size(100, 170));
1754 parent->SetMasksToBounds(true);
1755 typename Types::LayerType* surface =
1756 this->CreateDrawingSurface(parent,
1757 this->identity_matrix,
1758 gfx::PointF(0.f, 100.f),
1759 gfx::Size(50, 50),
1760 true);
1761 this->CreateReplicaLayer(
1762 surface, this->identity_matrix, gfx::PointF(50.f, 50.f), gfx::Size());
1763 this->CalcDrawEtc(parent);
1764
1765 TestOcclusionTrackerWithClip<typename Types::LayerType,
1766 typename Types::RenderSurfaceType> occlusion(
1767 gfx::Rect(0, 0, 1000, 1000));
1768
1769 this->VisitLayer(surface, &occlusion);
1770
1771 EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(),
1772 occlusion.occlusion_from_inside_target().ToString());
1773
1774 this->VisitContributingSurface(surface, &occlusion);
1775 this->EnterLayer(parent, &occlusion, false);
1776
1777 // The surface and replica should both be occluding the parent.
1778 EXPECT_EQ(
1779 UnionRegions(gfx::Rect(0, 100, 50, 50),
1780 gfx::Rect(50, 150, 50, 20)).ToString(),
1781 occlusion.occlusion_from_inside_target().ToString());
1782 }
1783 };
1784
1785 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaWithClipping);
1786
1787 template <class Types>
1788 class OcclusionTrackerTestReplicaWithMask : public OcclusionTrackerTest<Types> {
1789 protected:
1790 explicit OcclusionTrackerTestReplicaWithMask(bool opaque_layers)
1791 : OcclusionTrackerTest<Types>(opaque_layers) {}
1792 void RunMyTest() {
1793 typename Types::ContentLayerType* parent = this->CreateRoot(
1794 this->identity_matrix, gfx::PointF(), gfx::Size(100, 200));
1795 typename Types::LayerType* surface =
1796 this->CreateDrawingSurface(parent,
1797 this->identity_matrix,
1798 gfx::PointF(0.f, 100.f),
1799 gfx::Size(50, 50),
1800 true);
1801 typename Types::LayerType* replica = this->CreateReplicaLayer(
1802 surface, this->identity_matrix, gfx::PointF(50.f, 50.f), gfx::Size());
1803 this->CreateMaskLayer(replica, gfx::Size(10, 10));
1804 this->CalcDrawEtc(parent);
1805
1806 TestOcclusionTrackerWithClip<typename Types::LayerType,
1807 typename Types::RenderSurfaceType> occlusion(
1808 gfx::Rect(0, 0, 1000, 1000));
1809
1810 this->VisitLayer(surface, &occlusion);
1811
1812 EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(),
1813 occlusion.occlusion_from_inside_target().ToString());
1814
1815 this->VisitContributingSurface(surface, &occlusion);
1816 this->EnterLayer(parent, &occlusion, false);
1817
1818 // The replica should not be occluding the parent, since it has a mask
1819 // applied to it.
1820 EXPECT_EQ(gfx::Rect(0, 100, 50, 50).ToString(),
1821 occlusion.occlusion_from_inside_target().ToString());
1822 }
1823 };
1824
1825 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaWithMask);
1826
1827 template <class Types>
1828 class OcclusionTrackerTestLayerClipRectOutsideChild
1829 : public OcclusionTrackerTest<Types> {
1830 protected:
1831 explicit OcclusionTrackerTestLayerClipRectOutsideChild(bool opaque_layers)
1832 : OcclusionTrackerTest<Types>(opaque_layers) {}
1833 void RunMyTest() {
1834 typename Types::ContentLayerType* parent = this->CreateRoot(
1835 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
1836 typename Types::ContentLayerType* clip =
1837 this->CreateDrawingLayer(parent,
1838 this->identity_matrix,
1839 gfx::PointF(200.f, 100.f),
1840 gfx::Size(100, 100),
1841 false);
1842 clip->SetMasksToBounds(true);
1843 typename Types::ContentLayerType* layer =
1844 this->CreateDrawingLayer(clip,
1845 this->identity_matrix,
1846 gfx::PointF(-200.f, -100.f),
1847 gfx::Size(200, 200),
1848 false);
1849 this->CalcDrawEtc(parent);
1850
1851 TestOcclusionTrackerWithClip<typename Types::LayerType,
1852 typename Types::RenderSurfaceType> occlusion(
1853 gfx::Rect(0, 0, 1000, 1000));
1854
1855 this->EnterLayer(layer, &occlusion, false);
1856
1857 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
1858 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
1859 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
1860 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
1861 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(200, 100, 100, 100)));
1862
1863 this->LeaveLayer(layer, &occlusion);
1864 this->EnterLayer(clip, &occlusion, false);
1865
1866 EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(-100, 0, 100, 100)));
1867 EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(0, -100, 100, 100)));
1868 EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(100, 0, 100, 100)));
1869 EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(0, 100, 100, 100)));
1870 EXPECT_FALSE(occlusion.OccludedLayer(clip, gfx::Rect(0, 0, 100, 100)));
1871
1872 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
1873 occlusion.UnoccludedLayerContentRect(
1874 clip, gfx::Rect(-100, -100, 300, 300)));
1875 }
1876 };
1877
1878 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestLayerClipRectOutsideChild);
1879
1880 template <class Types>
1881 class OcclusionTrackerTestViewportRectOutsideChild
1882 : public OcclusionTrackerTest<Types> {
1883 protected:
1884 explicit OcclusionTrackerTestViewportRectOutsideChild(bool opaque_layers)
1885 : OcclusionTrackerTest<Types>(opaque_layers) {}
1886 void RunMyTest() {
1887 typename Types::ContentLayerType* parent = this->CreateRoot(
1888 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
1889 typename Types::ContentLayerType* layer =
1890 this->CreateDrawingSurface(parent,
1891 this->identity_matrix,
1892 gfx::PointF(),
1893 gfx::Size(200, 200),
1894 true);
1895 this->CalcDrawEtc(parent);
1896
1897 TestOcclusionTrackerWithClip<typename Types::LayerType,
1898 typename Types::RenderSurfaceType> occlusion(
1899 gfx::Rect(200, 100, 100, 100));
1900
1901 this->EnterLayer(layer, &occlusion, false);
1902
1903 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
1904 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
1905 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
1906 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
1907 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(200, 100, 100, 100)));
1908
1909 this->LeaveLayer(layer, &occlusion);
1910 this->VisitContributingSurface(layer, &occlusion);
1911 this->EnterLayer(parent, &occlusion, false);
1912
1913 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 0, 100, 100)));
1914 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
1915 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 0, 100, 100)));
1916 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
1917 EXPECT_FALSE(
1918 occlusion.OccludedLayer(parent, gfx::Rect(200, 100, 100, 100)));
1919 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 0, 100, 100)));
1920 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 200, 100, 100)));
1921 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 200, 100, 100)));
1922 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100)));
1923
1924 EXPECT_RECT_EQ(gfx::Rect(200, 100, 100, 100),
1925 occlusion.UnoccludedLayerContentRect(
1926 parent, gfx::Rect(0, 0, 300, 300)));
1927 }
1928 };
1929
1930 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestViewportRectOutsideChild);
1931
1932 template <class Types>
1933 class OcclusionTrackerTestLayerClipRectOverChild
1934 : public OcclusionTrackerTest<Types> {
1935 protected:
1936 explicit OcclusionTrackerTestLayerClipRectOverChild(bool opaque_layers)
1937 : OcclusionTrackerTest<Types>(opaque_layers) {}
1938 void RunMyTest() {
1939 typename Types::ContentLayerType* parent = this->CreateRoot(
1940 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
1941 typename Types::ContentLayerType* clip =
1942 this->CreateDrawingLayer(parent,
1943 this->identity_matrix,
1944 gfx::PointF(100.f, 100.f),
1945 gfx::Size(100, 100),
1946 false);
1947 clip->SetMasksToBounds(true);
1948 typename Types::ContentLayerType* layer =
1949 this->CreateDrawingSurface(clip,
1950 this->identity_matrix,
1951 gfx::PointF(-100.f, -100.f),
1952 gfx::Size(200, 200),
1953 true);
1954 this->CalcDrawEtc(parent);
1955
1956 TestOcclusionTrackerWithClip<typename Types::LayerType,
1957 typename Types::RenderSurfaceType> occlusion(
1958 gfx::Rect(0, 0, 1000, 1000));
1959
1960 this->EnterLayer(layer, &occlusion, false);
1961
1962 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
1963 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
1964 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
1965 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
1966
1967 this->LeaveLayer(layer, &occlusion);
1968 this->VisitContributingSurface(layer, &occlusion);
1969
1970 EXPECT_EQ(gfx::Rect(100, 100, 100, 100).ToString(),
1971 occlusion.occlusion_from_inside_target().ToString());
1972
1973 this->EnterLayer(clip, &occlusion, false);
1974
1975 EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(0, 0, 100, 100)));
1976 EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(0, 100, 100, 100)));
1977 EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(100, 0, 100, 100)));
1978 EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(100, 100, 100, 100)));
1979 EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(200, 100, 100, 100)));
1980 EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(200, 0, 100, 100)));
1981 EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(0, 200, 100, 100)));
1982 EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(100, 200, 100, 100)));
1983 EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(200, 200, 100, 100)));
1984
1985 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
1986 clip, gfx::Rect(0, 0, 300, 300)).IsEmpty());
1987 }
1988 };
1989
1990 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestLayerClipRectOverChild);
1991
1992 template <class Types>
1993 class OcclusionTrackerTestViewportRectOverChild
1994 : public OcclusionTrackerTest<Types> {
1995 protected:
1996 explicit OcclusionTrackerTestViewportRectOverChild(bool opaque_layers)
1997 : OcclusionTrackerTest<Types>(opaque_layers) {}
1998 void RunMyTest() {
1999 typename Types::ContentLayerType* parent = this->CreateRoot(
2000 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2001 typename Types::ContentLayerType* layer =
2002 this->CreateDrawingSurface(parent,
2003 this->identity_matrix,
2004 gfx::PointF(),
2005 gfx::Size(200, 200),
2006 true);
2007 this->CalcDrawEtc(parent);
2008
2009 TestOcclusionTrackerWithClip<typename Types::LayerType,
2010 typename Types::RenderSurfaceType> occlusion(
2011 gfx::Rect(100, 100, 100, 100));
2012
2013 this->EnterLayer(layer, &occlusion, false);
2014
2015 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
2016 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
2017 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
2018 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
2019
2020 this->LeaveLayer(layer, &occlusion);
2021 this->VisitContributingSurface(layer, &occlusion);
2022 this->EnterLayer(parent, &occlusion, false);
2023
2024 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 0, 100, 100)));
2025 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
2026 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 0, 100, 100)));
2027 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100)));
2028 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 100, 100, 100)));
2029 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 0, 100, 100)));
2030 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 200, 100, 100)));
2031 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 200, 100, 100)));
2032 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100)));
2033
2034 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
2035 parent, gfx::Rect(0, 0, 300, 300)).IsEmpty());
2036 }
2037 };
2038
2039 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestViewportRectOverChild);
2040
2041 template <class Types>
2042 class OcclusionTrackerTestLayerClipRectPartlyOverChild
2043 : public OcclusionTrackerTest<Types> {
2044 protected:
2045 explicit OcclusionTrackerTestLayerClipRectPartlyOverChild(bool opaque_layers)
2046 : OcclusionTrackerTest<Types>(opaque_layers) {}
2047 void RunMyTest() {
2048 typename Types::ContentLayerType* parent = this->CreateRoot(
2049 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2050 typename Types::ContentLayerType* clip =
2051 this->CreateDrawingLayer(parent,
2052 this->identity_matrix,
2053 gfx::PointF(50.f, 50.f),
2054 gfx::Size(200, 200),
2055 false);
2056 clip->SetMasksToBounds(true);
2057 typename Types::ContentLayerType* layer =
2058 this->CreateDrawingSurface(clip,
2059 this->identity_matrix,
2060 gfx::PointF(-50.f, -50.f),
2061 gfx::Size(200, 200),
2062 true);
2063 this->CalcDrawEtc(parent);
2064
2065 TestOcclusionTrackerWithClip<typename Types::LayerType,
2066 typename Types::RenderSurfaceType> occlusion(
2067 gfx::Rect(0, 0, 1000, 1000));
2068
2069 this->EnterLayer(layer, &occlusion, false);
2070
2071 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
2072 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
2073 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
2074 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
2075
2076 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 50)));
2077 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 50, 100)));
2078 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 50)));
2079 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 50, 100)));
2080
2081 this->LeaveLayer(layer, &occlusion);
2082 this->VisitContributingSurface(layer, &occlusion);
2083 this->EnterLayer(clip, &occlusion, false);
2084
2085 EXPECT_EQ(gfx::Rect(50, 50, 150, 150).ToString(),
2086 occlusion.occlusion_from_inside_target().ToString());
2087 }
2088 };
2089
2090 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestLayerClipRectPartlyOverChild);
2091
2092 template <class Types>
2093 class OcclusionTrackerTestViewportRectPartlyOverChild
2094 : public OcclusionTrackerTest<Types> {
2095 protected:
2096 explicit OcclusionTrackerTestViewportRectPartlyOverChild(bool opaque_layers)
2097 : OcclusionTrackerTest<Types>(opaque_layers) {}
2098 void RunMyTest() {
2099 typename Types::ContentLayerType* parent = this->CreateRoot(
2100 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2101 typename Types::ContentLayerType* layer =
2102 this->CreateDrawingSurface(parent,
2103 this->identity_matrix,
2104 gfx::PointF(),
2105 gfx::Size(200, 200),
2106 true);
2107 this->CalcDrawEtc(parent);
2108
2109 TestOcclusionTrackerWithClip<typename Types::LayerType,
2110 typename Types::RenderSurfaceType> occlusion(
2111 gfx::Rect(50, 50, 200, 200));
2112
2113 this->EnterLayer(layer, &occlusion, false);
2114
2115 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
2116 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
2117 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
2118 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
2119
2120 this->LeaveLayer(layer, &occlusion);
2121 this->VisitContributingSurface(layer, &occlusion);
2122 this->EnterLayer(parent, &occlusion, false);
2123
2124 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 0, 100, 100)));
2125 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
2126 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 0, 100, 100)));
2127 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100)));
2128 EXPECT_FALSE(
2129 occlusion.OccludedLayer(parent, gfx::Rect(200, 100, 100, 100)));
2130 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(200, 0, 100, 100)));
2131 EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(0, 200, 100, 100)));
2132 EXPECT_FALSE(
2133 occlusion.OccludedLayer(parent, gfx::Rect(100, 200, 100, 100)));
2134 EXPECT_FALSE(
2135 occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100)));
2136
2137 EXPECT_RECT_EQ(gfx::Rect(50, 50, 200, 200),
2138 occlusion.UnoccludedLayerContentRect(
2139 parent, gfx::Rect(0, 0, 300, 300)));
2140 EXPECT_RECT_EQ(gfx::Rect(200, 50, 50, 50),
2141 occlusion.UnoccludedLayerContentRect(
2142 parent, gfx::Rect(0, 0, 300, 100)));
2143 EXPECT_RECT_EQ(gfx::Rect(200, 100, 50, 100),
2144 occlusion.UnoccludedLayerContentRect(
2145 parent, gfx::Rect(0, 100, 300, 100)));
2146 EXPECT_RECT_EQ(gfx::Rect(200, 100, 50, 100),
2147 occlusion.UnoccludedLayerContentRect(
2148 parent, gfx::Rect(200, 100, 100, 100)));
2149 EXPECT_RECT_EQ(gfx::Rect(100, 200, 100, 50),
2150 occlusion.UnoccludedLayerContentRect(
2151 parent, gfx::Rect(100, 200, 100, 100)));
2152 }
2153 };
2154
2155 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestViewportRectPartlyOverChild);
2156
2157 template <class Types>
2158 class OcclusionTrackerTestViewportRectOverNothing
2159 : public OcclusionTrackerTest<Types> {
2160 protected:
2161 explicit OcclusionTrackerTestViewportRectOverNothing(bool opaque_layers)
2162 : OcclusionTrackerTest<Types>(opaque_layers) {}
2163 void RunMyTest() {
2164 typename Types::ContentLayerType* parent = this->CreateRoot(
2165 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2166 typename Types::ContentLayerType* layer =
2167 this->CreateDrawingSurface(parent,
2168 this->identity_matrix,
2169 gfx::PointF(),
2170 gfx::Size(200, 200),
2171 true);
2172 this->CalcDrawEtc(parent);
2173
2174 TestOcclusionTrackerWithClip<typename Types::LayerType,
2175 typename Types::RenderSurfaceType> occlusion(
2176 gfx::Rect(500, 500, 100, 100));
2177
2178 this->EnterLayer(layer, &occlusion, false);
2179
2180 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
2181 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
2182 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
2183 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
2184
2185 this->LeaveLayer(layer, &occlusion);
2186 this->VisitContributingSurface(layer, &occlusion);
2187 this->EnterLayer(parent, &occlusion, false);
2188
2189 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 0, 100, 100)));
2190 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
2191 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 0, 100, 100)));
2192 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100)));
2193 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 100, 100, 100)));
2194 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 0, 100, 100)));
2195 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 200, 100, 100)));
2196 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 200, 100, 100)));
2197 EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100)));
2198
2199 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
2200 parent, gfx::Rect(0, 0, 300, 300)).IsEmpty());
2201 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
2202 parent, gfx::Rect(0, 0, 300, 100)).IsEmpty());
2203 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
2204 parent, gfx::Rect(0, 100, 300, 100)).IsEmpty());
2205 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
2206 parent, gfx::Rect(200, 100, 100, 100)).IsEmpty());
2207 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
2208 parent, gfx::Rect(100, 200, 100, 100)).IsEmpty());
2209 }
2210 };
2211
2212 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestViewportRectOverNothing);
2213
2214 template <class Types>
2215 class OcclusionTrackerTestLayerClipRectForLayerOffOrigin
2216 : public OcclusionTrackerTest<Types> {
2217 protected:
2218 explicit OcclusionTrackerTestLayerClipRectForLayerOffOrigin(
2219 bool opaque_layers)
2220 : OcclusionTrackerTest<Types>(opaque_layers) {}
2221 void RunMyTest() {
2222 typename Types::ContentLayerType* parent = this->CreateRoot(
2223 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2224 typename Types::ContentLayerType* layer =
2225 this->CreateDrawingSurface(parent,
2226 this->identity_matrix,
2227 gfx::PointF(),
2228 gfx::Size(200, 200),
2229 true);
2230 this->CalcDrawEtc(parent);
2231
2232 TestOcclusionTrackerWithClip<typename Types::LayerType,
2233 typename Types::RenderSurfaceType> occlusion(
2234 gfx::Rect(0, 0, 1000, 1000));
2235 this->EnterLayer(layer, &occlusion, false);
2236
2237 // This layer is translated when drawn into its target. So if the clip rect
2238 // given from the target surface is not in that target space, then after
2239 // translating these query rects into the target, they will fall outside the
2240 // clip and be considered occluded.
2241 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
2242 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
2243 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
2244 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
2245 }
2246 };
2247
2248 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestLayerClipRectForLayerOffOrigin);
2249
2250 template <class Types>
2251 class OcclusionTrackerTestOpaqueContentsRegionEmpty
2252 : public OcclusionTrackerTest<Types> {
2253 protected:
2254 explicit OcclusionTrackerTestOpaqueContentsRegionEmpty(bool opaque_layers)
2255 : OcclusionTrackerTest<Types>(opaque_layers) {}
2256 void RunMyTest() {
2257 typename Types::ContentLayerType* parent = this->CreateRoot(
2258 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2259 typename Types::ContentLayerType* layer =
2260 this->CreateDrawingSurface(parent,
2261 this->identity_matrix,
2262 gfx::PointF(),
2263 gfx::Size(200, 200),
2264 false);
2265 this->CalcDrawEtc(parent);
2266
2267 TestOcclusionTrackerWithClip<typename Types::LayerType,
2268 typename Types::RenderSurfaceType> occlusion(
2269 gfx::Rect(0, 0, 1000, 1000));
2270 this->EnterLayer(layer, &occlusion, false);
2271
2272 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
2273 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
2274 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
2275 EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
2276
2277 // Occluded since its outside the surface bounds.
2278 EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(200, 100, 100, 100)));
2279
2280 this->LeaveLayer(layer, &occlusion);
2281 this->VisitContributingSurface(layer, &occlusion);
2282 this->EnterLayer(parent, &occlusion, false);
2283
2284 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
2285 }
2286 };
2287
2288 MAIN_AND_IMPL_THREAD_TEST(OcclusionTrackerTestOpaqueContentsRegionEmpty);
2289
2290 template <class Types>
2291 class OcclusionTrackerTestOpaqueContentsRegionNonEmpty
2292 : public OcclusionTrackerTest<Types> {
2293 protected:
2294 explicit OcclusionTrackerTestOpaqueContentsRegionNonEmpty(bool opaque_layers)
2295 : OcclusionTrackerTest<Types>(opaque_layers) {}
2296 void RunMyTest() {
2297 typename Types::ContentLayerType* parent = this->CreateRoot(
2298 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2299 typename Types::ContentLayerType* layer =
2300 this->CreateDrawingLayer(parent,
2301 this->identity_matrix,
2302 gfx::PointF(100.f, 100.f),
2303 gfx::Size(200, 200),
2304 false);
2305 this->CalcDrawEtc(parent);
2306 {
2307 TestOcclusionTrackerWithClip<typename Types::LayerType,
2308 typename Types::RenderSurfaceType> occlusion(
2309 gfx::Rect(0, 0, 1000, 1000));
2310 layer->SetOpaqueContentsRect(gfx::Rect(0, 0, 100, 100));
2311
2312 this->ResetLayerIterator();
2313 this->VisitLayer(layer, &occlusion);
2314 this->EnterLayer(parent, &occlusion, false);
2315
2316 EXPECT_EQ(gfx::Rect(100, 100, 100, 100).ToString(),
2317 occlusion.occlusion_from_inside_target().ToString());
2318
2319 EXPECT_FALSE(
2320 occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
2321 EXPECT_TRUE(
2322 occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100)));
2323 EXPECT_FALSE(
2324 occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100)));
2325 }
2326 {
2327 TestOcclusionTrackerWithClip<typename Types::LayerType,
2328 typename Types::RenderSurfaceType> occlusion(
2329 gfx::Rect(0, 0, 1000, 1000));
2330 layer->SetOpaqueContentsRect(gfx::Rect(20, 20, 180, 180));
2331
2332 this->ResetLayerIterator();
2333 this->VisitLayer(layer, &occlusion);
2334 this->EnterLayer(parent, &occlusion, false);
2335
2336 EXPECT_EQ(gfx::Rect(120, 120, 180, 180).ToString(),
2337 occlusion.occlusion_from_inside_target().ToString());
2338
2339 EXPECT_FALSE(
2340 occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
2341 EXPECT_FALSE(
2342 occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100)));
2343 EXPECT_TRUE(
2344 occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100)));
2345 }
2346 {
2347 TestOcclusionTrackerWithClip<typename Types::LayerType,
2348 typename Types::RenderSurfaceType> occlusion(
2349 gfx::Rect(0, 0, 1000, 1000));
2350 layer->SetOpaqueContentsRect(gfx::Rect(150, 150, 100, 100));
2351
2352 this->ResetLayerIterator();
2353 this->VisitLayer(layer, &occlusion);
2354 this->EnterLayer(parent, &occlusion, false);
2355
2356 EXPECT_EQ(gfx::Rect(250, 250, 50, 50).ToString(),
2357 occlusion.occlusion_from_inside_target().ToString());
2358
2359 EXPECT_FALSE(
2360 occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
2361 EXPECT_FALSE(
2362 occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100)));
2363 EXPECT_FALSE(
2364 occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100)));
2365 }
2366 }
2367 };
2368
2369 MAIN_AND_IMPL_THREAD_TEST(OcclusionTrackerTestOpaqueContentsRegionNonEmpty);
2370
2371 template <class Types>
2372 class OcclusionTrackerTest3dTransform : public OcclusionTrackerTest<Types> {
2373 protected:
2374 explicit OcclusionTrackerTest3dTransform(bool opaque_layers)
2375 : OcclusionTrackerTest<Types>(opaque_layers) {}
2376 void RunMyTest() {
2377 gfx::Transform transform;
2378 transform.RotateAboutYAxis(30.0);
2379
2380 typename Types::ContentLayerType* parent = this->CreateRoot(
2381 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2382 typename Types::LayerType* container = this->CreateLayer(
2383 parent, this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2384 typename Types::ContentLayerType* layer =
2385 this->CreateDrawingLayer(container,
2386 transform,
2387 gfx::PointF(100.f, 100.f),
2388 gfx::Size(200, 200),
2389 true);
2390 this->CalcDrawEtc(parent);
2391
2392 TestOcclusionTrackerWithClip<typename Types::LayerType,
2393 typename Types::RenderSurfaceType> occlusion(
2394 gfx::Rect(0, 0, 1000, 1000));
2395 this->EnterLayer(layer, &occlusion, false);
2396
2397 // The layer is rotated in 3d but without preserving 3d, so it only gets
2398 // resized.
2399 EXPECT_RECT_EQ(
2400 gfx::Rect(0, 0, 200, 200),
2401 occlusion.UnoccludedLayerContentRect(layer, gfx::Rect(0, 0, 200, 200)));
2402 }
2403 };
2404
2405 MAIN_AND_IMPL_THREAD_TEST(OcclusionTrackerTest3dTransform);
2406
2407 template <class Types>
2408 class OcclusionTrackerTestUnsorted3dLayers
2409 : public OcclusionTrackerTest<Types> {
2410 protected:
2411 explicit OcclusionTrackerTestUnsorted3dLayers(bool opaque_layers)
2412 : OcclusionTrackerTest<Types>(opaque_layers) {}
2413 void RunMyTest() {
2414 // Currently, The main thread layer iterator does not iterate over 3d items
2415 // in sorted order, because layer sorting is not performed on the main
2416 // thread. Because of this, the occlusion tracker cannot assume that a 3d
2417 // layer occludes other layers that have not yet been iterated over. For
2418 // now, the expected behavior is that a 3d layer simply does not add any
2419 // occlusion to the occlusion tracker.
2420
2421 gfx::Transform translation_to_front;
2422 translation_to_front.Translate3d(0.0, 0.0, -10.0);
2423 gfx::Transform translation_to_back;
2424 translation_to_front.Translate3d(0.0, 0.0, -100.0);
2425
2426 typename Types::ContentLayerType* parent = this->CreateRoot(
2427 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2428 typename Types::ContentLayerType* child1 = this->CreateDrawingLayer(
2429 parent, translation_to_back, gfx::PointF(), gfx::Size(100, 100), true);
2430 typename Types::ContentLayerType* child2 =
2431 this->CreateDrawingLayer(parent,
2432 translation_to_front,
2433 gfx::PointF(50.f, 50.f),
2434 gfx::Size(100, 100),
2435 true);
2436 parent->SetPreserves3d(true);
2437
2438 this->CalcDrawEtc(parent);
2439
2440 TestOcclusionTrackerWithClip<typename Types::LayerType,
2441 typename Types::RenderSurfaceType> occlusion(
2442 gfx::Rect(0, 0, 1000, 1000));
2443 this->VisitLayer(child2, &occlusion);
2444 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
2445 EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
2446
2447 this->VisitLayer(child1, &occlusion);
2448 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
2449 EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
2450 }
2451 };
2452
2453 // This test will have different layer ordering on the impl thread; the test
2454 // will only work on the main thread.
2455 MAIN_THREAD_TEST(OcclusionTrackerTestUnsorted3dLayers);
2456
2457 template <class Types>
2458 class OcclusionTrackerTestPerspectiveTransform
2459 : public OcclusionTrackerTest<Types> {
2460 protected:
2461 explicit OcclusionTrackerTestPerspectiveTransform(bool opaque_layers)
2462 : OcclusionTrackerTest<Types>(opaque_layers) {}
2463 void RunMyTest() {
2464 gfx::Transform transform;
2465 transform.Translate(150.0, 150.0);
2466 transform.ApplyPerspectiveDepth(400.0);
2467 transform.RotateAboutXAxis(-30.0);
2468 transform.Translate(-150.0, -150.0);
2469
2470 typename Types::ContentLayerType* parent = this->CreateRoot(
2471 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2472 typename Types::LayerType* container = this->CreateLayer(
2473 parent, this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2474 typename Types::ContentLayerType* layer =
2475 this->CreateDrawingLayer(container,
2476 transform,
2477 gfx::PointF(100.f, 100.f),
2478 gfx::Size(200, 200),
2479 true);
2480 container->SetPreserves3d(true);
2481 layer->SetPreserves3d(true);
2482 this->CalcDrawEtc(parent);
2483
2484 TestOcclusionTrackerWithClip<typename Types::LayerType,
2485 typename Types::RenderSurfaceType> occlusion(
2486 gfx::Rect(0, 0, 1000, 1000));
2487 this->EnterLayer(layer, &occlusion, false);
2488
2489 EXPECT_RECT_EQ(
2490 gfx::Rect(0, 0, 200, 200),
2491 occlusion.UnoccludedLayerContentRect(layer, gfx::Rect(0, 0, 200, 200)));
2492 }
2493 };
2494
2495 // This test requires accumulating occlusion of 3d layers, which are skipped by
2496 // the occlusion tracker on the main thread. So this test should run on the impl
2497 // thread.
2498 IMPL_THREAD_TEST(OcclusionTrackerTestPerspectiveTransform);
2499
2500 template <class Types>
2501 class OcclusionTrackerTestPerspectiveTransformBehindCamera
2502 : public OcclusionTrackerTest<Types> {
2503 protected:
2504 explicit OcclusionTrackerTestPerspectiveTransformBehindCamera(
2505 bool opaque_layers)
2506 : OcclusionTrackerTest<Types>(opaque_layers) {}
2507 void RunMyTest() {
2508 // This test is based on the platform/chromium/compositing/3d-corners.html
2509 // layout test.
2510 gfx::Transform transform;
2511 transform.Translate(250.0, 50.0);
2512 transform.ApplyPerspectiveDepth(10.0);
2513 transform.Translate(-250.0, -50.0);
2514 transform.Translate(250.0, 50.0);
2515 transform.RotateAboutXAxis(-167.0);
2516 transform.Translate(-250.0, -50.0);
2517
2518 typename Types::ContentLayerType* parent = this->CreateRoot(
2519 this->identity_matrix, gfx::PointF(), gfx::Size(500, 100));
2520 typename Types::LayerType* container = this->CreateLayer(
2521 parent, this->identity_matrix, gfx::PointF(), gfx::Size(500, 500));
2522 typename Types::ContentLayerType* layer = this->CreateDrawingLayer(
2523 container, transform, gfx::PointF(), gfx::Size(500, 500), true);
2524 container->SetPreserves3d(true);
2525 layer->SetPreserves3d(true);
2526 this->CalcDrawEtc(parent);
2527
2528 TestOcclusionTrackerWithClip<typename Types::LayerType,
2529 typename Types::RenderSurfaceType> occlusion(
2530 gfx::Rect(0, 0, 1000, 1000));
2531 this->EnterLayer(layer, &occlusion, false);
2532
2533 // The bottom 11 pixel rows of this layer remain visible inside the
2534 // container, after translation to the target surface. When translated back,
2535 // this will include many more pixels but must include at least the bottom
2536 // 11 rows.
2537 EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
2538 layer, gfx::Rect(0, 0, 500, 500)).Contains(gfx::Rect(0, 489, 500, 11)));
2539 }
2540 };
2541
2542 // This test requires accumulating occlusion of 3d layers, which are skipped by
2543 // the occlusion tracker on the main thread. So this test should run on the impl
2544 // thread.
2545 IMPL_THREAD_TEST(OcclusionTrackerTestPerspectiveTransformBehindCamera);
2546
2547 template <class Types>
2548 class OcclusionTrackerTestLayerBehindCameraDoesNotOcclude
2549 : public OcclusionTrackerTest<Types> {
2550 protected:
2551 explicit OcclusionTrackerTestLayerBehindCameraDoesNotOcclude(
2552 bool opaque_layers)
2553 : OcclusionTrackerTest<Types>(opaque_layers) {}
2554 void RunMyTest() {
2555 gfx::Transform transform;
2556 transform.Translate(50.0, 50.0);
2557 transform.ApplyPerspectiveDepth(100.0);
2558 transform.Translate3d(0.0, 0.0, 110.0);
2559 transform.Translate(-50.0, -50.0);
2560
2561 typename Types::ContentLayerType* parent = this->CreateRoot(
2562 this->identity_matrix, gfx::PointF(), gfx::Size(100, 100));
2563 typename Types::ContentLayerType* layer = this->CreateDrawingLayer(
2564 parent, transform, gfx::PointF(), gfx::Size(100, 100), true);
2565 parent->SetPreserves3d(true);
2566 layer->SetPreserves3d(true);
2567 this->CalcDrawEtc(parent);
2568
2569 TestOcclusionTrackerWithClip<typename Types::LayerType,
2570 typename Types::RenderSurfaceType> occlusion(
2571 gfx::Rect(0, 0, 1000, 1000));
2572
2573 // The |layer| is entirely behind the camera and should not occlude.
2574 this->VisitLayer(layer, &occlusion);
2575 this->EnterLayer(parent, &occlusion, false);
2576 EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
2577 EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
2578 }
2579 };
2580
2581 // This test requires accumulating occlusion of 3d layers, which are skipped by
2582 // the occlusion tracker on the main thread. So this test should run on the impl
2583 // thread.
2584 IMPL_THREAD_TEST(OcclusionTrackerTestLayerBehindCameraDoesNotOcclude);
2585
2586 template <class Types>
2587 class OcclusionTrackerTestLargePixelsOccludeInsideClipRect
2588 : public OcclusionTrackerTest<Types> {
2589 protected:
2590 explicit OcclusionTrackerTestLargePixelsOccludeInsideClipRect(
2591 bool opaque_layers)
2592 : OcclusionTrackerTest<Types>(opaque_layers) {}
2593 void RunMyTest() {
2594 gfx::Transform transform;
2595 transform.Translate(50.0, 50.0);
2596 transform.ApplyPerspectiveDepth(100.0);
2597 transform.Translate3d(0.0, 0.0, 99.0);
2598 transform.Translate(-50.0, -50.0);
2599
2600 typename Types::ContentLayerType* parent = this->CreateRoot(
2601 this->identity_matrix, gfx::PointF(), gfx::Size(100, 100));
2602 parent->SetMasksToBounds(true);
2603 typename Types::ContentLayerType* layer = this->CreateDrawingLayer(
2604 parent, transform, gfx::PointF(), gfx::Size(100, 100), true);
2605 parent->SetPreserves3d(true);
2606 layer->SetPreserves3d(true);
2607 this->CalcDrawEtc(parent);
2608
2609 TestOcclusionTrackerWithClip<typename Types::LayerType,
2610 typename Types::RenderSurfaceType> occlusion(
2611 gfx::Rect(0, 0, 1000, 1000));
2612
2613 // This is very close to the camera, so pixels in its visible_content_rect()
2614 // will actually go outside of the layer's clip rect. Ensure that those
2615 // pixels don't occlude things outside the clip rect.
2616 this->VisitLayer(layer, &occlusion);
2617 this->EnterLayer(parent, &occlusion, false);
2618 EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
2619 occlusion.occlusion_from_inside_target().ToString());
2620 EXPECT_EQ(gfx::Rect().ToString(),
2621 occlusion.occlusion_from_outside_target().ToString());
2622 }
2623 };
2624
2625 // This test requires accumulating occlusion of 3d layers, which are skipped by
2626 // the occlusion tracker on the main thread. So this test should run on the impl
2627 // thread.
2628 IMPL_THREAD_TEST(OcclusionTrackerTestLargePixelsOccludeInsideClipRect);
2629
2630 template <class Types>
2631 class OcclusionTrackerTestAnimationOpacity1OnMainThread
2632 : public OcclusionTrackerTest<Types> {
2633 protected:
2634 explicit OcclusionTrackerTestAnimationOpacity1OnMainThread(bool opaque_layers)
2635 : OcclusionTrackerTest<Types>(opaque_layers) {}
2636 void RunMyTest() {
2637 // parent
2638 // +--layer
2639 // +--surface
2640 // | +--surface_child
2641 // | +--surface_child2
2642 // +--parent2
2643 // +--topmost
2644
2645 typename Types::ContentLayerType* parent = this->CreateRoot(
2646 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2647 typename Types::ContentLayerType* layer =
2648 this->CreateDrawingLayer(parent,
2649 this->identity_matrix,
2650 gfx::PointF(),
2651 gfx::Size(300, 300),
2652 true);
2653 typename Types::ContentLayerType* surface =
2654 this->CreateDrawingSurface(parent,
2655 this->identity_matrix,
2656 gfx::PointF(),
2657 gfx::Size(300, 300),
2658 true);
2659 typename Types::ContentLayerType* surface_child =
2660 this->CreateDrawingLayer(surface,
2661 this->identity_matrix,
2662 gfx::PointF(),
2663 gfx::Size(200, 300),
2664 true);
2665 typename Types::ContentLayerType* surface_child2 =
2666 this->CreateDrawingLayer(surface,
2667 this->identity_matrix,
2668 gfx::PointF(),
2669 gfx::Size(100, 300),
2670 true);
2671 typename Types::ContentLayerType* parent2 =
2672 this->CreateDrawingLayer(parent,
2673 this->identity_matrix,
2674 gfx::PointF(),
2675 gfx::Size(300, 300),
2676 false);
2677 typename Types::ContentLayerType* topmost =
2678 this->CreateDrawingLayer(parent,
2679 this->identity_matrix,
2680 gfx::PointF(250.f, 0.f),
2681 gfx::Size(50, 300),
2682 true);
2683
2684 AddOpacityTransitionToController(
2685 layer->layer_animation_controller(), 10.0, 0.f, 1.f, false);
2686 AddOpacityTransitionToController(
2687 surface->layer_animation_controller(), 10.0, 0.f, 1.f, false);
2688 this->CalcDrawEtc(parent);
2689
2690 EXPECT_TRUE(layer->draw_opacity_is_animating());
2691 EXPECT_FALSE(surface->draw_opacity_is_animating());
2692 EXPECT_TRUE(surface->render_surface()->draw_opacity_is_animating());
2693
2694 TestOcclusionTrackerWithClip<typename Types::LayerType,
2695 typename Types::RenderSurfaceType> occlusion(
2696 gfx::Rect(0, 0, 1000, 1000));
2697
2698 this->VisitLayer(topmost, &occlusion);
2699 this->EnterLayer(parent2, &occlusion, false);
2700 // This occlusion will affect all surfaces.
2701 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
2702 occlusion.occlusion_from_inside_target().ToString());
2703 EXPECT_EQ(gfx::Rect().ToString(),
2704 occlusion.occlusion_from_outside_target().ToString());
2705 EXPECT_EQ(gfx::Rect(0, 0, 250, 300).ToString(),
2706 occlusion.UnoccludedLayerContentRect(
2707 parent2, gfx::Rect(0, 0, 300, 300)).ToString());
2708 this->LeaveLayer(parent2, &occlusion);
2709
2710 this->VisitLayer(surface_child2, &occlusion);
2711 this->EnterLayer(surface_child, &occlusion, false);
2712 EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(),
2713 occlusion.occlusion_from_inside_target().ToString());
2714 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
2715 occlusion.occlusion_from_outside_target().ToString());
2716 EXPECT_RECT_EQ(gfx::Rect(100, 0, 100, 300),
2717 occlusion.UnoccludedLayerContentRect(
2718 surface_child, gfx::Rect(0, 0, 200, 300)));
2719 this->LeaveLayer(surface_child, &occlusion);
2720 this->EnterLayer(surface, &occlusion, false);
2721 EXPECT_EQ(gfx::Rect(0, 0, 200, 300).ToString(),
2722 occlusion.occlusion_from_inside_target().ToString());
2723 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
2724 occlusion.occlusion_from_outside_target().ToString());
2725 EXPECT_RECT_EQ(gfx::Rect(200, 0, 50, 300),
2726 occlusion.UnoccludedLayerContentRect(
2727 surface, gfx::Rect(0, 0, 300, 300)));
2728 this->LeaveLayer(surface, &occlusion);
2729
2730 this->EnterContributingSurface(surface, &occlusion, false);
2731 // Occlusion within the surface is lost when leaving the animating surface.
2732 EXPECT_EQ(gfx::Rect().ToString(),
2733 occlusion.occlusion_from_inside_target().ToString());
2734 EXPECT_EQ(gfx::Rect().ToString(),
2735 occlusion.occlusion_from_outside_target().ToString());
2736 EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300),
2737 occlusion.UnoccludedContributingSurfaceContentRect(
2738 surface, false, gfx::Rect(0, 0, 300, 300), NULL));
2739 this->LeaveContributingSurface(surface, &occlusion);
2740
2741 // Occlusion from outside the animating surface still exists.
2742 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
2743 occlusion.occlusion_from_inside_target().ToString());
2744 EXPECT_EQ(gfx::Rect().ToString(),
2745 occlusion.occlusion_from_outside_target().ToString());
2746
2747 this->VisitLayer(layer, &occlusion);
2748 this->EnterLayer(parent, &occlusion, false);
2749
2750 // Occlusion is not added for the animating |layer|.
2751 EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300),
2752 occlusion.UnoccludedLayerContentRect(
2753 parent, gfx::Rect(0, 0, 300, 300)));
2754 }
2755 };
2756
2757 MAIN_THREAD_TEST(OcclusionTrackerTestAnimationOpacity1OnMainThread);
2758
2759 template <class Types>
2760 class OcclusionTrackerTestAnimationOpacity0OnMainThread
2761 : public OcclusionTrackerTest<Types> {
2762 protected:
2763 explicit OcclusionTrackerTestAnimationOpacity0OnMainThread(bool opaque_layers)
2764 : OcclusionTrackerTest<Types>(opaque_layers) {}
2765 void RunMyTest() {
2766 typename Types::ContentLayerType* parent = this->CreateRoot(
2767 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2768 typename Types::ContentLayerType* layer =
2769 this->CreateDrawingLayer(parent,
2770 this->identity_matrix,
2771 gfx::PointF(),
2772 gfx::Size(300, 300),
2773 true);
2774 typename Types::ContentLayerType* surface =
2775 this->CreateDrawingSurface(parent,
2776 this->identity_matrix,
2777 gfx::PointF(),
2778 gfx::Size(300, 300),
2779 true);
2780 typename Types::ContentLayerType* surface_child =
2781 this->CreateDrawingLayer(surface,
2782 this->identity_matrix,
2783 gfx::PointF(),
2784 gfx::Size(200, 300),
2785 true);
2786 typename Types::ContentLayerType* surface_child2 =
2787 this->CreateDrawingLayer(surface,
2788 this->identity_matrix,
2789 gfx::PointF(),
2790 gfx::Size(100, 300),
2791 true);
2792 typename Types::ContentLayerType* parent2 =
2793 this->CreateDrawingLayer(parent,
2794 this->identity_matrix,
2795 gfx::PointF(),
2796 gfx::Size(300, 300),
2797 false);
2798 typename Types::ContentLayerType* topmost =
2799 this->CreateDrawingLayer(parent,
2800 this->identity_matrix,
2801 gfx::PointF(250.f, 0.f),
2802 gfx::Size(50, 300),
2803 true);
2804
2805 AddOpacityTransitionToController(
2806 layer->layer_animation_controller(), 10.0, 1.f, 0.f, false);
2807 AddOpacityTransitionToController(
2808 surface->layer_animation_controller(), 10.0, 1.f, 0.f, false);
2809 this->CalcDrawEtc(parent);
2810
2811 EXPECT_TRUE(layer->draw_opacity_is_animating());
2812 EXPECT_FALSE(surface->draw_opacity_is_animating());
2813 EXPECT_TRUE(surface->render_surface()->draw_opacity_is_animating());
2814
2815 TestOcclusionTrackerWithClip<typename Types::LayerType,
2816 typename Types::RenderSurfaceType> occlusion(
2817 gfx::Rect(0, 0, 1000, 1000));
2818
2819 this->VisitLayer(topmost, &occlusion);
2820 this->EnterLayer(parent2, &occlusion, false);
2821 // This occlusion will affect all surfaces.
2822 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
2823 occlusion.occlusion_from_inside_target().ToString());
2824 EXPECT_EQ(gfx::Rect().ToString(),
2825 occlusion.occlusion_from_outside_target().ToString());
2826 EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300),
2827 occlusion.UnoccludedLayerContentRect(
2828 parent, gfx::Rect(0, 0, 300, 300)));
2829 this->LeaveLayer(parent2, &occlusion);
2830
2831 this->VisitLayer(surface_child2, &occlusion);
2832 this->EnterLayer(surface_child, &occlusion, false);
2833 EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(),
2834 occlusion.occlusion_from_inside_target().ToString());
2835 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
2836 occlusion.occlusion_from_outside_target().ToString());
2837 EXPECT_RECT_EQ(gfx::Rect(100, 0, 100, 300),
2838 occlusion.UnoccludedLayerContentRect(
2839 surface_child, gfx::Rect(0, 0, 200, 300)));
2840 this->LeaveLayer(surface_child, &occlusion);
2841 this->EnterLayer(surface, &occlusion, false);
2842 EXPECT_EQ(gfx::Rect(0, 0, 200, 300).ToString(),
2843 occlusion.occlusion_from_inside_target().ToString());
2844 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
2845 occlusion.occlusion_from_outside_target().ToString());
2846 EXPECT_RECT_EQ(gfx::Rect(200, 0, 50, 300),
2847 occlusion.UnoccludedLayerContentRect(
2848 surface, gfx::Rect(0, 0, 300, 300)));
2849 this->LeaveLayer(surface, &occlusion);
2850
2851 this->EnterContributingSurface(surface, &occlusion, false);
2852 // Occlusion within the surface is lost when leaving the animating surface.
2853 EXPECT_EQ(gfx::Rect().ToString(),
2854 occlusion.occlusion_from_inside_target().ToString());
2855 EXPECT_EQ(gfx::Rect().ToString(),
2856 occlusion.occlusion_from_outside_target().ToString());
2857 EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300),
2858 occlusion.UnoccludedContributingSurfaceContentRect(
2859 surface, false, gfx::Rect(0, 0, 300, 300), NULL));
2860 this->LeaveContributingSurface(surface, &occlusion);
2861
2862 // Occlusion from outside the animating surface still exists.
2863 EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
2864 occlusion.occlusion_from_inside_target().ToString());
2865 EXPECT_EQ(gfx::Rect().ToString(),
2866 occlusion.occlusion_from_outside_target().ToString());
2867
2868 this->VisitLayer(layer, &occlusion);
2869 this->EnterLayer(parent, &occlusion, false);
2870
2871 // Occlusion is not added for the animating |layer|.
2872 EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300),
2873 occlusion.UnoccludedLayerContentRect(
2874 parent, gfx::Rect(0, 0, 300, 300)));
2875 }
2876 };
2877
2878 MAIN_THREAD_TEST(OcclusionTrackerTestAnimationOpacity0OnMainThread);
2879
2880 template <class Types>
2881 class OcclusionTrackerTestAnimationTranslateOnMainThread
2882 : public OcclusionTrackerTest<Types> {
2883 protected:
2884 explicit OcclusionTrackerTestAnimationTranslateOnMainThread(
2885 bool opaque_layers)
2886 : OcclusionTrackerTest<Types>(opaque_layers) {}
2887 void RunMyTest() {
2888 typename Types::ContentLayerType* parent = this->CreateRoot(
2889 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
2890 typename Types::ContentLayerType* layer =
2891 this->CreateDrawingLayer(parent,
2892 this->identity_matrix,
2893 gfx::PointF(),
2894 gfx::Size(300, 300),
2895 true);
2896 typename Types::ContentLayerType* surface =
2897 this->CreateDrawingSurface(parent,
2898 this->identity_matrix,
2899 gfx::PointF(),
2900 gfx::Size(300, 300),
2901 true);
2902 typename Types::ContentLayerType* surface_child =
2903 this->CreateDrawingLayer(surface,
2904 this->identity_matrix,
2905 gfx::PointF(),
2906 gfx::Size(200, 300),
2907 true);
2908 typename Types::ContentLayerType* surface_child2 =
2909 this->CreateDrawingLayer(surface,
2910 this->identity_matrix,
2911 gfx::PointF(),
2912 gfx::Size(100, 300),
2913 true);
2914 typename Types::ContentLayerType* surface2 = this->CreateDrawingSurface(
2915 parent, this->identity_matrix, gfx::PointF(), gfx::Size(50, 300), true);
2916
2917 AddAnimatedTransformToController(
2918 layer->layer_animation_controller(), 10.0, 30, 0);
2919 AddAnimatedTransformToController(
2920 surface->layer_animation_controller(), 10.0, 30, 0);
2921 AddAnimatedTransformToController(
2922 surface_child->layer_animation_controller(), 10.0, 30, 0);
2923 this->CalcDrawEtc(parent);
2924
2925 EXPECT_TRUE(layer->draw_transform_is_animating());
2926 EXPECT_TRUE(layer->screen_space_transform_is_animating());
2927 EXPECT_TRUE(
2928 surface->render_surface()->target_surface_transforms_are_animating());
2929 EXPECT_TRUE(
2930 surface->render_surface()->screen_space_transforms_are_animating());
2931 // The surface owning layer doesn't animate against its own surface.
2932 EXPECT_FALSE(surface->draw_transform_is_animating());
2933 EXPECT_TRUE(surface->screen_space_transform_is_animating());
2934 EXPECT_TRUE(surface_child->draw_transform_is_animating());
2935 EXPECT_TRUE(surface_child->screen_space_transform_is_animating());
2936
2937 TestOcclusionTrackerWithClip<typename Types::LayerType,
2938 typename Types::RenderSurfaceType> occlusion(
2939 gfx::Rect(0, 0, 1000, 1000));
2940
2941 this->VisitLayer(surface2, &occlusion);
2942 this->EnterContributingSurface(surface2, &occlusion, false);
2943
2944 EXPECT_EQ(gfx::Rect(0, 0, 50, 300).ToString(),
2945 occlusion.occlusion_from_inside_target().ToString());
2946
2947 this->LeaveContributingSurface(surface2, &occlusion);
2948 this->EnterLayer(surface_child2, &occlusion, false);
2949
2950 // surface_child2 is moving in screen space but not relative to its target,
2951 // so occlusion should happen in its target space only. It also means that
2952 // things occluding from outside the target (e.g. surface2) cannot occlude
2953 // this layer.
2954 EXPECT_EQ(gfx::Rect().ToString(),
2955 occlusion.occlusion_from_outside_target().ToString());
2956
2957 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 300),
2958 occlusion.UnoccludedLayerContentRect(
2959 surface_child2, gfx::Rect(0, 0, 100, 300)));
2960 EXPECT_FALSE(
2961 occlusion.OccludedLayer(surface_child, gfx::Rect(0, 0, 50, 300)));
2962
2963 this->LeaveLayer(surface_child2, &occlusion);
2964 this->EnterLayer(surface_child, &occlusion, false);
2965 EXPECT_FALSE(
2966 occlusion.OccludedLayer(surface_child, gfx::Rect(0, 0, 100, 300)));
2967 EXPECT_EQ(gfx::Rect().ToString(),
2968 occlusion.occlusion_from_outside_target().ToString());
2969 EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(),
2970 occlusion.occlusion_from_inside_target().ToString());
2971 EXPECT_RECT_EQ(gfx::Rect(100, 0, 200, 300),
2972 occlusion.UnoccludedLayerContentRect(
2973 surface, gfx::Rect(0, 0, 300, 300)));
2974
2975 // The surface_child is occluded by the surface_child2, but is moving
2976 // relative its target, so it can't be occluded.
2977 EXPECT_RECT_EQ(gfx::Rect(0, 0, 200, 300),
2978 occlusion.UnoccludedLayerContentRect(
2979 surface_child, gfx::Rect(0, 0, 200, 300)));
2980 EXPECT_FALSE(
2981 occlusion.OccludedLayer(surface_child, gfx::Rect(0, 0, 50, 300)));
2982
2983 this->LeaveLayer(surface_child, &occlusion);
2984 this->EnterLayer(surface, &occlusion, false);
2985 // The surface_child is moving in screen space but not relative to its
2986 // target, so occlusion should happen from within the target only.
2987 EXPECT_EQ(gfx::Rect().ToString(),
2988 occlusion.occlusion_from_outside_target().ToString());
2989 EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(),
2990 occlusion.occlusion_from_inside_target().ToString());
2991 EXPECT_RECT_EQ(gfx::Rect(100, 0, 200, 300),
2992 occlusion.UnoccludedLayerContentRect(
2993 surface, gfx::Rect(0, 0, 300, 300)));
2994
2995 this->LeaveLayer(surface, &occlusion);
2996 // The surface's owning layer is moving in screen space but not relative to
2997 // its target, so occlusion should happen within the target only.
2998 EXPECT_EQ(gfx::Rect().ToString(),
2999 occlusion.occlusion_from_outside_target().ToString());
3000 EXPECT_EQ(gfx::Rect(0, 0, 300, 300).ToString(),
3001 occlusion.occlusion_from_inside_target().ToString());
3002 EXPECT_RECT_EQ(gfx::Rect(0, 0, 0, 0),
3003 occlusion.UnoccludedLayerContentRect(
3004 surface, gfx::Rect(0, 0, 300, 300)));
3005
3006 this->EnterContributingSurface(surface, &occlusion, false);
3007 // The contributing |surface| is animating so it can't be occluded.
3008 EXPECT_RECT_EQ(gfx::Rect(0, 0, 300, 300),
3009 occlusion.UnoccludedContributingSurfaceContentRect(
3010 surface, false, gfx::Rect(0, 0, 300, 300), NULL));
3011 this->LeaveContributingSurface(surface, &occlusion);
3012
3013 this->EnterLayer(layer, &occlusion, false);
3014 // The |surface| is moving in the screen and in its target, so all occlusion
3015 // within the surface is lost when leaving it.
3016 EXPECT_RECT_EQ(gfx::Rect(50, 0, 250, 300),
3017 occlusion.UnoccludedLayerContentRect(
3018 parent, gfx::Rect(0, 0, 300, 300)));
3019 this->LeaveLayer(layer, &occlusion);
3020
3021 this->EnterLayer(parent, &occlusion, false);
3022 // The |layer| is animating in the screen and in its target, so no occlusion
3023 // is added.
3024 EXPECT_RECT_EQ(gfx::Rect(50, 0, 250, 300),
3025 occlusion.UnoccludedLayerContentRect(
3026 parent, gfx::Rect(0, 0, 300, 300)));
3027 }
3028 };
3029
3030 MAIN_THREAD_TEST(OcclusionTrackerTestAnimationTranslateOnMainThread);
3031
3032 template <class Types>
3033 class OcclusionTrackerTestSurfaceOcclusionTranslatesToParent
3034 : public OcclusionTrackerTest<Types> {
3035 protected:
3036 explicit OcclusionTrackerTestSurfaceOcclusionTranslatesToParent(
3037 bool opaque_layers)
3038 : OcclusionTrackerTest<Types>(opaque_layers) {}
3039 void RunMyTest() {
3040 gfx::Transform surface_transform;
3041 surface_transform.Translate(300.0, 300.0);
3042 surface_transform.Scale(2.0, 2.0);
3043 surface_transform.Translate(-150.0, -150.0);
3044
3045 typename Types::ContentLayerType* parent = this->CreateRoot(
3046 this->identity_matrix, gfx::PointF(), gfx::Size(500, 500));
3047 typename Types::ContentLayerType* surface = this->CreateDrawingSurface(
3048 parent, surface_transform, gfx::PointF(), gfx::Size(300, 300), false);
3049 typename Types::ContentLayerType* surface2 =
3050 this->CreateDrawingSurface(parent,
3051 this->identity_matrix,
3052 gfx::PointF(50.f, 50.f),
3053 gfx::Size(300, 300),
3054 false);
3055 surface->SetOpaqueContentsRect(gfx::Rect(0, 0, 200, 200));
3056 surface2->SetOpaqueContentsRect(gfx::Rect(0, 0, 200, 200));
3057 this->CalcDrawEtc(parent);
3058
3059 TestOcclusionTrackerWithClip<typename Types::LayerType,
3060 typename Types::RenderSurfaceType> occlusion(
3061 gfx::Rect(0, 0, 1000, 1000));
3062
3063 this->VisitLayer(surface2, &occlusion);
3064 this->VisitContributingSurface(surface2, &occlusion);
3065
3066 EXPECT_EQ(gfx::Rect().ToString(),
3067 occlusion.occlusion_from_outside_target().ToString());
3068 EXPECT_EQ(gfx::Rect(50, 50, 200, 200).ToString(),
3069 occlusion.occlusion_from_inside_target().ToString());
3070
3071 // Clear any stored occlusion.
3072 occlusion.set_occlusion_from_outside_target(Region());
3073 occlusion.set_occlusion_from_inside_target(Region());
3074
3075 this->VisitLayer(surface, &occlusion);
3076 this->VisitContributingSurface(surface, &occlusion);
3077
3078 EXPECT_EQ(gfx::Rect().ToString(),
3079 occlusion.occlusion_from_outside_target().ToString());
3080 EXPECT_EQ(gfx::Rect(0, 0, 400, 400).ToString(),
3081 occlusion.occlusion_from_inside_target().ToString());
3082 }
3083 };
3084
3085 MAIN_AND_IMPL_THREAD_TEST(
3086 OcclusionTrackerTestSurfaceOcclusionTranslatesToParent);
3087
3088 template <class Types>
3089 class OcclusionTrackerTestSurfaceOcclusionTranslatesWithClipping
3090 : public OcclusionTrackerTest<Types> {
3091 protected:
3092 explicit OcclusionTrackerTestSurfaceOcclusionTranslatesWithClipping(
3093 bool opaque_layers)
3094 : OcclusionTrackerTest<Types>(opaque_layers) {}
3095 void RunMyTest() {
3096 typename Types::ContentLayerType* parent = this->CreateRoot(
3097 this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
3098 parent->SetMasksToBounds(true);
3099 typename Types::ContentLayerType* surface =
3100 this->CreateDrawingSurface(parent,
3101 this->identity_matrix,
3102 gfx::PointF(),
3103 gfx::Size(500, 300),
3104 false);
3105 surface->SetOpaqueContentsRect(gfx::Rect(0, 0, 400, 200));
3106 this->CalcDrawEtc(parent);
3107
3108 TestOcclusionTrackerWithClip<typename Types::LayerType,
3109 typename Types::RenderSurfaceType> occlusion(
3110 gfx::Rect(0, 0, 1000, 1000));
3111
3112 this->VisitLayer(surface, &occlusion);
3113 this->VisitContributingSurface(surface, &occlusion);
3114
3115 EXPECT_EQ(gfx::Rect().ToString(),
3116 occlusion.occlusion_from_outside_target().ToString());
3117 EXPECT_EQ(gfx::Rect(0, 0, 300, 200).ToString(),
3118 occlusion.occlusion_from_inside_target().ToString());
3119 }
3120 };
3121
3122 MAIN_AND_IMPL_THREAD_TEST(
3123 OcclusionTrackerTestSurfaceOcclusionTranslatesWithClipping);
3124
3125 template <class Types>
3126 class OcclusionTrackerTestReplicaOccluded : public OcclusionTrackerTest<Types> {
3127 protected:
3128 explicit OcclusionTrackerTestReplicaOccluded(bool opaque_layers)
3129 : OcclusionTrackerTest<Types>(opaque_layers) {}
3130 void RunMyTest() {
3131 typename Types::ContentLayerType* parent = this->CreateRoot(
3132 this->identity_matrix, gfx::PointF(), gfx::Size(100, 200));
3133 typename Types::LayerType* surface =
3134 this->CreateDrawingSurface(parent,
3135 this->identity_matrix,
3136 gfx::PointF(),
3137 gfx::Size(100, 100),
3138 true);
3139 this->CreateReplicaLayer(surface,
3140 this->identity_matrix,
3141 gfx::PointF(0.f, 100.f),
3142 gfx::Size(100, 100));
3143 typename Types::LayerType* topmost =
3144 this->CreateDrawingLayer(parent,
3145 this->identity_matrix,
3146 gfx::PointF(0.f, 100.f),
3147 gfx::Size(100, 100),
3148 true);
3149 this->CalcDrawEtc(parent);
3150
3151 TestOcclusionTrackerWithClip<typename Types::LayerType,
3152 typename Types::RenderSurfaceType> occlusion(
3153 gfx::Rect(0, 0, 1000, 1000));
3154
3155 // |topmost| occludes the replica, but not the surface itself.
3156 this->VisitLayer(topmost, &occlusion);
3157
3158 EXPECT_EQ(gfx::Rect().ToString(),
3159 occlusion.occlusion_from_outside_target().ToString());
3160 EXPECT_EQ(gfx::Rect(0, 100, 100, 100).ToString(),
3161 occlusion.occlusion_from_inside_target().ToString());
3162
3163 this->VisitLayer(surface, &occlusion);
3164
3165 EXPECT_EQ(gfx::Rect(0, 100, 100, 100).ToString(),
3166 occlusion.occlusion_from_outside_target().ToString());
3167 EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
3168 occlusion.occlusion_from_inside_target().ToString());
3169
3170 this->EnterContributingSurface(surface, &occlusion, false);
3171
3172 // Surface is not occluded so it shouldn't think it is.
3173 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
3174 occlusion.UnoccludedContributingSurfaceContentRect(
3175 surface, false, gfx::Rect(0, 0, 100, 100), NULL));
3176 }
3177 };
3178
3179 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaOccluded);
3180
3181 template <class Types>
3182 class OcclusionTrackerTestSurfaceWithReplicaUnoccluded
3183 : public OcclusionTrackerTest<Types> {
3184 protected:
3185 explicit OcclusionTrackerTestSurfaceWithReplicaUnoccluded(bool opaque_layers)
3186 : OcclusionTrackerTest<Types>(opaque_layers) {}
3187 void RunMyTest() {
3188 typename Types::ContentLayerType* parent = this->CreateRoot(
3189 this->identity_matrix, gfx::PointF(), gfx::Size(100, 200));
3190 typename Types::LayerType* surface =
3191 this->CreateDrawingSurface(parent,
3192 this->identity_matrix,
3193 gfx::PointF(),
3194 gfx::Size(100, 100),
3195 true);
3196 this->CreateReplicaLayer(surface,
3197 this->identity_matrix,
3198 gfx::PointF(0.f, 100.f),
3199 gfx::Size(100, 100));
3200 typename Types::LayerType* topmost =
3201 this->CreateDrawingLayer(parent,
3202 this->identity_matrix,
3203 gfx::PointF(),
3204 gfx::Size(100, 110),
3205 true);
3206 this->CalcDrawEtc(parent);
3207
3208 TestOcclusionTrackerWithClip<typename Types::LayerType,
3209 typename Types::RenderSurfaceType> occlusion(
3210 gfx::Rect(0, 0, 1000, 1000));
3211
3212 // |topmost| occludes the surface, but not the entire surface's replica.
3213 this->VisitLayer(topmost, &occlusion);
3214
3215 EXPECT_EQ(gfx::Rect().ToString(),
3216 occlusion.occlusion_from_outside_target().ToString());
3217 EXPECT_EQ(gfx::Rect(0, 0, 100, 110).ToString(),
3218 occlusion.occlusion_from_inside_target().ToString());
3219
3220 this->VisitLayer(surface, &occlusion);
3221
3222 EXPECT_EQ(gfx::Rect(0, 0, 100, 110).ToString(),
3223 occlusion.occlusion_from_outside_target().ToString());
3224 EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
3225 occlusion.occlusion_from_inside_target().ToString());
3226
3227 this->EnterContributingSurface(surface, &occlusion, false);
3228
3229 // Surface is occluded, but only the top 10px of the replica.
3230 EXPECT_RECT_EQ(gfx::Rect(0, 0, 0, 0),
3231 occlusion.UnoccludedContributingSurfaceContentRect(
3232 surface, false, gfx::Rect(0, 0, 100, 100), NULL));
3233 EXPECT_RECT_EQ(gfx::Rect(0, 10, 100, 90),
3234 occlusion.UnoccludedContributingSurfaceContentRect(
3235 surface, true, gfx::Rect(0, 0, 100, 100), NULL));
3236 }
3237 };
3238
3239 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceWithReplicaUnoccluded);
3240
3241 template <class Types>
3242 class OcclusionTrackerTestSurfaceAndReplicaOccludedDifferently
3243 : public OcclusionTrackerTest<Types> {
3244 protected:
3245 explicit OcclusionTrackerTestSurfaceAndReplicaOccludedDifferently(
3246 bool opaque_layers)
3247 : OcclusionTrackerTest<Types>(opaque_layers) {}
3248 void RunMyTest() {
3249 typename Types::ContentLayerType* parent = this->CreateRoot(
3250 this->identity_matrix, gfx::PointF(), gfx::Size(100, 200));
3251 typename Types::LayerType* surface =
3252 this->CreateDrawingSurface(parent,
3253 this->identity_matrix,
3254 gfx::PointF(),
3255 gfx::Size(100, 100),
3256 true);
3257 this->CreateReplicaLayer(surface,
3258 this->identity_matrix,
3259 gfx::PointF(0.f, 100.f),
3260 gfx::Size(100, 100));
3261 typename Types::LayerType* over_surface = this->CreateDrawingLayer(
3262 parent, this->identity_matrix, gfx::PointF(), gfx::Size(40, 100), true);
3263 typename Types::LayerType* over_replica =
3264 this->CreateDrawingLayer(parent,
3265 this->identity_matrix,
3266 gfx::PointF(0.f, 100.f),
3267 gfx::Size(50, 100),
3268 true);
3269 this->CalcDrawEtc(parent);
3270
3271 TestOcclusionTrackerWithClip<typename Types::LayerType,
3272 typename Types::RenderSurfaceType> occlusion(
3273 gfx::Rect(0, 0, 1000, 1000));
3274
3275 // These occlude the surface and replica differently, so we can test each
3276 // one.
3277 this->VisitLayer(over_replica, &occlusion);
3278 this->VisitLayer(over_surface, &occlusion);
3279
3280 EXPECT_EQ(gfx::Rect().ToString(),
3281 occlusion.occlusion_from_outside_target().ToString());
3282 EXPECT_EQ(UnionRegions(gfx::Rect(0, 0, 40, 100), gfx::Rect(0, 100, 50, 100))
3283 .ToString(),
3284 occlusion.occlusion_from_inside_target().ToString());
3285
3286 this->VisitLayer(surface, &occlusion);
3287
3288 EXPECT_EQ(UnionRegions(gfx::Rect(0, 0, 40, 100), gfx::Rect(0, 100, 50, 100))
3289 .ToString(),
3290 occlusion.occlusion_from_outside_target().ToString());
3291 EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
3292 occlusion.occlusion_from_inside_target().ToString());
3293
3294 this->EnterContributingSurface(surface, &occlusion, false);
3295
3296 // Surface and replica are occluded different amounts.
3297 EXPECT_RECT_EQ(gfx::Rect(40, 0, 60, 100),
3298 occlusion.UnoccludedContributingSurfaceContentRect(
3299 surface, false, gfx::Rect(0, 0, 100, 100), NULL));
3300 EXPECT_RECT_EQ(gfx::Rect(50, 0, 50, 100),
3301 occlusion.UnoccludedContributingSurfaceContentRect(
3302 surface, true, gfx::Rect(0, 0, 100, 100), NULL));
3303 }
3304 };
3305
3306 ALL_OCCLUSIONTRACKER_TEST(
3307 OcclusionTrackerTestSurfaceAndReplicaOccludedDifferently);
3308
3309 template <class Types>
3310 class OcclusionTrackerTestSurfaceChildOfSurface
3311 : public OcclusionTrackerTest<Types> {
3312 protected:
3313 explicit OcclusionTrackerTestSurfaceChildOfSurface(bool opaque_layers)
3314 : OcclusionTrackerTest<Types>(opaque_layers) {}
3315 void RunMyTest() {
3316 // This test verifies that the surface cliprect does not end up empty and
3317 // clip away the entire unoccluded rect.
3318
3319 typename Types::ContentLayerType* parent = this->CreateRoot(
3320 this->identity_matrix, gfx::PointF(), gfx::Size(100, 200));
3321 typename Types::LayerType* surface =
3322 this->CreateDrawingSurface(parent,
3323 this->identity_matrix,
3324 gfx::PointF(),
3325 gfx::Size(100, 100),
3326 true);
3327 typename Types::LayerType* surface_child =
3328 this->CreateDrawingSurface(surface,
3329 this->identity_matrix,
3330 gfx::PointF(0.f, 10.f),
3331 gfx::Size(100, 50),
3332 true);
3333 typename Types::LayerType* topmost = this->CreateDrawingLayer(
3334 parent, this->identity_matrix, gfx::PointF(), gfx::Size(100, 50), true);
3335 this->CalcDrawEtc(parent);
3336
3337 TestOcclusionTrackerWithClip<typename Types::LayerType,
3338 typename Types::RenderSurfaceType> occlusion(
3339 gfx::Rect(-100, -100, 1000, 1000));
3340
3341 // |topmost| occludes everything partially so we know occlusion is happening
3342 // at all.
3343 this->VisitLayer(topmost, &occlusion);
3344
3345 EXPECT_EQ(gfx::Rect().ToString(),
3346 occlusion.occlusion_from_outside_target().ToString());
3347 EXPECT_EQ(gfx::Rect(0, 0, 100, 50).ToString(),
3348 occlusion.occlusion_from_inside_target().ToString());
3349
3350 this->VisitLayer(surface_child, &occlusion);
3351
3352 // surface_child increases the occlusion in the screen by a narrow sliver.
3353 EXPECT_EQ(gfx::Rect(0, -10, 100, 50).ToString(),
3354 occlusion.occlusion_from_outside_target().ToString());
3355 // In its own surface, surface_child is at 0,0 as is its occlusion.
3356 EXPECT_EQ(gfx::Rect(0, 0, 100, 50).ToString(),
3357 occlusion.occlusion_from_inside_target().ToString());
3358
3359 // The root layer always has a clip rect. So the parent of |surface| has a
3360 // clip rect. However, the owning layer for |surface| does not mask to
3361 // bounds, so it doesn't have a clip rect of its own. Thus the parent of
3362 // |surface_child| exercises different code paths as its parent does not
3363 // have a clip rect.
3364
3365 this->EnterContributingSurface(surface_child, &occlusion, false);
3366 // The surface_child's parent does not have a clip rect as it owns a render
3367 // surface. Make sure the unoccluded rect does not get clipped away
3368 // inappropriately.
3369 EXPECT_RECT_EQ(gfx::Rect(0, 40, 100, 10),
3370 occlusion.UnoccludedContributingSurfaceContentRect(
3371 surface_child, false, gfx::Rect(0, 0, 100, 50), NULL));
3372 this->LeaveContributingSurface(surface_child, &occlusion);
3373
3374 // When the surface_child's occlusion is transformed up to its parent, make
3375 // sure it is not clipped away inappropriately also.
3376 this->EnterLayer(surface, &occlusion, false);
3377 EXPECT_EQ(gfx::Rect(0, 0, 100, 50).ToString(),
3378 occlusion.occlusion_from_outside_target().ToString());
3379 EXPECT_EQ(gfx::Rect(0, 10, 100, 50).ToString(),
3380 occlusion.occlusion_from_inside_target().ToString());
3381 this->LeaveLayer(surface, &occlusion);
3382
3383 this->EnterContributingSurface(surface, &occlusion, false);
3384 // The surface's parent does have a clip rect as it is the root layer.
3385 EXPECT_RECT_EQ(gfx::Rect(0, 50, 100, 50),
3386 occlusion.UnoccludedContributingSurfaceContentRect(
3387 surface, false, gfx::Rect(0, 0, 100, 100), NULL));
3388 }
3389 };
3390
3391 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceChildOfSurface);
3392
3393 template <class Types>
3394 class OcclusionTrackerTestTopmostSurfaceIsClippedToViewport
3395 : public OcclusionTrackerTest<Types> {
3396 protected:
3397 explicit OcclusionTrackerTestTopmostSurfaceIsClippedToViewport(
3398 bool opaque_layers)
3399 : OcclusionTrackerTest<Types>(opaque_layers) {}
3400 void RunMyTest() {
3401 // This test verifies that the top-most surface is considered occluded
3402 // outside of its target's clip rect and outside the viewport rect.
3403
3404 typename Types::ContentLayerType* parent = this->CreateRoot(
3405 this->identity_matrix, gfx::PointF(), gfx::Size(100, 200));
3406 typename Types::LayerType* surface =
3407 this->CreateDrawingSurface(parent,
3408 this->identity_matrix,
3409 gfx::PointF(),
3410 gfx::Size(100, 300),
3411 true);
3412 this->CalcDrawEtc(parent);
3413 {
3414 // Make a viewport rect that is larger than the root layer.
3415 TestOcclusionTrackerWithClip<typename Types::LayerType,
3416 typename Types::RenderSurfaceType> occlusion(
3417 gfx::Rect(0, 0, 1000, 1000));
3418
3419 this->VisitLayer(surface, &occlusion);
3420
3421 // The root layer always has a clip rect. So the parent of |surface| has a
3422 // clip rect giving the surface itself a clip rect.
3423 this->EnterContributingSurface(surface, &occlusion, false);
3424 // Make sure the parent's clip rect clips the unoccluded region of the
3425 // child surface.
3426 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 200),
3427 occlusion.UnoccludedContributingSurfaceContentRect(
3428 surface, false, gfx::Rect(0, 0, 100, 300), NULL));
3429 }
3430 this->ResetLayerIterator();
3431 {
3432 // Make a viewport rect that is smaller than the root layer.
3433 TestOcclusionTrackerWithClip<typename Types::LayerType,
3434 typename Types::RenderSurfaceType> occlusion(
3435 gfx::Rect(0, 0, 100, 100));
3436
3437 this->VisitLayer(surface, &occlusion);
3438
3439 // The root layer always has a clip rect. So the parent of |surface| has a
3440 // clip rect giving the surface itself a clip rect.
3441 this->EnterContributingSurface(surface, &occlusion, false);
3442 // Make sure the viewport rect clips the unoccluded region of the child
3443 // surface.
3444 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
3445 occlusion.UnoccludedContributingSurfaceContentRect(
3446 surface, false, gfx::Rect(0, 0, 100, 300), NULL));
3447 }
3448 }
3449 };
3450
3451 ALL_OCCLUSIONTRACKER_TEST(
3452 OcclusionTrackerTestTopmostSurfaceIsClippedToViewport);
3453
3454 template <class Types>
3455 class OcclusionTrackerTestSurfaceChildOfClippingSurface
3456 : public OcclusionTrackerTest<Types> {
3457 protected:
3458 explicit OcclusionTrackerTestSurfaceChildOfClippingSurface(bool opaque_layers)
3459 : OcclusionTrackerTest<Types>(opaque_layers) {}
3460 void RunMyTest() {
3461 // This test verifies that the surface cliprect does not end up empty and
3462 // clip away the entire unoccluded rect.
3463
3464 typename Types::ContentLayerType* parent = this->CreateRoot(
3465 this->identity_matrix, gfx::PointF(), gfx::Size(80, 200));
3466 parent->SetMasksToBounds(true);
3467 typename Types::LayerType* surface =
3468 this->CreateDrawingSurface(parent,
3469 this->identity_matrix,
3470 gfx::PointF(),
3471 gfx::Size(100, 100),
3472 true);
3473 typename Types::LayerType* surface_child =
3474 this->CreateDrawingSurface(surface,
3475 this->identity_matrix,
3476 gfx::PointF(),
3477 gfx::Size(100, 100),
3478 false);
3479 typename Types::LayerType* topmost = this->CreateDrawingLayer(
3480 parent, this->identity_matrix, gfx::PointF(), gfx::Size(100, 50), true);
3481 this->CalcDrawEtc(parent);
3482
3483 TestOcclusionTrackerWithClip<typename Types::LayerType,
3484 typename Types::RenderSurfaceType> occlusion(
3485 gfx::Rect(0, 0, 1000, 1000));
3486
3487 // |topmost| occludes everything partially so we know occlusion is happening
3488 // at all.
3489 this->VisitLayer(topmost, &occlusion);
3490
3491 EXPECT_EQ(gfx::Rect().ToString(),
3492 occlusion.occlusion_from_outside_target().ToString());
3493 EXPECT_EQ(gfx::Rect(0, 0, 80, 50).ToString(),
3494 occlusion.occlusion_from_inside_target().ToString());
3495
3496 // surface_child is not opaque and does not occlude, so we have a non-empty
3497 // unoccluded area on surface.
3498 this->VisitLayer(surface_child, &occlusion);
3499
3500 EXPECT_EQ(gfx::Rect(0, 0, 80, 50).ToString(),
3501 occlusion.occlusion_from_outside_target().ToString());
3502 EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(),
3503 occlusion.occlusion_from_inside_target().ToString());
3504
3505 // The root layer always has a clip rect. So the parent of |surface| has a
3506 // clip rect. However, the owning layer for |surface| does not mask to
3507 // bounds, so it doesn't have a clip rect of its own. Thus the parent of
3508 // |surface_child| exercises different code paths as its parent does not
3509 // have a clip rect.
3510
3511 this->EnterContributingSurface(surface_child, &occlusion, false);
3512 // The surface_child's parent does not have a clip rect as it owns a render
3513 // surface.
3514 EXPECT_EQ(
3515 gfx::Rect(0, 50, 80, 50).ToString(),
3516 occlusion.UnoccludedContributingSurfaceContentRect(
3517 surface_child, false, gfx::Rect(0, 0, 100, 100), NULL).ToString());
3518 this->LeaveContributingSurface(surface_child, &occlusion);
3519
3520 this->VisitLayer(surface, &occlusion);
3521 this->EnterContributingSurface(surface, &occlusion, false);
3522 // The surface's parent does have a clip rect as it is the root layer.
3523 EXPECT_EQ(gfx::Rect(0, 50, 80, 50).ToString(),
3524 occlusion.UnoccludedContributingSurfaceContentRect(
3525 surface, false, gfx::Rect(0, 0, 100, 100), NULL).ToString());
3526 }
3527 };
3528
3529 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceChildOfClippingSurface);
3530
3531 template <class Types>
3532 class OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter
3533 : public OcclusionTrackerTest<Types> {
3534 protected:
3535 explicit OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter(
3536 bool opaque_layers)
3537 : OcclusionTrackerTest<Types>(opaque_layers) {}
3538 void RunMyTest() {
3539 gfx::Transform scale_by_half;
3540 scale_by_half.Scale(0.5, 0.5);
3541
3542 // Make a surface and its replica, each 50x50, that are completely
3543 // surrounded by opaque layers which are above them in the z-order. The
3544 // surface is scaled to test that the pixel moving is done in the target
3545 // space, where the background filter is applied, but the surface appears at
3546 // 50, 50 and the replica at 200, 50.
3547 typename Types::ContentLayerType* parent = this->CreateRoot(
3548 this->identity_matrix, gfx::PointF(), gfx::Size(300, 150));
3549 typename Types::LayerType* filtered_surface =
3550 this->CreateDrawingLayer(parent,
3551 scale_by_half,
3552 gfx::PointF(50.f, 50.f),
3553 gfx::Size(100, 100),
3554 false);
3555 this->CreateReplicaLayer(filtered_surface,
3556 this->identity_matrix,
3557 gfx::PointF(300.f, 0.f),
3558 gfx::Size());
3559 typename Types::LayerType* occluding_layer1 = this->CreateDrawingLayer(
3560 parent, this->identity_matrix, gfx::PointF(), gfx::Size(300, 50), true);
3561 typename Types::LayerType* occluding_layer2 =
3562 this->CreateDrawingLayer(parent,
3563 this->identity_matrix,
3564 gfx::PointF(0.f, 100.f),
3565 gfx::Size(300, 50),
3566 true);
3567 typename Types::LayerType* occluding_layer3 =
3568 this->CreateDrawingLayer(parent,
3569 this->identity_matrix,
3570 gfx::PointF(0.f, 50.f),
3571 gfx::Size(50, 50),
3572 true);
3573 typename Types::LayerType* occluding_layer4 =
3574 this->CreateDrawingLayer(parent,
3575 this->identity_matrix,
3576 gfx::PointF(100.f, 50.f),
3577 gfx::Size(100, 50),
3578 true);
3579 typename Types::LayerType* occluding_layer5 =
3580 this->CreateDrawingLayer(parent,
3581 this->identity_matrix,
3582 gfx::PointF(250.f, 50.f),
3583 gfx::Size(50, 50),
3584 true);
3585
3586 // Filters make the layer own a surface.
3587 FilterOperations filters;
3588 filters.Append(FilterOperation::CreateBlurFilter(10.f));
3589 filtered_surface->SetBackgroundFilters(filters);
3590
3591 // Save the distance of influence for the blur effect.
3592 int outset_top, outset_right, outset_bottom, outset_left;
3593 filters.GetOutsets(
3594 &outset_top, &outset_right, &outset_bottom, &outset_left);
3595
3596 this->CalcDrawEtc(parent);
3597
3598 TestOcclusionTrackerWithClip<typename Types::LayerType,
3599 typename Types::RenderSurfaceType> occlusion(
3600 gfx::Rect(0, 0, 1000, 1000));
3601
3602 // These layers occlude pixels directly beside the filtered_surface. Because
3603 // filtered surface blends pixels in a radius, it will need to see some of
3604 // the pixels (up to radius far) underneath the occluding layers.
3605 this->VisitLayer(occluding_layer5, &occlusion);
3606 this->VisitLayer(occluding_layer4, &occlusion);
3607 this->VisitLayer(occluding_layer3, &occlusion);
3608 this->VisitLayer(occluding_layer2, &occlusion);
3609 this->VisitLayer(occluding_layer1, &occlusion);
3610
3611 Region expected_occlusion;
3612 expected_occlusion.Union(gfx::Rect(0, 0, 300, 50));
3613 expected_occlusion.Union(gfx::Rect(0, 50, 50, 50));
3614 expected_occlusion.Union(gfx::Rect(100, 50, 100, 50));
3615 expected_occlusion.Union(gfx::Rect(250, 50, 50, 50));
3616 expected_occlusion.Union(gfx::Rect(0, 100, 300, 50));
3617
3618 EXPECT_EQ(expected_occlusion.ToString(),
3619 occlusion.occlusion_from_inside_target().ToString());
3620 EXPECT_EQ(gfx::Rect().ToString(),
3621 occlusion.occlusion_from_outside_target().ToString());
3622
3623 this->VisitLayer(filtered_surface, &occlusion);
3624
3625 // The filtered layer/replica does not occlude.
3626 Region expected_occlusion_outside_surface;
3627 expected_occlusion_outside_surface.Union(gfx::Rect(-50, -50, 300, 50));
3628 expected_occlusion_outside_surface.Union(gfx::Rect(-50, 0, 50, 50));
3629 expected_occlusion_outside_surface.Union(gfx::Rect(50, 0, 100, 50));
3630 expected_occlusion_outside_surface.Union(gfx::Rect(200, 0, 50, 50));
3631 expected_occlusion_outside_surface.Union(gfx::Rect(-50, 50, 300, 50));
3632
3633 EXPECT_EQ(expected_occlusion_outside_surface.ToString(),
3634 occlusion.occlusion_from_outside_target().ToString());
3635 EXPECT_EQ(gfx::Rect().ToString(),
3636 occlusion.occlusion_from_inside_target().ToString());
3637
3638 // The surface has a background blur, so it needs pixels that are currently
3639 // considered occluded in order to be drawn. So the pixels it needs should
3640 // be removed some the occluded area so that when we get to the parent they
3641 // are drawn.
3642 this->VisitContributingSurface(filtered_surface, &occlusion);
3643
3644 this->EnterLayer(parent, &occlusion, false);
3645
3646 Region expected_blurred_occlusion;
3647 expected_blurred_occlusion.Union(gfx::Rect(0, 0, 300, 50 - outset_top));
3648 expected_blurred_occlusion.Union(gfx::Rect(
3649 0, 50 - outset_top, 50 - outset_left, 50 + outset_top + outset_bottom));
3650 expected_blurred_occlusion.Union(
3651 gfx::Rect(100 + outset_right,
3652 50 - outset_top,
3653 100 - outset_right - outset_left,
3654 50 + outset_top + outset_bottom));
3655 expected_blurred_occlusion.Union(
3656 gfx::Rect(250 + outset_right,
3657 50 - outset_top,
3658 50 - outset_right,
3659 50 + outset_top + outset_bottom));
3660 expected_blurred_occlusion.Union(
3661 gfx::Rect(0, 100 + outset_bottom, 300, 50 - outset_bottom));
3662
3663 EXPECT_EQ(expected_blurred_occlusion.ToString(),
3664 occlusion.occlusion_from_inside_target().ToString());
3665 EXPECT_EQ(gfx::Rect().ToString(),
3666 occlusion.occlusion_from_outside_target().ToString());
3667
3668 gfx::Rect outset_rect;
3669 gfx::Rect test_rect;
3670
3671 // Nothing in the blur outsets for the filtered_surface is occluded.
3672 outset_rect = gfx::Rect(50 - outset_left,
3673 50 - outset_top,
3674 50 + outset_left + outset_right,
3675 50 + outset_top + outset_bottom);
3676 test_rect = outset_rect;
3677 EXPECT_EQ(
3678 outset_rect.ToString(),
3679 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString());
3680
3681 // Stuff outside the blur outsets is still occluded though.
3682 test_rect = outset_rect;
3683 test_rect.Inset(0, 0, -1, 0);
3684 EXPECT_EQ(
3685 outset_rect.ToString(),
3686 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString());
3687 test_rect = outset_rect;
3688 test_rect.Inset(0, 0, 0, -1);
3689 EXPECT_EQ(
3690 outset_rect.ToString(),
3691 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString());
3692 test_rect = outset_rect;
3693 test_rect.Inset(-1, 0, 0, 0);
3694 EXPECT_EQ(
3695 outset_rect.ToString(),
3696 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString());
3697 test_rect = outset_rect;
3698 test_rect.Inset(0, -1, 0, 0);
3699 EXPECT_EQ(
3700 outset_rect.ToString(),
3701 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString());
3702
3703 // Nothing in the blur outsets for the filtered_surface's replica is
3704 // occluded.
3705 outset_rect = gfx::Rect(200 - outset_left,
3706 50 - outset_top,
3707 50 + outset_left + outset_right,
3708 50 + outset_top + outset_bottom);
3709 test_rect = outset_rect;
3710 EXPECT_EQ(
3711 outset_rect.ToString(),
3712 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString());
3713
3714 // Stuff outside the blur outsets is still occluded though.
3715 test_rect = outset_rect;
3716 test_rect.Inset(0, 0, -1, 0);
3717 EXPECT_EQ(
3718 outset_rect.ToString(),
3719 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString());
3720 test_rect = outset_rect;
3721 test_rect.Inset(0, 0, 0, -1);
3722 EXPECT_EQ(
3723 outset_rect.ToString(),
3724 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString());
3725 test_rect = outset_rect;
3726 test_rect.Inset(-1, 0, 0, 0);
3727 EXPECT_EQ(
3728 outset_rect.ToString(),
3729 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString());
3730 test_rect = outset_rect;
3731 test_rect.Inset(0, -1, 0, 0);
3732 EXPECT_EQ(
3733 outset_rect.ToString(),
3734 occlusion.UnoccludedLayerContentRect(parent, test_rect).ToString());
3735 }
3736 };
3737
3738 ALL_OCCLUSIONTRACKER_TEST(
3739 OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter);
3740
3741 template <class Types>
3742 class OcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice
3743 : public OcclusionTrackerTest<Types> {
3744 protected:
3745 explicit OcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice(
3746 bool opaque_layers)
3747 : OcclusionTrackerTest<Types>(opaque_layers) {}
3748 void RunMyTest() {
3749 gfx::Transform scale_by_half;
3750 scale_by_half.Scale(0.5, 0.5);
3751
3752 // Makes two surfaces that completely cover |parent|. The occlusion both
3753 // above and below the filters will be reduced by each of them.
3754 typename Types::ContentLayerType* root = this->CreateRoot(
3755 this->identity_matrix, gfx::PointF(), gfx::Size(75, 75));
3756 typename Types::LayerType* parent = this->CreateSurface(
3757 root, scale_by_half, gfx::PointF(), gfx::Size(150, 150));
3758 parent->SetMasksToBounds(true);
3759 typename Types::LayerType* filtered_surface1 = this->CreateDrawingLayer(
3760 parent, scale_by_half, gfx::PointF(), gfx::Size(300, 300), false);
3761 typename Types::LayerType* filtered_surface2 = this->CreateDrawingLayer(
3762 parent, scale_by_half, gfx::PointF(), gfx::Size(300, 300), false);
3763 typename Types::LayerType* occluding_layer_above =
3764 this->CreateDrawingLayer(parent,
3765 this->identity_matrix,
3766 gfx::PointF(100.f, 100.f),
3767 gfx::Size(50, 50),
3768 true);
3769
3770 // Filters make the layers own surfaces.
3771 FilterOperations filters;
3772 filters.Append(FilterOperation::CreateBlurFilter(1.f));
3773 filtered_surface1->SetBackgroundFilters(filters);
3774 filtered_surface2->SetBackgroundFilters(filters);
3775
3776 // Save the distance of influence for the blur effect.
3777 int outset_top, outset_right, outset_bottom, outset_left;
3778 filters.GetOutsets(
3779 &outset_top, &outset_right, &outset_bottom, &outset_left);
3780
3781 this->CalcDrawEtc(root);
3782
3783 TestOcclusionTrackerWithClip<typename Types::LayerType,
3784 typename Types::RenderSurfaceType> occlusion(
3785 gfx::Rect(0, 0, 1000, 1000));
3786
3787 this->VisitLayer(occluding_layer_above, &occlusion);
3788 EXPECT_EQ(gfx::Rect().ToString(),
3789 occlusion.occlusion_from_outside_target().ToString());
3790 EXPECT_EQ(gfx::Rect(100 / 2, 100 / 2, 50 / 2, 50 / 2).ToString(),
3791 occlusion.occlusion_from_inside_target().ToString());
3792
3793 this->VisitLayer(filtered_surface2, &occlusion);
3794 this->VisitContributingSurface(filtered_surface2, &occlusion);
3795 this->VisitLayer(filtered_surface1, &occlusion);
3796 this->VisitContributingSurface(filtered_surface1, &occlusion);
3797
3798 // Test expectations in the target.
3799 gfx::Rect expected_occlusion =
3800 gfx::Rect(100 / 2 + outset_right * 2,
3801 100 / 2 + outset_bottom * 2,
3802 50 / 2 - (outset_left + outset_right) * 2,
3803 50 / 2 - (outset_top + outset_bottom) * 2);
3804 EXPECT_EQ(expected_occlusion.ToString(),
3805 occlusion.occlusion_from_inside_target().ToString());
3806
3807 // Test expectations in the screen are the same as in the target, as the
3808 // render surface is 1:1 with the screen.
3809 EXPECT_EQ(expected_occlusion.ToString(),
3810 occlusion.occlusion_from_outside_target().ToString());
3811 }
3812 };
3813
3814 ALL_OCCLUSIONTRACKER_TEST(
3815 OcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice);
3816
3817 template <class Types>
3818 class OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilterWithClip
3819 : public OcclusionTrackerTest<Types> {
3820 protected:
3821 explicit
3822 OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilterWithClip(
3823 bool opaque_layers)
3824 : OcclusionTrackerTest<Types>(opaque_layers) {}
3825 void RunMyTest() {
3826 // Make a surface and its replica, Each 50x50, that are completely
3827 // surrounded by opaque layers which are above them in the z-order.
3828 typename Types::ContentLayerType* parent = this->CreateRoot(
3829 this->identity_matrix, gfx::PointF(), gfx::Size(300, 150));
3830 // We stick the filtered surface inside a clipping surface so that we can
3831 // make sure the clip is honored when exposing pixels for
3832 // the background filter.
3833 typename Types::LayerType* clipping_surface =
3834 this->CreateDrawingSurface(parent,
3835 this->identity_matrix,
3836 gfx::PointF(),
3837 gfx::Size(300, 70),
3838 false);
3839 clipping_surface->SetMasksToBounds(true);
3840 typename Types::LayerType* filtered_surface =
3841 this->CreateDrawingLayer(clipping_surface,
3842 this->identity_matrix,
3843 gfx::PointF(50.f, 50.f),
3844 gfx::Size(50, 50),
3845 false);
3846 this->CreateReplicaLayer(filtered_surface,
3847 this->identity_matrix,
3848 gfx::PointF(150.f, 0.f),
3849 gfx::Size());
3850 typename Types::LayerType* occluding_layer1 = this->CreateDrawingLayer(
3851 parent, this->identity_matrix, gfx::PointF(), gfx::Size(300, 50), true);
3852 typename Types::LayerType* occluding_layer2 =
3853 this->CreateDrawingLayer(parent,
3854 this->identity_matrix,
3855 gfx::PointF(0.f, 100.f),
3856 gfx::Size(300, 50),
3857 true);
3858 typename Types::LayerType* occluding_layer3 =
3859 this->CreateDrawingLayer(parent,
3860 this->identity_matrix,
3861 gfx::PointF(0.f, 50.f),
3862 gfx::Size(50, 50),
3863 true);
3864 typename Types::LayerType* occluding_layer4 =
3865 this->CreateDrawingLayer(parent,
3866 this->identity_matrix,
3867 gfx::PointF(100.f, 50.f),
3868 gfx::Size(100, 50),
3869 true);
3870 typename Types::LayerType* occluding_layer5 =
3871 this->CreateDrawingLayer(parent,
3872 this->identity_matrix,
3873 gfx::PointF(250.f, 50.f),
3874 gfx::Size(50, 50),
3875 true);
3876
3877 // Filters make the layer own a surface. This filter is large enough that it
3878 // goes outside the bottom of the clipping_surface.
3879 FilterOperations filters;
3880 filters.Append(FilterOperation::CreateBlurFilter(12.f));
3881 filtered_surface->SetBackgroundFilters(filters);
3882
3883 // Save the distance of influence for the blur effect.
3884 int outset_top, outset_right, outset_bottom, outset_left;
3885 filters.GetOutsets(
3886 &outset_top, &outset_right, &outset_bottom, &outset_left);
3887
3888 this->CalcDrawEtc(parent);
3889
3890 TestOcclusionTrackerWithClip<typename Types::LayerType,
3891 typename Types::RenderSurfaceType> occlusion(
3892 gfx::Rect(0, 0, 1000, 1000));
3893
3894 // These layers occlude pixels directly beside the filtered_surface. Because
3895 // filtered surface blends pixels in a radius, it will need to see some of
3896 // the pixels (up to radius far) underneath the occluding layers.
3897 this->VisitLayer(occluding_layer5, &occlusion);
3898 this->VisitLayer(occluding_layer4, &occlusion);
3899 this->VisitLayer(occluding_layer3, &occlusion);
3900 this->VisitLayer(occluding_layer2, &occlusion);
3901 this->VisitLayer(occluding_layer1, &occlusion);
3902
3903 Region expected_occlusion;
3904 expected_occlusion.Union(gfx::Rect(0, 0, 300, 50));
3905 expected_occlusion.Union(gfx::Rect(0, 50, 50, 50));
3906 expected_occlusion.Union(gfx::Rect(100, 50, 100, 50));
3907 expected_occlusion.Union(gfx::Rect(250, 50, 50, 50));
3908 expected_occlusion.Union(gfx::Rect(0, 100, 300, 50));
3909
3910 EXPECT_EQ(expected_occlusion.ToString(),
3911 occlusion.occlusion_from_inside_target().ToString());
3912 EXPECT_EQ(gfx::Rect().ToString(),
3913 occlusion.occlusion_from_outside_target().ToString());
3914
3915 // Everything outside the surface/replica is occluded but the
3916 // surface/replica itself is not.
3917 this->VisitLayer(filtered_surface, &occlusion);
3918
3919 // The filtered layer/replica does not occlude.
3920 Region expected_occlusion_outside_surface;
3921 expected_occlusion_outside_surface.Union(gfx::Rect(-50, -50, 300, 50));
3922 expected_occlusion_outside_surface.Union(gfx::Rect(-50, 0, 50, 50));
3923 expected_occlusion_outside_surface.Union(gfx::Rect(50, 0, 100, 50));
3924 expected_occlusion_outside_surface.Union(gfx::Rect(200, 0, 50, 50));
3925 expected_occlusion_outside_surface.Union(gfx::Rect(-50, 50, 300, 50));
3926
3927 EXPECT_EQ(expected_occlusion_outside_surface.ToString(),
3928 occlusion.occlusion_from_outside_target().ToString());
3929 EXPECT_EQ(gfx::Rect().ToString(),
3930 occlusion.occlusion_from_inside_target().ToString());
3931
3932 // The surface has a background blur, so it needs pixels that are currently
3933 // considered occluded in order to be drawn. So the pixels it needs should
3934 // be removed some the occluded area so that when we get to the parent they
3935 // are drawn.
3936 this->VisitContributingSurface(filtered_surface, &occlusion);
3937
3938 this->VisitLayer(clipping_surface, &occlusion);
3939 this->EnterContributingSurface(clipping_surface, &occlusion, false);
3940
3941 Region expected_blurred_occlusion;
3942 expected_blurred_occlusion.Union(gfx::Rect(0, 0, 300, 50 - outset_top));
3943 expected_blurred_occlusion.Union(gfx::Rect(
3944 0, 50 - outset_top, 50 - outset_left, 20 + outset_top + outset_bottom));
3945 expected_blurred_occlusion.Union(
3946 gfx::Rect(100 + outset_right,
3947 50 - outset_top,
3948 100 - outset_right - outset_left,
3949 20 + outset_top + outset_bottom));
3950 expected_blurred_occlusion.Union(
3951 gfx::Rect(250 + outset_right,
3952 50 - outset_top,
3953 50 - outset_right,
3954 20 + outset_top + outset_bottom));
3955 expected_blurred_occlusion.Union(gfx::Rect(0, 100 + 5, 300, 50 - 5));
3956
3957 EXPECT_EQ(expected_blurred_occlusion.ToString(),
3958 occlusion.occlusion_from_outside_target().ToString());
3959 EXPECT_EQ(gfx::Rect().ToString(),
3960 occlusion.occlusion_from_inside_target().ToString());
3961
3962 gfx::Rect outset_rect;
3963 gfx::Rect clipped_outset_rect;
3964 gfx::Rect test_rect;
3965
3966 // Nothing in the (clipped) blur outsets for the filtered_surface is
3967 // occluded.
3968 outset_rect = gfx::Rect(50 - outset_left,
3969 50 - outset_top,
3970 50 + outset_left + outset_right,
3971 50 + outset_top + outset_bottom);
3972 clipped_outset_rect = outset_rect;
3973 clipped_outset_rect.Intersect(gfx::Rect(0 - outset_left,
3974 0 - outset_top,
3975 300 + outset_left + outset_right,
3976 70 + outset_top + outset_bottom));
3977 clipped_outset_rect.Intersect(gfx::Rect(0, 0, 300, 70));
3978 test_rect = outset_rect;
3979 EXPECT_RECT_EQ(
3980 clipped_outset_rect,
3981 occlusion.UnoccludedLayerContentRect(clipping_surface, test_rect));
3982
3983 // Stuff outside the (clipped) blur outsets is still occluded though.
3984 test_rect = outset_rect;
3985 test_rect.Inset(0, 0, -1, 0);
3986 EXPECT_RECT_EQ(
3987 clipped_outset_rect,
3988 occlusion.UnoccludedLayerContentRect(clipping_surface, test_rect));
3989 test_rect = outset_rect;
3990 test_rect.Inset(0, 0, 0, -1);
3991 EXPECT_RECT_EQ(
3992 clipped_outset_rect,
3993 occlusion.UnoccludedLayerContentRect(clipping_surface, test_rect));
3994 test_rect = outset_rect;
3995 test_rect.Inset(-1, 0, 0, 0);
3996 EXPECT_RECT_EQ(
3997 clipped_outset_rect,
3998 occlusion.UnoccludedLayerContentRect(clipping_surface, test_rect));
3999 test_rect = outset_rect;
4000 test_rect.Inset(0, -1, 0, 0);
4001 EXPECT_RECT_EQ(
4002 clipped_outset_rect,
4003 occlusion.UnoccludedLayerContentRect(clipping_surface, test_rect));
4004
4005 // Nothing in the (clipped) blur outsets for the filtered_surface's replica
4006 // is occluded.
4007 outset_rect = gfx::Rect(200 - outset_left,
4008 50 - outset_top,
4009 50 + outset_left + outset_right,
4010 50 + outset_top + outset_bottom);
4011 clipped_outset_rect = outset_rect;
4012 clipped_outset_rect.Intersect(gfx::Rect(0 - outset_left,
4013 0 - outset_top,
4014 300 + outset_left + outset_right,
4015 70 + outset_top + outset_bottom));
4016 clipped_outset_rect.Intersect(gfx::Rect(0, 0, 300, 70));
4017 test_rect = outset_rect;
4018 EXPECT_RECT_EQ(
4019 clipped_outset_rect,
4020 occlusion.UnoccludedLayerContentRect(clipping_surface, test_rect));
4021
4022 // Stuff outside the (clipped) blur outsets is still occluded though.
4023 test_rect = outset_rect;
4024 test_rect.Inset(0, 0, -1, 0);
4025 EXPECT_RECT_EQ(
4026 clipped_outset_rect,
4027 occlusion.UnoccludedLayerContentRect(clipping_surface, test_rect));
4028 test_rect = outset_rect;
4029 test_rect.Inset(0, 0, 0, -1);
4030 EXPECT_RECT_EQ(
4031 clipped_outset_rect,
4032 occlusion.UnoccludedLayerContentRect(clipping_surface, test_rect));
4033 test_rect = outset_rect;
4034 test_rect.Inset(-1, 0, 0, 0);
4035 EXPECT_RECT_EQ(
4036 clipped_outset_rect,
4037 occlusion.UnoccludedLayerContentRect(clipping_surface, test_rect));
4038 test_rect = outset_rect;
4039 test_rect.Inset(0, -1, 0, 0);
4040 EXPECT_RECT_EQ(
4041 clipped_outset_rect,
4042 occlusion.UnoccludedLayerContentRect(clipping_surface, test_rect));
4043 }
4044 };
4045
4046 ALL_OCCLUSIONTRACKER_TEST(
4047 OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilterWithClip);
4048
4049 template <class Types>
4050 class OcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter
4051 : public OcclusionTrackerTest<Types> {
4052 protected:
4053 explicit OcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter(
4054 bool opaque_layers)
4055 : OcclusionTrackerTest<Types>(opaque_layers) {}
4056 void RunMyTest() {
4057 gfx::Transform scale_by_half;
4058 scale_by_half.Scale(0.5, 0.5);
4059
4060 // Make a surface and its replica, each 50x50, with a smaller 30x30 layer
4061 // centered below each. The surface is scaled to test that the pixel moving
4062 // is done in the target space, where the background filter is applied, but
4063 // the surface appears at 50, 50 and the replica at 200, 50.
4064 typename Types::ContentLayerType* parent = this->CreateRoot(
4065 this->identity_matrix, gfx::PointF(), gfx::Size(300, 150));
4066 typename Types::LayerType* behind_surface_layer =
4067 this->CreateDrawingLayer(parent,
4068 this->identity_matrix,
4069 gfx::PointF(60.f, 60.f),
4070 gfx::Size(30, 30),
4071 true);
4072 typename Types::LayerType* behind_replica_layer =
4073 this->CreateDrawingLayer(parent,
4074 this->identity_matrix,
4075 gfx::PointF(210.f, 60.f),
4076 gfx::Size(30, 30),
4077 true);
4078 typename Types::LayerType* filtered_surface =
4079 this->CreateDrawingLayer(parent,
4080 scale_by_half,
4081 gfx::PointF(50.f, 50.f),
4082 gfx::Size(100, 100),
4083 false);
4084 this->CreateReplicaLayer(filtered_surface,
4085 this->identity_matrix,
4086 gfx::PointF(300.f, 0.f),
4087 gfx::Size());
4088
4089 // Filters make the layer own a surface.
4090 FilterOperations filters;
4091 filters.Append(FilterOperation::CreateBlurFilter(3.f));
4092 filtered_surface->SetBackgroundFilters(filters);
4093
4094 this->CalcDrawEtc(parent);
4095
4096 TestOcclusionTrackerWithClip<typename Types::LayerType,
4097 typename Types::RenderSurfaceType> occlusion(
4098 gfx::Rect(0, 0, 1000, 1000));
4099
4100 // The surface has a background blur, so it blurs non-opaque pixels below
4101 // it.
4102 this->VisitLayer(filtered_surface, &occlusion);
4103 this->VisitContributingSurface(filtered_surface, &occlusion);
4104
4105 this->VisitLayer(behind_replica_layer, &occlusion);
4106 this->VisitLayer(behind_surface_layer, &occlusion);
4107
4108 // The layers behind the surface are not blurred, and their occlusion does
4109 // not change, until we leave the surface. So it should not be modified by
4110 // the filter here.
4111 gfx::Rect occlusion_behind_surface = gfx::Rect(60, 60, 30, 30);
4112 gfx::Rect occlusion_behind_replica = gfx::Rect(210, 60, 30, 30);
4113
4114 Region expected_opaque_bounds =
4115 UnionRegions(occlusion_behind_surface, occlusion_behind_replica);
4116 EXPECT_EQ(expected_opaque_bounds.ToString(),
4117 occlusion.occlusion_from_inside_target().ToString());
4118
4119 EXPECT_EQ(gfx::Rect().ToString(),
4120 occlusion.occlusion_from_outside_target().ToString());
4121 }
4122 };
4123
4124 ALL_OCCLUSIONTRACKER_TEST(
4125 OcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter);
4126
4127 template <class Types>
4128 class OcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded
4129 : public OcclusionTrackerTest<Types> {
4130 protected:
4131 explicit OcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded(
4132 bool opaque_layers)
4133 : OcclusionTrackerTest<Types>(opaque_layers) {}
4134 void RunMyTest() {
4135 gfx::Transform scale_by_half;
4136 scale_by_half.Scale(0.5, 0.5);
4137
4138 // Make a surface and its replica, each 50x50, that are completely occluded
4139 // by opaque layers which are above them in the z-order. The surface is
4140 // scaled to test that the pixel moving is done in the target space, where
4141 // the background filter is applied, but the surface appears at 50, 50 and
4142 // the replica at 200, 50.
4143 typename Types::ContentLayerType* parent = this->CreateRoot(
4144 this->identity_matrix, gfx::PointF(), gfx::Size(300, 150));
4145 typename Types::LayerType* filtered_surface =
4146 this->CreateDrawingLayer(parent,
4147 scale_by_half,
4148 gfx::PointF(50.f, 50.f),
4149 gfx::Size(100, 100),
4150 false);
4151 this->CreateReplicaLayer(filtered_surface,
4152 this->identity_matrix,
4153 gfx::PointF(300.f, 0.f),
4154 gfx::Size());
4155 typename Types::LayerType* above_surface_layer =
4156 this->CreateDrawingLayer(parent,
4157 this->identity_matrix,
4158 gfx::PointF(50.f, 50.f),
4159 gfx::Size(50, 50),
4160 true);
4161 typename Types::LayerType* above_replica_layer =
4162 this->CreateDrawingLayer(parent,
4163 this->identity_matrix,
4164 gfx::PointF(200.f, 50.f),
4165 gfx::Size(50, 50),
4166 true);
4167
4168 // Filters make the layer own a surface.
4169 FilterOperations filters;
4170 filters.Append(FilterOperation::CreateBlurFilter(3.f));
4171 filtered_surface->SetBackgroundFilters(filters);
4172
4173 this->CalcDrawEtc(parent);
4174
4175 TestOcclusionTrackerWithClip<typename Types::LayerType,
4176 typename Types::RenderSurfaceType> occlusion(
4177 gfx::Rect(0, 0, 1000, 1000));
4178
4179 this->VisitLayer(above_replica_layer, &occlusion);
4180 this->VisitLayer(above_surface_layer, &occlusion);
4181
4182 this->VisitLayer(filtered_surface, &occlusion);
4183 {
4184 // The layers above the filtered surface occlude from outside.
4185 gfx::Rect occlusion_above_surface = gfx::Rect(0, 0, 50, 50);
4186 gfx::Rect occlusion_above_replica = gfx::Rect(150, 0, 50, 50);
4187 Region expected_opaque_region =
4188 UnionRegions(occlusion_above_surface, occlusion_above_replica);
4189
4190 EXPECT_EQ(gfx::Rect().ToString(),
4191 occlusion.occlusion_from_inside_target().ToString());
4192 EXPECT_EQ(expected_opaque_region.ToString(),
4193 occlusion.occlusion_from_outside_target().ToString());
4194 }
4195
4196 // The surface has a background blur, so it blurs non-opaque pixels below
4197 // it.
4198 this->VisitContributingSurface(filtered_surface, &occlusion);
4199 {
4200 // The filter is completely occluded, so it should not blur anything and
4201 // reduce any occlusion.
4202 gfx::Rect occlusion_above_surface = gfx::Rect(50, 50, 50, 50);
4203 gfx::Rect occlusion_above_replica = gfx::Rect(200, 50, 50, 50);
4204 Region expected_opaque_region =
4205 UnionRegions(occlusion_above_surface, occlusion_above_replica);
4206
4207 EXPECT_EQ(expected_opaque_region.ToString(),
4208 occlusion.occlusion_from_inside_target().ToString());
4209 EXPECT_EQ(gfx::Rect().ToString(),
4210 occlusion.occlusion_from_outside_target().ToString());
4211 }
4212 }
4213 };
4214
4215 ALL_OCCLUSIONTRACKER_TEST(
4216 OcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded);
4217
4218 template <class Types>
4219 class OcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded
4220 : public OcclusionTrackerTest<Types> {
4221 protected:
4222 explicit
4223 OcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded(
4224 bool opaque_layers)
4225 : OcclusionTrackerTest<Types>(opaque_layers) {}
4226 void RunMyTest() {
4227 gfx::Transform scale_by_half;
4228 scale_by_half.Scale(0.5, 0.5);
4229
4230 // Make a surface and its replica, each 50x50, that are partially occluded
4231 // by opaque layers which are above them in the z-order. The surface is
4232 // scaled to test that the pixel moving is done in the target space, where
4233 // the background filter is applied, but the surface appears at 50, 50 and
4234 // the replica at 200, 50.
4235 typename Types::ContentLayerType* parent = this->CreateRoot(
4236 this->identity_matrix, gfx::PointF(), gfx::Size(300, 150));
4237 typename Types::LayerType* filtered_surface =
4238 this->CreateDrawingLayer(parent,
4239 scale_by_half,
4240 gfx::PointF(50.f, 50.f),
4241 gfx::Size(100, 100),
4242 false);
4243 this->CreateReplicaLayer(filtered_surface,
4244 this->identity_matrix,
4245 gfx::PointF(300.f, 0.f),
4246 gfx::Size());
4247 typename Types::LayerType* above_surface_layer =
4248 this->CreateDrawingLayer(parent,
4249 this->identity_matrix,
4250 gfx::PointF(70.f, 50.f),
4251 gfx::Size(30, 50),
4252 true);
4253 typename Types::LayerType* above_replica_layer =
4254 this->CreateDrawingLayer(parent,
4255 this->identity_matrix,
4256 gfx::PointF(200.f, 50.f),
4257 gfx::Size(30, 50),
4258 true);
4259 typename Types::LayerType* beside_surface_layer =
4260 this->CreateDrawingLayer(parent,
4261 this->identity_matrix,
4262 gfx::PointF(90.f, 40.f),
4263 gfx::Size(10, 10),
4264 true);
4265 typename Types::LayerType* beside_replica_layer =
4266 this->CreateDrawingLayer(parent,
4267 this->identity_matrix,
4268 gfx::PointF(200.f, 40.f),
4269 gfx::Size(10, 10),
4270 true);
4271
4272 // Filters make the layer own a surface.
4273 FilterOperations filters;
4274 filters.Append(FilterOperation::CreateBlurFilter(3.f));
4275 filtered_surface->SetBackgroundFilters(filters);
4276
4277 // Save the distance of influence for the blur effect.
4278 int outset_top, outset_right, outset_bottom, outset_left;
4279 filters.GetOutsets(
4280 &outset_top, &outset_right, &outset_bottom, &outset_left);
4281
4282 this->CalcDrawEtc(parent);
4283
4284 TestOcclusionTrackerWithClip<typename Types::LayerType,
4285 typename Types::RenderSurfaceType> occlusion(
4286 gfx::Rect(0, 0, 1000, 1000));
4287
4288 this->VisitLayer(beside_replica_layer, &occlusion);
4289 this->VisitLayer(beside_surface_layer, &occlusion);
4290 this->VisitLayer(above_replica_layer, &occlusion);
4291 this->VisitLayer(above_surface_layer, &occlusion);
4292
4293 // The surface has a background blur, so it blurs non-opaque pixels below
4294 // it.
4295 this->VisitLayer(filtered_surface, &occlusion);
4296 this->VisitContributingSurface(filtered_surface, &occlusion);
4297
4298 // The filter in the surface and replica are partially unoccluded. Only the
4299 // unoccluded parts should reduce occlusion. This means it will push back
4300 // the occlusion that touches the unoccluded part (occlusion_above___), but
4301 // it will not touch occlusion_beside____ since that is not beside the
4302 // unoccluded part of the surface, even though it is beside the occluded
4303 // part of the surface.
4304 gfx::Rect occlusion_above_surface =
4305 gfx::Rect(70 + outset_right, 50, 30 - outset_right, 50);
4306 gfx::Rect occlusion_above_replica =
4307 gfx::Rect(200, 50, 30 - outset_left, 50);
4308 gfx::Rect occlusion_beside_surface = gfx::Rect(90, 40, 10, 10);
4309 gfx::Rect occlusion_beside_replica = gfx::Rect(200, 40, 10, 10);
4310
4311 Region expected_occlusion;
4312 expected_occlusion.Union(occlusion_above_surface);
4313 expected_occlusion.Union(occlusion_above_replica);
4314 expected_occlusion.Union(occlusion_beside_surface);
4315 expected_occlusion.Union(occlusion_beside_replica);
4316
4317 ASSERT_EQ(expected_occlusion.ToString(),
4318 occlusion.occlusion_from_inside_target().ToString());
4319 EXPECT_EQ(gfx::Rect().ToString(),
4320 occlusion.occlusion_from_outside_target().ToString());
4321
4322 Region::Iterator expected_rects(expected_occlusion);
4323 Region::Iterator target_surface_rects(
4324 occlusion.occlusion_from_inside_target());
4325 for (; expected_rects.has_rect();
4326 expected_rects.next(), target_surface_rects.next()) {
4327 ASSERT_TRUE(target_surface_rects.has_rect());
4328 EXPECT_EQ(expected_rects.rect(), target_surface_rects.rect());
4329 }
4330 }
4331 };
4332
4333 ALL_OCCLUSIONTRACKER_TEST(
4334 OcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded);
4335
4336 template <class Types>
4337 class OcclusionTrackerTestMinimumTrackingSize
4338 : public OcclusionTrackerTest<Types> {
4339 protected:
4340 explicit OcclusionTrackerTestMinimumTrackingSize(bool opaque_layers)
4341 : OcclusionTrackerTest<Types>(opaque_layers) {}
4342 void RunMyTest() {
4343 gfx::Size tracking_size(100, 100);
4344 gfx::Size below_tracking_size(99, 99);
4345
4346 typename Types::ContentLayerType* parent = this->CreateRoot(
4347 this->identity_matrix, gfx::PointF(), gfx::Size(400, 400));
4348 typename Types::LayerType* large = this->CreateDrawingLayer(
4349 parent, this->identity_matrix, gfx::PointF(), tracking_size, true);
4350 typename Types::LayerType* small =
4351 this->CreateDrawingLayer(parent,
4352 this->identity_matrix,
4353 gfx::PointF(),
4354 below_tracking_size,
4355 true);
4356 this->CalcDrawEtc(parent);
4357
4358 TestOcclusionTrackerWithClip<typename Types::LayerType,
4359 typename Types::RenderSurfaceType> occlusion(
4360 gfx::Rect(0, 0, 1000, 1000));
4361 occlusion.set_minimum_tracking_size(tracking_size);
4362
4363 // The small layer is not tracked because it is too small.
4364 this->VisitLayer(small, &occlusion);
4365
4366 EXPECT_EQ(gfx::Rect().ToString(),
4367 occlusion.occlusion_from_outside_target().ToString());
4368 EXPECT_EQ(gfx::Rect().ToString(),
4369 occlusion.occlusion_from_inside_target().ToString());
4370
4371 // The large layer is tracked as it is large enough.
4372 this->VisitLayer(large, &occlusion);
4373
4374 EXPECT_EQ(gfx::Rect().ToString(),
4375 occlusion.occlusion_from_outside_target().ToString());
4376 EXPECT_EQ(gfx::Rect(tracking_size).ToString(),
4377 occlusion.occlusion_from_inside_target().ToString());
4378 }
4379 };
4380
4381 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestMinimumTrackingSize);
4382
4383 template <class Types>
4384 class OcclusionTrackerTestViewportClipIsExternalOcclusion
4385 : public OcclusionTrackerTest<Types> {
4386 protected:
4387 explicit OcclusionTrackerTestViewportClipIsExternalOcclusion(
4388 bool opaque_layers)
4389 : OcclusionTrackerTest<Types>(opaque_layers) {}
4390 void RunMyTest() {
4391 typename Types::ContentLayerType* parent = this->CreateRoot(
4392 this->identity_matrix, gfx::PointF(), gfx::Size(400, 400));
4393 typename Types::LayerType* small =
4394 this->CreateDrawingSurface(parent,
4395 this->identity_matrix,
4396 gfx::PointF(),
4397 gfx::Size(200, 200),
4398 false);
4399 typename Types::LayerType* large =
4400 this->CreateDrawingLayer(small,
4401 this->identity_matrix,
4402 gfx::PointF(),
4403 gfx::Size(400, 400),
4404 false);
4405 small->SetMasksToBounds(true);
4406 this->CalcDrawEtc(parent);
4407
4408 TestOcclusionTrackerWithClip<typename Types::LayerType,
4409 typename Types::RenderSurfaceType> occlusion(
4410 gfx::Rect(0, 0, 100, 100));
4411
4412 this->EnterLayer(large, &occlusion, false);
4413
4414 bool has_occlusion_from_outside_target_surface = false;
4415 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
4416 occlusion.UnoccludedLayerContentRect(
4417 large,
4418 gfx::Rect(0, 0, 400, 400),
4419 &has_occlusion_from_outside_target_surface));
4420 EXPECT_TRUE(has_occlusion_from_outside_target_surface);
4421
4422 has_occlusion_from_outside_target_surface = false;
4423 EXPECT_FALSE(
4424 occlusion.OccludedLayer(large,
4425 gfx::Rect(0, 0, 400, 400),
4426 &has_occlusion_from_outside_target_surface));
4427 EXPECT_TRUE(has_occlusion_from_outside_target_surface);
4428
4429 this->LeaveLayer(large, &occlusion);
4430 this->VisitLayer(small, &occlusion);
4431
4432 has_occlusion_from_outside_target_surface = false;
4433 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
4434 occlusion.UnoccludedLayerContentRect(
4435 small,
4436 gfx::Rect(0, 0, 200, 200),
4437 &has_occlusion_from_outside_target_surface));
4438 EXPECT_TRUE(has_occlusion_from_outside_target_surface);
4439
4440 has_occlusion_from_outside_target_surface = false;
4441 EXPECT_FALSE(
4442 occlusion.OccludedLayer(small,
4443 gfx::Rect(0, 0, 200, 200),
4444 &has_occlusion_from_outside_target_surface));
4445 EXPECT_TRUE(has_occlusion_from_outside_target_surface);
4446
4447 this->EnterContributingSurface(small, &occlusion, false);
4448
4449 has_occlusion_from_outside_target_surface = false;
4450 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
4451 occlusion.UnoccludedContributingSurfaceContentRect(
4452 small,
4453 false,
4454 gfx::Rect(0, 0, 200, 200),
4455 &has_occlusion_from_outside_target_surface));
4456 EXPECT_TRUE(has_occlusion_from_outside_target_surface);
4457 }
4458 };
4459
4460 ALL_OCCLUSIONTRACKER_TEST(
4461 OcclusionTrackerTestViewportClipIsExternalOcclusion)
4462
4463 template <class Types>
4464 class OcclusionTrackerTestLayerClipIsExternalOcclusion
4465 : public OcclusionTrackerTest<Types> {
4466 protected:
4467 explicit OcclusionTrackerTestLayerClipIsExternalOcclusion(bool opaque_layers)
4468 : OcclusionTrackerTest<Types>(opaque_layers) {}
4469 void RunMyTest() {
4470 typename Types::ContentLayerType* parent = this->CreateRoot(
4471 this->identity_matrix, gfx::PointF(), gfx::Size(400, 400));
4472 typename Types::LayerType* smallest = this->CreateDrawingLayer(
4473 parent, this->identity_matrix, gfx::PointF(), gfx::Size(50, 50), false);
4474 typename Types::LayerType* smaller =
4475 this->CreateDrawingSurface(smallest,
4476 this->identity_matrix,
4477 gfx::PointF(),
4478 gfx::Size(100, 100),
4479 false);
4480 typename Types::LayerType* small =
4481 this->CreateDrawingSurface(smaller,
4482 this->identity_matrix,
4483 gfx::PointF(),
4484 gfx::Size(200, 200),
4485 false);
4486 typename Types::LayerType* large =
4487 this->CreateDrawingLayer(small,
4488 this->identity_matrix,
4489 gfx::PointF(),
4490 gfx::Size(400, 400),
4491 false);
4492 smallest->SetMasksToBounds(true);
4493 smaller->SetMasksToBounds(true);
4494 small->SetMasksToBounds(true);
4495 this->CalcDrawEtc(parent);
4496
4497 TestOcclusionTrackerWithClip<typename Types::LayerType,
4498 typename Types::RenderSurfaceType> occlusion(
4499 gfx::Rect(0, 0, 1000, 1000));
4500
4501 this->EnterLayer(large, &occlusion, false);
4502
4503 // Clipping from the smaller layer is from outside the target surface.
4504 bool has_occlusion_from_outside_target_surface = false;
4505 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
4506 occlusion.UnoccludedLayerContentRect(
4507 large,
4508 gfx::Rect(0, 0, 400, 400),
4509 &has_occlusion_from_outside_target_surface));
4510 EXPECT_TRUE(has_occlusion_from_outside_target_surface);
4511
4512 has_occlusion_from_outside_target_surface = false;
4513 EXPECT_FALSE(
4514 occlusion.OccludedLayer(large,
4515 gfx::Rect(0, 0, 400, 400),
4516 &has_occlusion_from_outside_target_surface));
4517 EXPECT_TRUE(has_occlusion_from_outside_target_surface);
4518
4519 this->LeaveLayer(large, &occlusion);
4520 this->VisitLayer(small, &occlusion);
4521
4522 // Clipping from the smaller layer is from outside the target surface.
4523 has_occlusion_from_outside_target_surface = false;
4524 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
4525 occlusion.UnoccludedLayerContentRect(
4526 small,
4527 gfx::Rect(0, 0, 200, 200),
4528 &has_occlusion_from_outside_target_surface));
4529 EXPECT_TRUE(has_occlusion_from_outside_target_surface);
4530
4531 has_occlusion_from_outside_target_surface = false;
4532 EXPECT_FALSE(
4533 occlusion.OccludedLayer(small,
4534 gfx::Rect(0, 0, 200, 200),
4535 &has_occlusion_from_outside_target_surface));
4536 EXPECT_TRUE(has_occlusion_from_outside_target_surface);
4537
4538 this->EnterContributingSurface(small, &occlusion, false);
4539
4540 // The |small| surface is clipped from outside its target by |smallest|.
4541 has_occlusion_from_outside_target_surface = false;
4542 EXPECT_RECT_EQ(gfx::Rect(0, 0, 50, 50),
4543 occlusion.UnoccludedContributingSurfaceContentRect(
4544 small,
4545 false,
4546 gfx::Rect(0, 0, 200, 200),
4547 &has_occlusion_from_outside_target_surface));
4548 EXPECT_TRUE(has_occlusion_from_outside_target_surface);
4549
4550 this->LeaveContributingSurface(small, &occlusion);
4551 this->VisitLayer(smaller, &occlusion);
4552 this->EnterContributingSurface(smaller, &occlusion, false);
4553
4554 // The |smaller| surface is clipped from inside its target by |smallest|.
4555 has_occlusion_from_outside_target_surface = false;
4556 EXPECT_RECT_EQ(gfx::Rect(0, 0, 50, 50),
4557 occlusion.UnoccludedContributingSurfaceContentRect(
4558 smaller,
4559 false,
4560 gfx::Rect(0, 0, 100, 100),
4561 &has_occlusion_from_outside_target_surface));
4562 EXPECT_FALSE(has_occlusion_from_outside_target_surface);
4563 }
4564 };
4565
4566 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestLayerClipIsExternalOcclusion)
4567
4568 template <class Types>
4569 class OcclusionTrackerTestPreventOcclusionOnLayer
4570 : public OcclusionTrackerTest<Types> {
4571 protected:
4572 explicit OcclusionTrackerTestPreventOcclusionOnLayer(bool opaque_layers)
4573 : OcclusionTrackerTest<Types>(opaque_layers) {}
4574 void RunMyTest() {
4575 typename Types::ContentLayerType* parent = this->CreateRoot(
4576 this->identity_matrix, gfx::PointF(), gfx::Size(400, 400));
4577 typename Types::LayerType* unprevented = this->CreateDrawingLayer(
4578 parent, this->identity_matrix, gfx::PointF(), gfx::Size(50, 50), false);
4579 typename Types::LayerType* prevented = this->CreateDrawingLayer(
4580 parent, this->identity_matrix, gfx::PointF(), gfx::Size(50, 50), false);
4581 typename Types::LayerType* occluding = this->CreateDrawingLayer(
4582 parent, this->identity_matrix, gfx::PointF(), gfx::Size(50, 50), true);
4583 this->CalcDrawEtc(parent);
4584
4585 TestOcclusionTrackerWithClip<typename Types::LayerType,
4586 typename Types::RenderSurfaceType> occlusion(
4587 gfx::Rect(0, 0, 1000, 1000));
4588 bool external_occlusion = false;
4589
4590 this->VisitLayer(occluding, &occlusion);
4591 this->EnterLayer(prevented, &occlusion, true);
4592
4593 // This layer is not occluded because it is prevented.
4594 EXPECT_FALSE(occlusion.OccludedLayer(prevented,
4595 gfx::Rect(50, 50),
4596 &external_occlusion));
4597 EXPECT_FALSE(external_occlusion);
4598
4599 EXPECT_EQ(gfx::Rect(50, 50).ToString(),
4600 occlusion.UnoccludedLayerContentRect(
4601 prevented,
4602 gfx::Rect(50, 50),
4603 &external_occlusion).ToString());
4604 EXPECT_FALSE(external_occlusion);
4605
4606 this->LeaveLayer(prevented, &occlusion);
4607 this->EnterLayer(unprevented, &occlusion, false);
4608
4609 // This layer is fully occluded.
4610 EXPECT_TRUE(occlusion.OccludedLayer(unprevented,
4611 gfx::Rect(50, 50),
4612 &external_occlusion));
4613 EXPECT_FALSE(external_occlusion);
4614
4615 EXPECT_EQ(gfx::Rect().ToString(),
4616 occlusion.UnoccludedLayerContentRect(
4617 unprevented,
4618 gfx::Rect(50, 50),
4619 &external_occlusion).ToString());
4620 EXPECT_FALSE(external_occlusion);
4621
4622 this->LeaveLayer(unprevented, &occlusion);
4623 }
4624 };
4625
4626 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestPreventOcclusionOnLayer)
4627
4628 template <class Types>
4629 class OcclusionTrackerTestPreventOcclusionOnContributingSurface
4630 : public OcclusionTrackerTest<Types> {
4631 protected:
4632 explicit OcclusionTrackerTestPreventOcclusionOnContributingSurface(
4633 bool opaque_layers)
4634 : OcclusionTrackerTest<Types>(opaque_layers) {}
4635 void RunMyTest() {
4636 typename Types::ContentLayerType* parent = this->CreateRoot(
4637 this->identity_matrix, gfx::PointF(), gfx::Size(400, 400));
4638 typename Types::LayerType* unprevented = this->CreateDrawingSurface(
4639 parent, this->identity_matrix, gfx::PointF(), gfx::Size(50, 50), false);
4640 typename Types::LayerType* prevented = this->CreateDrawingSurface(
4641 parent, this->identity_matrix, gfx::PointF(), gfx::Size(50, 50), false);
4642 typename Types::LayerType* occluding = this->CreateDrawingLayer(
4643 parent, this->identity_matrix, gfx::PointF(), gfx::Size(50, 50), true);
4644 this->CalcDrawEtc(parent);
4645
4646 TestOcclusionTrackerWithClip<typename Types::LayerType,
4647 typename Types::RenderSurfaceType> occlusion(
4648 gfx::Rect(0, 0, 1000, 1000));
4649 bool external_occlusion = false;
4650
4651 this->VisitLayer(occluding, &occlusion);
4652 this->EnterLayer(prevented, &occlusion, true);
4653
4654 // This layer is not occluded because it is prevented.
4655 EXPECT_EQ(gfx::Rect(50, 50).ToString(),
4656 occlusion.UnoccludedLayerContentRect(
4657 prevented,
4658 gfx::Rect(50, 50),
4659 &external_occlusion).ToString());
4660 EXPECT_FALSE(external_occlusion);
4661
4662 this->LeaveLayer(prevented, &occlusion);
4663 this->EnterContributingSurface(prevented, &occlusion, true);
4664
4665 // This contributing surface is not occluded because it is prevented.
4666 EXPECT_EQ(gfx::Rect(50, 50).ToString(),
4667 occlusion.UnoccludedContributingSurfaceContentRect(
4668 prevented,
4669 false, // is_replica
4670 gfx::Rect(50, 50),
4671 &external_occlusion).ToString());
4672 EXPECT_FALSE(external_occlusion);
4673
4674 this->LeaveContributingSurface(prevented, &occlusion);
4675 this->EnterLayer(unprevented, &occlusion, false);
4676
4677 // This layer is fully occluded from outside its surface.
4678 EXPECT_EQ(gfx::Rect().ToString(),
4679 occlusion.UnoccludedLayerContentRect(
4680 unprevented,
4681 gfx::Rect(50, 50),
4682 &external_occlusion).ToString());
4683 EXPECT_TRUE(external_occlusion);
4684
4685 this->LeaveLayer(unprevented, &occlusion);
4686 this->EnterContributingSurface(unprevented, &occlusion, false);
4687
4688 // This contributing surface is fully occluded.
4689 EXPECT_EQ(gfx::Rect().ToString(),
4690 occlusion.UnoccludedContributingSurfaceContentRect(
4691 unprevented,
4692 false, // is_replica
4693 gfx::Rect(50, 50),
4694 &external_occlusion).ToString());
4695 EXPECT_FALSE(external_occlusion);
4696
4697 this->LeaveContributingSurface(unprevented, &occlusion);
4698 }
4699 };
4700
4701 ALL_OCCLUSIONTRACKER_TEST(
4702 OcclusionTrackerTestPreventOcclusionOnContributingSurface)
4703
4704 template <class Types>
4705 class OcclusionTrackerTestPreventOcclusionByClipping
4706 : public OcclusionTrackerTest<Types> {
4707 protected:
4708 explicit OcclusionTrackerTestPreventOcclusionByClipping(bool opaque_layers)
4709 : OcclusionTrackerTest<Types>(opaque_layers) {}
4710 void RunMyTest() {
4711 typename Types::ContentLayerType* parent = this->CreateRoot(
4712 this->identity_matrix, gfx::PointF(), gfx::Size(400, 400));
4713 typename Types::LayerType* unprevented = this->CreateDrawingLayer(
4714 parent, this->identity_matrix, gfx::PointF(), gfx::Size(50, 50), false);
4715 typename Types::LayerType* prevented = this->CreateDrawingLayer(
4716 parent, this->identity_matrix, gfx::PointF(), gfx::Size(50, 50), false);
4717 this->CalcDrawEtc(parent);
4718
4719 TestOcclusionTrackerWithClip<typename Types::LayerType,
4720 typename Types::RenderSurfaceType> occlusion(
4721 gfx::Rect(0, 0, 10, 10));
4722 bool external_occlusion = false;
4723
4724 this->EnterLayer(prevented, &occlusion, true);
4725
4726 // This layer is not occluded because it is prevented.
4727 EXPECT_FALSE(occlusion.OccludedLayer(prevented,
4728 gfx::Rect(50, 50),
4729 &external_occlusion));
4730 EXPECT_FALSE(external_occlusion);
4731
4732 EXPECT_EQ(gfx::Rect(50, 50).ToString(),
4733 occlusion.UnoccludedLayerContentRect(
4734 prevented,
4735 gfx::Rect(50, 50),
4736 &external_occlusion).ToString());
4737 EXPECT_FALSE(external_occlusion);
4738
4739 this->LeaveLayer(prevented, &occlusion);
4740 this->EnterLayer(unprevented, &occlusion, false);
4741
4742 // This layer is clipped by the screen space clip rect.
4743 EXPECT_EQ(gfx::Rect(10, 10).ToString(),
4744 occlusion.UnoccludedLayerContentRect(
4745 unprevented,
4746 gfx::Rect(50, 50),
4747 &external_occlusion).ToString());
4748 EXPECT_TRUE(external_occlusion);
4749
4750 this->LeaveLayer(unprevented, &occlusion);
4751 }
4752 };
4753
4754 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestPreventOcclusionByClipping)
4755
4756 template <class Types>
4757 class OcclusionTrackerTestScaledLayerIsClipped
4758 : public OcclusionTrackerTest<Types> {
4759 protected:
4760 explicit OcclusionTrackerTestScaledLayerIsClipped(bool opaque_layers)
4761 : OcclusionTrackerTest<Types>(opaque_layers) {}
4762 void RunMyTest() {
4763 gfx::Transform scale_transform;
4764 scale_transform.Scale(512.0, 512.0);
4765
4766 typename Types::ContentLayerType* parent = this->CreateRoot(
4767 this->identity_matrix, gfx::PointF(), gfx::Size(400, 400));
4768 typename Types::LayerType* clip = this->CreateLayer(parent,
4769 this->identity_matrix,
4770 gfx::PointF(10.f, 10.f),
4771 gfx::Size(50, 50));
4772 clip->SetMasksToBounds(true);
4773 typename Types::LayerType* scale = this->CreateLayer(
4774 clip, scale_transform, gfx::PointF(), gfx::Size(1, 1));
4775 typename Types::LayerType* scaled = this->CreateDrawingLayer(
4776 scale, this->identity_matrix, gfx::PointF(), gfx::Size(500, 500), true);
4777 this->CalcDrawEtc(parent);
4778
4779 TestOcclusionTrackerWithClip<typename Types::LayerType,
4780 typename Types::RenderSurfaceType> occlusion(
4781 gfx::Rect(0, 0, 1000, 1000));
4782
4783 this->VisitLayer(scaled, &occlusion);
4784
4785 EXPECT_EQ(gfx::Rect().ToString(),
4786 occlusion.occlusion_from_outside_target().ToString());
4787 EXPECT_EQ(gfx::Rect(10, 10, 50, 50).ToString(),
4788 occlusion.occlusion_from_inside_target().ToString());
4789 }
4790 };
4791
4792 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestScaledLayerIsClipped)
4793
4794 template <class Types>
4795 class OcclusionTrackerTestScaledLayerInSurfaceIsClipped
4796 : public OcclusionTrackerTest<Types> {
4797 protected:
4798 explicit OcclusionTrackerTestScaledLayerInSurfaceIsClipped(bool opaque_layers)
4799 : OcclusionTrackerTest<Types>(opaque_layers) {}
4800 void RunMyTest() {
4801 gfx::Transform scale_transform;
4802 scale_transform.Scale(512.0, 512.0);
4803
4804 typename Types::ContentLayerType* parent = this->CreateRoot(
4805 this->identity_matrix, gfx::PointF(), gfx::Size(400, 400));
4806 typename Types::LayerType* clip = this->CreateLayer(parent,
4807 this->identity_matrix,
4808 gfx::PointF(10.f, 10.f),
4809 gfx::Size(50, 50));
4810 clip->SetMasksToBounds(true);
4811 typename Types::LayerType* surface = this->CreateDrawingSurface(
4812 clip, this->identity_matrix, gfx::PointF(), gfx::Size(400, 30), false);
4813 typename Types::LayerType* scale = this->CreateLayer(
4814 surface, scale_transform, gfx::PointF(), gfx::Size(1, 1));
4815 typename Types::LayerType* scaled = this->CreateDrawingLayer(
4816 scale, this->identity_matrix, gfx::PointF(), gfx::Size(500, 500), true);
4817 this->CalcDrawEtc(parent);
4818
4819 TestOcclusionTrackerWithClip<typename Types::LayerType,
4820 typename Types::RenderSurfaceType> occlusion(
4821 gfx::Rect(0, 0, 1000, 1000));
4822
4823 this->VisitLayer(scaled, &occlusion);
4824 this->VisitLayer(surface, &occlusion);
4825 this->VisitContributingSurface(surface, &occlusion);
4826
4827 EXPECT_EQ(gfx::Rect().ToString(),
4828 occlusion.occlusion_from_outside_target().ToString());
4829 EXPECT_EQ(gfx::Rect(10, 10, 50, 50).ToString(),
4830 occlusion.occlusion_from_inside_target().ToString());
4831 }
4832 };
4833
4834 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestScaledLayerInSurfaceIsClipped)
4835
4836 template <class Types>
4837 class OcclusionTrackerTestCopyRequestDoesOcclude
4838 : public OcclusionTrackerTest<Types> {
4839 protected:
4840 explicit OcclusionTrackerTestCopyRequestDoesOcclude(bool opaque_layers)
4841 : OcclusionTrackerTest<Types>(opaque_layers) {}
4842 void RunMyTest() {
4843 typename Types::ContentLayerType* root = this->CreateRoot(
4844 this->identity_matrix, gfx::Point(), gfx::Size(400, 400));
4845 typename Types::ContentLayerType* parent = this->CreateDrawingLayer(
4846 root, this->identity_matrix, gfx::Point(), gfx::Size(400, 400), true);
4847 typename Types::LayerType* copy = this->CreateLayer(parent,
4848 this->identity_matrix,
4849 gfx::Point(100, 0),
4850 gfx::Size(200, 400));
4851 this->AddCopyRequest(copy);
4852 typename Types::LayerType* copy_child = this->CreateDrawingLayer(
4853 copy,
4854 this->identity_matrix,
4855 gfx::PointF(),
4856 gfx::Size(200, 400),
4857 true);
4858 this->CalcDrawEtc(root);
4859
4860 TestOcclusionTrackerWithClip<typename Types::LayerType,
4861 typename Types::RenderSurfaceType> occlusion(
4862 gfx::Rect(0, 0, 1000, 1000));
4863
4864 this->VisitLayer(copy_child, &occlusion);
4865 EXPECT_EQ(gfx::Rect().ToString(),
4866 occlusion.occlusion_from_outside_target().ToString());
4867 EXPECT_EQ(gfx::Rect(200, 400).ToString(),
4868 occlusion.occlusion_from_inside_target().ToString());
4869
4870 // CopyRequests cause the layer to own a surface.
4871 this->VisitContributingSurface(copy, &occlusion);
4872
4873 // The occlusion from the copy should be kept.
4874 EXPECT_EQ(gfx::Rect().ToString(),
4875 occlusion.occlusion_from_outside_target().ToString());
4876 EXPECT_EQ(gfx::Rect(100, 0, 200, 400).ToString(),
4877 occlusion.occlusion_from_inside_target().ToString());
4878 }
4879 };
4880
4881 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestCopyRequestDoesOcclude)
4882
4883 template <class Types>
4884 class OcclusionTrackerTestHiddenCopyRequestDoesNotOcclude
4885 : public OcclusionTrackerTest<Types> {
4886 protected:
4887 explicit OcclusionTrackerTestHiddenCopyRequestDoesNotOcclude(
4888 bool opaque_layers)
4889 : OcclusionTrackerTest<Types>(opaque_layers) {}
4890 void RunMyTest() {
4891 typename Types::ContentLayerType* root = this->CreateRoot(
4892 this->identity_matrix, gfx::Point(), gfx::Size(400, 400));
4893 typename Types::ContentLayerType* parent = this->CreateDrawingLayer(
4894 root, this->identity_matrix, gfx::Point(), gfx::Size(400, 400), true);
4895 typename Types::LayerType* hide = this->CreateLayer(
4896 parent, this->identity_matrix, gfx::Point(), gfx::Size());
4897 typename Types::LayerType* copy = this->CreateLayer(
4898 hide, this->identity_matrix, gfx::Point(100, 0), gfx::Size(200, 400));
4899 this->AddCopyRequest(copy);
4900 typename Types::LayerType* copy_child = this->CreateDrawingLayer(
4901 copy, this->identity_matrix, gfx::PointF(), gfx::Size(200, 400), true);
4902
4903 // The |copy| layer is hidden but since it is being copied, it will be
4904 // drawn.
4905 hide->SetHideLayerAndSubtree(true);
4906
4907 this->CalcDrawEtc(root);
4908
4909 TestOcclusionTrackerWithClip<typename Types::LayerType,
4910 typename Types::RenderSurfaceType> occlusion(
4911 gfx::Rect(0, 0, 1000, 1000));
4912
4913 this->VisitLayer(copy_child, &occlusion);
4914 EXPECT_EQ(gfx::Rect().ToString(),
4915 occlusion.occlusion_from_outside_target().ToString());
4916 EXPECT_EQ(gfx::Rect(200, 400).ToString(),
4917 occlusion.occlusion_from_inside_target().ToString());
4918
4919 // CopyRequests cause the layer to own a surface.
4920 this->VisitContributingSurface(copy, &occlusion);
4921
4922 // The occlusion from the copy should be dropped since it is hidden.
4923 EXPECT_EQ(gfx::Rect().ToString(),
4924 occlusion.occlusion_from_outside_target().ToString());
4925 EXPECT_EQ(gfx::Rect().ToString(),
4926 occlusion.occlusion_from_inside_target().ToString());
4927 }
4928 };
4929
4930 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestHiddenCopyRequestDoesNotOcclude)
4931
4932 } // namespace
4933 } // namespace cc