Aura: Make compositor_unittests work with --ui-enable-threaded-compositing

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/cancelable_callback.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 70 matching lines @@
   }
 
  private:
   SkColor color_;
 };
 
 const int kDrawWaitTimeOutMs = 1000;
 
 class DrawWaiter : public ui::CompositorObserver {
  public:
-  DrawWaiter() {}
+  DrawWaiter() : did_draw_(false) {}
 
-  void Wait(ui::Compositor* compositor) {
+  bool Wait(ui::Compositor* compositor) {
+    did_draw_ = false;
     compositor->AddObserver(this);
     wait_run_loop_.reset(new base::RunLoop());
     base::CancelableClosure timeout(
         base::Bind(&DrawWaiter::TimedOutWhileWaiting,
                    base::Unretained(this)));
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE, timeout.callback(),
         base::TimeDelta::FromMilliseconds(kDrawWaitTimeOutMs));
     wait_run_loop_->Run();
     compositor->RemoveObserver(this);
+    return did_draw_;
   }
 
  private:
   void TimedOutWhileWaiting() {
     LOG(ERROR) << "Timed out waiting for draw.";
     wait_run_loop_->Quit();
   }
 
   // ui::CompositorObserver implementation.
   virtual void OnCompositingDidCommit(Compositor* compositor) OVERRIDE {}
   virtual void OnCompositingStarted(Compositor* compositor,
                                     base::TimeTicks start_time) OVERRIDE {}
   virtual void OnCompositingEnded(Compositor* compositor) OVERRIDE {
+    did_draw_ = true;
     wait_run_loop_->Quit();
   }
   virtual void OnCompositingAborted(Compositor* compositor) OVERRIDE {}
   virtual void OnCompositingLockStateChanged(Compositor* compositor) OVERRIDE {}
   virtual void OnUpdateVSyncParameters(Compositor* compositor,
                                        base::TimeTicks timebase,
                                        base::TimeDelta interval) OVERRIDE {}
 
   scoped_ptr<base::RunLoop> wait_run_loop_;
+  bool did_draw_;
 
   DISALLOW_COPY_AND_ASSIGN(DrawWaiter);
 };
 
 class LayerWithRealCompositorTest : public testing::Test {
  public:
   LayerWithRealCompositorTest() {
     if (PathService::Get(gfx::DIR_TEST_DATA, &test_data_directory_)) {
       test_data_directory_ = test_data_directory_.AppendASCII("compositor");
     } else {
@@ skipping 37 matching lines @@
     GetCompositor()->SetRootLayer(root);
     GetCompositor()->ScheduleDraw();
     WaitForDraw();
   }
 
   bool ReadPixels(SkBitmap* bitmap) {
     return GetCompositor()->ReadPixels(bitmap,
                                        gfx::Rect(GetCompositor()->size()));
   }
 
-  void WaitForDraw() {
+  bool WaitForDraw() {
     DrawWaiter draw_waiter;
-    draw_waiter.Wait(GetCompositor());
+    return draw_waiter.Wait(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 222 matching lines @@
 
   l1->Add(l2.get());
   l1->Add(l4.get());
   l2->Add(l3.get());
 
   DrawTree(l1.get());
 }
 
 class LayerWithDelegateTest : public testing::Test, public CompositorDelegate {
  public:
-  LayerWithDelegateTest() : schedule_draw_invoked_(false) {}
+  LayerWithDelegateTest() {}
   virtual ~LayerWithDelegateTest() {}
 
   // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
     ui::SetupTestCompositor();
-    compositor_.reset(new Compositor(
-        this, gfx::kNullAcceleratedWidget));
+    compositor_.reset(new Compositor(this, gfx::kNullAcceleratedWidget));
     compositor_->SetScaleAndSize(1.0f, gfx::Size(1000, 1000));
   }
 
   virtual void TearDown() OVERRIDE {
   }
 
   Compositor* compositor() { return compositor_.get(); }
 
   virtual 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;
   }
 
   virtual Layer* CreateNoTextureLayer(const gfx::Rect& bounds) {
     Layer* layer = CreateLayer(LAYER_NOT_DRAWN);
     layer->SetBounds(bounds);
     return layer;
   }
 
   void DrawTree(Layer* root) {
     compositor()->SetRootLayer(root);
-    compositor()->Draw(false);
+    Draw();
   }
 
   // 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_->Draw(false);
+    compositor()->ScheduleDraw();
+    WaitForDraw();
+  }
+
+  bool WaitForDraw() {
+    DrawWaiter draw_waiter;
+    return draw_waiter.Wait(compositor());
   }
 
   // CompositorDelegate overrides.
   virtual void ScheduleDraw() OVERRIDE {
-    schedule_draw_invoked_ = true;
+    DCHECK(!ui::Compositor::WasInitializedWithThread());
+    if (compositor_) {
+      MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&Compositor::Draw, compositor_->AsWeakPtr(), false));
+    }
   }
 
