// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This file was automatically generated with:
// ../../ui/gfx/x/gen_xproto.py \
//    ../../third_party/xcbproto/src \
//    gen/ui/gfx/x \
//    bigreq \
//    dri3 \
//    glx \
//    randr \
//    render \
//    screensaver \
//    shape \
//    shm \
//    sync \
//    xfixes \
//    xinput \
//    xkb \
//    xproto \
//    xtest

#include "dri3.h"

#include <unistd.h>
#include <xcb/xcb.h>
#include <xcb/xcbext.h>

#include "base/logging.h"
#include "base/posix/eintr_wrapper.h"
#include "ui/gfx/x/connection.h"
#include "ui/gfx/x/xproto_internal.h"

namespace x11 {

Dri3::Dri3(Connection* connection, const x11::QueryExtensionReply& info)
    : connection_(connection), info_(info) {}

Future<Dri3::QueryVersionReply> Dri3::QueryVersion(
    const Dri3::QueryVersionRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& major_version = request.major_version;
  auto& minor_version = request.minor_version;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 0;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // major_version
  buf.Write(&major_version);

  // minor_version
  buf.Write(&minor_version);

  Align(&buf, 4);

  return connection_->SendRequest<Dri3::QueryVersionReply>(
      &buf, "Dri3::QueryVersion", false);
}

Future<Dri3::QueryVersionReply> Dri3::QueryVersion(
    const uint32_t& major_version,
    const uint32_t& minor_version) {
  return Dri3::QueryVersion(
      Dri3::QueryVersionRequest{major_version, minor_version});
}

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Dri3::QueryVersionReply> detail::ReadReply<
    Dri3::QueryVersionReply>(ReadBuffer* buffer) {
  auto& buf = *buffer;
  auto reply = std::make_unique<Dri3::QueryVersionReply>();

  auto& sequence = (*reply).sequence;
  auto& major_version = (*reply).major_version;
  auto& minor_version = (*reply).minor_version;

  // response_type
  uint8_t response_type;
  Read(&response_type, &buf);

  // pad0
  Pad(&buf, 1);

  // sequence
  Read(&sequence, &buf);

  // length
  uint32_t length;
  Read(&length, &buf);

  // major_version
  Read(&major_version, &buf);

  // minor_version
  Read(&minor_version, &buf);

  Align(&buf, 4);
  CHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);

  return reply;
}

Future<Dri3::OpenReply> Dri3::Open(const Dri3::OpenRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& drawable = request.drawable;
  auto& provider = request.provider;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 1;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // drawable
  buf.Write(&drawable);

  // provider
  buf.Write(&provider);

  Align(&buf, 4);

  return connection_->SendRequest<Dri3::OpenReply>(&buf, "Dri3::Open", true);
}

Future<Dri3::OpenReply> Dri3::Open(const Drawable& drawable,
                                   const uint32_t& provider) {
  return Dri3::Open(Dri3::OpenRequest{drawable, provider});
}

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Dri3::OpenReply> detail::ReadReply<Dri3::OpenReply>(
    ReadBuffer* buffer) {
  auto& buf = *buffer;
  auto reply = std::make_unique<Dri3::OpenReply>();

  auto& nfd = (*reply).nfd;
  auto& sequence = (*reply).sequence;
  auto& device_fd = (*reply).device_fd;

  // response_type
  uint8_t response_type;
  Read(&response_type, &buf);

  // nfd
  Read(&nfd, &buf);

  // sequence
  Read(&sequence, &buf);

  // length
  uint32_t length;
  Read(&length, &buf);

  // device_fd
  device_fd = RefCountedFD(buf.TakeFd());

  // pad0
  Pad(&buf, 24);

  Align(&buf, 4);
  CHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);

  return reply;
}

