// Copyright 2021 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.

// This file was automatically generated with:
// ../../ui/gfx/x/gen_xproto.py \
//    ../../third_party/xcbproto/src \
//    gen/ui/gfx/x \
//    bigreq \
//    composite \
//    damage \
//    dpms \
//    dri2 \
//    dri3 \
//    ge \
//    glx \
//    present \
//    randr \
//    record \
//    render \
//    res \
//    screensaver \
//    shape \
//    shm \
//    sync \
//    xc_misc \
//    xevie \
//    xf86dri \
//    xf86vidmode \
//    xfixes \
//    xinerama \
//    xinput \
//    xkb \
//    xprint \
//    xproto \
//    xselinux \
//    xtest \
//    xv \
//    xvmc

#include "xf86dri.h"

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

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

namespace x11 {

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

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

  WriteBuffer buf;

  // 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));

  Align(&buf, 4);

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

Future<XF86Dri::QueryVersionReply> XF86Dri::QueryVersion() {
  return XF86Dri::QueryVersion(XF86Dri::QueryVersionRequest{});
}

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

  auto& sequence = (*reply).sequence;
  auto& dri_major_version = (*reply).dri_major_version;
  auto& dri_minor_version = (*reply).dri_minor_version;
  auto& dri_minor_patch = (*reply).dri_minor_patch;

  // 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);

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

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

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

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

  return reply;
}

Future<XF86Dri::QueryDirectRenderingCapableReply>
XF86Dri::QueryDirectRenderingCapable(
    const XF86Dri::QueryDirectRenderingCapableRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& screen = request.screen;

  // 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));

  // screen
  buf.Write(&screen);

  Align(&buf, 4);

  return connection_->SendRequest<XF86Dri::QueryDirectRenderingCapableReply>(
      &buf, "XF86Dri::QueryDirectRenderingCapable", false);
}

Future<XF86Dri::QueryDirectRenderingCapableReply>
XF86Dri::QueryDirectRenderingCapable(const uint32_t& screen) {
  return XF86Dri::QueryDirectRenderingCapable(
      XF86Dri::QueryDirectRenderingCapableRequest{screen});
}

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

  auto& sequence = (*reply).sequence;
  auto& is_capable = (*reply).is_capable;

  // 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);

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

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

  return reply;
}

Future<XF86Dri::OpenConnectionReply> XF86Dri::OpenConnection(
    const XF86Dri::OpenConnectionRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& screen = request.screen;

  // 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));

  // screen
  buf.Write(&screen);

  Align(&buf, 4);

  return connection_->SendRequest<XF86Dri::OpenConnectionReply>(
      &buf, "XF86Dri::OpenConnection", false);
}

Future<XF86Dri::OpenConnectionReply> XF86Dri::OpenConnection(
    const uint32_t& screen) {
  return XF86Dri::OpenConnection(XF86Dri::OpenConnectionRequest{screen});
}

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

  auto& sequence = (*reply).sequence;
  auto& sarea_handle_low = (*reply).sarea_handle_low;
  auto& sarea_handle_high = (*reply).sarea_handle_high;
  uint32_t bus_id_len{};
  auto& bus_id = (*reply).bus_id;

  // 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);

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

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

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

  // pad1
  Pad(&buf, 12);

  // bus_id
  bus_id.resize(bus_id_len);
  for (auto& bus_id_elem : bus_id) {
    // bus_id_elem
    Read(&bus_id_elem, &buf);
  }

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

  return reply;
}

Future<void> XF86Dri::CloseConnection(
    const XF86Dri::CloseConnectionRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& screen = request.screen;

  // 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));

  // screen
  buf.Write(&screen);

  Align(&buf, 4);

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

Future<void> XF86Dri::CloseConnection(const uint32_t& screen) {
  return XF86Dri::CloseConnection(XF86Dri::CloseConnectionRequest{screen});
}

Future<XF86Dri::GetClientDriverNameReply> XF86Dri::GetClientDriverName(
    const XF86Dri::GetClientDriverNameRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& screen = request.screen;

  // 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));

  // screen
  buf.Write(&screen);

  Align(&buf, 4);

  return connection_->SendRequest<XF86Dri::GetClientDriverNameReply>(
      &buf, "XF86Dri::GetClientDriverName", false);
}

Future<XF86Dri::GetClientDriverNameReply> XF86Dri::GetClientDriverName(
    const uint32_t& screen) {
  return XF86Dri::GetClientDriverName(
      XF86Dri::GetClientDriverNameRequest{screen});
}

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

  auto& sequence = (*reply).sequence;
  auto& client_driver_major_version = (*reply).client_driver_major_version;
  auto& client_driver_minor_version = (*reply).client_driver_minor_version;
  auto& client_driver_patch_version = (*reply).client_driver_patch_version;
  uint32_t client_driver_name_len{};
  auto& client_driver_name = (*reply).client_driver_name;

  // 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);

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

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

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

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

  // pad1
  Pad(&buf, 8);

  // client_driver_name
  client_driver_name.resize(client_driver_name_len);
  for (auto& client_driver_name_elem : client_driver_name) {
    // client_driver_name_elem
    Read(&client_driver_name_elem, &buf);
  }

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

  return reply;
}

