gpu: Initial implementation of CommitOverlayPlanes

ui/gl/gl_surface.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_GL_GL_SURFACE_H_
 #define UI_GL_GL_SURFACE_H_
 
 #include <string>
 
 #include "base/callback.h"
@@ skipping 52 matching lines @@
 
   // Get the size of the surface.
   virtual gfx::Size GetSize() = 0;
 
   // Get the underlying platform specific surface "handle".
   virtual void* GetHandle() = 0;
 
   // Returns whether or not the surface supports PostSubBuffer.
   virtual bool SupportsPostSubBuffer();
 
+  // Returns whether or not the surface supports CommitOverlayPlanes.
+  virtual bool SupportsCommitOverlayPlanes();
+
   // Returns whether SwapBuffersAsync() is supported.
   virtual bool SupportsAsyncSwap();
 
   // Returns the internal frame buffer object name if the surface is backed by
   // FBO. Otherwise returns 0.
   virtual unsigned int GetBackingFrameBufferObject();
 
   typedef base::Callback<void(SwapResult)> SwapCompletionCallback;
   // Swaps front and back buffers. This has no effect for off-screen
   // contexts. On some platforms, we want to send SwapBufferAck only after the
   // surface is displayed on screen. The callback can be used to delay sending
   // SwapBufferAck till that data is available. The callback should be run on
   // the calling thread (i.e. same thread SwapBuffersAsync is called)
   virtual void SwapBuffersAsync(const SwapCompletionCallback& callback);
 
   // Copy part of the backbuffer to the frontbuffer.
   virtual gfx::SwapResult PostSubBuffer(int x, int y, int width, int height);
 
   // Copy part of the backbuffer to the frontbuffer. On some platforms, we want
   // to send SwapBufferAck only after the surface is displayed on screen. The
   // callback can be used to delay sending SwapBufferAck till that data is
   // available. The callback should be run on the calling thread (i.e. same
   // thread PostSubBufferAsync is called)
   virtual void PostSubBufferAsync(int x,
                                   int y,
                                   int width,
                                   int height,
                                   const SwapCompletionCallback& callback);
 
+  // Show overlay planes but don't swap the front and back buffers. This acts
+  // like SwapBuffers from the point of view of the client, but is cheaper when
+  // overlays account for all the damage.
+  virtual gfx::SwapResult CommitOverlayPlanes();
+
+  // Show overlay planes but don't swap the front and back buffers. On some
+  // platforms, we want to send SwapBufferAck only after the overlays are
+  // displayed on screen. The callback can be used to delay sending
+  // SwapBufferAck till that data is available. The callback should be run on
+  // the calling thread (i.e. same thread CommitOverlayPlanesAsync is called).
+  virtual void CommitOverlayPlanesAsync(const SwapCompletionCallback& callback);
+
   // Initialize GL bindings.
   static bool InitializeOneOff();
 
   // Called after a context is made current with this surface. Returns false
   // on error.
   virtual bool OnMakeCurrent(GLContext* context);
 
   // Called when the surface is bound as the current framebuffer for the
   // current context.
   virtual void NotifyWasBound();
@@ skipping 13 matching lines @@
   // Get the platfrom specific configuration for this surface, if available.
   virtual void* GetConfig();
 
   // Get the GL pixel format of the surface, if available.
   virtual unsigned GetFormat();
 
   // Get access to a helper providing time of recent refresh and period
   // of screen refresh. If unavailable, returns NULL.
   virtual VSyncProvider* GetVSyncProvider();
 
-  // Schedule an overlay plane to be shown at swap time.
+  // Schedule an overlay plane to be shown at swap time, or on the next
+  // CommitOverlayPlanes call.
   // |z_order| specifies the stacking order of the plane relative to the
   // main framebuffer located at index 0. For the case where there is no
   // main framebuffer, overlays may be scheduled at 0, taking its place.
   // |transform| specifies how the buffer is to be transformed during
   // composition.
   // |image| to be presented by the overlay.
   // |bounds_rect| specify where it is supposed to be on the screen in pixels.
   // |crop_rect| specifies the region within the buffer to be placed inside
   // |bounds_rect|.
   virtual bool ScheduleOverlayPlane(int z_order,
@@ skipping 67 matching lines @@
   bool DeferDraws() override;
   bool IsOffscreen() override;
   gfx::SwapResult SwapBuffers() override;
   void SwapBuffersAsync(const SwapCompletionCallback& callback) override;
   gfx::SwapResult PostSubBuffer(int x, int y, int width, int height) override;
   void PostSubBufferAsync(int x,
                           int y,
                           int width,
                           int height,
                           const SwapCompletionCallback& callback) override;
+  gfx::SwapResult CommitOverlayPlanes() override;
+  void CommitOverlayPlanesAsync(
+      const SwapCompletionCallback& callback) override;
   bool SupportsPostSubBuffer() override;
+  bool SupportsCommitOverlayPlanes() override;
   bool SupportsAsyncSwap() override;
   gfx::Size GetSize() override;
   void* GetHandle() override;
   unsigned int GetBackingFrameBufferObject() override;
   bool OnMakeCurrent(GLContext* context) override;
   bool SetBackbufferAllocation(bool allocated) override;
   void SetFrontbufferAllocation(bool allocated) override;
   void* GetShareHandle() override;
   void* GetDisplay() override;
   void* GetConfig() override;
@@ skipping 13 matching lines @@
 
  private:
   scoped_refptr<GLSurface> surface_;
 
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceAdapter);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GL_GL_SURFACE_H_