Future<void> Dri3::PixmapFromBuffer(
    const Dri3::PixmapFromBufferRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& pixmap = request.pixmap;
  auto& drawable = request.drawable;
  auto& size = request.size;
  auto& width = request.width;
  auto& height = request.height;
  auto& stride = request.stride;
  auto& depth = request.depth;
  auto& bpp = request.bpp;
  auto& pixmap_fd = request.pixmap_fd;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 2;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // pixmap
  buf.Write(&pixmap);

  // drawable
  buf.Write(&drawable);

  // size
  buf.Write(&size);

  // width
  buf.Write(&width);

  // height
  buf.Write(&height);

  // stride
  buf.Write(&stride);

  // depth
  buf.Write(&depth);

  // bpp
  buf.Write(&bpp);

  // pixmap_fd
  buf.fds().push_back(HANDLE_EINTR(dup(pixmap_fd.get())));

  Align(&buf, 4);

  return connection_->SendRequest<void>(&buf, "Dri3::PixmapFromBuffer", false);
}

Future<void> Dri3::PixmapFromBuffer(const Pixmap& pixmap,
                                    const Drawable& drawable,
                                    const uint32_t& size,
                                    const uint16_t& width,
                                    const uint16_t& height,
                                    const uint16_t& stride,
                                    const uint8_t& depth,
                                    const uint8_t& bpp,
                                    const RefCountedFD& pixmap_fd) {
  return Dri3::PixmapFromBuffer(Dri3::PixmapFromBufferRequest{
      pixmap, drawable, size, width, height, stride, depth, bpp, pixmap_fd});
}

Future<Dri3::BufferFromPixmapReply> Dri3::BufferFromPixmap(
    const Dri3::BufferFromPixmapRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& pixmap = request.pixmap;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 3;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // pixmap
  buf.Write(&pixmap);

  Align(&buf, 4);

  return connection_->SendRequest<Dri3::BufferFromPixmapReply>(
      &buf, "Dri3::BufferFromPixmap", true);
}

Future<Dri3::BufferFromPixmapReply> Dri3::BufferFromPixmap(
    const Pixmap& pixmap) {
  return Dri3::BufferFromPixmap(Dri3::BufferFromPixmapRequest{pixmap});
}

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Dri3::BufferFromPixmapReply> detail::ReadReply<
    Dri3::BufferFromPixmapReply>(ReadBuffer* buffer) {
  auto& buf = *buffer;
  auto reply = std::make_unique<Dri3::BufferFromPixmapReply>();

  auto& nfd = (*reply).nfd;
  auto& sequence = (*reply).sequence;
  auto& size = (*reply).size;
  auto& width = (*reply).width;
  auto& height = (*reply).height;
  auto& stride = (*reply).stride;
  auto& depth = (*reply).depth;
  auto& bpp = (*reply).bpp;
  auto& pixmap_fd = (*reply).pixmap_fd;

  // response_type
  uint8_t response_type;
  Read(&response_type, &buf);

  // nfd
  Read(&nfd, &buf);

  // sequence
  Read(&sequence, &buf);

  // length
  uint32_t length;
  Read(&length, &buf);

  // size
  Read(&size, &buf);

  // width
  Read(&width, &buf);

  // height
  Read(&height, &buf);

  // stride
  Read(&stride, &buf);

  // depth
  Read(&depth, &buf);

  // bpp
  Read(&bpp, &buf);

  // pixmap_fd
  pixmap_fd = RefCountedFD(buf.TakeFd());

  // pad0
  Pad(&buf, 12);

  Align(&buf, 4);
  CHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);

  return reply;
}

Future<void> Dri3::FenceFromFD(const Dri3::FenceFromFDRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& drawable = request.drawable;
  auto& fence = request.fence;
  auto& initially_triggered = request.initially_triggered;
  auto& fence_fd = request.fence_fd;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 4;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // drawable
  buf.Write(&drawable);

  // fence
  buf.Write(&fence);

  // initially_triggered
  buf.Write(&initially_triggered);

  // pad0
  Pad(&buf, 3);

  // fence_fd
  buf.fds().push_back(HANDLE_EINTR(dup(fence_fd.get())));

  Align(&buf, 4);

  return connection_->SendRequest<void>(&buf, "Dri3::FenceFromFD", false);
}

Future<void> Dri3::FenceFromFD(const Drawable& drawable,
                               const uint32_t& fence,
                               const uint8_t& initially_triggered,
                               const RefCountedFD& fence_fd) {
  return Dri3::FenceFromFD(
      Dri3::FenceFromFDRequest{drawable, fence, initially_triggered, fence_fd});
}