Future<XF86Dri::CreateContextReply> XF86Dri::CreateContext(
    const XF86Dri::CreateContextRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& screen = request.screen;
  auto& visual = request.visual;
  auto& context = request.context;

  // 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));

  // screen
  buf.Write(&screen);

  // visual
  buf.Write(&visual);

  // context
  buf.Write(&context);

  Align(&buf, 4);

  return connection_->SendRequest<XF86Dri::CreateContextReply>(
      &buf, "XF86Dri::CreateContext", false);
}

Future<XF86Dri::CreateContextReply> XF86Dri::CreateContext(
    const uint32_t& screen,
    const uint32_t& visual,
    const uint32_t& context) {
  return XF86Dri::CreateContext(
      XF86Dri::CreateContextRequest{screen, visual, context});
}

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

  auto& sequence = (*reply).sequence;
  auto& hw_context = (*reply).hw_context;

  // 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);

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

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

  return reply;
}

Future<void> XF86Dri::DestroyContext(
    const XF86Dri::DestroyContextRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& screen = request.screen;
  auto& context = request.context;

  // 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));

  // screen
  buf.Write(&screen);

  // context
  buf.Write(&context);

  Align(&buf, 4);

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

Future<void> XF86Dri::DestroyContext(const uint32_t& screen,
                                     const uint32_t& context) {
  return XF86Dri::DestroyContext(
      XF86Dri::DestroyContextRequest{screen, context});
}

Future<XF86Dri::CreateDrawableReply> XF86Dri::CreateDrawable(
    const XF86Dri::CreateDrawableRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& screen = request.screen;
  auto& drawable = request.drawable;

  // 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));

  // screen
  buf.Write(&screen);

  // drawable
  buf.Write(&drawable);

  Align(&buf, 4);

  return connection_->SendRequest<XF86Dri::CreateDrawableReply>(
      &buf, "XF86Dri::CreateDrawable", false);
}

Future<XF86Dri::CreateDrawableReply> XF86Dri::CreateDrawable(
    const uint32_t& screen,
    const uint32_t& drawable) {
  return XF86Dri::CreateDrawable(
      XF86Dri::CreateDrawableRequest{screen, drawable});
}

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

  auto& sequence = (*reply).sequence;
  auto& hw_drawable_handle = (*reply).hw_drawable_handle;

  // 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);

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

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

  return reply;
}