- protected:
-  // Set to true when ScheduleDraw (CompositorDelegate override) is invoked.
-  bool schedule_draw_invoked_;
-
  private:
   scoped_ptr<Compositor> compositor_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerWithDelegateTest);
 };
 
 // L1
 //  +-- L2
 TEST_F(LayerWithDelegateTest, ConvertPointToLayer_Simple) {
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorRED,
@@ skipping 36 matching lines @@
   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(LayerWithRealCompositorTest, MAYBE_Delegate) {
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorBLACK,
                                         gfx::Rect(20, 20, 400, 400)));
   GetCompositor()->SetRootLayer(l1.get());
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
 
   TestLayerDelegate delegate;
   l1->set_delegate(&delegate);
   delegate.AddColor(SK_ColorWHITE);
   delegate.AddColor(SK_ColorYELLOW);
   delegate.AddColor(SK_ColorGREEN);
 
   l1->SchedulePaint(gfx::Rect(0, 0, 400, 400));
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
 
   EXPECT_EQ(delegate.color_index(), 1);
   EXPECT_EQ(delegate.paint_size(), l1->bounds().size());
 
   l1->SchedulePaint(gfx::Rect(10, 10, 200, 200));
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   EXPECT_EQ(delegate.color_index(), 2);
   EXPECT_EQ(delegate.paint_size(), gfx::Size(200, 200));
 
   l1->SchedulePaint(gfx::Rect(5, 5, 50, 50));
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   EXPECT_EQ(delegate.color_index(), 0);
   EXPECT_EQ(delegate.paint_size(), gfx::Size(50, 50));
 }
 
 TEST_F(LayerWithRealCompositorTest, MAYBE_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());
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
 
   DrawTreeLayerDelegate d1;
   l1->set_delegate(&d1);
   DrawTreeLayerDelegate d2;
   l2->set_delegate(&d2);
   DrawTreeLayerDelegate d3;
   l3->set_delegate(&d3);
 
   l2->SchedulePaint(gfx::Rect(5, 5, 5, 5));
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   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(LayerWithRealCompositorTest, MAYBE_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());
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
 
   DrawTreeLayerDelegate d2;
   l2->set_delegate(&d2);
   DrawTreeLayerDelegate d3;
   l3->set_delegate(&d3);
 
   l2->SchedulePaint(gfx::Rect(5, 5, 5, 5));
   l3->SchedulePaint(gfx::Rect(5, 5, 5, 5));
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
 
   // |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 147 matching lines @@
   EXPECT_EQ("2,3,1", GetLayerChildrenNames(*root.get()));
 }
 
 // Verifies SetBounds triggers the appropriate painting/drawing.
 TEST_F(LayerWithNullDelegateTest, SetBoundsSchedulesPaint) {
   scoped_ptr<Layer> l1(CreateTextureLayer(gfx::Rect(0, 0, 200, 200)));
   compositor()->SetRootLayer(l1.get());
 
   Draw();
 
-  schedule_draw_invoked_ = false;
   l1->SetBounds(gfx::Rect(5, 5, 200, 200));
 
   // The CompositorDelegate (us) should have been told to draw for a move.
-  EXPECT_TRUE(schedule_draw_invoked_);
+  EXPECT_TRUE(WaitForDraw());
 
-  schedule_draw_invoked_ = false;
   l1->SetBounds(gfx::Rect(5, 5, 100, 100));
 
   // The CompositorDelegate (us) should have been told to draw for a resize.
-  EXPECT_TRUE(schedule_draw_invoked_);
+  EXPECT_TRUE(WaitForDraw());
 }
 
 // Checks that pixels are actually drawn to the screen with a read back.
 // Currently disabled on all platforms, see http://crbug.com/148709.
 TEST_F(LayerWithRealCompositorTest, MAYBE_DrawPixels) {
   scoped_ptr<Layer> layer(CreateColorLayer(SK_ColorRED,
                                            gfx::Rect(0, 0, 500, 500)));
   scoped_ptr<Layer> layer2(CreateColorLayer(SK_ColorBLUE,
                                             gfx::Rect(0, 0, 500, 10)));
 
@@ skipping 60 matching lines @@
   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.
   observer.Reset();
   l1->ScheduleDraw();
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   EXPECT_TRUE(observer.notified());
 
   // Moving, but not resizing, a layer should alert the observers.
   observer.Reset();
   l2->SetBounds(gfx::Rect(0, 0, 350, 350));
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   EXPECT_TRUE(observer.notified());
 
   // So should resizing a layer.
   observer.Reset();
   l2->SetBounds(gfx::Rect(0, 0, 400, 400));
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   EXPECT_TRUE(observer.notified());
 
   // Opacity changes should alert the observers.
   observer.Reset();
   l2->SetOpacity(0.5f);
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   EXPECT_TRUE(observer.notified());
 
   // So should setting the opacity back.
   observer.Reset();
   l2->SetOpacity(1.0f);
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   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();
+  EXPECT_TRUE(WaitForDraw());
   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()->OnSwapBuffersAborted();
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   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();
+  EXPECT_TRUE(WaitForDraw());
 
   EXPECT_FALSE(observer.notified());
 }
 
 // Checks that modifying the hierarchy correctly affects final composite.
 TEST_F(LayerWithRealCompositorTest, MAYBE_ModifyHierarchy) {
   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(50, 50));
 
   // l0
   //  +-l11
