aura: fast resizes for accelerated pages

ui/aura/root_window.h

 // 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.
 
 #ifndef UI_AURA_ROOT_WINDOW_H_
 #define UI_AURA_ROOT_WINDOW_H_
 #pragma once
 
 #include "base/basictypes.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "ui/aura/aura_export.h"
 #include "ui/aura/cursor.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/gestures/gesture_recognizer.h"
 #include "ui/aura/window.h"
 #include "ui/base/events.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/compositor_observer.h"
 #include "ui/gfx/compositor/layer_animation_observer.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/point.h"
 
 namespace gfx {
 class Size;
 }
 
 namespace ui {
 class LayerAnimationSequence;
 class Transform;
 }
 
 namespace aura {
 
+class RootWindow;
 class RootWindowHost;
 class RootWindowObserver;
 class KeyEvent;
 class MouseEvent;
 class StackingClient;
 class ScrollEvent;
 class TouchEvent;
 class GestureEvent;
 
+// This class represents a lock on the compositor, that can be used to prevent a
+// compositing pass from happening while we're waiting for an asynchronous
+// event. The typical use case is when waiting for a renderer to produce a frame
+// at the right size. The caller keeps a reference on this object, and drops the
+// reference once it desires to release the lock.
+// Note however that the lock is canceled after a short timeout to ensure
+// responsiveness of the UI, so the compositor tree should be kept in a
+// "reasonable" state while the lock is held.
+// Don't instantiate this class directly, use RootWindow::GetCompositorLock.
+class AURA_EXPORT CompositorLock :
+    public base::RefCounted<CompositorLock>,
+    public base::SupportsWeakPtr<CompositorLock> {
+ public:
+  ~CompositorLock();
+
+ private:
+  friend class RootWindow;
+
+  CompositorLock(RootWindow* root_window);
+  void CancelLock();
+
+  RootWindow* root_window_;
+  DISALLOW_COPY_AND_ASSIGN(CompositorLock);
+};
+
 // RootWindow is responsible for hosting a set of windows.
 class AURA_EXPORT RootWindow : public ui::CompositorDelegate,
                                public ui::CompositorObserver,
                                public Window,
                                public internal::FocusManager,
                                public ui::LayerAnimationObserver {
  public:
   explicit RootWindow(const gfx::Rect& initial_bounds);
   virtual ~RootWindow();
 
@@ skipping 127 matching lines @@
   // These methods are used to defer the processing of mouse events related
   // to resize. A client (typically a RenderWidgetHostViewAura) can call
   // HoldMouseMoves when an resize is initiated and then ReleaseMouseMoves
   // once the resize is completed.
   //
   // More than one hold can be invoked and each hold must be cancelled by a
   // release before we resume normal operation.
   void HoldMouseMoves();
   void ReleaseMouseMoves();
 
+  // Creates a compositor lock.
+  scoped_refptr<CompositorLock> GetCompositorLock();
+
   // Sets if the window should be focused when shown.
   void SetFocusWhenShown(bool focus_when_shown);
 
   // Overridden from Window:
   virtual RootWindow* GetRootWindow() OVERRIDE;
   virtual const RootWindow* GetRootWindow() const OVERRIDE;
   virtual void SetTransform(const ui::Transform& transform) OVERRIDE;
 
   // Overridden from ui::CompositorDelegate:
   virtual void ScheduleDraw() OVERRIDE;
 
   // Overridden from ui::CompositorObserver:
   virtual void OnCompositingStarted(ui::Compositor*) OVERRIDE;
   virtual void OnCompositingEnded(ui::Compositor*) OVERRIDE;
 
  private:
   friend class Window;
+  friend class CompositorLock;
 
   // Called whenever the mouse moves, tracks the current |mouse_moved_handler_|,
   // sending exited and entered events as its value changes.
   void HandleMouseMoved(const MouseEvent& event, Window* target);
 
   // Called whenever the |capture_window_| changes.
   // Sends capture changed events to event filters for old capture window.
   void HandleMouseCaptureChanged(Window* old_capture_window);
 
   bool ProcessMouseEvent(Window* target, MouseEvent* event);
@@ skipping 45 matching lines @@
   gfx::Rect GetInitialHostWindowBounds() const;
 
   // Posts a task to send synthesized mouse move event if there
   // is no a pending task.
   void PostMouseMoveEventAfterWindowChange();
 
   // Creates and dispatches synthesized mouse move event using the
   // current mouse location.
   void SynthesizeMouseMoveEvent();
 
+  // Called by CompositorLock.
+  void UnlockCompositor();
+
   scoped_ptr<ui::Compositor> compositor_;
 
   scoped_ptr<RootWindowHost> host_;
 
   // If set before the RootWindow is created, the cursor will be drawn within
   // the Aura root window but hidden outside of it, and it'll remain hidden
   // after the Aura window is closed.
   static bool hide_host_cursor_;
 
   // Used to schedule painting.
@@ skipping 32 matching lines @@
   bool draw_on_compositing_end_;
 
   bool defer_draw_scheduling_;
 
   // How many holds are outstanding. We try to defer dispatching mouse moves
   // while the count is > 0.
   int mouse_move_hold_count_;
   bool should_hold_mouse_moves_;
   scoped_ptr<MouseEvent> held_mouse_move_;
 
+  CompositorLock* compositor_lock_;
+  bool draw_on_compositor_unlock_;
+
   DISALLOW_COPY_AND_ASSIGN(RootWindow);
 };
 
 }  // namespace aura
 
 #endif  // UI_AURA_ROOT_WINDOW_H_