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/bind.h"
 #include "base/command_line.h"
@@ skipping 24 matching lines @@
 #include "ui/gfx/display.h"
 #include "ui/gfx/point3.h"
 #include "ui/gfx/screen.h"
 
 using std::vector;
 
 namespace aura {
 
 namespace {
 
-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 18 matching lines @@
       static_cast<Window*>(consumer) : NULL;
 }
 
 void SetLastMouseLocation(const Window* root_window,
                           const gfx::Point& location) {
   Env::GetInstance()->SetLastMouseLocation(*root_window, location);
 }
 
 }  // 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;
-}
-
 bool RootWindow::hide_host_cursor_ = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, public:
 
 RootWindow::RootWindow(const gfx::Rect& initial_bounds)
     : Window(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           host_(RootWindowHost::Create(this, initial_bounds))),
       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),
       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);
 }
 
 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 89 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 115 matching lines @@
     // 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_;
-}
-
 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);
   return host_->GrabSnapshot(snapshot_pixels, png_representation);
 }
@@ skipping 23 matching lines @@
   // 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 (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;
 
@@ skipping 556 matching lines @@
   // TODO(derat|oshima): Don't use mouse_button_flags_ as it's
   // currently broken. See/ crbug.com/107931.
   MouseEvent event(ui::ET_MOUSE_MOVED,
                    orig_mouse_location,
                    orig_mouse_location,
                    ui::EF_IS_SYNTHESIZED);
   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