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 38 matching lines @@
   }
   bool Resize(const gfx::Size& size) override {
     if (!ozone_surface_->ResizeNativeWindow(size)) {
       if (!ReinitializeNativeSurface() ||
           !ozone_surface_->ResizeNativeWindow(size))
         return false;
     }
 
     return NativeViewGLSurfaceEGL::Resize(size);
   }
-  bool SwapBuffers() override {
-    if (!NativeViewGLSurfaceEGL::SwapBuffers())
-      return false;
+  gfx::SwapResult SwapBuffers() override {
+    if (NativeViewGLSurfaceEGL::SwapBuffers() == gfx::SwapResult::SWAP_FAILED)
+      return gfx::SwapResult::SWAP_FAILED;
 
-    return ozone_surface_->OnSwapBuffers();
+    return ozone_surface_->OnSwapBuffers() ? gfx::SwapResult::SWAP_ACK
+                                           : gfx::SwapResult::SWAP_FAILED;
   }
   bool ScheduleOverlayPlane(int z_order,
                             OverlayTransform transform,
                             GLImage* image,
                             const Rect& bounds_rect,
                             const RectF& crop_rect) override {
     return image->ScheduleOverlayPlane(
         widget_, z_order, transform, bounds_rect, crop_rect);
   }
 
@@ skipping 61 matching lines @@
     if (!vsync_provider_)
       return false;
     return true;
   }
   bool Resize(const gfx::Size& size) override {
     if (!ozone_surface_->ResizeNativeWindow(size))
       return false;
 
     return SurfacelessEGL::Resize(size);
   }
-  bool SwapBuffers() override {
+  gfx::SwapResult SwapBuffers() override {
     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 false;
+        return gfx::SwapResult::SWAP_FAILED;
 
       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();
+    return ozone_surface_->OnSwapBuffers() ? gfx::SwapResult::SWAP_ACK
+                                           : gfx::SwapResult::SWAP_FAILED;
   }
   bool ScheduleOverlayPlane(int z_order,
                             OverlayTransform transform,
                             GLImage* image,
                             const Rect& bounds_rect,
                             const RectF& crop_rect) override {
     unsubmitted_frames_.back()->overlays.push_back(PendingFrame::Overlay(
         z_order, transform, image, bounds_rect, crop_rect));
     return true;
   }
   bool IsOffscreen() override { return false; }
   VSyncProvider* GetVSyncProvider() override { return vsync_provider_.get(); }
   bool SupportsPostSubBuffer() override { return true; }
-  bool PostSubBuffer(int x, int y, int width, int height) override {
+  gfx::SwapResult PostSubBuffer(int x, int y, int width, int height) override {
     // The actual sub buffer handling is handled at higher layers.
-    SwapBuffers();
-    return true;
+    return SwapBuffers();
   }
   bool SwapBuffersAsync(const SwapCompletionCallback& callback) override {
     // If last swap failed, don't try to schedule new ones.
     if (!last_swap_buffers_result_)
       return false;
 
     glFlush();
 
-    base::Closure surface_swap_callback =
+    SwapCompletionCallback 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 90 matching lines @@
                                   EGL_NONE};
     return eglCreateSyncKHR(GetDisplay(), EGL_SYNC_FENCE_KHR, attrib_list);
   }
 
   void FenceRetired(EGLSyncKHR fence, PendingFrame* frame) {
     eglDestroySyncKHR(GetDisplay(), fence);
     frame->ready = true;
     SubmitFrame();
   }
 
-  void SwapCompleted(const SwapCompletionCallback& callback) {
-    callback.Run();
+  void SwapCompleted(const SwapCompletionCallback& callback,
+                     gfx::SwapResult result) {
+    callback.Run(result);
     swap_buffers_pending_ = false;
 
     SubmitFrame();
   }
 
   // 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_;
@@ skipping 38 matching lines @@
   }
 
   bool Resize(const gfx::Size& size) override {
     if (size == GetSize())
       return true;
     return GLSurfaceOzoneSurfaceless::Resize(size) && CreatePixmaps();
   }
 
   bool SupportsPostSubBuffer() override { return false; }
 
-  bool SwapBuffers() override {
+  gfx::SwapResult SwapBuffers() override {
     if (!images_[current_surface_]->ScheduleOverlayPlane(
             widget_, 0, OverlayTransform::OVERLAY_TRANSFORM_NONE,
             gfx::Rect(GetSize()), gfx::RectF(1, 1)))
-      return false;
-    if (!GLSurfaceOzoneSurfaceless::SwapBuffers())
-      return false;
+      return gfx::SwapResult::SWAP_FAILED;
+    if (GLSurfaceOzoneSurfaceless::SwapBuffers() ==
+        gfx::SwapResult::SWAP_FAILED)
+      return gfx::SwapResult::SWAP_FAILED;
     current_surface_ ^= 1;
     BindFramebuffer();
-    return true;
+    return gfx::SwapResult::SWAP_ACK;
   }
 
   bool SwapBuffersAsync(const SwapCompletionCallback& callback) override {
     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;
     current_surface_ ^= 1;
@@ skipping 200 matching lines @@
       NOTREACHED();
       return NULL;
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::SurfaceFactoryOzone::GetInstance()->GetNativeDisplay();
 }
 
 }  // namespace gfx