Unified OutputSurface::SwapBuffers.

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"
@@ skipping 341 matching lines @@
 void CompositorLock::CancelLock() {
   if (!compositor_)
     return;
   compositor_->UnlockCompositor();
   compositor_ = NULL;
 }
 
 // static
 void DrawWaiterForTest::Wait(Compositor* compositor) {
   DrawWaiterForTest waiter;
+  waiter.wait_for_commit_ = false;
   waiter.WaitImpl(compositor);
 }
 
+// static
+void DrawWaiterForTest::WaitForCommit(Compositor* compositor) {
+  DrawWaiterForTest waiter;
+  waiter.wait_for_commit_ = true;
+  waiter.WaitImpl(compositor);
+}
+
 DrawWaiterForTest::DrawWaiterForTest() {
 }
 
 DrawWaiterForTest::~DrawWaiterForTest() {
 }
 
 void DrawWaiterForTest::WaitImpl(Compositor* compositor) {
   compositor->AddObserver(this);
   wait_run_loop_.reset(new base::RunLoop());
   wait_run_loop_->Run();
   compositor->RemoveObserver(this);
 }
 
 void DrawWaiterForTest::OnCompositingDidCommit(Compositor* compositor) {
+  if (wait_for_commit_)
+    wait_run_loop_->Quit();
 }
 
 void DrawWaiterForTest::OnCompositingStarted(Compositor* compositor,
                                              base::TimeTicks start_time) {
 }
 
 void DrawWaiterForTest::OnCompositingEnded(Compositor* compositor) {
-  wait_run_loop_->Quit();
+  if (!wait_for_commit_)
+    wait_run_loop_->Quit();
 }
 
 void DrawWaiterForTest::OnCompositingAborted(Compositor* compositor) {
 }
 
 void DrawWaiterForTest::OnCompositingLockStateChanged(Compositor* compositor) {
 }
 
 void DrawWaiterForTest::OnUpdateVSyncParameters(Compositor* compositor,
                                                 base::TimeTicks timebase,
@@ skipping 354 matching lines @@
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingDidCommit(this));
 }
 
 void Compositor::DidCommitAndDrawFrame() {
   base::TimeTicks start_time = base::TimeTicks::Now();
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingStarted(this, start_time));
-  // If we're threaded without a swap complete callback, we have to
-  // call DidCompleteSwapBuffersManually.
-  if (g_compositor_thread &&
-      !host_->GetRendererCapabilities().using_swap_complete_callback)
-    DidCompleteSwapBuffers();
 }
 
 void Compositor::DidCompleteSwapBuffers() {
   DCHECK(g_compositor_thread);
   NotifyEnd();
 }
 
 void Compositor::ScheduleComposite() {
   if (!disable_schedule_composite_)
     ScheduleDraw();
@@ skipping 70 matching lines @@
 COMPOSITOR_EXPORT void DisableTestCompositor() {
   ResetImplicitFactory();
   g_test_compositor_enabled = false;
 }
 
 COMPOSITOR_EXPORT bool IsTestCompositorEnabled() {
   return g_test_compositor_enabled;
 }
 
 }  // namespace ui