Unified OutputSurface::SwapBuffers.

ui/compositor/layer_unittest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 108 matching lines @@
 
   bool ReadPixels(SkBitmap* bitmap) {
     return GetCompositor()->ReadPixels(bitmap,
                                        gfx::Rect(GetCompositor()->size()));
   }
 
   void WaitForDraw() {
     ui::DrawWaiterForTest::Wait(GetCompositor());
   }
 
+  void WaitForCommit() {
+    ui::DrawWaiterForTest::WaitForCommit(GetCompositor());
+  }
+
   // Invalidates the entire contents of the layer.
   void SchedulePaintForLayer(Layer* layer) {
     layer->SchedulePaint(
         gfx::Rect(0, 0, layer->bounds().width(), layer->bounds().height()));
   }
 
   const base::FilePath& test_data_directory() const {
     return test_data_directory_;
   }
 
@@ skipping 108 matching lines @@
     return base::Closure();
   }
 
   DISALLOW_COPY_AND_ASSIGN(NullLayerDelegate);
 };
 
 // Remembers if it has been notified.
 class TestCompositorObserver : public CompositorObserver {
  public:
   TestCompositorObserver()
-      : started_(false), ended_(false), aborted_(false) {}
+      : committed_(false), started_(false), ended_(false), aborted_(false) {}
 
+  bool committed() const { return committed_; }
   bool notified() const { return started_ && ended_; }
   bool aborted() const { return aborted_; }
 
   void Reset() {
+    committed_ = false;
     started_ = false;
     ended_ = false;
     aborted_ = false;
   }
 
  private:
   virtual void OnCompositingDidCommit(Compositor* compositor) OVERRIDE {
+    committed_ = true;
   }
 
   virtual void OnCompositingStarted(Compositor* compositor,
                                     base::TimeTicks start_time) OVERRIDE {
     started_ = true;
   }
 
   virtual void OnCompositingEnded(Compositor* compositor) OVERRIDE {
     ended_ = true;
   }
 
   virtual void OnCompositingAborted(Compositor* compositor) OVERRIDE {
     aborted_ = true;
   }
 
   virtual void OnCompositingLockStateChanged(Compositor* compositor) OVERRIDE {
   }
 
   virtual void OnUpdateVSyncParameters(Compositor* compositor,
                                        base::TimeTicks timebase,
                                        base::TimeDelta interval) OVERRIDE {
   }
 
+  bool committed_;
   bool started_;
   bool ended_;
   bool aborted_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCompositorObserver);
 };
 
 }  // namespace
 
 #if defined(OS_WIN)
@@ skipping 108 matching lines @@
   // Invokes DrawTree on the compositor.
   void Draw() {
     compositor()->ScheduleDraw();
     WaitForDraw();
   }
 
   void WaitForDraw() {
     DrawWaiterForTest::Wait(compositor());
   }
 
+  void WaitForCommit() {
+    DrawWaiterForTest::WaitForCommit(compositor());
+  }
+
   // CompositorDelegate overrides.
   virtual void ScheduleDraw() OVERRIDE {
     DCHECK(!ui::Compositor::WasInitializedWithThread());
     if (compositor_) {
       base::MessageLoop::current()->PostTask(
           FROM_HERE, base::Bind(&Compositor::Draw, compositor_->AsWeakPtr()));
     }
   }
 
  private:
@@ skipping 381 matching lines @@
                                         gfx::Rect(10, 10, 350, 350)));
   l1->Add(l2.get());
   TestCompositorObserver observer;
   GetCompositor()->AddObserver(&observer);
 
   // Explicitly called DrawTree should cause the observers to be notified.
   // NOTE: this call to DrawTree sets l1 to be the compositor's root layer.
   DrawTree(l1.get());
   EXPECT_TRUE(observer.notified());
 
-  // As should scheduling a draw and waiting.
+  // ScheduleDraw without any visible change should cause a commit.
   observer.Reset();
   l1->ScheduleDraw();
-  WaitForDraw();
-  EXPECT_TRUE(observer.notified());
+  WaitForCommit();
+  EXPECT_TRUE(observer.committed());
 
   // Moving, but not resizing, a layer should alert the observers.
   observer.Reset();
   l2->SetBounds(gfx::Rect(0, 0, 350, 350));
   WaitForDraw();
   EXPECT_TRUE(observer.notified());
 
   // So should resizing a layer.
   observer.Reset();
   l2->SetBounds(gfx::Rect(0, 0, 400, 400));
@@ skipping 73 matching lines @@
   // WritePNGFile(bitmap, ref_img1);
   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img1, cc::ExactPixelComparator(true)));
 
   l0->StackAtTop(l11.get());
   DrawTree(l0.get());
   ASSERT_TRUE(ReadPixels(&bitmap));
   ASSERT_FALSE(bitmap.empty());
   // WritePNGFile(bitmap, ref_img2);
   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img2, cc::ExactPixelComparator(true)));
 
