src/cc/trees/occlusion_tracker_unittest.cc

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