Future<Dri3::FDFromFenceReply> Dri3::FDFromFence(
    const Dri3::FDFromFenceRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& drawable = request.drawable;
  auto& fence = request.fence;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 5;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // drawable
  buf.Write(&drawable);

  // fence
  buf.Write(&fence);

  Align(&buf, 4);

  return connection_->SendRequest<Dri3::FDFromFenceReply>(
      &buf, "Dri3::FDFromFence", true);
}

Future<Dri3::FDFromFenceReply> Dri3::FDFromFence(const Drawable& drawable,
                                                 const uint32_t& fence) {
  return Dri3::FDFromFence(Dri3::FDFromFenceRequest{drawable, fence});
}

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Dri3::FDFromFenceReply> detail::ReadReply<
    Dri3::FDFromFenceReply>(ReadBuffer* buffer) {
  auto& buf = *buffer;
  auto reply = std::make_unique<Dri3::FDFromFenceReply>();

  auto& nfd = (*reply).nfd;
  auto& sequence = (*reply).sequence;
  auto& fence_fd = (*reply).fence_fd;

  // response_type
  uint8_t response_type;
  Read(&response_type, &buf);

  // nfd
  Read(&nfd, &buf);

  // sequence
  Read(&sequence, &buf);

  // length
  uint32_t length;
  Read(&length, &buf);

  // fence_fd
  fence_fd = RefCountedFD(buf.TakeFd());

  // pad0
  Pad(&buf, 24);

  Align(&buf, 4);
  CHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);

  return reply;
}

Future<Dri3::GetSupportedModifiersReply> Dri3::GetSupportedModifiers(
    const Dri3::GetSupportedModifiersRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& window = request.window;
  auto& depth = request.depth;
  auto& bpp = request.bpp;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 6;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // window
  buf.Write(&window);

  // depth
  buf.Write(&depth);

  // bpp
  buf.Write(&bpp);

  // pad0
  Pad(&buf, 2);

  Align(&buf, 4);

  return connection_->SendRequest<Dri3::GetSupportedModifiersReply>(
      &buf, "Dri3::GetSupportedModifiers", false);
}

Future<Dri3::GetSupportedModifiersReply> Dri3::GetSupportedModifiers(
    const uint32_t& window,
    const uint8_t& depth,
    const uint8_t& bpp) {
  return Dri3::GetSupportedModifiers(
      Dri3::GetSupportedModifiersRequest{window, depth, bpp});
}

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Dri3::GetSupportedModifiersReply> detail::ReadReply<
    Dri3::GetSupportedModifiersReply>(ReadBuffer* buffer) {
  auto& buf = *buffer;
  auto reply = std::make_unique<Dri3::GetSupportedModifiersReply>();

  auto& sequence = (*reply).sequence;
  uint32_t num_window_modifiers{};
  uint32_t num_screen_modifiers{};
  auto& window_modifiers = (*reply).window_modifiers;
  auto& screen_modifiers = (*reply).screen_modifiers;

  // response_type
  uint8_t response_type;
  Read(&response_type, &buf);

  // pad0
  Pad(&buf, 1);

  // sequence
  Read(&sequence, &buf);

  // length
  uint32_t length;
  Read(&length, &buf);

  // num_window_modifiers
  Read(&num_window_modifiers, &buf);

  // num_screen_modifiers
  Read(&num_screen_modifiers, &buf);

  // pad1
  Pad(&buf, 16);

  // window_modifiers
  window_modifiers.resize(num_window_modifiers);
  for (auto& window_modifiers_elem : window_modifiers) {
    // window_modifiers_elem
    Read(&window_modifiers_elem, &buf);
  }

  // screen_modifiers
  screen_modifiers.resize(num_screen_modifiers);
  for (auto& screen_modifiers_elem : screen_modifiers) {
    // screen_modifiers_elem
    Read(&screen_modifiers_elem, &buf);
  }

  Align(&buf, 4);
  CHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);

  return reply;
}

