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