Use WebKit compositor in ui::Layer

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/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"
 
 namespace ui {
 
 namespace {
 
 // There are three test classes in here that configure the Compositor and
 // Layer's slightly differently:
 // - LayerWithNullDelegateTest uses TestCompositor and NullLayerDelegate as the
 //   LayerDelegate. This is typically the base class you want to use.
 // - LayerWithDelegateTest uses TestCompositor and does not set a LayerDelegate
 //   on the delegates.
 // - LayerWithRealCompositorTest when a real compositor is required for testing.
 //    - Slow because they bring up a window and run the real compositor. This
 //      is typically not what you want.
+
+class ColoredLayer : public Layer, public LayerDelegate {
+ public:
+  ColoredLayer(Compositor* compositor, SkColor color)
+      : Layer(compositor, Layer::LAYER_HAS_TEXTURE),
+        color_(color) {
+    set_delegate(this);
+  }
+
+  virtual ~ColoredLayer() { }
+
+  // Overridden from LayerDelegate:
+  virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
+    canvas->GetSkCanvas()->drawColor(color_);
+  }
+
+ private:
+  SkColor color_;
+};
+
 class LayerWithRealCompositorTest : public testing::Test {
  public:
   LayerWithRealCompositorTest() {}
   virtual ~LayerWithRealCompositorTest() {}
 
   // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
     const gfx::Rect host_bounds(10, 10, 500, 500);
     window_.reset(TestCompositorHost::Create(host_bounds));
     window_->Show();
   }
 
   virtual void TearDown() OVERRIDE {
   }
 
   Compositor* GetCompositor() {
     return window_->GetCompositor();
   }
 
   Layer* CreateLayer(Layer::LayerType type) {
     return new Layer(GetCompositor(), type);
   }
 
   Layer* CreateColorLayer(SkColor color, const gfx::Rect& bounds) {
-    Layer* layer = CreateLayer(Layer::LAYER_HAS_TEXTURE);
+    Layer* layer = new ColoredLayer(GetCompositor(), color);
     layer->SetBounds(bounds);
-    PaintColorToLayer(layer, color);
     return layer;
   }
 
   Layer* CreateNoTextureLayer(const gfx::Rect& bounds) {
     Layer* layer = CreateLayer(Layer::LAYER_HAS_NO_TEXTURE);
     layer->SetBounds(bounds);
     return layer;
   }
 
   gfx::Canvas* CreateCanvasForLayer(const Layer* layer) {
     return gfx::Canvas::CreateCanvas(layer->bounds().width(),
                                      layer->bounds().height(),
                                      false);
   }
 
-  void PaintColorToLayer(Layer* layer, SkColor color) {
-    scoped_ptr<gfx::Canvas> canvas(CreateCanvasForLayer(layer));
-    canvas->FillRectInt(color, 0, 0, layer->bounds().width(),
-                        layer->bounds().height());
-    layer->SetCanvas(*canvas->GetSkCanvas(), layer->bounds().origin());
-  }
-
   void DrawTree(Layer* root) {
     GetCompositor()->SetRootLayer(root);
     GetCompositor()->Draw(false);
   }
 
   void RunPendingMessages() {
     MessageLoopForUI::current()->RunAllPending();
   }
 
   // Invalidates the entire contents of the layer.
   void SchedulePaintForLayer(Layer* layer) {
     layer->SchedulePaint(
         gfx::Rect(0, 0, layer->bounds().width(), layer->bounds().height()));
   }
 
  private:
-  MessageLoopForUI message_loop_;
   scoped_ptr<TestCompositorHost> window_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerWithRealCompositorTest);
 };
 
 // LayerDelegate that paints colors to the layer.
 class TestLayerDelegate : public LayerDelegate {
  public:
-  explicit TestLayerDelegate(Layer* owner) : owner_(owner), color_index_(0) {}
+  explicit TestLayerDelegate() : color_index_(0) {}
   virtual ~TestLayerDelegate() {}
 
   void AddColor(SkColor color) {
     colors_.push_back(color);
   }
 
   gfx::Size paint_size() const { return paint_size_; }
   int color_index() const { return color_index_; }
 
   // Overridden from LayerDelegate:
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
     SkBitmap contents = canvas->AsCanvasSkia()->ExtractBitmap();
     paint_size_ = gfx::Size(contents.width(), contents.height());
     canvas->FillRectInt(colors_.at(color_index_), 0, 0,
                         contents.width(),
                         contents.height());
     color_index_ = (color_index_ + 1) % static_cast<int>(colors_.size());
   }
 
  private:
