gpu: Add CHROMIUM_copy_image extension.

ui/ozone/platform/drm/gpu/gbm_surfaceless.cc

 // Copyright 2016 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/ozone/platform/drm/gpu/gbm_surfaceless.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
-#include "base/threading/worker_pool.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/ozone/common/egl_util.h"
 #include "ui/ozone/platform/drm/gpu/drm_vsync_provider.h"
 #include "ui/ozone/platform/drm/gpu/drm_window_proxy.h"
 #include "ui/ozone/platform/drm/gpu/gbm_surface_factory.h"
 #include "ui/ozone/platform/drm/gpu/scanout_buffer.h"
 
 namespace ui {
 
-namespace {
-
-void WaitForFence(EGLDisplay display, EGLSyncKHR fence) {
-  eglClientWaitSyncKHR(display, fence, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
-                       EGL_FOREVER_KHR);
-}
-
-}  // namespace
-
 GbmSurfaceless::GbmSurfaceless(GbmSurfaceFactory* surface_factory,
                                std::unique_ptr<DrmWindowProxy> window,
                                gfx::AcceleratedWidget widget)
     : SurfacelessEGL(gfx::Size()),
       surface_factory_(surface_factory),
       window_(std::move(window)),
       widget_(widget),
       has_implicit_external_sync_(
           HasEGLExtension("EGL_ARM_implicit_external_sync")),
       has_image_flush_external_(
@@ skipping 70 matching lines @@
   SwapCompletionCallback surface_swap_callback = base::Bind(
       &GbmSurfaceless::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_ || has_image_flush_external_) {
-    EGLSyncKHR fence = InsertFence(has_implicit_external_sync_);
-    if (!fence) {
+    const EGLint attrib_list[] = {EGL_SYNC_CONDITION_KHR,
+                                  EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM,
+                                  EGL_NONE};
+    base::Closure frame_ready_callback = base::Bind(
+        &GbmSurfaceless::FrameReady, weak_factory_.GetWeakPtr(), frame);
+    if (!InsertSyncFence(has_implicit_external_sync_ ? attrib_list : nullptr,
+                         frame_ready_callback)) {
       callback.Run(gfx::SwapResult::SWAP_FAILED);
       return;
     }
 
-    base::Closure fence_wait_task =
-        base::Bind(&WaitForFence, GetDisplay(), fence);
-
-    base::Closure fence_retired_callback =
-        base::Bind(&GbmSurfaceless::FenceRetired, weak_factory_.GetWeakPtr(),
-                   fence, frame);
-
-    base::WorkerPool::PostTaskAndReply(FROM_HERE, fence_wait_task,
-                                       fence_retired_callback, false);
     return;  // Defer frame submission until fence signals.
   }
 
-  frame->ready = true;
-  SubmitFrame();
+  FrameReady(frame);
 }
 
 void GbmSurfaceless::PostSubBufferAsync(
     int x,
     int y,
     int width,
     int height,
     const SwapCompletionCallback& callback) {
   // The actual sub buffer handling is handled at higher layers.
   SwapBuffersAsync(callback);
@@ skipping 59 matching lines @@
     }
 
     if (IsUniversalDisplayLinkDevice())
       glFinish();
 
     window_->SchedulePageFlip(planes_, frame->callback);
     planes_.clear();
   }
 }
 
-EGLSyncKHR GbmSurfaceless::InsertFence(bool implicit) {
-  const EGLint attrib_list[] = {EGL_SYNC_CONDITION_KHR,
-                                EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM,
-                                EGL_NONE};
-  return eglCreateSyncKHR(GetDisplay(), EGL_SYNC_FENCE_KHR,
-                          implicit ? attrib_list : NULL);
-}
-
-void GbmSurfaceless::FenceRetired(EGLSyncKHR fence, PendingFrame* frame) {
-  eglDestroySyncKHR(GetDisplay(), fence);
+void GbmSurfaceless::FrameReady(PendingFrame* frame) {
   frame->ready = true;
   SubmitFrame();
 }
 
 void GbmSurfaceless::SwapCompleted(const SwapCompletionCallback& callback,
                                    gfx::SwapResult result) {
   callback.Run(result);
   swap_buffers_pending_ = false;
   if (result == gfx::SwapResult::SWAP_FAILED) {
     last_swap_buffers_result_ = false;
     return;
   }
 
   SubmitFrame();
 }
 
 bool GbmSurfaceless::IsUniversalDisplayLinkDevice() {
   return planes_.empty() ? false : planes_[0].buffer->RequiresGlFinish();
 }
 
 }  // namespace ui