exo: Improve motion event synchronization.

components/exo/wayland/clients/motion_events.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.
 
 // Implementation of a client that produces output in the form of RGBA
 // buffers when receiving pointer/touch events. RGB contains the lower
 // 24 bits of the event timestamp and A is 0xff.
 
 #include <fcntl.h>
 #include <linux-dmabuf-unstable-v1-client-protocol.h>
@@ skipping 141 matching lines @@
 };
 using ScopedTexture = base::ScopedGeneric<GLuint, DeleteTextureTraits>;
 
 struct DeleteEglImageTraits {
   static EGLImageKHR InvalidValue() { return 0; }
   static void Free(EGLImageKHR image) {
     eglDestroyImageKHR(eglGetCurrentDisplay(), image);
   }
 };
 using ScopedEglImage = base::ScopedGeneric<EGLImageKHR, DeleteEglImageTraits>;
+
+struct DeleteEglSyncTraits {
+  static EGLSyncKHR InvalidValue() { return 0; }
+  static void Free(EGLSyncKHR sync) {
+    eglDestroySyncKHR(eglGetCurrentDisplay(), sync);
+  }
+};
+using ScopedEglSync = base::ScopedGeneric<EGLSyncKHR, DeleteEglSyncTraits>;
 #endif
 
 struct Buffer {
   std::unique_ptr<wl_buffer> buffer;
   bool busy = false;
 #if defined(OZONE_PLATFORM_GBM)
   std::unique_ptr<gbm_bo> bo;
   std::unique_ptr<ScopedEglImage> egl_image;
+  std::unique_ptr<ScopedEglSync> egl_sync;
   std::unique_ptr<ScopedTexture> texture;
 #endif
   std::unique_ptr<zwp_linux_buffer_params_v1> params;
   base::SharedMemory shared_memory;
   std::unique_ptr<wl_shm_pool> shm_pool;
   sk_sp<SkSurface> sk_surface;
 };
 
 void BufferRelease(void* data, wl_buffer* /* buffer */) {
   Buffer* buffer = static_cast<Buffer*>(data);
@@ skipping 212 matching lines @@
   }
   if (!globals_.shell) {
     LOG(ERROR) << "Can't find shell interface";
     return 1;
   }
   if (!globals_.seat) {
     LOG(ERROR) << "Can't find seat interface";
     return 1;
   }
 
+#if defined(OZONE_PLATFORM_GBM)
   EGLenum egl_sync_type = 0;
-#if defined(OZONE_PLATFORM_GBM)
   if (use_drm_) {
     // Number of files to look for when discovering DRM devices.
     const uint32_t kDrmMaxMinor = 15;
     const uint32_t kRenderNodeStart = 128;
     const uint32_t kRenderNodeEnd = kRenderNodeStart + kDrmMaxMinor;
 
     for (uint32_t i = kRenderNodeStart; i < kRenderNodeEnd; i++) {
       std::string dri_render_node(
           base::StringPrintf(kDriRenderNodeTemplate, i));
       base::ScopedFD drm_fd(open(dri_render_node.c_str(), O_RDWR));
@@ skipping 15 matching lines @@
       LOG_IF(ERROR, use_drm_) << "Can't find drm device: '" << *use_drm_ << "'";
       LOG_IF(ERROR, !use_drm_) << "Can't find drm device";
       return 1;
     }
 
     device_.reset(gbm_create_device(drm_fd_.get()));
     if (!device_) {
       LOG(ERROR) << "Can't create gbm device";
       return 1;
     }
+
+    if (gl::GLSurfaceEGL::HasEGLExtension("EGL_EXT_image_flush_external") ||
+        gl::GLSurfaceEGL::HasEGLExtension("EGL_ARM_implicit_external_sync")) {
+      egl_sync_type = EGL_SYNC_FENCE_KHR;
+    }
+    if (gl::GLSurfaceEGL::HasEGLExtension("EGL_ANDROID_native_fence_sync")) {
+      egl_sync_type = EGL_SYNC_NATIVE_FENCE_ANDROID;
+    }
   }
 
   sk_sp<const GrGLInterface> native_interface(GrGLCreateNativeInterface());
   DCHECK(native_interface);
   gr_context_ = sk_sp<GrContext>(GrContext::Create(
       kOpenGL_GrBackend,
       reinterpret_cast<GrBackendContext>(native_interface.get())));
   DCHECK(gr_context_);