-  Layer* owner_;
   std::vector<SkColor> colors_;
   int color_index_;
   gfx::Size paint_size_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLayerDelegate);
 };
 
 // LayerDelegate that verifies that a layer was asked to update its canvas.
 class DrawTreeLayerDelegate : public LayerDelegate {
  public:
@@ skipping 85 matching lines @@
   virtual void TearDown() OVERRIDE {
   }
 
   Compositor* compositor() { return compositor_.get(); }
 
   virtual Layer* CreateLayer(Layer::LayerType type) {
     return new Layer(compositor(), type);
   }
 
   Layer* CreateColorLayer(SkColor color, const gfx::Rect& bounds) {
-    Layer* layer = CreateLayer(Layer::LAYER_HAS_TEXTURE);
+    Layer* layer = new ColoredLayer(compositor(), color);
     layer->SetBounds(bounds);
-    PaintColorToLayer(layer, color);
     return layer;
   }
 
   virtual Layer* CreateNoTextureLayer(const gfx::Rect& bounds) {
     Layer* layer = CreateLayer(Layer::LAYER_HAS_NO_TEXTURE);
     layer->SetBounds(bounds);
     return layer;
   }
 
   gfx::Canvas* CreateCanvasForLayer(const Layer* layer) {
     return gfx::Canvas::CreateCanvas(layer->bounds().width(),
                                      layer->bounds().height(),
                                      false);
   }
 
-  void PaintColorToLayer(Layer* layer, SkColor color) {
-    scoped_ptr<gfx::Canvas> canvas(CreateCanvasForLayer(layer));
-    canvas->FillRectInt(color, 0, 0, layer->bounds().width(),
-                        layer->bounds().height());
-    layer->SetCanvas(*canvas->GetSkCanvas(), layer->bounds().origin());
-  }
-
   void DrawTree(Layer* root) {
     compositor()->SetRootLayer(root);
     compositor()->Draw(false);
   }
 
   // Invalidates the entire contents of the layer.
   void SchedulePaintForLayer(Layer* layer) {
     layer->SchedulePaint(
         gfx::Rect(0, 0, layer->bounds().width(), layer->bounds().height()));
   }
 
   // Invokes DrawTree on the compositor.
   void Draw() {
-    compositor_->root_layer()->DrawTree();
+    compositor_->Draw(false);
   }
 
  private:
   scoped_refptr<TestCompositor> compositor_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerWithDelegateTest);
 };
 
 // L1
 //  +-- L2
@@ skipping 34 matching lines @@
   Layer::ConvertPointToLayer(l3.get(), l1.get(), &point1_in_l3_coords);
   gfx::Point point1_in_l1_coords(25, 25);
   EXPECT_EQ(point1_in_l1_coords, point1_in_l3_coords);
 
   gfx::Point point2_in_l1_coords(5, 5);
   Layer::ConvertPointToLayer(l1.get(), l3.get(), &point2_in_l1_coords);
   gfx::Point point2_in_l3_coords(-15, -15);
   EXPECT_EQ(point2_in_l3_coords, point2_in_l1_coords);
 }
 
-TEST_F(LayerWithDelegateTest, Delegate) {
+TEST_F(LayerWithRealCompositorTest, Delegate) {
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorBLACK,
                                         gfx::Rect(20, 20, 400, 400)));
