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

ui/compositor/compositor.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_COMPOSITOR_COMPOSITOR_H_
 #define UI_COMPOSITOR_COMPOSITOR_H_
 
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 108 matching lines @@
 // An interface to allow the compositor to communicate with its owner.
 class COMPOSITOR_EXPORT CompositorDelegate {
  public:
   // Requests the owner to schedule a redraw of the layer tree.
   virtual void ScheduleDraw() = 0;
 
  protected:
   virtual ~CompositorDelegate() {}
 };
 
+// This class represents a lock on the compositor, that can be used to prevent
+// commits to the compositor tree 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 cancelled 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 Compositor::GetCompositorLock.
+class COMPOSITOR_EXPORT CompositorLock
+    : public base::RefCounted<CompositorLock>,
+      public base::SupportsWeakPtr<CompositorLock> {
+ private:
+  friend class base::RefCounted<CompositorLock>;
+  friend class Compositor;
+
+  explicit CompositorLock(Compositor* compositor);
+  ~CompositorLock();
+
+  void CancelLock();
+
+  Compositor* compositor_;
+  DISALLOW_COPY_AND_ASSIGN(CompositorLock);
+};
+
+
 // Compositor object to take care of GPU painting.
 // A Browser compositor object is responsible for generating the final
 // displayable form of pixels comprising a single widget's contents. It draws an
 // appropriately transformed texture for each transformed view in the widget's
 // view hierarchy.
 class COMPOSITOR_EXPORT Compositor
     : NON_EXPORTED_BASE(public WebKit::WebLayerTreeViewClient) {
  public:
   Compositor(CompositorDelegate* delegate,
              gfx::AcceleratedWidget widget);
@@ skipping 50 matching lines @@
   // Compositor does not own observers. It is the responsibility of the
   // observer to remove itself when it is done observing.
   void AddObserver(CompositorObserver* observer);
   void RemoveObserver(CompositorObserver* observer);
   bool HasObserver(CompositorObserver* observer);
 
   // Returns whether a draw is pending, that is, if we're between the Draw call
   // and the OnCompositingEnded.
   bool DrawPending() const { return swap_posted_; }
 
-  // Returns whether the drawing is issued from a separate thread
-  // (i.e. |Compositor::Initialize(true)| was called).
-  bool IsThreaded() const;
+  // Creates a compositor lock. Returns NULL if it is not possible to lock at
+  // this time (i.e. we're waiting to complete a previous unlock).
+  scoped_refptr<CompositorLock> GetCompositorLock();
 
   // Internal functions, called back by command-buffer contexts on swap buffer
   // events.
 
   // Signals swap has been posted.
   void OnSwapBuffersPosted();
 
   // Signals swap has completed.
   void OnSwapBuffersComplete();
 
   // Signals swap has aborted (e.g. lost context).
   void OnSwapBuffersAborted();
 
   // WebLayerTreeViewClient implementation.
   virtual void updateAnimations(double frameBeginTime);
   virtual void layout();
   virtual void applyScrollAndScale(const WebKit::WebSize& scrollDelta,
                                    float scaleFactor);
   virtual WebKit::WebCompositorOutputSurface* createOutputSurface();
   virtual void didRecreateOutputSurface(bool success);
   virtual void didCommit();
   virtual void didCommitAndDrawFrame();
   virtual void didCompleteSwapBuffers();
   virtual void scheduleComposite();
 
   int last_started_frame() { return last_started_frame_; }
   int last_ended_frame() { return last_ended_frame_; }
 
+  bool IsLocked() { return compositor_lock_ != NULL; }
+
  private:
   friend class base::RefCounted<Compositor>;
+  friend class CompositorLock;
+
+  // Called by CompositorLock.
+  void UnlockCompositor();
+
+  // Called to release any pending CompositorLock
+  void CancelCompositorLock();
 
   // Notifies the compositor that compositing is complete.
   void NotifyEnd();
 
   CompositorDelegate* delegate_;
   gfx::Size size_;
 
   // The root of the Layer tree drawn by this compositor.
   Layer* root_layer_;
 
   ObserverList<CompositorObserver> observer_list_;
 
   gfx::AcceleratedWidget widget_;
   scoped_ptr<WebKit::WebLayer> root_web_layer_;
   scoped_ptr<WebKit::WebLayerTreeView> host_;
 
   // This is set to true when the swap buffers has been posted and we're waiting
   // for completion.
   bool swap_posted_;
 
   // The device scale factor of the monitor that this compositor is compositing
   // layers on.
   float device_scale_factor_;
 
   int last_started_frame_;
   int last_ended_frame_;
 
   bool disable_schedule_composite_;
 
+  CompositorLock* compositor_lock_;
+
   DISALLOW_COPY_AND_ASSIGN(Compositor);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_COMPOSITOR_H_