Adding status to swap complete

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"
 #include "base/memory/ref_counted.h"
 #include "build/build_config.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/overlay_transform.h"
+#include "ui/gfx/swap_result.h"
 #include "ui/gl/gl_export.h"
 #include "ui/gl/gl_implementation.h"
 
 namespace gfx {
 
 class GLContext;
 class GLImage;
 class VSyncProvider;
 
 // Encapsulates a surface that can be rendered to with GL, hiding platform
@@ skipping 23 matching lines @@
   // Unschedule the GpuScheduler and return true to abort the processing of
   // a GL draw call to this surface and defer it until the GpuScheduler is
   // rescheduled.
   virtual bool DeferDraws();
 
   // Returns true if this surface is offscreen.
   virtual bool IsOffscreen() = 0;
 
   // Swaps front and back buffers. This has no effect for off-screen
   // contexts.
-  virtual bool SwapBuffers() = 0;
+  virtual gfx::SwapResult SwapBuffers() = 0;
 
   // 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 the internal frame buffer object name if the surface is backed by
   // FBO. Otherwise returns 0.
   virtual unsigned int GetBackingFrameBufferObject();
 
-  typedef base::Callback<void()> SwapCompletionCallback;
+  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 bool SwapBuffersAsync(const SwapCompletionCallback& callback);
 
   // Copy part of the backbuffer to the frontbuffer.
-  virtual bool PostSubBuffer(int x, int y, int width, int height);
+  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 bool PostSubBufferAsync(int x,
                                   int y,
                                   int width,
                                   int height,
@@ skipping 101 matching lines @@
 class GL_EXPORT GLSurfaceAdapter : public GLSurface {
  public:
   explicit GLSurfaceAdapter(GLSurface* surface);
 
   bool Initialize() override;
   void Destroy() override;
   bool Resize(const gfx::Size& size) override;
   bool Recreate() override;
   bool DeferDraws() override;
   bool IsOffscreen() override;
-  bool SwapBuffers() override;
+  gfx::SwapResult SwapBuffers() override;
   bool SwapBuffersAsync(const SwapCompletionCallback& callback) override;
-  bool PostSubBuffer(int x, int y, int width, int height) override;
+  gfx::SwapResult PostSubBuffer(int x, int y, int width, int height) override;
   bool PostSubBufferAsync(int x,
                           int y,
                           int width,
                           int height,
                           const SwapCompletionCallback& callback) override;
   bool SupportsPostSubBuffer() override;
   gfx::Size GetSize() override;
   void* GetHandle() override;
   unsigned int GetBackingFrameBufferObject() override;
   bool OnMakeCurrent(GLContext* context) override;
@@ skipping 18 matching lines @@
 
  private:
   scoped_refptr<GLSurface> surface_;
 
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceAdapter);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GL_GL_SURFACE_H_