-  // l11 is already at the front, should have no effect.
+  // should restore to original configuration
+  l0->StackAbove(l12.get(), l11.get());
+  DrawTree(l0.get());
+  ASSERT_TRUE(ReadPixels(&bitmap));
+  ASSERT_FALSE(bitmap.empty());
+  EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img1, cc::ExactPixelComparator(true)));
+
+  // l11 back to front
   l0->StackAtTop(l11.get());
   DrawTree(l0.get());
   ASSERT_TRUE(ReadPixels(&bitmap));
   ASSERT_FALSE(bitmap.empty());
-  EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img2, cc::ExactPixelComparator(true)));
-
-  // l11 is already at the front, should have no effect.
-  l0->StackAbove(l11.get(), l12.get());
-  DrawTree(l0.get());
-  ASSERT_TRUE(ReadPixels(&bitmap));
-  ASSERT_FALSE(bitmap.empty());
   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img2, cc::ExactPixelComparator(true)));
 
   // should restore to original configuration
   l0->StackAbove(l12.get(), l11.get());
   DrawTree(l0.get());
   ASSERT_TRUE(ReadPixels(&bitmap));
   ASSERT_FALSE(bitmap.empty());
   EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img1, cc::ExactPixelComparator(true)));
+
+  // l11 back to front
+  l0->StackAbove(l11.get(), l12.get());
+  DrawTree(l0.get());
+  ASSERT_TRUE(ReadPixels(&bitmap));
+  ASSERT_FALSE(bitmap.empty());
+  EXPECT_TRUE(MatchesPNGFile(bitmap, ref_img2, cc::ExactPixelComparator(true)));
 }
 
 // Opacity is rendered correctly.
 // Checks that modifying the hierarchy correctly affects final composite.
 TEST_F(LayerWithRealCompositorTest, MAYBE_Opacity) {
   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(50, 50));
 
   // l0
   //  +-l11
   scoped_ptr<Layer> l0(CreateColorLayer(SK_ColorRED,
@@ skipping 76 matching lines @@
   SchedulePaintLayerDelegate child_delegate;
   scoped_ptr<Layer> child(CreateColorLayer(SK_ColorBLUE,
                                            gfx::Rect(0, 0, 200, 200)));
   child_delegate.set_layer(child.get());
 
   root->Add(child.get());
 
   SchedulePaintForLayer(root.get());
   DrawTree(root.get());
   child->SchedulePaint(gfx::Rect(0, 0, 20, 20));
-  child_delegate.GetPaintCountAndClear();
+  EXPECT_EQ(1, child_delegate.GetPaintCountAndClear());
 
   // Set a rect so that when OnPaintLayer() is invoked SchedulePaint is invoked
   // again.
   child_delegate.SetSchedulePaintRect(gfx::Rect(10, 10, 30, 30));
-  WaitForDraw();
-  // |child| should have been painted once.
+  WaitForCommit();
   EXPECT_EQ(1, child_delegate.GetPaintCountAndClear());
 
   // Because SchedulePaint() was invoked from OnPaintLayer() |child| should
   // still need to be painted.
-  WaitForDraw();
+  WaitForCommit();
   EXPECT_EQ(1, child_delegate.GetPaintCountAndClear());
   EXPECT_TRUE(child_delegate.last_clip_rect().Contains(
                   gfx::Rect(10, 10, 30, 30)));
 }
 
 TEST_F(LayerWithRealCompositorTest, MAYBE_ScaleUpDown) {
   scoped_ptr<Layer> root(CreateColorLayer(SK_ColorWHITE,
                                           gfx::Rect(10, 20, 200, 220)));
   TestLayerDelegate root_delegate;
   root_delegate.AddColor(SK_ColorWHITE);
@@ skipping 162 matching lines @@
   DrawTree(root.get());
 
   // Reset into invisible state.
   child->SetVisible(false);
   DrawTree(root.get());
   delegate.Reset();
 
   // Move layer.
   child->SetBounds(gfx::Rect(200, 200, 500, 500));
   child->SetVisible(true);
-  WaitForDraw();
   DrawTree(root.get());
   EXPECT_FALSE(delegate.painted());
 
   // Reset into invisible state.
   child->SetVisible(false);
   DrawTree(root.get());
   delegate.Reset();
 
   // Resize layer.
   child->SetBounds(gfx::Rect(200, 200, 400, 400));
   child->SetVisible(true);
-  WaitForDraw();
   DrawTree(root.get());
   EXPECT_TRUE(delegate.painted());
 }
 
 static scoped_ptr<cc::DelegatedFrameData> MakeFrameData(gfx::Size size) {
   scoped_ptr<cc::DelegatedFrameData> frame_data(new cc::DelegatedFrameData);
   scoped_ptr<cc::RenderPass> render_pass(cc::RenderPass::Create());
   render_pass->SetNew(cc::RenderPass::Id(1, 1),
                       gfx::Rect(size),
                       gfx::RectF(),
@@ skipping 106 matching lines @@
   l1->SetOpacity(0.5f);
 
   // Change l1's cc::Layer.
   l1->SwitchCCLayerForTest();
 
   // Ensure that the opacity animation completed.
   EXPECT_FLOAT_EQ(l1->opacity(), 0.5f);
 }
 
 }  // namespace ui