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/observer_list.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 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 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 49 matching lines @@
   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.
+  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::WebGraphicsContext3D* createContext3D();
   virtual void didRebindGraphicsContext(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_; }
 
  private:
   friend class base::RefCounted<Compositor>;
+  friend class CompositorLock;
+
+  // Called by CompositorLock.
+  void Unlock();
 
   // When reading back pixel data we often get RGBA rather than BGRA pixels and
   // and the image often needs to be flipped vertically.
   static void SwizzleRGBAToBGRAAndFlip(unsigned char* pixels,
                                        const gfx::Size& image_size);
 
   // Notifies the compositor that compositing is complete.
   void NotifyEnd();
 
   CompositorDelegate* delegate_;
@@ skipping 14 matching lines @@
 
   // 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_;
 
+  enum CommitsAllowedState {
+    // We've told |root_layer_| to enable commits, but no commit has cleared.
+    ENABLED_NEEDS_COMMIT,
+    // We've committed since being enabled.
+    ENABLED_DID_COMMIT,
+    // We will tell |root_layer_| to defer commits once an commit clears.
+    DISABLED_PENDING_COMMIT,
+    // We told |root_layer_| to disable commits.
+    DISABLED,
+  };
+
+  CommitsAllowedState commits_allowed_;
+
+  CompositorLock* compositor_lock_;
+
   DISALLOW_COPY_AND_ASSIGN(Compositor);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_COMPOSITOR_H_