Aura: Resize locks with --ui-enable-threaded-compositing

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/auto_reset.h"
 #include "base/bind.h"
@@ skipping 32 matching lines @@
 
 using std::vector;
 
 namespace aura {
 
 namespace {
 
 const char kRootWindowForAcceleratedWidget[] =
     "__AURA_ROOT_WINDOW_ACCELERATED_WIDGET__";
 
-const int kCompositorLockTimeoutMs = 67;
-
 // Returns true if |target| has a non-client (frame) component at |location|,
 // in window coordinates.
 bool IsNonClientLocation(Window* target, const gfx::Point& location) {
   if (!target->delegate())
     return false;
   int hit_test_code = target->delegate()->GetNonClientComponent(location);
   return hit_test_code != HTCLIENT && hit_test_code != HTNOWHERE;
 }
 
 typedef std::vector<EventFilter*> EventFilters;
@@ skipping 24 matching lines @@
 RootWindowHost* CreateHost(RootWindow* root_window,
                            const RootWindow::CreateParams& params) {
   RootWindowHost* host = params.host ?
       params.host : RootWindowHost::Create(params.initial_bounds);
   host->SetDelegate(root_window);
   return host;
 }
 
 }  // namespace
 
-CompositorLock::CompositorLock(RootWindow* root_window)
-    : root_window_(root_window) {
-  MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&CompositorLock::CancelLock, AsWeakPtr()),
-      base::TimeDelta::FromMilliseconds(kCompositorLockTimeoutMs));
-}
-
-CompositorLock::~CompositorLock() {
-  CancelLock();
-}
-
-void CompositorLock::CancelLock() {
-  if (!root_window_)
-    return;
-  root_window_->UnlockCompositor();
-  root_window_ = NULL;
-}
-
 RootWindow::CreateParams::CreateParams(const gfx::Rect& a_initial_bounds)
     : initial_bounds(a_initial_bounds),
       host(NULL) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, public:
 
 RootWindow::RootWindow(const CreateParams& params)
     : Window(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(host_(CreateHost(this, params))),
       ALLOW_THIS_IN_INITIALIZER_LIST(schedule_paint_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(event_factory_(this)),
       mouse_button_flags_(0),
       touch_ids_down_(0),
       last_cursor_(ui::kCursorNull),
       mouse_pressed_handler_(NULL),
       mouse_moved_handler_(NULL),
       mouse_event_dispatch_target_(NULL),
       event_dispatch_target_(NULL),
       focus_manager_(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),
-      ALLOW_THIS_IN_INITIALIZER_LIST(held_mouse_event_factory_(this)),
-      compositor_lock_(NULL),
-      draw_on_compositor_unlock_(false) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(held_mouse_event_factory_(this)) {
   SetName("RootWindow");
 
   compositor_.reset(new ui::Compositor(this, host_->GetAcceleratedWidget()));
   DCHECK(compositor_.get());
   compositor_->AddObserver(this);
 
   prop_.reset(new ui::ViewProp(host_->GetAcceleratedWidget(),
                                kRootWindowForAcceleratedWidget,
                                this));
 }
 
 RootWindow::~RootWindow() {
-  if (compositor_lock_) {
-    // No need to schedule a draw, we're going away.
-    draw_on_compositor_unlock_ = 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 101 matching lines @@
   // being used in fullscreen mode, so root_window bounds = window bounds.
   return host_->ConfineCursorToRootWindow();
 }
 
 void RootWindow::Draw() {
   defer_draw_scheduling_ = false;
   if (waiting_on_compositing_end_) {
     draw_on_compositing_end_ = true;
     return;
   }
-  if (compositor_lock_) {
-    draw_on_compositor_unlock_ = true;
-    return;
-  }
   waiting_on_compositing_end_ = true;
 
   TRACE_EVENT_ASYNC_BEGIN0("ui", "RootWindow::Draw",
                            compositor_->last_started_frame() + 1);
 
   compositor_->Draw(false);
 }
 
 void RootWindow::ScheduleFullDraw() {
   compositor_->ScheduleFullDraw();
@@ skipping 109 matching lines @@
 }
 
 void RootWindow::ToggleFullScreen() {
   host_->ToggleFullScreen();
 }
 
 void RootWindow::HoldMouseMoves() {
   if (!mouse_move_hold_count_)
     held_mouse_event_factory_.InvalidateWeakPtrs();
   ++mouse_move_hold_count_;
+  TRACE_EVENT_ASYNC_BEGIN0("ui", "RootWindow::HoldMouseMoves", this);
 }
 
 void RootWindow::ReleaseMouseMoves() {
   --mouse_move_hold_count_;
   DCHECK_GE(mouse_move_hold_count_, 0);
   if (!mouse_move_hold_count_ && held_mouse_move_.get()) {
     // We don't want to call DispatchHeldMouseMove directly, because this might
     // be called from a deep stack while another event, in which case
     // dispatching another one may not be safe/expected.
     // Instead we post a task, that we may cancel if HoldMouseMoves is called
     // again before it executes.
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&RootWindow::DispatchHeldMouseMove,
                    held_mouse_event_factory_.GetWeakPtr()));
   }
-}
-
-scoped_refptr<CompositorLock> RootWindow::GetCompositorLock() {
-  if (!compositor_lock_)
-    compositor_lock_ = new CompositorLock(this);
-  return compositor_lock_;
+  TRACE_EVENT_ASYNC_END0("ui", "RootWindow::HoldMouseMoves", this);
 }
 
 void RootWindow::SetFocusWhenShown(bool focused) {
   host_->SetFocusWhenShown(focused);
 }
 
 bool RootWindow::GrabSnapshot(const gfx::Rect& snapshot_bounds,
                               std::vector<unsigned char>* png_representation) {
   DCHECK(bounds().Contains(snapshot_bounds));
   gfx::Rect snapshot_pixels = ui::ConvertRectToPixel(layer(), snapshot_bounds);
@@ skipping 32 matching lines @@
 // RootWindow, ui::EventTarget implementation:
 
 ui::EventTarget* RootWindow::GetParentTarget() {
   return Env::GetInstance();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::CompositorDelegate implementation:
 
 void RootWindow::ScheduleDraw() {
-  if (compositor_lock_) {
-    draw_on_compositor_unlock_ = true;
-  } else if (!defer_draw_scheduling_) {
+  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:
 
 void RootWindow::OnCompositingDidCommit(ui::Compositor*) {
 }
 
-void RootWindow::OnCompositingWillStart(ui::Compositor*) {
-}
-
 void RootWindow::OnCompositingStarted(ui::Compositor*) {
 }
 
 void RootWindow::OnCompositingEnded(ui::Compositor*) {
   TRACE_EVENT_ASYNC_END0("ui", "RootWindow::Draw",
                          compositor_->last_ended_frame());
   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();
   }
 }
 
 void RootWindow::OnCompositingAborted(ui::Compositor*) {
 }
 
+void RootWindow::OnCompositingLockStateChanged(ui::Compositor*) {
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::LayerDelegate implementation:
 
 void RootWindow::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
   const bool cursor_is_in_bounds =
       GetBoundsInScreen().Contains(Env::GetInstance()->last_mouse_location());
   bool cursor_visible = false;
   client::CursorClient* cursor_client = client::GetCursorClient(this);
   if (cursor_is_in_bounds && cursor_client) {
@@ skipping 517 matching lines @@
   // currently broken. See/ crbug.com/107931.
   ui::MouseEvent event(ui::ET_MOUSE_MOVED,
                        orig_mouse_location,
                        orig_mouse_location,
                        ui::EF_IS_SYNTHESIZED);
   event.set_system_location(Env::GetInstance()->last_mouse_location());
   OnHostMouseEvent(&event);
 #endif
 }
 
-void RootWindow::UnlockCompositor() {
-  DCHECK(compositor_lock_);
-  compositor_lock_ = NULL;
-  if (draw_on_compositor_unlock_) {
-    draw_on_compositor_unlock_ = false;
-    ScheduleDraw();
-  }
-}
-
 }  // namespace aura