Future<void> XF86Dri::DestroyDrawable(
    const XF86Dri::DestroyDrawableRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& screen = request.screen;
  auto& drawable = request.drawable;

  // 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));

  // screen
  buf.Write(&screen);

  // drawable
  buf.Write(&drawable);

  Align(&buf, 4);

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

Future<void> XF86Dri::DestroyDrawable(const uint32_t& screen,
                                      const uint32_t& drawable) {
  return XF86Dri::DestroyDrawable(
      XF86Dri::DestroyDrawableRequest{screen, drawable});
}

Future<XF86Dri::GetDrawableInfoReply> XF86Dri::GetDrawableInfo(
    const XF86Dri::GetDrawableInfoRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& screen = request.screen;
  auto& drawable = request.drawable;

  // 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));

  // screen
  buf.Write(&screen);

  // drawable
  buf.Write(&drawable);

  Align(&buf, 4);

  return connection_->SendRequest<XF86Dri::GetDrawableInfoReply>(
      &buf, "XF86Dri::GetDrawableInfo", false);
}

Future<XF86Dri::GetDrawableInfoReply> XF86Dri::GetDrawableInfo(
    const uint32_t& screen,
    const uint32_t& drawable) {
  return XF86Dri::GetDrawableInfo(
      XF86Dri::GetDrawableInfoRequest{screen, drawable});
}

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

  auto& sequence = (*reply).sequence;
  auto& drawable_table_index = (*reply).drawable_table_index;
  auto& drawable_table_stamp = (*reply).drawable_table_stamp;
  auto& drawable_origin_X = (*reply).drawable_origin_X;
  auto& drawable_origin_Y = (*reply).drawable_origin_Y;
  auto& drawable_size_W = (*reply).drawable_size_W;
  auto& drawable_size_H = (*reply).drawable_size_H;
  uint32_t num_clip_rects{};
  auto& back_x = (*reply).back_x;
  auto& back_y = (*reply).back_y;
  uint32_t num_back_clip_rects{};
  auto& clip_rects = (*reply).clip_rects;
  size_t clip_rects_len = clip_rects.size();
  auto& back_clip_rects = (*reply).back_clip_rects;
  size_t back_clip_rects_len = back_clip_rects.size();

  // 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);

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

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

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

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

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

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

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

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

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

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

  // clip_rects
  clip_rects.resize(num_clip_rects);
  for (auto& clip_rects_elem : clip_rects) {
    // clip_rects_elem
    {
      auto& x1 = clip_rects_elem.x1;
      auto& y1 = clip_rects_elem.y1;
      auto& x2 = clip_rects_elem.x2;
      auto& x3 = clip_rects_elem.x3;

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

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

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

      // x3
      Read(&x3, &buf);
    }
  }

  // back_clip_rects
  back_clip_rects.resize(num_back_clip_rects);
  for (auto& back_clip_rects_elem : back_clip_rects) {
    // back_clip_rects_elem
    {
      auto& x1 = back_clip_rects_elem.x1;
      auto& y1 = back_clip_rects_elem.y1;
      auto& x2 = back_clip_rects_elem.x2;
      auto& x3 = back_clip_rects_elem.x3;

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

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

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

      // x3
      Read(&x3, &buf);
    }
  }

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

  return reply;
}

Future<XF86Dri::GetDeviceInfoReply> XF86Dri::GetDeviceInfo(
    const XF86Dri::GetDeviceInfoRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& screen = request.screen;

  // 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));

  // screen
  buf.Write(&screen);

  Align(&buf, 4);

  return connection_->SendRequest<XF86Dri::GetDeviceInfoReply>(
      &buf, "XF86Dri::GetDeviceInfo", false);
}

Future<XF86Dri::GetDeviceInfoReply> XF86Dri::GetDeviceInfo(
    const uint32_t& screen) {
  return XF86Dri::GetDeviceInfo(XF86Dri::GetDeviceInfoRequest{screen});
}

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

  auto& sequence = (*reply).sequence;
  auto& framebuffer_handle_low = (*reply).framebuffer_handle_low;
  auto& framebuffer_handle_high = (*reply).framebuffer_handle_high;
  auto& framebuffer_origin_offset = (*reply).framebuffer_origin_offset;
  auto& framebuffer_size = (*reply).framebuffer_size;
  auto& framebuffer_stride = (*reply).framebuffer_stride;
  uint32_t device_private_size{};
  auto& device_private = (*reply).device_private;
  size_t device_private_len = device_private.size();

  // 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);

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

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

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

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

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

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

  // device_private
  device_private.resize(device_private_size);
  for (auto& device_private_elem : device_private) {
    // device_private_elem
    Read(&device_private_elem, &buf);
  }

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

  return reply;
}

Future<XF86Dri::AuthConnectionReply> XF86Dri::AuthConnection(
    const XF86Dri::AuthConnectionRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& screen = request.screen;
  auto& magic = request.magic;

  // 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));

  // screen
  buf.Write(&screen);

  // magic
  buf.Write(&magic);

  Align(&buf, 4);

  return connection_->SendRequest<XF86Dri::AuthConnectionReply>(
      &buf, "XF86Dri::AuthConnection", false);
}

Future<XF86Dri::AuthConnectionReply> XF86Dri::AuthConnection(
    const uint32_t& screen,
    const uint32_t& magic) {
  return XF86Dri::AuthConnection(XF86Dri::AuthConnectionRequest{screen, magic});
}

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

  auto& sequence = (*reply).sequence;
  auto& authenticated = (*reply).authenticated;

  // 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);

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

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

  return reply;
}

}  // namespace x11