Revert of Adding status to swap complete

ui/gl/gl_surface_ozone.cc

 // Copyright 2014 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.
 
 #include "ui/gl/gl_surface.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 26 matching lines @@
 
 // A thin wrapper around GLSurfaceEGL that owns the EGLNativeWindow
 class GL_EXPORT GLSurfaceOzoneEGL : public NativeViewGLSurfaceEGL {
  public:
   GLSurfaceOzoneEGL(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                     AcceleratedWidget widget);
 
   // GLSurface:
   bool Initialize() override;
   bool Resize(const gfx::Size& size) override;
-  gfx::SwapResult SwapBuffers() override;
+  bool SwapBuffers() override;
   bool ScheduleOverlayPlane(int z_order,
                             OverlayTransform transform,
                             GLImage* image,
                             const Rect& bounds_rect,
                             const RectF& crop_rect) override;
 
  private:
   using NativeViewGLSurfaceEGL::Initialize;
 
   ~GLSurfaceOzoneEGL() override;
@@ skipping 22 matching lines @@
 bool GLSurfaceOzoneEGL::Resize(const gfx::Size& size) {
   if (!ozone_surface_->ResizeNativeWindow(size)) {
     if (!ReinitializeNativeSurface() ||
         !ozone_surface_->ResizeNativeWindow(size))
       return false;
   }
 
   return NativeViewGLSurfaceEGL::Resize(size);
 }
 
-gfx::SwapResult GLSurfaceOzoneEGL::SwapBuffers() {
-  gfx::SwapResult result = NativeViewGLSurfaceEGL::SwapBuffers();
-  if (result != gfx::SwapResult::SWAP_ACK)
-    return result;
+bool GLSurfaceOzoneEGL::SwapBuffers() {
+  if (!NativeViewGLSurfaceEGL::SwapBuffers())
+    return false;
 
-  return ozone_surface_->OnSwapBuffers() ? gfx::SwapResult::SWAP_ACK
-                                         : gfx::SwapResult::SWAP_FAILED;
+  return ozone_surface_->OnSwapBuffers();
 }
 
 bool GLSurfaceOzoneEGL::ScheduleOverlayPlane(int z_order,
                                              OverlayTransform transform,
                                              GLImage* image,
                                              const Rect& bounds_rect,
                                              const RectF& crop_rect) {
   return image->ScheduleOverlayPlane(widget_, z_order, transform, bounds_rect,
                                      crop_rect);
 }
@@ skipping 29 matching lines @@
 }
 
 class GL_EXPORT GLSurfaceOzoneSurfaceless : public SurfacelessEGL {
  public:
   GLSurfaceOzoneSurfaceless(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                             AcceleratedWidget widget);
 
   // GLSurface:
   bool Initialize() override;
   bool Resize(const gfx::Size& size) override;
-  gfx::SwapResult SwapBuffers() override;
+  bool SwapBuffers() override;
   bool ScheduleOverlayPlane(int z_order,
                             OverlayTransform transform,
                             GLImage* image,
                             const Rect& bounds_rect,
                             const RectF& crop_rect) override;
   bool IsOffscreen() override;
   VSyncProvider* GetVSyncProvider() override;
   bool SupportsPostSubBuffer() override;
-  gfx::SwapResult PostSubBuffer(int x, int y, int width, int height) override;
+  bool PostSubBuffer(int x, int y, int width, int height) override;
   bool SwapBuffersAsync(const SwapCompletionCallback& callback) override;
   bool PostSubBufferAsync(int x,
                           int y,
                           int width,
                           int height,
                           const SwapCompletionCallback& callback) override;
 
  protected:
   struct Overlay {
     Overlay(int z_order,
@@ skipping 21 matching lines @@
     SwapCompletionCallback callback;
   };
 
   ~GLSurfaceOzoneSurfaceless() override;
 
   void SubmitFrame();
 
   EGLSyncKHR InsertFence();
   void FenceRetired(EGLSyncKHR fence, PendingFrame* frame);
 
-  void SwapCompleted(const SwapCompletionCallback& callback,
-                     gfx::SwapResult result);
+  void SwapCompleted(const SwapCompletionCallback& callback);
 
   // The native surface. Deleting this is allowed to free the EGLNativeWindow.
   scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface_;
   AcceleratedWidget widget_;
   scoped_ptr<VSyncProvider> vsync_provider_;
   ScopedVector<PendingFrame> unsubmitted_frames_;
   bool has_implicit_external_sync_;
   bool last_swap_buffers_result_;
   bool swap_buffers_pending_;
 
@@ skipping 52 matching lines @@
   if (!vsync_provider_)
     return false;
   return true;
 }
 bool GLSurfaceOzoneSurfaceless::Resize(const gfx::Size& size) {
   if (!ozone_surface_->ResizeNativeWindow(size))
     return false;
 
   return SurfacelessEGL::Resize(size);
 }
-gfx::SwapResult GLSurfaceOzoneSurfaceless::SwapBuffers() {
+bool GLSurfaceOzoneSurfaceless::SwapBuffers() {
   glFlush();
   // TODO: the following should be replaced by a per surface flush as it gets
   // implemented in GL drivers.
   if (has_implicit_external_sync_) {
     EGLSyncKHR fence = InsertFence();
     if (!fence)
-      return SwapResult::SWAP_FAILED;
+      return false;
 
     EGLDisplay display = GetDisplay();
     WaitForFence(display, fence);
     eglDestroySyncKHR(display, fence);
   } else if (ozone_surface_->IsUniversalDisplayLinkDevice()) {
     glFinish();
   }
 
   unsubmitted_frames_.back()->ScheduleOverlayPlanes(widget_);
   unsubmitted_frames_.back()->overlays.clear();
 
-  return ozone_surface_->OnSwapBuffers() ? gfx::SwapResult::SWAP_ACK
-                                         : gfx::SwapResult::SWAP_FAILED;
+  return ozone_surface_->OnSwapBuffers();
 }
 bool GLSurfaceOzoneSurfaceless::ScheduleOverlayPlane(int z_order,
                                                      OverlayTransform transform,
                                                      GLImage* image,
                                                      const Rect& bounds_rect,
                                                      const RectF& crop_rect) {
   unsubmitted_frames_.back()->overlays.push_back(
       Overlay(z_order, transform, image, bounds_rect, crop_rect));
   return true;
 }
 bool GLSurfaceOzoneSurfaceless::IsOffscreen() {
   return false;
 }
 VSyncProvider* GLSurfaceOzoneSurfaceless::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 bool GLSurfaceOzoneSurfaceless::SupportsPostSubBuffer() {
   return true;
 }
-gfx::SwapResult GLSurfaceOzoneSurfaceless::PostSubBuffer(int x,
-                                                         int y,
-                                                         int width,
-                                                         int height) {
+bool GLSurfaceOzoneSurfaceless::PostSubBuffer(int x,
+                                              int y,
+                                              int width,
+                                              int height) {
   // The actual sub buffer handling is handled at higher layers.
   SwapBuffers();
-  return gfx::SwapResult::SWAP_ACK;
+  return true;
 }
 bool GLSurfaceOzoneSurfaceless::SwapBuffersAsync(
     const SwapCompletionCallback& callback) {
   // If last swap failed, don't try to schedule new ones.
   if (!last_swap_buffers_result_)
     return false;
 
   glFlush();
 
-  SwapCompletionCallback surface_swap_callback =
+  base::Closure surface_swap_callback =
       base::Bind(&GLSurfaceOzoneSurfaceless::SwapCompleted,
                  weak_factory_.GetWeakPtr(), callback);
 
   PendingFrame* frame = unsubmitted_frames_.back();
   frame->callback = surface_swap_callback;
   unsubmitted_frames_.push_back(new PendingFrame());
 
   // TODO: the following should be replaced by a per surface flush as it gets
   // implemented in GL drivers.
   if (has_implicit_external_sync_) {
@@ skipping 54 matching lines @@
 }
 
 void GLSurfaceOzoneSurfaceless::FenceRetired(EGLSyncKHR fence,
                                              PendingFrame* frame) {
   eglDestroySyncKHR(GetDisplay(), fence);
   frame->ready = true;
   SubmitFrame();
 }
 
 void GLSurfaceOzoneSurfaceless::SwapCompleted(
-    const SwapCompletionCallback& callback,
-    gfx::SwapResult result) {
-  callback.Run(result);
+    const SwapCompletionCallback& callback) {
+  callback.Run();
   swap_buffers_pending_ = false;
 
   SubmitFrame();
 }
 
 // This provides surface-like semantics implemented through surfaceless.
 // A framebuffer is bound automatically.
 class GL_EXPORT GLSurfaceOzoneSurfacelessSurfaceImpl
     : public GLSurfaceOzoneSurfaceless {
  public:
   GLSurfaceOzoneSurfacelessSurfaceImpl(
       scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
       AcceleratedWidget widget);
 
   // GLSurface:
   unsigned int GetBackingFrameBufferObject() override;
   bool OnMakeCurrent(GLContext* context) override;
   bool Resize(const gfx::Size& size) override;
   bool SupportsPostSubBuffer() override;
-  gfx::SwapResult SwapBuffers() override;
+  bool SwapBuffers() override;
   bool SwapBuffersAsync(const SwapCompletionCallback& callback) override;
   void Destroy() override;
 
  private:
   class SurfaceImage : public GLImageLinuxDMABuffer {
    public:
     SurfaceImage(const gfx::Size& size, unsigned internalformat);
 
     bool Initialize(scoped_refptr<ui::NativePixmap> pixmap,
                     gfx::GpuMemoryBuffer::Format format);
@@ skipping 82 matching lines @@
 bool GLSurfaceOzoneSurfacelessSurfaceImpl::Resize(const gfx::Size& size) {
   if (size == GetSize())
     return true;
   return GLSurfaceOzoneSurfaceless::Resize(size) && CreatePixmaps();
 }
 
 bool GLSurfaceOzoneSurfacelessSurfaceImpl::SupportsPostSubBuffer() {
   return false;
 }
 
-gfx::SwapResult GLSurfaceOzoneSurfacelessSurfaceImpl::SwapBuffers() {
+bool GLSurfaceOzoneSurfacelessSurfaceImpl::SwapBuffers() {
   if (!images_[current_surface_]->ScheduleOverlayPlane(
           widget_, 0, OverlayTransform::OVERLAY_TRANSFORM_NONE,
           gfx::Rect(GetSize()), gfx::RectF(1, 1)))
-    return gfx::SwapResult::SWAP_FAILED;
-  gfx::SwapResult result = GLSurfaceOzoneSurfaceless::SwapBuffers();
-  if (result != gfx::SwapResult::SWAP_ACK)
-    return result;
+    return false;
+  if (!GLSurfaceOzoneSurfaceless::SwapBuffers())
+    return false;
   current_surface_ ^= 1;
   BindFramebuffer();
-  return gfx::SwapResult::SWAP_ACK;
+  return true;
 }
 
 bool GLSurfaceOzoneSurfacelessSurfaceImpl::SwapBuffersAsync(
     const SwapCompletionCallback& callback) {
   if (!images_[current_surface_]->ScheduleOverlayPlane(
           widget_, 0, OverlayTransform::OVERLAY_TRANSFORM_NONE,
           gfx::Rect(GetSize()), gfx::RectF(1, 1)))
     return false;
   if (!GLSurfaceOzoneSurfaceless::SwapBuffersAsync(callback))
     return false;
@@ skipping 167 matching lines @@
       NOTREACHED();
       return NULL;
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::SurfaceFactoryOzone::GetInstance()->GetNativeDisplay();
 }
 
 }  // namespace gfx