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

content/browser/renderer_host/render_widget_host_view_aura.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 CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_
 
 #include <map>
+#include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/renderer_host/image_transport_factory.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/common/content_export.h"
 #include "ui/aura/client/activation_delegate.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/compositor/compositor_observer.h"
 #include "ui/gfx/rect.h"
 #include "webkit/glue/webcursor.h"
 
 namespace aura {
 class CompositorLock;
 }
 
 namespace gfx {
 class Canvas;
 }
 
 namespace ui {
+class CompositorLock;
 class InputMethod;
 class Texture;
 }
 
 namespace WebKit {
 class WebTouchEvent;
 }
 
 namespace content {
 class RenderWidgetHostImpl;
@@ skipping 143 matching lines @@
   friend class RenderWidgetHostView;
 
   // Should construct only via RenderWidgetHostView::CreateViewForWidget.
   explicit RenderWidgetHostViewAura(RenderWidgetHost* host);
 
  private:
   class WindowObserver;
   friend class WindowObserver;
 
   // Overridden from ui::CompositorObserver:
-  virtual void OnCompositingDidCommit(ui::Compositor* compositor) OVERRIDE;
-  virtual void OnCompositingWillStart(ui::Compositor* compositor) OVERRIDE;
   virtual void OnCompositingStarted(ui::Compositor* compositor) OVERRIDE;
   virtual void OnCompositingEnded(ui::Compositor* compositor) OVERRIDE;
   virtual void OnCompositingAborted(ui::Compositor* compositor) OVERRIDE;
 
   // Overridden from ImageTransportFactoryObserver:
   virtual void OnLostResources(ui::Compositor* compositor) OVERRIDE;
 
   virtual ~RenderWidgetHostViewAura();
 
   void UpdateCursorIfOverSelf();
   void UpdateExternalTexture();
+
+  // Given the size of the latest accelerated surface from the renderer,
+  // deactivate and remove spent locks.
+  void UpdateResizeLocks(const gfx::Size& surface_size_in_dip);
+
+  // Returns true if no pending resize locks have timed-out and
+  // there is more than one active resize lock pending.
+  bool CanFastTrackACK(const gfx::Size& surface_size_in_dip);
+
   ui::InputMethod* GetInputMethod() const;
 
   // Returns whether the widget needs an input grab to work properly.
   bool NeedsInputGrab();
 
   // Confirm existing composition text in the webpage and ask the input method
   // to cancel its ongoing composition session.
   void FinishImeCompositionSession();
 
   // This method computes movementX/Y and keeps track of mouse location for
   // mouse lock on all mouse move events.
   void ModifyEventMovementAndCoords(WebKit::WebMouseEvent* event);
 
   // If |clip| is non-empty and and doesn't contain |rect| or |clip| is empty
   // SchedulePaint() is invoked for |rect|.
   void SchedulePaintIfNotInClip(const gfx::Rect& rect, const gfx::Rect& clip);
 
   // Helper method to determine if, in mouse locked mode, the cursor should be
   // moved to center.
   bool ShouldMoveToCenter();
 
-  // Run the compositing callbacks.
-  void RunCompositingDidCommitCallbacks(ui::Compositor* compositor);
-  void RunCompositingWillStartCallbacks(ui::Compositor* compositor);
+  void RunCompositingStartedCallbacks(ui::Compositor* compositor);
+
+  // Add a callback that waits for a commit and the start of a draw.
+  void AddCompositingStartedCallback(
+      base::Callback<void(ui::Compositor*)> callback);
 
   // Insert a sync point into the compositor's command stream and acknowledge
   // that we have presented the accelerated surface buffer.
   static void InsertSyncPointAndACK(int32 route_id,
                                     int gpu_host_id,
                                     ui::Compositor* compositor);
 
   // Called when window_ is removed from the window tree.
   void RemovingFromRootWindow();
 
@@ skipping 65 matching lines @@
 
   // Indicates if there is onging composition text.
   bool has_composition_text_;
 
   // Current tooltip text.
   string16 tooltip_;
 
   std::vector< base::Callback<void(ui::Compositor*)> >
       on_compositing_did_commit_callbacks_;
 
-  std::vector< base::Callback<void(ui::Compositor*)> >
-      on_compositing_will_start_callbacks_;
+  typedef std::pair<int, base::Callback<void(ui::Compositor*)> >
+      CommitIdAndCallback;
+  std::vector<CommitIdAndCallback> on_compositing_started_callbacks_;
 
   std::map<uint64, scoped_refptr<ui::Texture> >
       image_transport_clients_;
 
   uint64 current_surface_;
 
   // Protected means that the |current_surface_| may be in use by ui and cannot
   // be safely discarded. Things to consider are thumbnailer, compositor draw,
   // and tab visibility.
   bool current_surface_is_protected_;
@@ skipping 34 matching lines @@
 
   // Used to prevent further resizes while a resize is pending.
   class ResizeLock;
   // These locks are the ones waiting for a texture of the right size to come
   // back from the renderer/GPU process.
   std::vector<linked_ptr<ResizeLock> > resize_locks_;
   // These locks are the ones waiting for a frame to be drawn.
   std::vector<linked_ptr<ResizeLock> > locks_pending_draw_;
 
   // This lock is for waiting for a front surface to become available to draw.
-  scoped_refptr<aura::CompositorLock> released_front_lock_;
+  scoped_refptr<ui::CompositorLock> released_front_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAura);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_