gpu: Add CHROMIUM_copy_image extension.

ui/gl/gl_surface_egl.cc

 // Copyright (c) 2012 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_egl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
+#include "base/threading/thread.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_context_egl.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/gl_switches.h"
@@ skipping 315 matching lines @@
         }
       }
     }
     return config;
   }
 
   LOG(ERROR) << "No suitable EGL configs found.";
   return nullptr;
 }
 
+void WaitForSyncFence(EGLDisplay display, EGLSyncKHR fence) {
+  eglClientWaitSyncKHR(display, fence, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
+                       EGL_FOREVER_KHR);
+}
+
 }  // namespace
 
 void GetEGLInitDisplays(bool supports_angle_d3d,
                         bool supports_angle_opengl,
                         bool supports_angle_null,
                         const base::CommandLine* command_line,
                         std::vector<DisplayType>* init_displays) {
   // SwiftShader does not use the platform extensions
   if (command_line->GetSwitchValueASCII(switches::kUseGL) ==
       kGLImplementationSwiftShaderName) {
@@ skipping 781 matching lines @@
   }
 
   return handle;
 #endif
 }
 
 PbufferGLSurfaceEGL::~PbufferGLSurfaceEGL() {
   Destroy();
 }
 
+class SurfacelessEGL::EGLWaitSyncFenceThread
+    : public base::Thread,
+      public base::NonThreadSafe,
+      public base::RefCounted<EGLWaitSyncFenceThread> {
+ public:
+  static scoped_refptr<EGLWaitSyncFenceThread> Create() {
+    if (!g_wait_sync_fence_thread) {
+      g_wait_sync_fence_thread = new EGLWaitSyncFenceThread;
+      g_wait_sync_fence_thread->Start();
+    }
+    return g_wait_sync_fence_thread;
+  }
+
+ private:
+  friend class base::RefCounted<EGLWaitSyncFenceThread>;
+
+  EGLWaitSyncFenceThread() : base::Thread("EGLWaitSyncFence") {
+    DCHECK(CalledOnValidThread());
+  }
+  ~EGLWaitSyncFenceThread() override {
+    DCHECK(CalledOnValidThread());
+    g_wait_sync_fence_thread = nullptr;
+    Stop();
+  }
+
+  static EGLWaitSyncFenceThread* g_wait_sync_fence_thread;
+
+  DISALLOW_COPY_AND_ASSIGN(EGLWaitSyncFenceThread);
+};
+
+SurfacelessEGL::EGLWaitSyncFenceThread*
+    SurfacelessEGL::EGLWaitSyncFenceThread::g_wait_sync_fence_thread = nullptr;
+
 SurfacelessEGL::SurfacelessEGL(const gfx::Size& size)
-    : size_(size) {
+    : size_(size), weak_ptr_factory_(this) {
   format_ = GLSurface::SURFACE_SURFACELESS;
 }
 
 bool SurfacelessEGL::Initialize() {
+  wait_sync_fence_thread_ = EGLWaitSyncFenceThread::Create();
+  if (!wait_sync_fence_thread_)
+    return false;
   return Initialize(SURFACE_SURFACELESS);
 }
 
 bool SurfacelessEGL::Initialize(GLSurface::Format format) {
   format_ = format;
   return true;
 }
 
 void SurfacelessEGL::Destroy() {
 }
@@ skipping 23 matching lines @@
 }
 
 EGLSurface SurfacelessEGL::GetHandle() {
   return EGL_NO_SURFACE;
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
+bool SurfacelessEGL::SupportsInsertFence() {
+  return true;
+}
+
+void SurfacelessEGL::InsertFence(const base::Closure& callback) {
+  bool rv = InsertSyncFence(nullptr, callback);
+  LOG_IF(ERROR, !rv) << "InsertFence failed";
+}
+
+bool SurfacelessEGL::InsertSyncFence(const EGLint* attribs,
+                                     const base::Closure& callback) {
+  EGLSyncKHR fence =
+      eglCreateSyncKHR(GetDisplay(), EGL_SYNC_FENCE_KHR, attribs);
+  if (!fence)
+    return false;
+
+  wait_sync_fence_thread_->task_runner()->PostTaskAndReply(
+      FROM_HERE, base::Bind(&WaitForSyncFence, GetDisplay(), fence),
+      base::Bind(&SurfacelessEGL::FenceRetired, weak_ptr_factory_.GetWeakPtr(),
+                 fence, callback));
+  return true;
+}
+
+void SurfacelessEGL::FenceRetired(EGLSyncKHR fence,
+                                  const base::Closure& callback) {
+  eglDestroySyncKHR(GetDisplay(), fence);
+  callback.Run();
+}
+
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gl