GLSurfaceOzone: move the IsUDL() check after ScheduleOverlayPlanes()

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 265 matching lines @@
   // 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;
 
     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();
 
+  if (ozone_surface_->IsUniversalDisplayLinkDevice())
+    glFinish();
+
   return ozone_surface_->OnSwapBuffers() ? gfx::SwapResult::SWAP_ACK
                                          : gfx::SwapResult::SWAP_FAILED;
 }
 
 bool GLSurfaceOzoneSurfaceless::ScheduleOverlayPlane(int z_order,
                                                      OverlayTransform transform,
                                                      GLImage* image,
                                                      const Rect& bounds_rect,
                                                      const RectF& crop_rect) {
   unsubmitted_frames_.back()->overlays.push_back(
@@ skipping 48 matching lines @@
     base::Closure fence_wait_task =
         base::Bind(&WaitForFence, GetDisplay(), fence);
 
     base::Closure fence_retired_callback =
         base::Bind(&GLSurfaceOzoneSurfaceless::FenceRetired,
                    weak_factory_.GetWeakPtr(), fence, frame);
 
     base::WorkerPool::PostTaskAndReply(FROM_HERE, fence_wait_task,
                                        fence_retired_callback, false);
     return true;
-  } else if (ozone_surface_->IsUniversalDisplayLinkDevice()) {
-    glFinish();
   }
 
   frame->ready = true;
   SubmitFrame();
   return last_swap_buffers_result_;
 }
 
 bool GLSurfaceOzoneSurfaceless::PostSubBufferAsync(
     int x,
     int y,
@@ skipping 15 matching lines @@
     unsubmitted_frames_.weak_erase(unsubmitted_frames_.begin());
     swap_buffers_pending_ = true;
 
     if (!frame->ScheduleOverlayPlanes(widget_)) {
       // |callback| is a wrapper for SwapCompleted(). Call it to properly
       // propagate the failed state.
       frame->callback.Run(gfx::SwapResult::SWAP_FAILED);
       return;
     }
 
+    if (ozone_surface_->IsUniversalDisplayLinkDevice())
+      glFinish();
+
     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);
 }
@@ skipping 315 matching lines @@
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::OzonePlatform::GetInstance()
       ->GetSurfaceFactoryOzone()
       ->GetNativeDisplay();
 }
 
 }  // namespace gfx