Disable layer hole unit tests when using the WebKit compositor.

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 "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
@@ skipping 586 matching lines @@
   scoped_ptr<Layer> layer(CreateTextureRootLayer(gfx::Rect(0, 0, 0, 0)));
   Draw();
   EXPECT_TRUE(layer->texture() == NULL);
 
   layer->SetBounds(gfx::Rect(0, 0, 400, 400));
   Draw();
   EXPECT_TRUE(layer->texture() != NULL);
 }
 
 // Verifies that when there are many potential holes, the largest one is picked.
-TEST_F(LayerWithNullDelegateTest, LargestHole) {
+TEST_F(LayerWithNullDelegateTest,
+       NOT_APPLICABLE_TO_WEBKIT_COMPOSITOR(LargestHole)) {
   scoped_ptr<Layer> parent(CreateTextureRootLayer(gfx::Rect(0, 0, 400, 400)));
 
   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());
 
   Draw();
 
   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) {
+TEST_F(LayerWithNullDelegateTest,
+       NOT_APPLICABLE_TO_WEBKIT_COMPOSITOR(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());
 
   Draw();
 
   EXPECT_EQ(gfx::Rect(75, 75, 200, 200), node1->hole_rect());
   EXPECT_EQ(gfx::Rect(25, 25, 75, 75), node11->hole_rect());
   EXPECT_EQ(gfx::Rect(10, 10, 190, 190), node12->hole_rect());
 }
 
 // Verifies that a hole can only punched into a layer with opacity = 1.0f.
-TEST_F(LayerWithNullDelegateTest, NoHoleWhenPartialOpacity) {
+TEST_F(LayerWithNullDelegateTest,
+       NOT_APPLICABLE_TO_WEBKIT_COMPOSITOR(NoHoleWhenPartialOpacity)) {
   // 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());
 
   Draw();
   EXPECT_EQ(gfx::Rect(50, 50, 100, 100), node1->hole_rect());
   EXPECT_EQ(gfx::Rect(10, 10, 20, 20), node11->hole_rect());
 
 
   node11->SetOpacity(0.5f);
   Draw();
   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) {
+TEST_F(LayerWithNullDelegateTest,
+       NOT_APPLICABLE_TO_WEBKIT_COMPOSITOR(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());
 
   Draw();
   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);
   Draw();
   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) {
+TEST_F(LayerWithNullDelegateTest,
+       NOT_APPLICABLE_TO_WEBKIT_COMPOSITOR(
+           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());
 
   Draw();
   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);
   Draw();
   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) {
+TEST_F(LayerWithNullDelegateTest,
+       NOT_APPLICABLE_TO_WEBKIT_COMPOSITOR(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());
 
   Draw();
 
   EXPECT_EQ(gfx::Rect(50, 50, 100, 100), parent->hole_rect());
 }
 
 // Verifies that there is no hole present when one of the child layers has a
 // transform.
-TEST_F(LayerWithNullDelegateTest, NoHoleWithTransform) {
+TEST_F(LayerWithNullDelegateTest,
+       NOT_APPLICABLE_TO_WEBKIT_COMPOSITOR(NoHoleWithTransform)) {
   scoped_ptr<Layer> parent(CreateTextureRootLayer(gfx::Rect(0, 0, 400, 400)));
   scoped_ptr<Layer> child(CreateTextureLayer(gfx::Rect(50, 50, 100, 100)));
   parent->Add(child.get());
 
   Draw();
 
   EXPECT_TRUE(!parent->hole_rect().IsEmpty());
 
   ui::Transform t;
   t.SetTranslate(-50, -50);
   t.ConcatRotate(45.0f);
   t.ConcatTranslate(50, 50);
   child->SetTransform(t);
 
   Draw();
 
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), parent->hole_rect());
 }
 
 // Verifies that if the child layer is rotated by a multiple of ninety degrees
 // we punch a hole
-TEST_F(LayerWithNullDelegateTest, HoleWithNinetyDegreeTransforms) {
+TEST_F(LayerWithNullDelegateTest,
+       NOT_APPLICABLE_TO_WEBKIT_COMPOSITOR(HoleWithNinetyDegreeTransforms)) {
   scoped_ptr<Layer> parent(CreateTextureRootLayer(gfx::Rect(0, 0, 400, 400)));
   scoped_ptr<Layer> child(CreateTextureLayer(gfx::Rect(50, 50, 50, 50)));
   parent->Add(child.get());
 
   Draw();
 
   EXPECT_TRUE(!parent->hole_rect().IsEmpty());
 
   for (int i = -4; i <= 4; ++i) {
     SCOPED_TRACE(::testing::Message() << "Iteration " << i);
@@ skipping 10 matching lines @@
     t.TransformRect(&target_rect);
 
     Draw();
 
     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) {
+TEST_F(LayerWithNullDelegateTest,
+       NOT_APPLICABLE_TO_WEBKIT_COMPOSITOR(
+           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());
 
@@ skipping 302 matching lines @@
   GetCompositor()->RemoveObserver(&observer);
 
   // Opacity changes should no longer alert the removed observer.
   observer.Reset();
   l2->SetOpacity(0.5f);
   RunPendingMessages();
   EXPECT_FALSE(observer.notified());
 }
 
 } // namespace ui