Remove return bool in SurfaceOzoneEGL::OnSwapBuffersAsync

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 370 matching lines @@
 }
 
 void GLSurfaceOzoneSurfaceless::SubmitFrame() {
   DCHECK(!unsubmitted_frames_.empty());
 
   if (unsubmitted_frames_.front()->ready && !swap_buffers_pending_) {
     scoped_ptr<PendingFrame> frame(unsubmitted_frames_.front());
     unsubmitted_frames_.weak_erase(unsubmitted_frames_.begin());
     swap_buffers_pending_ = true;
 
-    last_swap_buffers_result_ =
-        frame->ScheduleOverlayPlanes(widget_) &&
-        ozone_surface_->OnSwapBuffersAsync(frame->callback);
+    last_swap_buffers_result_ = frame->ScheduleOverlayPlanes(widget_);

[spang, 2015/11/11 20:58:40]

Shouldn't this be

if (!frame->ScheduleOverlayPlanes(widget_)) {
  SwapCompleted(frame->callback, gfx::SwapResult::SWAP_FAILED);
  return;
}

[dnicoara, 2015/11/11 21:07:08]

I was thinking about this, but if some overlays have been scheduled there's no
way to clear them in the native surface. So the next swap buffers will add even
more buffers. And if that manages to succeed, now swap buffers fails because you
have too many overlays. That'd be worse to debug.

IMO ScheduleOverlayPlanes() shouldn't return a value. The native surface can't
allocate hardware resources until OnSwapBuffersAsync() anyways.

[dnicoara, 2015/11/11 21:33:56]

Done.

+    ozone_surface_->OnSwapBuffersAsync(frame->callback);
   }
 }
 
 EGLSyncKHR GLSurfaceOzoneSurfaceless::InsertFence() {
   const EGLint attrib_list[] = {EGL_SYNC_CONDITION_KHR,
                                 EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM,
                                 EGL_NONE};
   return eglCreateSyncKHR(GetDisplay(), EGL_SYNC_FENCE_KHR, attrib_list);
 }
 
 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);
   swap_buffers_pending_ = false;
+  last_swap_buffers_result_ &= result != gfx::SwapResult::SWAP_FAILED;

[spang, 2015/11/11 20:58:40]

There's no reason to &, just assign.

if (result == gfx::SwapResult::SWAP_FAILED)
  last_swap_buffers_result = false;

[dnicoara, 2015/11/11 21:33:56]

Done.

 
   SubmitFrame();
 }
 
 // This provides surface-like semantics implemented through surfaceless.
 // A framebuffer is bound automatically.
 class GL_EXPORT GLSurfaceOzoneSurfacelessSurfaceImpl
     : public GLSurfaceOzoneSurfaceless {
  public:
   GLSurfaceOzoneSurfacelessSurfaceImpl(
@@ skipping 288 matching lines @@
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::OzonePlatform::GetInstance()
       ->GetSurfaceFactoryOzone()
       ->GetNativeDisplay();
 }
 
 }  // namespace gfx