Future<void> Dri3::PixmapFromBuffers(
    const Dri3::PixmapFromBuffersRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& pixmap = request.pixmap;
  auto& window = request.window;
  uint8_t num_buffers{};
  auto& width = request.width;
  auto& height = request.height;
  auto& stride0 = request.stride0;
  auto& offset0 = request.offset0;
  auto& stride1 = request.stride1;
  auto& offset1 = request.offset1;
  auto& stride2 = request.stride2;
  auto& offset2 = request.offset2;
  auto& stride3 = request.stride3;
  auto& offset3 = request.offset3;
  auto& depth = request.depth;
  auto& bpp = request.bpp;
  auto& modifier = request.modifier;
  auto& buffers = request.buffers;
  size_t buffers_len = buffers.size();

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 7;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // pixmap
  buf.Write(&pixmap);

  // window
  buf.Write(&window);

  // num_buffers
  num_buffers = buffers.size();
  buf.Write(&num_buffers);

  // pad0
  Pad(&buf, 3);

  // width
  buf.Write(&width);

  // height
  buf.Write(&height);

  // stride0
  buf.Write(&stride0);

  // offset0
  buf.Write(&offset0);

  // stride1
  buf.Write(&stride1);

  // offset1
  buf.Write(&offset1);

  // stride2
  buf.Write(&stride2);

  // offset2
  buf.Write(&offset2);

  // stride3
  buf.Write(&stride3);

  // offset3
  buf.Write(&offset3);

  // depth
  buf.Write(&depth);

  // bpp
  buf.Write(&bpp);

  // pad1
  Pad(&buf, 2);

  // modifier
  buf.Write(&modifier);

  // buffers
  CHECK_EQ(static_cast<size_t>(num_buffers), buffers.size());
  for (auto& buffers_elem : buffers) {
    // buffers_elem
    buf.fds().push_back(HANDLE_EINTR(dup(buffers_elem.get())));
  }

  Align(&buf, 4);

  return connection_->SendRequest<void>(&buf, "Dri3::PixmapFromBuffers", false);
}

Future<void> Dri3::PixmapFromBuffers(const Pixmap& pixmap,
                                     const Window& window,
                                     const uint16_t& width,
                                     const uint16_t& height,
                                     const uint32_t& stride0,
                                     const uint32_t& offset0,
                                     const uint32_t& stride1,
                                     const uint32_t& offset1,
                                     const uint32_t& stride2,
                                     const uint32_t& offset2,
                                     const uint32_t& stride3,
                                     const uint32_t& offset3,
                                     const uint8_t& depth,
                                     const uint8_t& bpp,
                                     const uint64_t& modifier,
                                     const std::vector<RefCountedFD>& buffers) {
  return Dri3::PixmapFromBuffers(Dri3::PixmapFromBuffersRequest{
      pixmap, window, width, height, stride0, offset0, stride1, offset1,
      stride2, offset2, stride3, offset3, depth, bpp, modifier, buffers});
}

Future<Dri3::BuffersFromPixmapReply> Dri3::BuffersFromPixmap(
    const Dri3::BuffersFromPixmapRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& pixmap = request.pixmap;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 8;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // pixmap
  buf.Write(&pixmap);

  Align(&buf, 4);

  return connection_->SendRequest<Dri3::BuffersFromPixmapReply>(
      &buf, "Dri3::BuffersFromPixmap", true);
}

