Make SingleThreadProxy a SchedulerClient

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/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 76 matching lines @@
   }
   virtual ~LayerWithRealCompositorTest() {}
 
   // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
     bool enable_pixel_output = true;
     ui::ContextFactory* context_factory =
         InitializeContextFactoryForTests(enable_pixel_output);
 
     const gfx::Rect host_bounds(10, 10, 500, 500);
-    compositor_host_.reset(TestCompositorHost::Create(
-                               host_bounds, context_factory));
+    compositor_host_.reset(
+        TestCompositorHost::Create(host_bounds, context_factory));
     compositor_host_->Show();
   }
 
   virtual void TearDown() OVERRIDE {
     compositor_host_.reset();
     TerminateContextFactoryForTests();
   }
 
   Compositor* GetCompositor() { return compositor_host_->GetCompositor(); }
 
   Layer* CreateLayer(LayerType type) {
     return new Layer(type);
   }
 
   Layer* CreateColorLayer(SkColor color, const gfx::Rect& bounds) {
     Layer* layer = new ColoredLayer(color);
     layer->SetBounds(bounds);
     return layer;
   }
 
   Layer* CreateNoTextureLayer(const gfx::Rect& bounds) {
     Layer* layer = CreateLayer(LAYER_NOT_DRAWN);
     layer->SetBounds(bounds);
     return layer;
   }
 
   void DrawTree(Layer* root) {
     GetCompositor()->SetRootLayer(root);
     GetCompositor()->ScheduleDraw();
-    WaitForDraw();
+    WaitForSwap();
   }
 
   bool ReadPixels(SkBitmap* bitmap) {
     return ReadPixels(bitmap, gfx::Rect(GetCompositor()->size()));
   }
 
   bool ReadPixels(SkBitmap* bitmap, gfx::Rect source_rect) {
     scoped_refptr<ReadbackHolder> holder(new ReadbackHolder);
     scoped_ptr<cc::CopyOutputRequest> request =
         cc::CopyOutputRequest::CreateBitmapRequest(
             base::Bind(&ReadbackHolder::OutputRequestCallback, holder));
     request->set_area(source_rect);
 
     GetCompositor()->root_layer()->RequestCopyOfOutput(request.Pass());
 
-    // Wait for copy response.  This needs to wait as the compositor could
-    // be in the middle of a draw right now, and the commit with the
-    // copy output request may not be done on the first draw.
-    for (int i = 0; i < 2; i++) {
-      GetCompositor()->ScheduleDraw();
+    // Wait for copy response.  The copy output request will get committed
+    // before the first draw, but may not be part of the first draw's frame.
+    // The second draw will perform the async copy request, post the callback.
+    // The second loop finishes before the callback is run, so a third
+    // loop is needed.
+    for (int i = 0; i < 3; i++) {
+      GetCompositor()->ScheduleFullRedraw();
       WaitForDraw();
     }
 
     if (holder->completed()) {
       *bitmap = holder->result();
       return true;
     }
 
     // Callback never called.
     NOTREACHED();
     return false;
   }
 
   void WaitForDraw() {
-    ui::DrawWaiterForTest::Wait(GetCompositor());
+    ui::DrawWaiterForTest::WaitForCompositingStarted(GetCompositor());
+  }
+
+  void WaitForSwap() {
+    DrawWaiterForTest::WaitForCompositingEnded(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()));
@@ skipping 268 matching lines @@
         gfx::Rect(0, 0, layer->bounds().width(), layer->bounds().height()));
   }
 
   // Invokes DrawTree on the compositor.
   void Draw() {
     compositor()->ScheduleDraw();
     WaitForDraw();
   }
 
   void WaitForDraw() {
-    DrawWaiterForTest::Wait(compositor());
+    DrawWaiterForTest::WaitForCompositingStarted(compositor());
   }
 
   void WaitForCommit() {
     DrawWaiterForTest::WaitForCommit(compositor());
   }
 
  private:
   scoped_ptr<TestCompositorHost> compositor_host_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerWithDelegateTest);
@@ skipping 474 matching lines @@
 
   // ScheduleDraw without any visible change should cause a commit.
   observer.Reset();
   l1->ScheduleDraw();
   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();
+  WaitForSwap();
   EXPECT_TRUE(observer.notified());
 
   // So should resizing a layer.
   observer.Reset();
   l2->SetBounds(gfx::Rect(0, 0, 400, 400));
-  WaitForDraw();
+  WaitForSwap();
   EXPECT_TRUE(observer.notified());
 
   // Opacity changes should alert the observers.
   observer.Reset();
   l2->SetOpacity(0.5f);
-  WaitForDraw();
+  WaitForSwap();
   EXPECT_TRUE(observer.notified());
 
   // So should setting the opacity back.
   observer.Reset();
   l2->SetOpacity(1.0f);
-  WaitForDraw();
+  WaitForSwap();
   EXPECT_TRUE(observer.notified());
 
   // Setting the transform of a layer should alert the observers.
   observer.Reset();
   gfx::Transform transform;
   transform.Translate(200.0, 200.0);
   transform.Rotate(90.0);
   transform.Translate(-200.0, -200.0);
   l2->SetTransform(transform);
-  WaitForDraw();
+  WaitForSwap();
   EXPECT_TRUE(observer.notified());
 
   // A change resulting in an aborted swap buffer should alert the observer
   // and also signal an abort.
   observer.Reset();
   l2->SetOpacity(0.1f);
   GetCompositor()->DidAbortSwapBuffers();
-  WaitForDraw();
+  WaitForSwap();
   EXPECT_TRUE(observer.notified());
   EXPECT_TRUE(observer.aborted());
 
   GetCompositor()->RemoveObserver(&observer);
 
   // Opacity changes should no longer alert the removed observer.
   observer.Reset();
   l2->SetOpacity(0.5f);
-  WaitForDraw();
+  WaitForSwap();
 
   EXPECT_FALSE(observer.notified());
 }
 
 // Checks that modifying the hierarchy correctly affects final composite.
 TEST_F(LayerWithRealCompositorTest, ModifyHierarchy) {
   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(50, 50));
 
   // l0
   //  +-l11
@@ skipping 545 matching lines @@
 
   child->SetAnimator(LayerAnimator::CreateImplicitAnimator());
   child->SetOpacity(0.5f);
   EXPECT_TRUE(compositor()->layer_animator_collection()->HasActiveAnimators());
 
   child.reset();
   EXPECT_FALSE(compositor()->layer_animator_collection()->HasActiveAnimators());
 }
 
 }  // namespace ui