Tighter sync and faster ACK on SwapBuffers/PostSubBuffers

ui/aura/root_window.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/aura/root_window.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 113 matching lines @@
       mouse_moved_handler_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           gesture_recognizer_(ui::GestureRecognizer::Create(this))),
       synthesize_mouse_move_(false),
       waiting_on_compositing_end_(false),
       draw_on_compositing_end_(false),
       defer_draw_scheduling_(false),
       mouse_move_hold_count_(0),
       should_hold_mouse_moves_(false),
       compositor_lock_(NULL),
-      draw_on_compositor_unlock_(false),
-      draw_trace_count_(0) {
+      draw_on_compositor_unlock_(false) {
   SetName("RootWindow");
   should_hold_mouse_moves_ = !CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kAuraDisableHoldMouseMoves);
 
   compositor_.reset(new ui::Compositor(this, host_->GetAcceleratedWidget()));
   DCHECK(compositor_.get());
   compositor_->AddObserver(this);
 }
 
 RootWindow::~RootWindow() {
@@ skipping 90 matching lines @@
     defer_draw_scheduling_ = false;
     return;
   }
   if (compositor_lock_) {
     draw_on_compositor_unlock_ = true;
     defer_draw_scheduling_ = false;
     return;
   }
   waiting_on_compositing_end_ = true;
 
-  TRACE_EVENT_ASYNC_BEGIN0("ui", "RootWindow::Draw", draw_trace_count_++);
+  TRACE_EVENT_ASYNC_BEGIN0("ui", "RootWindow::Draw",
+                           compositor_->last_started_id() + 1);
 
-  defer_draw_scheduling_ = false;
   compositor_->Draw(false);
 }
 
 void RootWindow::ScheduleFullDraw() {
   compositor_->ScheduleFullDraw();
 }
 
 bool RootWindow::DispatchMouseEvent(MouseEvent* event) {
   if (mouse_move_hold_count_) {
     if (event->type() == ui::ET_MOUSE_DRAGGED ||
@@ skipping 323 matching lines @@
         base::Bind(&RootWindow::Draw, schedule_paint_factory_.GetWeakPtr()));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::CompositorObserver implementation:
 
 void RootWindow::OnCompositingStarted(ui::Compositor*) {
 }
 
+void RootWindow::OnCompositingWillEnd(ui::Compositor*) {
+  defer_draw_scheduling_ = false;

[piman, 2012/06/04 18:20:39]

A possible issue with this is that if other observers want to trigger a redraw
in their own OnCompositingWillEnd callback, then the ability to do so depends on
the observer order (leading to subtle bugs...).
I was thinking of moving some of the ScheduleDraw culling logic to Compositor -
in a way, that's where it belongs - where it'd be easier to do this.

[jonathan.backer, 2012/06/05 13:35:58]

Your point is taken. It's a potential problem.

I need to cull the ScheduleDraw's for the browser prioritization in the GPU
process to land (otherwise the browser draws 2 frames for every 1 from a
renderer). I'm happy to keep this or temporarily break your aura_bench suite.

Given that kicking ACKs on OnCompositingWillEnd is inherently dangerous, I
prefer the latter (breaking aura_bench). WDYT?

+}
+
 void RootWindow::OnCompositingEnded(ui::Compositor*) {
-  TRACE_EVENT_ASYNC_END0("ui", "RootWindow::Draw", draw_trace_count_);
+  TRACE_EVENT_ASYNC_END0("ui", "RootWindow::Draw",
+                         compositor_->last_ended_id());
   waiting_on_compositing_end_ = false;
   if (draw_on_compositing_end_) {
     draw_on_compositing_end_ = false;
 
     // Call ScheduleDraw() instead of Draw() in order to allow other
     // ui::CompositorObservers to be notified before starting another
     // draw cycle.
     ScheduleDraw();
   }
 }
@@ skipping 422 matching lines @@
 void RootWindow::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   if (draw_on_compositor_unlock_) {
     draw_on_compositor_unlock_ = false;
     ScheduleDraw();
   }
 }
 
 }  // namespace aura