Improve Aura overdraw by changing hole calculation

ui/gfx/compositor/layer_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <string>

[Ian Vollick, 2011/10/22 01:06:03]

Is this used?

+
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/compositor_observer.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/compositor/test_compositor.h"
 #include "ui/gfx/compositor/test_compositor_host.h"
 
@@ skipping 513 matching lines @@
 
   scoped_ptr<Layer> child1(CreateTextureLayer(gfx::Rect(50, 50, 100, 100)));
   parent->Add(child1.get());
 
   scoped_ptr<Layer> child2(CreateTextureLayer(gfx::Rect(75, 75, 200, 200)));
   parent->Add(child2.get());
 
   EXPECT_EQ(gfx::Rect(75, 75, 200, 200), parent->hole_rect());
 }
 
+// Verifies that the largest hole in the draw order is picked
+TEST_F(LayerWithNullDelegateTest, HoleGeneratedFromLeaf) {
+  // Layer tree looks like:
+  // node 1
+  // |_ node 11
+  //    |_ node 111
+  // |_ node 12
+  //    |_ node 121
+
+  scoped_ptr<Layer> node1(CreateTextureRootLayer(gfx::Rect(0, 0, 400, 400)));
+
+  scoped_ptr<Layer> node11(CreateTextureLayer(gfx::Rect(50, 50, 100, 100)));
+  node1->Add(node11.get());
+
+  scoped_ptr<Layer> node12(CreateTextureLayer(gfx::Rect(75, 75, 200, 200)));
+  node1->Add(node12.get());
+
+  scoped_ptr<Layer> node111(CreateTextureLayer(gfx::Rect(10, 10, 20, 20)));
+  node11->Add(node111.get());
+
+  scoped_ptr<Layer> node121(CreateTextureLayer(gfx::Rect(10, 10, 190, 190)));
+  node12->Add(node121.get());
+
+  EXPECT_EQ(gfx::Rect(75, 75, 200, 200), node1->hole_rect());
+  EXPECT_EQ(gfx::Rect(35, 35, 65, 65), node11->hole_rect());
+  EXPECT_EQ(gfx::Rect(10, 10, 190, 190), node12->hole_rect());
+}
+
+// Verifies that a layer can only punch a hole if the opacity of the layer
+// punching the hole and the layer being punched is the same.
+TEST_F(LayerWithNullDelegateTest, HoleWithRelativeOpacity) {
+  // Layer tree looks like:
+  // node 1
+  // |_ node 11
+  //    |_ node 111
+
+  scoped_ptr<Layer> node1(CreateTextureRootLayer(gfx::Rect(0, 0, 400, 400)));
+
+  scoped_ptr<Layer> node11(CreateTextureLayer(gfx::Rect(50, 50, 100, 100)));
+  node1->Add(node11.get());
+
+  scoped_ptr<Layer> node111(CreateTextureLayer(gfx::Rect(10, 10, 20, 20)));
+  node11->Add(node111.get());
+
+  EXPECT_EQ(gfx::Rect(50, 50, 100, 100), node1->hole_rect());
+  EXPECT_EQ(gfx::Rect(10, 10, 20, 20), node11->hole_rect());
+
+  // Combined opacity node11 = combined opacity node111
+  node11->SetOpacity(0.5f);
+  EXPECT_TRUE(node1->hole_rect().IsEmpty());
+  EXPECT_EQ(gfx::Rect(10, 10, 20, 20), node11->hole_rect());
+
+  // Combined opacity of node11 != combind opacity node111.
+  node111->SetOpacity(0.5f);
+  EXPECT_TRUE(node1->hole_rect().IsEmpty());
+  EXPECT_TRUE(node11->hole_rect().IsEmpty());
+}
+
+// Verifies that a non visible layer or any of its children is not a hole.
+TEST_F(LayerWithNullDelegateTest, NonVisibleLayerCannotBeHole) {
+  // Layer tree looks like:
+  // node 1
+  // |_ node 11
+  //    |_ node 111
+
+  scoped_ptr<Layer> node1(CreateTextureRootLayer(gfx::Rect(0, 0, 400, 400)));
+
+  scoped_ptr<Layer> node11(CreateTextureLayer(gfx::Rect(50, 50, 100, 100)));
+  node1->Add(node11.get());
+
+  scoped_ptr<Layer> node111(CreateTextureLayer(gfx::Rect(10, 10, 20, 20)));
+  node11->Add(node111.get());
+
+  EXPECT_EQ(gfx::Rect(50, 50, 100, 100), node1->hole_rect());
+  EXPECT_EQ(gfx::Rect(10, 10, 20, 20), node11->hole_rect());
+
+  node11->SetVisible(false);
+  EXPECT_TRUE(node1->hole_rect().IsEmpty());
+  EXPECT_TRUE(node11->hole_rect().IsEmpty());
+}
+
+// Verifies that a layer which doesn't fill its bounds opaquely cannot punch a
+// hole. However its children should still be able to punch a hole.
+TEST_F(LayerWithNullDelegateTest, LayerNotFillingBoundsOpaquelyCannotBeHole) {
+  // Layer tree looks like:
+  // node 1
+  // |_ node 11
+  //    |_ node 111
+
+  scoped_ptr<Layer> node1(CreateTextureRootLayer(gfx::Rect(0, 0, 400, 400)));
+
+  scoped_ptr<Layer> node11(CreateTextureLayer(gfx::Rect(50, 50, 100, 100)));
+  node1->Add(node11.get());
+
+  scoped_ptr<Layer> node111(CreateTextureLayer(gfx::Rect(10, 10, 20, 20)));
+  node11->Add(node111.get());
+
+  EXPECT_EQ(gfx::Rect(50, 50, 100, 100), node1->hole_rect());
+  EXPECT_EQ(gfx::Rect(10, 10, 20, 20), node11->hole_rect());
+
+  node11->SetFillsBoundsOpaquely(false);
+  EXPECT_EQ(gfx::Rect(60, 60, 20, 20), node1->hole_rect());
+  EXPECT_TRUE(node11->hole_rect().IsEmpty());
+}
+
 // Verifies that the hole is with respect to the local bounds of its parent.
 TEST_F(LayerWithNullDelegateTest, HoleLocalBounds) {
   scoped_ptr<Layer> parent(CreateTextureRootLayer(
       gfx::Rect(100, 100, 150, 150)));
 
   scoped_ptr<Layer> child(CreateTextureLayer(gfx::Rect(50, 50, 100, 100)));
   parent->Add(child.get());
 
   EXPECT_EQ(gfx::Rect(50, 50, 100, 100), parent->hole_rect());
 }
