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

ui/compositor/compositor.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 "ui/compositor/compositor.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/bind.h"
+#include "base/cancelable_callback.h"
 #include "base/command_line.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
+#include "base/run_loop.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "cc/base/switches.h"
 #include "cc/base/thread_impl.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/trees/layer_tree_host.h"
@@ skipping 73 matching lines @@
     return;
   delete g_implicit_factory;
   g_implicit_factory = NULL;
   g_context_factory = NULL;
 }
 
 }  // namespace
 
 namespace ui {
 
+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(compositor->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);
+};
+
 // static
 ContextFactory* ContextFactory::GetInstance() {
   if (!g_context_factory)
     SetupImplicitFactory();
   return g_context_factory;
 }
 
 // static
 void ContextFactory::SetInstance(ContextFactory* instance) {
   g_context_factory = instance;
@@ skipping 573 matching lines @@
     compositor_lock_ = new CompositorLock(this);
     if (g_compositor_thread)
       host_->SetDeferCommits(true);
     FOR_EACH_OBSERVER(CompositorObserver,
                       observer_list_,
                       OnCompositingLockStateChanged(this));
   }
   return compositor_lock_;
 }
 
+bool Compositor::WaitForDraw() {
+  DrawWaiter draw_waiter;
+  return draw_waiter.Wait(this);
+}
+
 void Compositor::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   if (g_compositor_thread)
     host_->SetDeferCommits(false);
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingLockStateChanged(this));
 }
 
@@ skipping 26 matching lines @@
 COMPOSITOR_EXPORT void DisableTestCompositor() {
   ResetImplicitFactory();
   g_test_compositor_enabled = false;
 }
 
 COMPOSITOR_EXPORT bool IsTestCompositorEnabled() {
   return g_test_compositor_enabled;
 }
 
 }  // namespace ui