exo: Connect frame callbacks with UI compositor begin frames.

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 <wayland-client-core.h>
 #include <wayland-client-protocol.h>
@@ skipping 16 matching lines @@
 DEFAULT_DELETER(wl_shm, wl_shm_destroy)
 DEFAULT_DELETER(wl_shm_pool, wl_shm_pool_destroy)
 DEFAULT_DELETER(wl_buffer, wl_buffer_destroy)
 DEFAULT_DELETER(wl_surface, wl_surface_destroy)
 DEFAULT_DELETER(wl_region, wl_region_destroy)
 DEFAULT_DELETER(wl_shell, wl_shell_destroy)
 DEFAULT_DELETER(wl_shell_surface, wl_shell_surface_destroy)
 DEFAULT_DELETER(wl_seat, wl_seat_destroy)
 DEFAULT_DELETER(wl_pointer, wl_pointer_destroy)
 DEFAULT_DELETER(wl_touch, wl_touch_destroy)
+DEFAULT_DELETER(wl_callback, wl_callback_destroy)
 
 namespace exo {
 namespace wayland {
 namespace clients {
 namespace {
 
 // Window size.
 const size_t kWidth = 256;
 const size_t kHeight = 256;
 
@@ skipping 51 matching lines @@
 void BufferRelease(void* data, wl_buffer* buffer) {
   BufferState* state = static_cast<BufferState*>(data);
 
   state->busy = false;
 }
 
 struct MainLoopContext {
   uint32_t color = 0xffffffff;
   bool needs_redraw = true;
   bool shutdown = false;
+  bool throttled = false;
 };
 
 void PointerEnter(void* data,
                   wl_pointer* pointer,
                   uint32_t serial,
                   wl_surface* surface,
                   wl_fixed_t x,
                   wl_fixed_t y) {}
 
 void PointerLeave(void* data,
@@ skipping 70 matching lines @@
   MainLoopContext* context = static_cast<MainLoopContext*>(data);
 
   context->color = 0xff000000 | time;
   context->needs_redraw = true;
 }
 
 void TouchFrame(void* data, wl_touch* touch) {}
 
 void TouchCancel(void* data, wl_touch* touch) {}
 
+void FrameCallback(void* data, wl_callback* callback, uint32_t time) {
+  MainLoopContext* context = static_cast<MainLoopContext*>(data);
+
+  context->throttled = false;
+}
+
 }  // namespace
 
 int MotionEventsMain() {
   std::unique_ptr<wl_display> display(wl_display_connect(nullptr));
   if (!display) {
     LOG(ERROR) << "wl_display_connect failed";
     return 1;
   }
 
   wl_registry_listener registry_listener = {RegistryHandler, RegistryRemover};
@@ skipping 90 matching lines @@
       static_cast<wl_touch*>(wl_seat_get_touch(globals.seat.get())));
   if (!touch) {
     LOG(ERROR) << "Can't get touch";
     return 1;
   }
 
   wl_touch_listener touch_listener = {TouchDown, TouchUp, TouchMotion,
                                       TouchFrame, TouchCancel};
   wl_touch_add_listener(touch.get(), &touch_listener, &context);
 
+  std::unique_ptr<wl_callback> frame_callback;
+  wl_callback_listener frame_listener = {FrameCallback};
+
   do {
     if (context.shutdown)
       break;
 
     if (!context.needs_redraw)
       continue;
 
+    if (context.throttled)
+      continue;
+
     BufferState* buffer =
         std::find_if(std::begin(buffers), std::end(buffers),
                      [](const BufferState& buffer) { return !buffer.busy; });
     if (buffer == std::end(buffers))
       continue;
 
     context.needs_redraw = false;
 
     static_assert(sizeof(uint32_t) == kBytesPerPixel,
                   "uint32_t must be same size as kBytesPerPixel");
     for (size_t y = 0; y < kHeight; y++) {
       uint32_t* pixel = reinterpret_cast<uint32_t*>(buffer->data + y * kStride);
       for (size_t x = 0; x < kWidth; x++)
         *pixel++ = context.color;
     }
 
     wl_surface_attach(surface.get(), buffer->buffer.get(), 0, 0);
     buffer->busy = true;
 
+    frame_callback.reset(wl_surface_frame(surface.get()));
+    wl_callback_add_listener(frame_callback.get(), &frame_listener, &context);
+    context.throttled = true;
+
     wl_surface_commit(surface.get());
     wl_display_flush(display.get());
   } while (wl_display_dispatch(display.get()) != -1);
 
   return 0;
 }
 
 }  // namespace clients
 }  // namespace wayland
 }  // namespace exo
 
 int main() {
   return exo::wayland::clients::MotionEventsMain();
 }