@@ skipping 34 matching lines @@
     child->SetTransform(t);
 
     gfx::Rect target_rect(child->bounds().size());
     t.ConcatTranslate(child->bounds().x(), child->bounds().y());
     t.TransformRect(&target_rect);
 
     EXPECT_EQ(target_rect, parent->hole_rect());
   }
 }
 
+// Verifies that a layer which doesn't have a texture cannot punch a
+// hole. However its children should still be able to punch a hole.
+TEST_F(LayerWithNullDelegateTest, HoleWithRelativeNinetyDegreeTransforms) {
+  // Layer tree looks like:
+  // node 1
+  // |_ node 11
+  // |_ node 12
+
+  scoped_ptr<Layer> node1(CreateTextureRootLayer(gfx::Rect(0, 0, 400, 400)));
+
+  scoped_ptr<Layer> node11(CreateTextureLayer(gfx::Rect(50, 50, 50, 50)));
+  node1->Add(node11.get());
+
+  scoped_ptr<Layer> node12(CreateTextureLayer(gfx::Rect(50, 50, 50, 50)));
+  node1->Add(node12.get());
+
+  EXPECT_EQ(gfx::Rect(0, 0, 50, 50), node11->hole_rect());
+  EXPECT_TRUE(node12->hole_rect().IsEmpty());
+
+  ui::Transform t1;
+  // Need to rotate in local coordinates.
+  t1.SetTranslate(-25, -25);
+  t1.ConcatRotate(45.0f);
+  t1.ConcatTranslate(25, 25);
+  node11->SetTransform(t1);
+
+  EXPECT_TRUE(node12->hole_rect().IsEmpty());
+  EXPECT_TRUE(node11->hole_rect().IsEmpty());
+
+  ui::Transform t2;
+  // Need to rotate in local coordinates.
+  t2.SetTranslate(-25, -25);
+  t2.ConcatRotate(-135.0f);
+  t2.ConcatTranslate(25, 25);
+  node12->SetTransform(t2);
+
+  // Do translation of target rect in order to account for inprecision of
+  // using floating point matrices vs integer rects.
+  ui::Transform t3;
+  gfx::Rect target_rect = gfx::Rect(node11->bounds().size());
+  t3.ConcatTransform(t2);
+  t1.Invert();
+  t3.ConcatTransform(t1);
+  t3.TransformRect(&target_rect);
+
+  EXPECT_TRUE(node12->hole_rect().IsEmpty());
+  EXPECT_EQ(target_rect, node11->hole_rect());
+}
+
 // Create this hierarchy:
 // L1 (no texture)
 //  +- L11 (texture)
 //  +- L12 (no texture) (added after L1 is already set as root-layer)
 //    +- L121 (texture)
 //    +- L122 (texture)
 TEST_F(LayerWithNullDelegateTest, NoCompositor) {
   scoped_ptr<Layer> l1(CreateLayer(Layer::LAYER_HAS_NO_TEXTURE));
   scoped_ptr<Layer> l11(CreateLayer(Layer::LAYER_HAS_TEXTURE));
   scoped_ptr<Layer> l12(CreateLayer(Layer::LAYER_HAS_NO_TEXTURE));
@@ skipping 79 matching lines @@
   EXPECT_FALSE(l2->IsDrawn());
   EXPECT_FALSE(l3->IsDrawn());
 
   l1->SetVisible(true);
   EXPECT_TRUE(l1->IsDrawn());
   EXPECT_TRUE(l2->IsDrawn());
   EXPECT_FALSE(l3->IsDrawn());
 }
 
 } // namespace ui