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 <vector>
 
 #include "base/callback.h"
 #include "base/gtest_prod_util.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;
 class WindowTracker;
 }
 
 namespace gfx {
 class Canvas;
 }
 
 namespace ui {
+class CompositorLock;
 class InputMethod;
 class Texture;
 }
 
 namespace content {
 class RenderWidgetHostImpl;
 class RenderWidgetHostView;
 
 // RenderWidgetHostView class hierarchy described in render_widget_host_view.h.
 class RenderWidgetHostViewAura
@@ skipping 153 matching lines @@
   explicit RenderWidgetHostViewAura(RenderWidgetHost* host);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, TouchEventState);
 
   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;
+  virtual void OnCompositingLockStateChanged(
+      ui::Compositor* compositor) OVERRIDE;
 
   // Overridden from ImageTransportFactoryObserver:
   virtual void OnLostResources() OVERRIDE;
 
   virtual ~RenderWidgetHostViewAura();
 
   void UpdateCursorIfOverSelf();
+  bool ShouldFastACK(uint64 surface_id);
   void UpdateExternalTexture();
   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);
 
   // 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,
+                                    bool presented,
                                     ui::Compositor* compositor);
 
   // Called when window_ is removed from the window tree.
   void RemovingFromRootWindow();
 
   // After clearing |current_surface_|, and waiting for the compositor to finish
   // using it, call this to inform the gpu process.
   void SetSurfaceNotInUseByCompositor(ui::Compositor* compositor);
 
   // This is called every time |current_surface_| usage changes (by thumbnailer,
@@ skipping 63 matching lines @@
 
   // Current tooltip text.
   string16 tooltip_;
 
   // The scale factor of the display the renderer is currently on.
   float device_scale_factor_;
 
   std::vector< base::Callback<void(ui::Compositor*)> >
       on_compositing_did_commit_callbacks_;
 
-  std::vector< base::Callback<void(ui::Compositor*)> >
-      on_compositing_will_start_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_;
   bool current_surface_in_use_by_compositor_;
@@ skipping 26 matching lines @@
   // events vs. normal mouse move events.
   bool synthetic_move_sent_;
 
   // Signals that the accelerated compositing has been turned on or off.
   // This is used to signal to turn off the external texture as soon as the
   // software backing store is updated.
   bool accelerated_compositing_state_changed_;
 
   // Used to prevent further resizes while a resize is pending.
   class ResizeLock;
+  typedef std::vector<linked_ptr<ResizeLock> > ResizeLockList;
+
   // 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_;
+  ResizeLockList resize_locks_;
+  // These locks are the ones waiting for a frame to be committed.
+  ResizeLockList locks_pending_commit_;
 
   // 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_;
 
   // Used to track the state of the window we're created from. Only used when
   // created fullscreen.
   scoped_ptr<aura::WindowTracker> host_tracker_;
 
+  enum CanLockCompositorState {
+    YES,
+    // We locked, so at some point we'll need to kick a frame.
+    YES_DID_LOCK,
+    // No. A lock timed out, we need to kick a new frame before locking again.
+    NO_PENDING_RENDERER_FRAME,
+    // No. We've got a frame, but it hasn't been committed.
+    NO_PENDING_COMMIT,
+  };
+  CanLockCompositorState can_lock_compositor_;
+
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAura);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_