aura: fast resizes for accelerated pages

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 35 matching lines @@
 typedef std::vector<EventFilter*> EventFilters;
 
 void GetEventFiltersToNotify(Window* target, EventFilters* filters) {
   while (target) {
     if (target->event_filter())
       filters->push_back(target->event_filter());
     target = target->parent();
   }
 }
 
+const int kCompositorLockTimeoutMs = 67;
+
 }  // namespace
 
+CompositorLock::CompositorLock(RootWindow* root_window)
+    : root_window_(root_window) {
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CompositorLock::CancelLock, AsWeakPtr()),
+      kCompositorLockTimeoutMs);
+}
+
+CompositorLock::~CompositorLock() {
+  CancelLock();
+}
+
+void CompositorLock::CancelLock() {
+  if (!root_window_)
+    return;
+  root_window_->UnlockCompositor();

[jonathan.backer, 2012/03/23 15:48:00]

I think that you want to "root_window_ = NULL" here.

[piman, 2012/03/23 17:41:09]

Thanks for paying attention! You're absolutely right, I had it originally and
then I lost it when moving stuff around.
Fixed.

+}
+
 bool RootWindow::hide_host_cursor_ = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, public:
 
 RootWindow::RootWindow(const gfx::Rect& initial_bounds)
     : Window(NULL),
       host_(aura::RootWindowHost::Create(initial_bounds)),
       ALLOW_THIS_IN_INITIALIZER_LIST(schedule_paint_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(event_factory_(this)),
       mouse_button_flags_(0),
       last_cursor_(kCursorNull),
       cursor_shown_(true),
       capture_window_(NULL),
       mouse_pressed_handler_(NULL),
       mouse_moved_handler_(NULL),
       focused_window_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           gesture_recognizer_(GestureRecognizer::Create())),
       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) {
+      should_hold_mouse_moves_(false),
+      compositor_lock_(NULL),
+      scheduled_while_locked_(false) {
   SetName("RootWindow");
   last_mouse_location_ = host_->QueryMouseLocation();
 
   should_hold_mouse_moves_ = !CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kAuraDisableHoldMouseMoves);
 
   compositor_.reset(new ui::Compositor(this, host_->GetAcceleratedWidget(),
       host_->GetBounds().size()));
   DCHECK(compositor_.get());
   compositor_->AddObserver(this);
   Init();
 }
 
 RootWindow::~RootWindow() {
+  if (compositor_lock_) {
+    // No need to schedule a draw, we're going away.
+    scheduled_while_locked_ = false;
+    compositor_lock_->CancelLock();
+    DCHECK(!compositor_lock_);
+  }
   compositor_->RemoveObserver(this);
   // Make sure to destroy the compositor before terminating so that state is
   // cleared and we don't hit asserts.
   compositor_.reset();
 
   // Tear down in reverse.  Frees any references held by the host.
   host_.reset(NULL);
 
   // An observer may have been added by an animation on the RootWindow.
   layer()->GetAnimator()->RemoveObserver(this);
@@ skipping 48 matching lines @@
   // being used in fullscreen mode, so root_window bounds = window bounds.
   return host_->ConfineCursorToRootWindow();
 }
 
 void RootWindow::Draw() {
   if (waiting_on_compositing_end_) {
     draw_on_compositing_end_ = true;
     defer_draw_scheduling_ = false;
     return;
   }
+  if (compositor_lock_) {
+    scheduled_while_locked_ = true;

[jonathan.backer, 2012/03/23 15:48:00]

nit: is it conceivable that the draw task had been posted prior to the lock?

how about draw_on_compositor_unlock_ ?

[piman, 2012/03/23 17:41:09]

Yes (imagine a caller doing ScheduleDraw() then GetCompositorLock() right away),
which is what this code catches.
Done.

+    defer_draw_scheduling_ = false;
+    return;
+  }
   waiting_on_compositing_end_ = true;
 
   compositor_->Draw(false);
   defer_draw_scheduling_ = false;
 }
 
 void RootWindow::ScheduleFullDraw() {
   compositor_->ScheduleFullDraw();
 }
 
@@ skipping 212 matching lines @@
 
 void RootWindow::ReleaseMouseMoves() {
   if (should_hold_mouse_moves_) {
     --mouse_move_hold_count_;
     DCHECK_GE(mouse_move_hold_count_, 0);
     if (!mouse_move_hold_count_)
       DispatchHeldMouseMove();
   }
 }
 
+scoped_refptr<CompositorLock> RootWindow::GetCompositorLock() {
+  if (!compositor_lock_)
+    compositor_lock_ = new CompositorLock(this);
+  return compositor_lock_;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, Window overrides:
 
 RootWindow* RootWindow::GetRootWindow() {
   return this;
 }
 
 const RootWindow* RootWindow::GetRootWindow() const {
   return this;
 }
 
 void RootWindow::SetTransform(const ui::Transform& transform) {
   Window::SetTransform(transform);
 
   // If the layer is not animating, then we need to update the host size
   // immediately.
   if (!layer()->GetAnimator()->is_animating())
     OnHostResized(host_->GetBounds().size());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::CompositorDelegate implementation:
 
 void RootWindow::ScheduleDraw() {
-  if (!defer_draw_scheduling_) {
+  if (compositor_lock_) {
+    scheduled_while_locked_ = true;
+  } else if (!defer_draw_scheduling_) {
     defer_draw_scheduling_ = true;
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&RootWindow::Draw, schedule_paint_factory_.GetWeakPtr()));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::CompositorObserver implementation:
 
@@ skipping 376 matching lines @@
   // TODO(derat|oshima): Don't use mouse_button_flags_ as it's
   // is currently broken. See/ crbug.com/107931.
   MouseEvent event(ui::ET_MOUSE_MOVED,
                    orig_mouse_location,
                    orig_mouse_location,
                    ui::EF_IS_SYNTHESIZED);
   DispatchMouseEvent(&event);
 #endif
 }
 
+void RootWindow::UnlockCompositor() {
+  DCHECK(compositor_lock_);
+  compositor_lock_ = NULL;
+  if (scheduled_while_locked_) {
+    scheduled_while_locked_ = false;
+    ScheduleDraw();
+  }
+}
+
 }  // namespace aura