-  TestLayerDelegate delegate(l1.get());
+  GetCompositor()->SetRootLayer(l1.get());
+  RunPendingMessages();
+
+  TestLayerDelegate delegate;
   l1->set_delegate(&delegate);
   delegate.AddColor(SK_ColorWHITE);
   delegate.AddColor(SK_ColorYELLOW);
   delegate.AddColor(SK_ColorGREEN);
 
-  compositor()->SetRootLayer(l1.get());
-
   l1->SchedulePaint(gfx::Rect(0, 0, 400, 400));
-  Draw();
+  RunPendingMessages();
   EXPECT_EQ(delegate.color_index(), 1);
   EXPECT_EQ(delegate.paint_size(), l1->bounds().size());
 
   l1->SchedulePaint(gfx::Rect(10, 10, 200, 200));
-  Draw();
+  RunPendingMessages();
   EXPECT_EQ(delegate.color_index(), 2);
   EXPECT_EQ(delegate.paint_size(), gfx::Size(200, 200));
 
   l1->SchedulePaint(gfx::Rect(5, 5, 50, 50));
-  Draw();
+  RunPendingMessages();
   EXPECT_EQ(delegate.color_index(), 0);
   EXPECT_EQ(delegate.paint_size(), gfx::Size(50, 50));
 }
 
-TEST_F(LayerWithDelegateTest, DrawTree) {
+TEST_F(LayerWithRealCompositorTest, DrawTree) {
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorRED,
                                         gfx::Rect(20, 20, 400, 400)));
   scoped_ptr<Layer> l2(CreateColorLayer(SK_ColorBLUE,
                                         gfx::Rect(10, 10, 350, 350)));
   scoped_ptr<Layer> l3(CreateColorLayer(SK_ColorYELLOW,
                                         gfx::Rect(10, 10, 100, 100)));
   l1->Add(l2.get());
   l2->Add(l3.get());
 
+  GetCompositor()->SetRootLayer(l1.get());
+  RunPendingMessages();
+
   DrawTreeLayerDelegate d1;
   l1->set_delegate(&d1);
   DrawTreeLayerDelegate d2;
   l2->set_delegate(&d2);
   DrawTreeLayerDelegate d3;
   l3->set_delegate(&d3);
 
-  compositor()->SetRootLayer(l1.get());
-
   l2->SchedulePaint(gfx::Rect(5, 5, 5, 5));
-  Draw();
+  RunPendingMessages();
   EXPECT_FALSE(d1.painted());
   EXPECT_TRUE(d2.painted());
   EXPECT_FALSE(d3.painted());
 }
 
 // Tests no-texture Layers.
 // Create this hierarchy:
 // L1 - red
 // +-- L2 - NO TEXTURE
 // |   +-- L3 - yellow
 // +-- L4 - magenta
 //
-TEST_F(LayerWithDelegateTest, HierarchyNoTexture) {
+TEST_F(LayerWithRealCompositorTest, HierarchyNoTexture) {
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorRED,
                                         gfx::Rect(20, 20, 400, 400)));
   scoped_ptr<Layer> l2(CreateNoTextureLayer(gfx::Rect(10, 10, 350, 350)));
   scoped_ptr<Layer> l3(CreateColorLayer(SK_ColorYELLOW,
                                         gfx::Rect(5, 5, 25, 25)));
   scoped_ptr<Layer> l4(CreateColorLayer(SK_ColorMAGENTA,
                                         gfx::Rect(300, 300, 100, 100)));
 
   l1->Add(l2.get());
   l1->Add(l4.get());
   l2->Add(l3.get());
 
+  GetCompositor()->SetRootLayer(l1.get());
+  RunPendingMessages();
+
   DrawTreeLayerDelegate d2;
   l2->set_delegate(&d2);
   DrawTreeLayerDelegate d3;
   l3->set_delegate(&d3);
 
-  compositor()->SetRootLayer(l1.get());
-
   l2->SchedulePaint(gfx::Rect(5, 5, 5, 5));
   l3->SchedulePaint(gfx::Rect(5, 5, 5, 5));
