Aura: Make views_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"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
-#include "base/run_loop.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "cc/layers/layer.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/test/pixel_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/compositor_setup.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_sequence.h"
@@ skipping 52 matching lines @@
   }
 
   virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE {
     return base::Closure();
   }
 
  private:
   SkColor color_;
 };
 
-const int kDrawWaitTimeOutMs = 1000;
-
-class DrawWaiter : public ui::CompositorObserver {
- public:
-  DrawWaiter() : did_draw_(false) {}
-
-  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 {
       LOG(ERROR) << "Could not open test data directory.";
     }
   }
   virtual ~LayerWithRealCompositorTest() {}
@@ skipping 34 matching lines @@
     GetCompositor()->ScheduleDraw();
     WaitForDraw();
   }
 
   bool ReadPixels(SkBitmap* bitmap) {
     return GetCompositor()->ReadPixels(bitmap,
                                        gfx::Rect(GetCompositor()->size()));
   }
 
   bool WaitForDraw() {
-    DrawWaiter draw_waiter;
-    return draw_waiter.Wait(GetCompositor());
+    return ui::DrawWaiterForTest::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 271 matching lines @@
         gfx::Rect(0, 0, layer->bounds().width(), layer->bounds().height()));
   }
 
   // Invokes DrawTree on the compositor.
   void Draw() {
     compositor()->ScheduleDraw();
     WaitForDraw();
   }
 
   bool WaitForDraw() {
-    DrawWaiter draw_waiter;
-    return draw_waiter.Wait(compositor());
+    return DrawWaiterForTest::Wait(compositor());
   }
 
   // CompositorDelegate overrides.
   virtual void ScheduleDraw() OVERRIDE {
     DCHECK(!ui::Compositor::WasInitializedWithThread());
     if (compositor_) {
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&Compositor::Draw, compositor_->AsWeakPtr(), false));
     }
@@ skipping 931 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