-
-  if (gl::GLSurfaceEGL::HasEGLExtension("EGL_EXT_image_flush_external") ||
-      gl::GLSurfaceEGL::HasEGLExtension("EGL_ARM_implicit_external_sync")) {
-    egl_sync_type = EGL_SYNC_FENCE_KHR;
-  }
-  if (gl::GLSurfaceEGL::HasEGLExtension("EGL_ANDROID_native_fence_sync")) {
-    egl_sync_type = EGL_SYNC_NATIVE_FENCE_ANDROID;
-  }
 #endif
 
   wl_buffer_listener buffer_listener = {BufferRelease};
 
   for (size_t i = 0; i < kBuffers; ++i) {
     if (!CreateBuffer(&buffers_[i]))
       return 1;
   }
   wl_display_roundtrip(display_.get());
   for (size_t i = 0; i < kBuffers; ++i) {
@@ skipping 61 matching lines @@
     return 1;
   }
 
   wl_touch_listener touch_listener = {TouchDown, TouchUp, TouchMotion,
                                       TouchFrame, TouchCancel};
   wl_touch_add_listener(touch.get(), &touch_listener, &event_times);
 
   Frame frame;
   std::unique_ptr<wl_callback> frame_callback;
   wl_callback_listener frame_listener = {FrameCallback};
-  std::deque<wl_buffer*> pending_frames;
+  std::deque<Buffer*> pending_frames;
 
   uint32_t frames = 0;
   size_t num_benchmark_runs_left = num_benchmark_runs_;
   base::TimeTicks benchmark_time;
   base::TimeDelta benchmark_wall_time;
   base::TimeDelta benchmark_cpu_time;
   std::string fps_counter_text("??");
 
   SkPaint text_paint;
   text_paint.setTextSize(32.0f);
@@ skipping 92 matching lines @@
       canvas->restore();
 
       // Draw FPS counter.
       if (show_fps_counter_) {
         canvas->drawText(fps_counter_text.c_str(), fps_counter_text.length(),
                          width_ - 48, 32, text_paint);
       }
 
       if (gr_context_) {
         gr_context_->flush();
+
+#if defined(OZONE_PLATFORM_GBM)
+        if (egl_sync_type) {
+          buffer->egl_sync.reset(new ScopedEglSync(eglCreateSyncKHR(
+              eglGetCurrentDisplay(), egl_sync_type, nullptr)));
+          DCHECK(buffer->egl_sync->is_valid());
+        }
+#endif
+
         glFlush();
-
-        if (egl_sync_type) {
-          EGLSyncKHR sync =
-              eglCreateSyncKHR(eglGetCurrentDisplay(), egl_sync_type, nullptr);
-          DCHECK(sync != EGL_NO_SYNC_KHR);
-          eglClientWaitSyncKHR(eglGetCurrentDisplay(), sync,
-                               EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
-                               EGL_FOREVER_KHR);
-          eglDestroySyncKHR(eglGetCurrentDisplay(), sync);
-        }
       }
 
       buffer->busy = true;
-      pending_frames.push_back(buffer->buffer.get());
+      pending_frames.push_back(buffer);
 
       if (num_benchmark_runs_ || show_fps_counter_) {
         ++frames;
         benchmark_wall_time += base::TimeTicks::Now() - wall_time_start;
         benchmark_cpu_time += base::ThreadTicks::Now() - cpu_time_start;
       }
       continue;
     }
 
     if (!frame.callback_pending) {
       DCHECK_GT(pending_frames.size(), 0u);
+      Buffer* buffer = pending_frames.front();
+      pending_frames.pop_front();
+
       wl_surface_set_buffer_scale(surface.get(), scale_);
       wl_surface_damage(surface.get(), 0, 0, width_ / scale_, height_ / scale_);
-      wl_surface_attach(surface.get(), pending_frames.front(), 0, 0);
-      pending_frames.pop_front();
+      wl_surface_attach(surface.get(), buffer->buffer.get(), 0, 0);
+
+#if defined(OZONE_PLATFORM_GBM)
+      if (buffer->egl_sync) {
+        eglClientWaitSyncKHR(eglGetCurrentDisplay(), buffer->egl_sync->get(),
+                             EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR);
+      }
+#endif
 
       frame_callback.reset(wl_surface_frame(surface.get()));
       wl_callback_add_listener(frame_callback.get(), &frame_listener, &frame);
       frame.callback_pending = true;
       wl_surface_commit(surface.get());
       wl_display_flush(display_.get());
       continue;
     }
 
     dispatch_status = wl_display_dispatch(display_.get());
@@ skipping 193 matching lines @@
         new std::string(command_line->GetSwitchValueASCII(switches::kUseDrm)));
   }
 
   exo::wayland::clients::MotionEvents client(
       width, height, scale, num_rects, max_frames_pending,
       command_line->HasSwitch(switches::kFullscreen),
       command_line->HasSwitch(switches::kShowFpsCounter), num_benchmark_runs,
       base::TimeDelta::FromMilliseconds(benchmark_interval_ms), use_drm.get());
   return client.Run();
 }