-  Draw();
+  RunPendingMessages();
 
   // |d2| should not have received a paint notification since it has no texture.
   EXPECT_FALSE(d2.painted());
   // |d3| should have received a paint notification.
   EXPECT_TRUE(d3.painted());
 }
 
 class LayerWithNullDelegateTest : public LayerWithDelegateTest {
  public:
   LayerWithNullDelegateTest() {}
@@ skipping 44 matching lines @@
   scoped_ptr<Layer> parent(CreateNoTextureLayer(gfx::Rect(0, 0, 400, 400)));
   scoped_ptr<Layer> child(CreateNoTextureLayer(gfx::Rect(50, 50, 100, 100)));
   parent->Add(child.get());
 
   compositor()->SetRootLayer(parent.get());
   Draw();
   EXPECT_TRUE(child->texture() == NULL);
   EXPECT_TRUE(parent->texture() == NULL);
 }
 
+// With the webkit compositor, we don't explicitly textures for layers, making
+// tests that check that we do fail.
+#if defined(USE_WEBKIT_COMPOSITOR)
+#define WEBKIT_COMPOSITOR_FAILS(X) FAILS_ ## X
+#else
+#define WEBKIT_COMPOSITOR_FAILS(X) X
+#endif
+
 // Verifies that a layer does not have a texture when the hole is the size
 // of the parent layer.
-TEST_F(LayerWithNullDelegateTest, LayerNoTextureHoleSizeOfLayer) {
+TEST_F(LayerWithNullDelegateTest,
+       WEBKIT_COMPOSITOR_FAILS(LayerNoTextureHoleSizeOfLayer)) {
   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_EQ(gfx::Rect(50, 50, 100, 100), parent->hole_rect());
   EXPECT_TRUE(parent->texture() != NULL);
 
   child->SetBounds(gfx::Rect(0, 0, 400, 400));
   Draw();
   EXPECT_TRUE(parent->texture() == NULL);
 }
 
 // Verifies that a layer which has opacity == 0 does not have a texture.
-TEST_F(LayerWithNullDelegateTest, LayerNoTextureTransparent) {
+TEST_F(LayerWithNullDelegateTest,
+       WEBKIT_COMPOSITOR_FAILS(LayerNoTextureTransparent)) {
   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());
 
   parent->SetOpacity(0.0f);
   child->SetOpacity(0.0f);
   Draw();
   EXPECT_TRUE(parent->texture() == NULL);
   EXPECT_TRUE(child->texture() == NULL);
 
   parent->SetOpacity(1.0f);
   Draw();
   EXPECT_TRUE(parent->texture() != NULL);
   EXPECT_TRUE(child->texture() == NULL);
 
   child->SetOpacity(1.0f);
   Draw();
   EXPECT_TRUE(parent->texture() != NULL);
   EXPECT_TRUE(child->texture() != NULL);
 }
 
 // Verifies that no texture is created for a layer with empty bounds.
-TEST_F(LayerWithNullDelegateTest, LayerTextureNonEmptySchedulePaint) {
+TEST_F(LayerWithNullDelegateTest,
+       WEBKIT_COMPOSITOR_FAILS(LayerTextureNonEmptySchedulePaint)) {
   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.
@@ skipping 51 matching lines @@
     EXPECT_EQ(target_rect, parent->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) {
+TEST_F(LayerWithNullDelegateTest, WEBKIT_COMPOSITOR_FAILS(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));
   scoped_ptr<Layer> l121(CreateLayer(Layer::LAYER_HAS_TEXTURE));
   scoped_ptr<Layer> l122(CreateLayer(Layer::LAYER_HAS_TEXTURE));
 
   EXPECT_EQ(NULL, l1->texture());
   EXPECT_EQ(NULL, l11->texture());
   EXPECT_EQ(NULL, l12->texture());
   EXPECT_EQ(NULL, l121->texture());
@@ skipping 72 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