Future<Dri3::BuffersFromPixmapReply> Dri3::BuffersFromPixmap(
    const Pixmap& pixmap) {
  return Dri3::BuffersFromPixmap(Dri3::BuffersFromPixmapRequest{pixmap});
}

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Dri3::BuffersFromPixmapReply> detail::ReadReply<
    Dri3::BuffersFromPixmapReply>(ReadBuffer* buffer) {
  auto& buf = *buffer;
  auto reply = std::make_unique<Dri3::BuffersFromPixmapReply>();

  uint8_t nfd{};
  auto& sequence = (*reply).sequence;
  auto& width = (*reply).width;
  auto& height = (*reply).height;
  auto& modifier = (*reply).modifier;
  auto& depth = (*reply).depth;
  auto& bpp = (*reply).bpp;
  auto& strides = (*reply).strides;
  auto& offsets = (*reply).offsets;
  auto& buffers = (*reply).buffers;

  // response_type
  uint8_t response_type;
  Read(&response_type, &buf);

  // nfd
  Read(&nfd, &buf);

  // sequence
  Read(&sequence, &buf);

  // length
  uint32_t length;
  Read(&length, &buf);

  // width
  Read(&width, &buf);

  // height
  Read(&height, &buf);

  // pad0
  Pad(&buf, 4);

  // modifier
  Read(&modifier, &buf);

  // depth
  Read(&depth, &buf);

  // bpp
  Read(&bpp, &buf);

  // pad1
  Pad(&buf, 6);

  // strides
  strides.resize(nfd);
  for (auto& strides_elem : strides) {
    // strides_elem
    Read(&strides_elem, &buf);
  }

  // offsets
  offsets.resize(nfd);
  for (auto& offsets_elem : offsets) {
    // offsets_elem
    Read(&offsets_elem, &buf);
  }

  // buffers
  buffers.resize(nfd);
  for (auto& buffers_elem : buffers) {
    // buffers_elem
    buffers_elem = RefCountedFD(buf.TakeFd());
  }

  Align(&buf, 4);
  CHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);

  return reply;
}

Future<void> Dri3::SetDRMDeviceInUse(
    const Dri3::SetDRMDeviceInUseRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& window = request.window;
  auto& drmMajor = request.drmMajor;
  auto& drmMinor = request.drmMinor;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 9;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // window
  buf.Write(&window);

  // drmMajor
  buf.Write(&drmMajor);

  // drmMinor
  buf.Write(&drmMinor);

  Align(&buf, 4);

  return connection_->SendRequest<void>(&buf, "Dri3::SetDRMDeviceInUse", false);
}

Future<void> Dri3::SetDRMDeviceInUse(const Window& window,
                                     const uint32_t& drmMajor,
                                     const uint32_t& drmMinor) {
  return Dri3::SetDRMDeviceInUse(
      Dri3::SetDRMDeviceInUseRequest{window, drmMajor, drmMinor});
}

Future<void> Dri3::ImportSyncobj(const Dri3::ImportSyncobjRequest& request) {
  if (!connection_->Ready() || !present()) {
    return {};
  }

  WriteBuffer buf;

  auto& syncobj = request.syncobj;
  auto& drawable = request.drawable;
  auto& syncobj_fd = request.syncobj_fd;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 10;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // syncobj
  buf.Write(&syncobj);

  // drawable
  buf.Write(&drawable);

  // syncobj_fd
  buf.fds().push_back(HANDLE_EINTR(dup(syncobj_fd.get())));

  Align(&buf, 4);

  return connection_->SendRequest<void>(&buf, "Dri3::ImportSyncobj", false);
}

Future<void> Dri3::ImportSyncobj(const Syncobj& syncobj,
                                 const Drawable& drawable,
                                 const RefCountedFD& syncobj_fd) {
  return Dri3::ImportSyncobj(
      Dri3::ImportSyncobjRequest{syncobj, drawable, syncobj_fd});
}

Future<void> Dri3::FreeSyncobj(const Dri3::FreeSyncobjRequest& request) {
  if (!connection_->Ready() || !present()) {
    return {};
  }

  WriteBuffer buf;

  auto& syncobj = request.syncobj;

  // major_opcode
  uint8_t major_opcode = info_.major_opcode;
  buf.Write(&major_opcode);

  // minor_opcode
  uint8_t minor_opcode = 11;
  buf.Write(&minor_opcode);

  // length
  // Caller fills in length for writes.
  Pad(&buf, sizeof(uint16_t));

  // syncobj
  buf.Write(&syncobj);

  Align(&buf, 4);

  return connection_->SendRequest<void>(&buf, "Dri3::FreeSyncobj", false);
}

Future<void> Dri3::FreeSyncobj(const Syncobj& syncobj) {
  return Dri3::FreeSyncobj(Dri3::FreeSyncobjRequest{syncobj});
}

}  // namespace x11