@@ skipping 138 matching lines @@
                                           gfx::Rect(0, 0, 500, 500)));
   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());
-  schedule_draw_invoked_ = false;
   child->SchedulePaint(gfx::Rect(0, 0, 20, 20));
   child_delegate.GetPaintCountAndClear();
-  EXPECT_TRUE(schedule_draw_invoked_);
-  schedule_draw_invoked_ = false;
+
   // Set a rect so that when OnPaintLayer() is invoked SchedulePaint is invoked
   // again.
   child_delegate.SetSchedulePaintRect(gfx::Rect(10, 10, 30, 30));
-  DrawTree(root.get());
+  EXPECT_TRUE(WaitForDraw());
   // |child| should have been painted once.
   EXPECT_EQ(1, child_delegate.GetPaintCountAndClear());
-  // ScheduleDraw() should have been invoked.
-  EXPECT_TRUE(schedule_draw_invoked_);
+
   // Because SchedulePaint() was invoked from OnPaintLayer() |child| should
   // still need to be painted.
-  DrawTree(root.get());
+  EXPECT_TRUE(WaitForDraw());
   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);
   root->set_delegate(&root_delegate);
 
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorWHITE,
                                         gfx::Rect(10, 20, 140, 180)));
   TestLayerDelegate l1_delegate;
   l1_delegate.AddColor(SK_ColorWHITE);
   l1->set_delegate(&l1_delegate);
 
   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(500, 500));
   GetCompositor()->SetRootLayer(root.get());
   root->Add(l1.get());
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
 
   EXPECT_EQ("10,20 200x220", root->bounds().ToString());
   EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
   gfx::Size size_in_pixel = root->cc_layer()->bounds();
   EXPECT_EQ("200x220", size_in_pixel.ToString());
   size_in_pixel = l1->cc_layer()->bounds();
   EXPECT_EQ("140x180", size_in_pixel.ToString());
   // No scale change, so no scale notification.
   EXPECT_EQ(0.0f, root_delegate.device_scale_factor());
   EXPECT_EQ(0.0f, l1_delegate.device_scale_factor());
 
   EXPECT_EQ("200x220", root_delegate.paint_size().ToString());
   EXPECT_EQ("140x180", l1_delegate.paint_size().ToString());
 
   // Scale up to 2.0. Changing scale doesn't change the bounds in DIP.
   GetCompositor()->SetScaleAndSize(2.0f, gfx::Size(500, 500));
   EXPECT_EQ("10,20 200x220", root->bounds().ToString());
   EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
   // Pixel size must have been scaled up.
   size_in_pixel = root->cc_layer()->bounds();
   EXPECT_EQ("400x440", size_in_pixel.ToString());
   size_in_pixel = l1->cc_layer()->bounds();
   EXPECT_EQ("280x360", size_in_pixel.ToString());
   // New scale factor must have been notified.
   EXPECT_EQ(2.0f, root_delegate.device_scale_factor());
   EXPECT_EQ(2.0f, l1_delegate.device_scale_factor());
 
   // Canvas size must have been scaled down up.
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   EXPECT_EQ("400x440", root_delegate.paint_size().ToString());
   EXPECT_EQ("2.0 2.0", root_delegate.ToScaleString());
   EXPECT_EQ("280x360", l1_delegate.paint_size().ToString());
   EXPECT_EQ("2.0 2.0", l1_delegate.ToScaleString());
 
   // Scale down back to 1.0f.
   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(500, 500));
   EXPECT_EQ("10,20 200x220", root->bounds().ToString());
   EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
   // Pixel size must have been scaled down.
   size_in_pixel = root->cc_layer()->bounds();
   EXPECT_EQ("200x220", size_in_pixel.ToString());
   size_in_pixel = l1->cc_layer()->bounds();
   EXPECT_EQ("140x180", size_in_pixel.ToString());
   // New scale factor must have been notified.
   EXPECT_EQ(1.0f, root_delegate.device_scale_factor());
   EXPECT_EQ(1.0f, l1_delegate.device_scale_factor());
 
   // Canvas size must have been scaled down too.
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   EXPECT_EQ("200x220", root_delegate.paint_size().ToString());
   EXPECT_EQ("1.0 1.0", root_delegate.ToScaleString());
   EXPECT_EQ("140x180", l1_delegate.paint_size().ToString());
   EXPECT_EQ("1.0 1.0", l1_delegate.ToScaleString());
 
   root_delegate.reset();
   l1_delegate.reset();
   // Just changing the size shouldn't notify the scale change nor
   // trigger repaint.
   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(1000, 1000));
   // No scale change, so no scale notification.
   EXPECT_EQ(0.0f, root_delegate.device_scale_factor());
   EXPECT_EQ(0.0f, l1_delegate.device_scale_factor());
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   EXPECT_EQ("0x0", root_delegate.paint_size().ToString());
   EXPECT_EQ("0.0 0.0", root_delegate.ToScaleString());
   EXPECT_EQ("0x0", l1_delegate.paint_size().ToString());
   EXPECT_EQ("0.0 0.0", l1_delegate.ToScaleString());
 }
 
 TEST_F(LayerWithRealCompositorTest, MAYBE_ScaleReparent) {
   scoped_ptr<Layer> root(CreateColorLayer(SK_ColorWHITE,
                                           gfx::Rect(10, 20, 200, 220)));
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorWHITE,
                                         gfx::Rect(10, 20, 140, 180)));
   TestLayerDelegate l1_delegate;
   l1_delegate.AddColor(SK_ColorWHITE);
   l1->set_delegate(&l1_delegate);
 
   GetCompositor()->SetScaleAndSize(1.0f, gfx::Size(500, 500));
   GetCompositor()->SetRootLayer(root.get());
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
 
   root->Add(l1.get());
   EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
   gfx::Size size_in_pixel = l1->cc_layer()->bounds();
   EXPECT_EQ("140x180", size_in_pixel.ToString());
   EXPECT_EQ(0.0f, l1_delegate.device_scale_factor());
 
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   EXPECT_EQ("140x180", l1_delegate.paint_size().ToString());
   EXPECT_EQ("1.0 1.0", l1_delegate.ToScaleString());
 
   // Remove l1 from root and change the scale.
   root->Remove(l1.get());
   EXPECT_EQ(NULL, l1->parent());
   EXPECT_EQ(NULL, l1->GetCompositor());
   GetCompositor()->SetScaleAndSize(2.0f, gfx::Size(500, 500));
   // Sanity check on root and l1.
   EXPECT_EQ("10,20 200x220", root->bounds().ToString());
   size_in_pixel = l1->cc_layer()->bounds();
   EXPECT_EQ("140x180", size_in_pixel.ToString());
 
 
   root->Add(l1.get());
   EXPECT_EQ("10,20 140x180", l1->bounds().ToString());
   size_in_pixel = l1->cc_layer()->bounds();
   EXPECT_EQ("280x360", size_in_pixel.ToString());
   EXPECT_EQ(2.0f, l1_delegate.device_scale_factor());
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   EXPECT_EQ("280x360", l1_delegate.paint_size().ToString());
   EXPECT_EQ("2.0 2.0", l1_delegate.ToScaleString());
 }
 
 // Tests layer::set_scale_content(false).
 TEST_F(LayerWithRealCompositorTest, MAYBE_NoScaleCanvas) {
   scoped_ptr<Layer> root(CreateColorLayer(SK_ColorWHITE,
                                           gfx::Rect(10, 20, 200, 220)));
   scoped_ptr<Layer> l1(CreateColorLayer(SK_ColorWHITE,
                                         gfx::Rect(10, 20, 140, 180)));
   l1->set_scale_content(false);
   root->Add(l1.get());
   TestLayerDelegate l1_delegate;
   l1_delegate.AddColor(SK_ColorWHITE);
   l1->set_delegate(&l1_delegate);
 
   GetCompositor()->SetScaleAndSize(2.0f, gfx::Size(500, 500));
   GetCompositor()->SetRootLayer(root.get());
   // Scale factor change is notified regardless of scale_content flag.
   EXPECT_EQ(2.0f, l1_delegate.device_scale_factor());
 
-  WaitForDraw();
+  EXPECT_TRUE(WaitForDraw());
   EXPECT_EQ("280x360", l1_delegate.paint_size().ToString());
   EXPECT_EQ("1.0 1.0", l1_delegate.ToScaleString());
 }
 
 // Verifies that when changing bounds on a layer that is invisible, and then
 // made visible, the right thing happens:
 // - if just a move, then no painting should happen.
 // - if a resize, the layer should be repainted.
 TEST_F(LayerWithDelegateTest, SetBoundsWhenInvisible) {
   scoped_ptr<Layer> root(CreateNoTextureLayer(gfx::Rect(0, 0, 1000, 1000)));
 
   scoped_ptr<Layer> child(CreateLayer(LAYER_TEXTURED));
   child->SetBounds(gfx::Rect(0, 0, 500, 500));
   DrawTreeLayerDelegate delegate;
   child->set_delegate(&delegate);
   root->Add(child.get());
 
   // Paint once for initial damage.
   child->SetVisible(true);
   DrawTree(root.get());
 
   // Reset into invisible state.
   child->SetVisible(false);
   DrawTree(root.get());
-  schedule_draw_invoked_ = false;
   delegate.Reset();
 
   // Move layer.
   child->SetBounds(gfx::Rect(200, 200, 500, 500));
   child->SetVisible(true);
-  EXPECT_TRUE(schedule_draw_invoked_);
+  EXPECT_TRUE(WaitForDraw());
   DrawTree(root.get());
   EXPECT_FALSE(delegate.painted());
 
   // Reset into invisible state.
   child->SetVisible(false);
   DrawTree(root.get());
-  schedule_draw_invoked_ = false;
   delegate.Reset();
 
   // Resize layer.
   child->SetBounds(gfx::Rect(200, 200, 400, 400));
   child->SetVisible(true);
-  EXPECT_TRUE(schedule_draw_invoked_);
+  EXPECT_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