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() {}
-
-  // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
-    DisableTestCompositor();
-    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(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();
-  }
-
-  bool ReadPixels(SkBitmap* bitmap) {
-    return GetCompositor()->ReadPixels(bitmap,
-                                       gfx::Rect(GetCompositor()->size()));
-  }
-
-  bool WaitForDraw() {
-    DrawWaiter draw_waiter;
-    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_;
-  }
-
- private:
-  scoped_ptr<TestCompositorHost> window_;
-
-  // The root directory for test files.
-  base::FilePath test_data_directory_;
-
-  DISALLOW_COPY_AND_ASSIGN(LayerWithRealCompositorTest);
-};
-
 // LayerDelegate that paints colors to the layer.
 class TestLayerDelegate : public LayerDelegate {
  public:
   explicit TestLayerDelegate() { reset(); }
   virtual ~TestLayerDelegate() {}
 
   void AddColor(SkColor color) {
     colors_.push_back(color);
   }
 
@@ skipping 134 matching lines @@
 
   bool started_;
   bool ended_;
   bool aborted_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCompositorObserver);
 };
 
 }  // namespace
 
+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() {}
+
+  // Overridden from testing::Test:
+  virtual void SetUp() OVERRIDE {
+    DisableTestCompositor();
+    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(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();
+  }
+
+  bool WaitForDraw() {
+    return GetCompositor()->WaitForDraw();
+  }
+
+  bool ReadPixels(SkBitmap* bitmap) {
+    return GetCompositor()->ReadPixels(bitmap,
+                                       gfx::Rect(GetCompositor()->size()));
+  }
+
+  // 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_;
+  }
+
+ private:
+  scoped_ptr<TestCompositorHost> window_;
+
+  // The root directory for test files.
+  base::FilePath test_data_directory_;
+
+  DISALLOW_COPY_AND_ASSIGN(LayerWithRealCompositorTest);
+};
+
 #if defined(OS_WIN)
 // These are disabled on windows as they don't run correctly on the buildbot.
 // Reenable once we move to the real compositor.
 #define MAYBE_Delegate DISABLED_Delegate
 #define MAYBE_Draw DISABLED_Draw
 #define MAYBE_DrawTree DISABLED_DrawTree
 #define MAYBE_Hierarchy DISABLED_Hierarchy
 #define MAYBE_HierarchyNoTexture DISABLED_HierarchyNoTexture
 #define MAYBE_DrawPixels DISABLED_DrawPixels
 #define MAYBE_SetRootLayer DISABLED_SetRootLayer
@@ skipping 96 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 compositor()->WaitForDraw();
   }
 
   // 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