// 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 "render.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 {

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

std::string Render::PictFormatError::ToString() const {
  std::stringstream ss_;
  ss_ << "Render::PictFormatError{";
  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
  ss_ << "}";
  return ss_.str();
}

template <>
void ReadError<Render::PictFormatError>(Render::PictFormatError* error_,
                                        ReadBuffer* buffer) {
  auto& buf = *buffer;

  auto& sequence = (*error_).sequence;

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

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

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

  DCHECK_LE(buf.offset, 32ul);
}
std::string Render::PictureError::ToString() const {
  std::stringstream ss_;
  ss_ << "Render::PictureError{";
  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
  ss_ << "}";
  return ss_.str();
}

template <>
void ReadError<Render::PictureError>(Render::PictureError* error_,
                                     ReadBuffer* buffer) {
  auto& buf = *buffer;

  auto& sequence = (*error_).sequence;

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

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

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

  DCHECK_LE(buf.offset, 32ul);
}
std::string Render::PictOpError::ToString() const {
  std::stringstream ss_;
  ss_ << "Render::PictOpError{";
  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
  ss_ << "}";
  return ss_.str();
}

template <>
void ReadError<Render::PictOpError>(Render::PictOpError* error_,
                                    ReadBuffer* buffer) {
  auto& buf = *buffer;

  auto& sequence = (*error_).sequence;

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

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

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

  DCHECK_LE(buf.offset, 32ul);
}
std::string Render::GlyphSetError::ToString() const {
  std::stringstream ss_;
  ss_ << "Render::GlyphSetError{";
  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
  ss_ << "}";
  return ss_.str();
}

template <>
void ReadError<Render::GlyphSetError>(Render::GlyphSetError* error_,
                                      ReadBuffer* buffer) {
  auto& buf = *buffer;

  auto& sequence = (*error_).sequence;

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

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

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

  DCHECK_LE(buf.offset, 32ul);
}
std::string Render::GlyphError::ToString() const {
  std::stringstream ss_;
  ss_ << "Render::GlyphError{";
  ss_ << ".sequence = " << static_cast<uint64_t>(sequence);
  ss_ << "}";
  return ss_.str();
}

template <>
void ReadError<Render::GlyphError>(Render::GlyphError* error_,
                                   ReadBuffer* buffer) {
  auto& buf = *buffer;

  auto& sequence = (*error_).sequence;

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

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

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

  DCHECK_LE(buf.offset, 32ul);
}
Future<Render::QueryVersionReply> Render::QueryVersion(
    const Render::QueryVersionRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& client_major_version = request.client_major_version;
  auto& client_minor_version = request.client_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));

  // client_major_version
  buf.Write(&client_major_version);

  // client_minor_version
  buf.Write(&client_minor_version);

  Align(&buf, 4);

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

Future<Render::QueryVersionReply> Render::QueryVersion(
    const uint32_t& client_major_version,
    const uint32_t& client_minor_version) {
  return Render::QueryVersion(
      Render::QueryVersionRequest{client_major_version, client_minor_version});
}

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Render::QueryVersionReply> detail::ReadReply<
    Render::QueryVersionReply>(ReadBuffer* buffer) {
  auto& buf = *buffer;
  auto reply = std::make_unique<Render::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);

  // pad1
  Pad(&buf, 16);

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

  return reply;
}

Future<Render::QueryPictFormatsReply> Render::QueryPictFormats(
    const Render::QueryPictFormatsRequest& 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 = 1;
  buf.Write(&minor_opcode);

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

  Align(&buf, 4);

  return connection_->SendRequest<Render::QueryPictFormatsReply>(
      &buf, "Render::QueryPictFormats", false);
}

Future<Render::QueryPictFormatsReply> Render::QueryPictFormats() {
  return Render::QueryPictFormats(Render::QueryPictFormatsRequest{});
}

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

  auto& sequence = (*reply).sequence;
  uint32_t num_formats{};
  uint32_t num_screens{};
  auto& num_depths = (*reply).num_depths;
  auto& num_visuals = (*reply).num_visuals;
  uint32_t num_subpixel{};
  auto& formats = (*reply).formats;
  size_t formats_len = formats.size();
  auto& screens = (*reply).screens;
  size_t screens_len = screens.size();
  auto& subpixels = (*reply).subpixels;
  size_t subpixels_len = subpixels.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);

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

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

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

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

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

  // pad1
  Pad(&buf, 4);

  // formats
  formats.resize(num_formats);
  for (auto& formats_elem : formats) {
    // formats_elem
    {
      auto& id = formats_elem.id;
      auto& type = formats_elem.type;
      auto& depth = formats_elem.depth;
      auto& direct = formats_elem.direct;
      auto& colormap = formats_elem.colormap;

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

      // type
      uint8_t tmp0;
      Read(&tmp0, &buf);
      type = static_cast<Render::PictType>(tmp0);

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

      // pad0
      Pad(&buf, 2);

      // direct
      {
        auto& red_shift = direct.red_shift;
        auto& red_mask = direct.red_mask;
        auto& green_shift = direct.green_shift;
        auto& green_mask = direct.green_mask;
        auto& blue_shift = direct.blue_shift;
        auto& blue_mask = direct.blue_mask;
        auto& alpha_shift = direct.alpha_shift;
        auto& alpha_mask = direct.alpha_mask;

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

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

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

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

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

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

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

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

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

  // screens
  screens.resize(num_screens);
  for (auto& screens_elem : screens) {
    // screens_elem
    {
      uint32_t num_depths{};
      auto& fallback = screens_elem.fallback;
      auto& depths = screens_elem.depths;
      size_t depths_len = depths.size();

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

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

      // depths
      depths.resize(num_depths);
      for (auto& depths_elem : depths) {
        // depths_elem
        {
          auto& depth = depths_elem.depth;
          uint16_t num_visuals{};
          auto& visuals = depths_elem.visuals;
          size_t visuals_len = visuals.size();

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

          // pad0
          Pad(&buf, 1);

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

          // pad1
          Pad(&buf, 4);

          // visuals
          visuals.resize(num_visuals);
          for (auto& visuals_elem : visuals) {
            // visuals_elem
            {
              auto& visual = visuals_elem.visual;
              auto& format = visuals_elem.format;

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

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

  // subpixels
  subpixels.resize(num_subpixel);
  for (auto& subpixels_elem : subpixels) {
    // subpixels_elem
    uint32_t tmp1;
    Read(&tmp1, &buf);
    subpixels_elem = static_cast<Render::SubPixel>(tmp1);
  }

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

  return reply;
}

Future<Render::QueryPictIndexValuesReply> Render::QueryPictIndexValues(
    const Render::QueryPictIndexValuesRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& format = request.format;

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

  // format
  buf.Write(&format);

  Align(&buf, 4);

  return connection_->SendRequest<Render::QueryPictIndexValuesReply>(
      &buf, "Render::QueryPictIndexValues", false);
}

Future<Render::QueryPictIndexValuesReply> Render::QueryPictIndexValues(
    const PictFormat& format) {
  return Render::QueryPictIndexValues(
      Render::QueryPictIndexValuesRequest{format});
}

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

  auto& sequence = (*reply).sequence;
  uint32_t num_values{};
  auto& values = (*reply).values;
  size_t values_len = values.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);

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

  // pad1
  Pad(&buf, 20);

  // values
  values.resize(num_values);
  for (auto& values_elem : values) {
    // values_elem
    {
      auto& pixel = values_elem.pixel;
      auto& red = values_elem.red;
      auto& green = values_elem.green;
      auto& blue = values_elem.blue;
      auto& alpha = values_elem.alpha;

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

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

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

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

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

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

  return reply;
}

Future<void> Render::CreatePicture(
    const Render::CreatePictureRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& pid = request.pid;
  auto& drawable = request.drawable;
  auto& format = request.format;
  CreatePictureAttribute value_mask{};
  auto& value_list = request;

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

  // pid
  buf.Write(&pid);

  // drawable
  buf.Write(&drawable);

  // format
  buf.Write(&format);

  // value_mask
  SwitchVar(CreatePictureAttribute::Repeat, value_list.repeat.has_value(), true,
            &value_mask);
  SwitchVar(CreatePictureAttribute::AlphaMap, value_list.alphamap.has_value(),
            true, &value_mask);
  SwitchVar(CreatePictureAttribute::AlphaXOrigin,
            value_list.alphaxorigin.has_value(), true, &value_mask);
  SwitchVar(CreatePictureAttribute::AlphaYOrigin,
            value_list.alphayorigin.has_value(), true, &value_mask);
  SwitchVar(CreatePictureAttribute::ClipXOrigin,
            value_list.clipxorigin.has_value(), true, &value_mask);
  SwitchVar(CreatePictureAttribute::ClipYOrigin,
            value_list.clipyorigin.has_value(), true, &value_mask);
  SwitchVar(CreatePictureAttribute::ClipMask, value_list.clipmask.has_value(),
            true, &value_mask);
  SwitchVar(CreatePictureAttribute::GraphicsExposure,
            value_list.graphicsexposure.has_value(), true, &value_mask);
  SwitchVar(CreatePictureAttribute::SubwindowMode,
            value_list.subwindowmode.has_value(), true, &value_mask);
  SwitchVar(CreatePictureAttribute::PolyEdge, value_list.polyedge.has_value(),
            true, &value_mask);
  SwitchVar(CreatePictureAttribute::PolyMode, value_list.polymode.has_value(),
            true, &value_mask);
  SwitchVar(CreatePictureAttribute::Dither, value_list.dither.has_value(), true,
            &value_mask);
  SwitchVar(CreatePictureAttribute::ComponentAlpha,
            value_list.componentalpha.has_value(), true, &value_mask);
  uint32_t tmp2;
  tmp2 = static_cast<uint32_t>(value_mask);
  buf.Write(&tmp2);

  // value_list
  auto value_list_expr = value_mask;
  if (CaseAnd(value_list_expr, CreatePictureAttribute::Repeat)) {
    auto& repeat = *value_list.repeat;

    // repeat
    uint32_t tmp3;
    tmp3 = static_cast<uint32_t>(repeat);
    buf.Write(&tmp3);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::AlphaMap)) {
    auto& alphamap = *value_list.alphamap;

    // alphamap
    buf.Write(&alphamap);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::AlphaXOrigin)) {
    auto& alphaxorigin = *value_list.alphaxorigin;

    // alphaxorigin
    buf.Write(&alphaxorigin);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::AlphaYOrigin)) {
    auto& alphayorigin = *value_list.alphayorigin;

    // alphayorigin
    buf.Write(&alphayorigin);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::ClipXOrigin)) {
    auto& clipxorigin = *value_list.clipxorigin;

    // clipxorigin
    buf.Write(&clipxorigin);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::ClipYOrigin)) {
    auto& clipyorigin = *value_list.clipyorigin;

    // clipyorigin
    buf.Write(&clipyorigin);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::ClipMask)) {
    auto& clipmask = *value_list.clipmask;

    // clipmask
    buf.Write(&clipmask);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::GraphicsExposure)) {
    auto& graphicsexposure = *value_list.graphicsexposure;

    // graphicsexposure
    buf.Write(&graphicsexposure);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::SubwindowMode)) {
    auto& subwindowmode = *value_list.subwindowmode;

    // subwindowmode
    uint32_t tmp4;
    tmp4 = static_cast<uint32_t>(subwindowmode);
    buf.Write(&tmp4);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::PolyEdge)) {
    auto& polyedge = *value_list.polyedge;

    // polyedge
    uint32_t tmp5;
    tmp5 = static_cast<uint32_t>(polyedge);
    buf.Write(&tmp5);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::PolyMode)) {
    auto& polymode = *value_list.polymode;

    // polymode
    uint32_t tmp6;
    tmp6 = static_cast<uint32_t>(polymode);
    buf.Write(&tmp6);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::Dither)) {
    auto& dither = *value_list.dither;

    // dither
    buf.Write(&dither);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::ComponentAlpha)) {
    auto& componentalpha = *value_list.componentalpha;

    // componentalpha
    buf.Write(&componentalpha);
  }

  Align(&buf, 4);

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

Future<void> Render::CreatePicture(
    const Picture& pid,
    const Drawable& drawable,
    const PictFormat& format,
    const absl::optional<Repeat>& repeat,
    const absl::optional<Picture>& alphamap,
    const absl::optional<int32_t>& alphaxorigin,
    const absl::optional<int32_t>& alphayorigin,
    const absl::optional<int32_t>& clipxorigin,
    const absl::optional<int32_t>& clipyorigin,
    const absl::optional<Pixmap>& clipmask,
    const absl::optional<uint32_t>& graphicsexposure,
    const absl::optional<SubwindowMode>& subwindowmode,
    const absl::optional<PolyEdge>& polyedge,
    const absl::optional<PolyMode>& polymode,
    const absl::optional<Atom>& dither,
    const absl::optional<uint32_t>& componentalpha) {
  return Render::CreatePicture(Render::CreatePictureRequest{
      pid, drawable, format, repeat, alphamap, alphaxorigin, alphayorigin,
      clipxorigin, clipyorigin, clipmask, graphicsexposure, subwindowmode,
      polyedge, polymode, dither, componentalpha});
}

Future<void> Render::ChangePicture(
    const Render::ChangePictureRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& picture = request.picture;
  CreatePictureAttribute value_mask{};
  auto& value_list = request;

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

  // picture
  buf.Write(&picture);

  // value_mask
  SwitchVar(CreatePictureAttribute::Repeat, value_list.repeat.has_value(), true,
            &value_mask);
  SwitchVar(CreatePictureAttribute::AlphaMap, value_list.alphamap.has_value(),
            true, &value_mask);
  SwitchVar(CreatePictureAttribute::AlphaXOrigin,
            value_list.alphaxorigin.has_value(), true, &value_mask);
  SwitchVar(CreatePictureAttribute::AlphaYOrigin,
            value_list.alphayorigin.has_value(), true, &value_mask);
  SwitchVar(CreatePictureAttribute::ClipXOrigin,
            value_list.clipxorigin.has_value(), true, &value_mask);
  SwitchVar(CreatePictureAttribute::ClipYOrigin,
            value_list.clipyorigin.has_value(), true, &value_mask);
  SwitchVar(CreatePictureAttribute::ClipMask, value_list.clipmask.has_value(),
            true, &value_mask);
  SwitchVar(CreatePictureAttribute::GraphicsExposure,
            value_list.graphicsexposure.has_value(), true, &value_mask);
  SwitchVar(CreatePictureAttribute::SubwindowMode,
            value_list.subwindowmode.has_value(), true, &value_mask);
  SwitchVar(CreatePictureAttribute::PolyEdge, value_list.polyedge.has_value(),
            true, &value_mask);
  SwitchVar(CreatePictureAttribute::PolyMode, value_list.polymode.has_value(),
            true, &value_mask);
  SwitchVar(CreatePictureAttribute::Dither, value_list.dither.has_value(), true,
            &value_mask);
  SwitchVar(CreatePictureAttribute::ComponentAlpha,
            value_list.componentalpha.has_value(), true, &value_mask);
  uint32_t tmp7;
  tmp7 = static_cast<uint32_t>(value_mask);
  buf.Write(&tmp7);

  // value_list
  auto value_list_expr = value_mask;
  if (CaseAnd(value_list_expr, CreatePictureAttribute::Repeat)) {
    auto& repeat = *value_list.repeat;

    // repeat
    uint32_t tmp8;
    tmp8 = static_cast<uint32_t>(repeat);
    buf.Write(&tmp8);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::AlphaMap)) {
    auto& alphamap = *value_list.alphamap;

    // alphamap
    buf.Write(&alphamap);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::AlphaXOrigin)) {
    auto& alphaxorigin = *value_list.alphaxorigin;

    // alphaxorigin
    buf.Write(&alphaxorigin);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::AlphaYOrigin)) {
    auto& alphayorigin = *value_list.alphayorigin;

    // alphayorigin
    buf.Write(&alphayorigin);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::ClipXOrigin)) {
    auto& clipxorigin = *value_list.clipxorigin;

    // clipxorigin
    buf.Write(&clipxorigin);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::ClipYOrigin)) {
    auto& clipyorigin = *value_list.clipyorigin;

    // clipyorigin
    buf.Write(&clipyorigin);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::ClipMask)) {
    auto& clipmask = *value_list.clipmask;

    // clipmask
    buf.Write(&clipmask);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::GraphicsExposure)) {
    auto& graphicsexposure = *value_list.graphicsexposure;

    // graphicsexposure
    buf.Write(&graphicsexposure);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::SubwindowMode)) {
    auto& subwindowmode = *value_list.subwindowmode;

    // subwindowmode
    uint32_t tmp9;
    tmp9 = static_cast<uint32_t>(subwindowmode);
    buf.Write(&tmp9);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::PolyEdge)) {
    auto& polyedge = *value_list.polyedge;

    // polyedge
    uint32_t tmp10;
    tmp10 = static_cast<uint32_t>(polyedge);
    buf.Write(&tmp10);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::PolyMode)) {
    auto& polymode = *value_list.polymode;

    // polymode
    uint32_t tmp11;
    tmp11 = static_cast<uint32_t>(polymode);
    buf.Write(&tmp11);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::Dither)) {
    auto& dither = *value_list.dither;

    // dither
    buf.Write(&dither);
  }
  if (CaseAnd(value_list_expr, CreatePictureAttribute::ComponentAlpha)) {
    auto& componentalpha = *value_list.componentalpha;

    // componentalpha
    buf.Write(&componentalpha);
  }

  Align(&buf, 4);

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

Future<void> Render::ChangePicture(
    const Picture& picture,
    const absl::optional<Repeat>& repeat,
    const absl::optional<Picture>& alphamap,
    const absl::optional<int32_t>& alphaxorigin,
    const absl::optional<int32_t>& alphayorigin,
    const absl::optional<int32_t>& clipxorigin,
    const absl::optional<int32_t>& clipyorigin,
    const absl::optional<Pixmap>& clipmask,
    const absl::optional<uint32_t>& graphicsexposure,
    const absl::optional<SubwindowMode>& subwindowmode,
    const absl::optional<PolyEdge>& polyedge,
    const absl::optional<PolyMode>& polymode,
    const absl::optional<Atom>& dither,
    const absl::optional<uint32_t>& componentalpha) {
  return Render::ChangePicture(Render::ChangePictureRequest{
      picture, repeat, alphamap, alphaxorigin, alphayorigin, clipxorigin,
      clipyorigin, clipmask, graphicsexposure, subwindowmode, polyedge,
      polymode, dither, componentalpha});
}

Future<void> Render::SetPictureClipRectangles(
    const Render::SetPictureClipRectanglesRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& picture = request.picture;
  auto& clip_x_origin = request.clip_x_origin;
  auto& clip_y_origin = request.clip_y_origin;
  auto& rectangles = request.rectangles;
  size_t rectangles_len = rectangles.size();

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

  // picture
  buf.Write(&picture);

  // clip_x_origin
  buf.Write(&clip_x_origin);

  // clip_y_origin
  buf.Write(&clip_y_origin);

  // rectangles
  DCHECK_EQ(static_cast<size_t>(rectangles_len), rectangles.size());
  for (auto& rectangles_elem : rectangles) {
    // rectangles_elem
    {
      auto& x = rectangles_elem.x;
      auto& y = rectangles_elem.y;
      auto& width = rectangles_elem.width;
      auto& height = rectangles_elem.height;

      // x
      buf.Write(&x);

      // y
      buf.Write(&y);

      // width
      buf.Write(&width);

      // height
      buf.Write(&height);
    }
  }

  Align(&buf, 4);

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

Future<void> Render::SetPictureClipRectangles(
    const Picture& picture,
    const int16_t& clip_x_origin,
    const int16_t& clip_y_origin,
    const std::vector<Rectangle>& rectangles) {
  return Render::SetPictureClipRectangles(
      Render::SetPictureClipRectanglesRequest{picture, clip_x_origin,
                                              clip_y_origin, rectangles});
}

Future<void> Render::FreePicture(const Render::FreePictureRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& picture = request.picture;

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

  // picture
  buf.Write(&picture);

  Align(&buf, 4);

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

Future<void> Render::FreePicture(const Picture& picture) {
  return Render::FreePicture(Render::FreePictureRequest{picture});
}

Future<void> Render::Composite(const Render::CompositeRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& op = request.op;
  auto& src = request.src;
  auto& mask = request.mask;
  auto& dst = request.dst;
  auto& src_x = request.src_x;
  auto& src_y = request.src_y;
  auto& mask_x = request.mask_x;
  auto& mask_y = request.mask_y;
  auto& dst_x = request.dst_x;
  auto& dst_y = request.dst_y;
  auto& width = request.width;
  auto& height = request.height;

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

  // op
  uint8_t tmp12;
  tmp12 = static_cast<uint8_t>(op);
  buf.Write(&tmp12);

  // pad0
  Pad(&buf, 3);

  // src
  buf.Write(&src);

  // mask
  buf.Write(&mask);

  // dst
  buf.Write(&dst);

  // src_x
  buf.Write(&src_x);

  // src_y
  buf.Write(&src_y);

  // mask_x
  buf.Write(&mask_x);

  // mask_y
  buf.Write(&mask_y);

  // dst_x
  buf.Write(&dst_x);

  // dst_y
  buf.Write(&dst_y);

  // width
  buf.Write(&width);

  // height
  buf.Write(&height);

  Align(&buf, 4);

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

Future<void> Render::Composite(const PictOp& op,
                               const Picture& src,
                               const Picture& mask,
                               const Picture& dst,
                               const int16_t& src_x,
                               const int16_t& src_y,
                               const int16_t& mask_x,
                               const int16_t& mask_y,
                               const int16_t& dst_x,
                               const int16_t& dst_y,
                               const uint16_t& width,
                               const uint16_t& height) {
  return Render::Composite(
      Render::CompositeRequest{op, src, mask, dst, src_x, src_y, mask_x, mask_y,
                               dst_x, dst_y, width, height});
}

Future<void> Render::Trapezoids(const Render::TrapezoidsRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& op = request.op;
  auto& src = request.src;
  auto& dst = request.dst;
  auto& mask_format = request.mask_format;
  auto& src_x = request.src_x;
  auto& src_y = request.src_y;
  auto& traps = request.traps;
  size_t traps_len = traps.size();

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

  // op
  uint8_t tmp13;
  tmp13 = static_cast<uint8_t>(op);
  buf.Write(&tmp13);

  // pad0
  Pad(&buf, 3);

  // src
  buf.Write(&src);

  // dst
  buf.Write(&dst);

  // mask_format
  buf.Write(&mask_format);

  // src_x
  buf.Write(&src_x);

  // src_y
  buf.Write(&src_y);

  // traps
  DCHECK_EQ(static_cast<size_t>(traps_len), traps.size());
  for (auto& traps_elem : traps) {
    // traps_elem
    {
      auto& top = traps_elem.top;
      auto& bottom = traps_elem.bottom;
      auto& left = traps_elem.left;
      auto& right = traps_elem.right;

      // top
      buf.Write(&top);

      // bottom
      buf.Write(&bottom);

      // left
      {
        auto& p1 = left.p1;
        auto& p2 = left.p2;

        // p1
        {
          auto& x = p1.x;
          auto& y = p1.y;

          // x
          buf.Write(&x);

          // y
          buf.Write(&y);
        }

        // p2
        {
          auto& x = p2.x;
          auto& y = p2.y;

          // x
          buf.Write(&x);

          // y
          buf.Write(&y);
        }
      }

      // right
      {
        auto& p1 = right.p1;
        auto& p2 = right.p2;

        // p1
        {
          auto& x = p1.x;
          auto& y = p1.y;

          // x
          buf.Write(&x);

          // y
          buf.Write(&y);
        }

        // p2
        {
          auto& x = p2.x;
          auto& y = p2.y;

          // x
          buf.Write(&x);

          // y
          buf.Write(&y);
        }
      }
    }
  }

  Align(&buf, 4);

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

Future<void> Render::Trapezoids(const PictOp& op,
                                const Picture& src,
                                const Picture& dst,
                                const PictFormat& mask_format,
                                const int16_t& src_x,
                                const int16_t& src_y,
                                const std::vector<Trapezoid>& traps) {
  return Render::Trapezoids(Render::TrapezoidsRequest{op, src, dst, mask_format,
                                                      src_x, src_y, traps});
}

Future<void> Render::Triangles(const Render::TrianglesRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& op = request.op;
  auto& src = request.src;
  auto& dst = request.dst;
  auto& mask_format = request.mask_format;
  auto& src_x = request.src_x;
  auto& src_y = request.src_y;
  auto& triangles = request.triangles;
  size_t triangles_len = triangles.size();

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

  // op
  uint8_t tmp14;
  tmp14 = static_cast<uint8_t>(op);
  buf.Write(&tmp14);

  // pad0
  Pad(&buf, 3);

  // src
  buf.Write(&src);

  // dst
  buf.Write(&dst);

  // mask_format
  buf.Write(&mask_format);

  // src_x
  buf.Write(&src_x);

  // src_y
  buf.Write(&src_y);

  // triangles
  DCHECK_EQ(static_cast<size_t>(triangles_len), triangles.size());
  for (auto& triangles_elem : triangles) {
    // triangles_elem
    {
      auto& p1 = triangles_elem.p1;
      auto& p2 = triangles_elem.p2;
      auto& p3 = triangles_elem.p3;

      // p1
      {
        auto& x = p1.x;
        auto& y = p1.y;

        // x
        buf.Write(&x);

        // y
        buf.Write(&y);
      }

      // p2
      {
        auto& x = p2.x;
        auto& y = p2.y;

        // x
        buf.Write(&x);

        // y
        buf.Write(&y);
      }

      // p3
      {
        auto& x = p3.x;
        auto& y = p3.y;

        // x
        buf.Write(&x);

        // y
        buf.Write(&y);
      }
    }
  }

  Align(&buf, 4);

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

Future<void> Render::Triangles(const PictOp& op,
                               const Picture& src,
                               const Picture& dst,
                               const PictFormat& mask_format,
                               const int16_t& src_x,
                               const int16_t& src_y,
                               const std::vector<Triangle>& triangles) {
  return Render::Triangles(Render::TrianglesRequest{op, src, dst, mask_format,
                                                    src_x, src_y, triangles});
}

Future<void> Render::TriStrip(const Render::TriStripRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& op = request.op;
  auto& src = request.src;
  auto& dst = request.dst;
  auto& mask_format = request.mask_format;
  auto& src_x = request.src_x;
  auto& src_y = request.src_y;
  auto& points = request.points;
  size_t points_len = points.size();

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

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

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

  // op
  uint8_t tmp15;
  tmp15 = static_cast<uint8_t>(op);
  buf.Write(&tmp15);

  // pad0
  Pad(&buf, 3);

  // src
  buf.Write(&src);

  // dst
  buf.Write(&dst);

  // mask_format
  buf.Write(&mask_format);

  // src_x
  buf.Write(&src_x);

  // src_y
  buf.Write(&src_y);

  // points
  DCHECK_EQ(static_cast<size_t>(points_len), points.size());
  for (auto& points_elem : points) {
    // points_elem
    {
      auto& x = points_elem.x;
      auto& y = points_elem.y;

      // x
      buf.Write(&x);

      // y
      buf.Write(&y);
    }
  }

  Align(&buf, 4);

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

Future<void> Render::TriStrip(const PictOp& op,
                              const Picture& src,
                              const Picture& dst,
                              const PictFormat& mask_format,
                              const int16_t& src_x,
                              const int16_t& src_y,
                              const std::vector<PointFix>& points) {
  return Render::TriStrip(
      Render::TriStripRequest{op, src, dst, mask_format, src_x, src_y, points});
}

Future<void> Render::TriFan(const Render::TriFanRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& op = request.op;
  auto& src = request.src;
  auto& dst = request.dst;
  auto& mask_format = request.mask_format;
  auto& src_x = request.src_x;
  auto& src_y = request.src_y;
  auto& points = request.points;
  size_t points_len = points.size();

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

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

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

  // op
  uint8_t tmp16;
  tmp16 = static_cast<uint8_t>(op);
  buf.Write(&tmp16);

  // pad0
  Pad(&buf, 3);

  // src
  buf.Write(&src);

  // dst
  buf.Write(&dst);

  // mask_format
  buf.Write(&mask_format);

  // src_x
  buf.Write(&src_x);

  // src_y
  buf.Write(&src_y);

  // points
  DCHECK_EQ(static_cast<size_t>(points_len), points.size());
  for (auto& points_elem : points) {
    // points_elem
    {
      auto& x = points_elem.x;
      auto& y = points_elem.y;

      // x
      buf.Write(&x);

      // y
      buf.Write(&y);
    }
  }

  Align(&buf, 4);

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

Future<void> Render::TriFan(const PictOp& op,
                            const Picture& src,
                            const Picture& dst,
                            const PictFormat& mask_format,
                            const int16_t& src_x,
                            const int16_t& src_y,
                            const std::vector<PointFix>& points) {
  return Render::TriFan(
      Render::TriFanRequest{op, src, dst, mask_format, src_x, src_y, points});
}

Future<void> Render::CreateGlyphSet(
    const Render::CreateGlyphSetRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& gsid = request.gsid;
  auto& format = request.format;

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

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

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

  // gsid
  buf.Write(&gsid);

  // format
  buf.Write(&format);

  Align(&buf, 4);

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

Future<void> Render::CreateGlyphSet(const GlyphSet& gsid,
                                    const PictFormat& format) {
  return Render::CreateGlyphSet(Render::CreateGlyphSetRequest{gsid, format});
}

Future<void> Render::ReferenceGlyphSet(
    const Render::ReferenceGlyphSetRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& gsid = request.gsid;
  auto& existing = request.existing;

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

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

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

  // gsid
  buf.Write(&gsid);

  // existing
  buf.Write(&existing);

  Align(&buf, 4);

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

Future<void> Render::ReferenceGlyphSet(const GlyphSet& gsid,
                                       const GlyphSet& existing) {
  return Render::ReferenceGlyphSet(
      Render::ReferenceGlyphSetRequest{gsid, existing});
}

Future<void> Render::FreeGlyphSet(const Render::FreeGlyphSetRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& glyphset = request.glyphset;

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

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

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

  // glyphset
  buf.Write(&glyphset);

  Align(&buf, 4);

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

Future<void> Render::FreeGlyphSet(const GlyphSet& glyphset) {
  return Render::FreeGlyphSet(Render::FreeGlyphSetRequest{glyphset});
}

Future<void> Render::AddGlyphs(const Render::AddGlyphsRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& glyphset = request.glyphset;
  uint32_t glyphs_len{};
  auto& glyphids = request.glyphids;
  size_t glyphids_len = glyphids.size();
  auto& glyphs = request.glyphs;
  auto& data = request.data;
  size_t data_len = data.size();

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

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

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

  // glyphset
  buf.Write(&glyphset);

  // glyphs_len
  glyphs_len = glyphs.size();
  buf.Write(&glyphs_len);

  // glyphids
  DCHECK_EQ(static_cast<size_t>(glyphs_len), glyphids.size());
  for (auto& glyphids_elem : glyphids) {
    // glyphids_elem
    buf.Write(&glyphids_elem);
  }

  // glyphs
  DCHECK_EQ(static_cast<size_t>(glyphs_len), glyphs.size());
  for (auto& glyphs_elem : glyphs) {
    // glyphs_elem
    {
      auto& width = glyphs_elem.width;
      auto& height = glyphs_elem.height;
      auto& x = glyphs_elem.x;
      auto& y = glyphs_elem.y;
      auto& x_off = glyphs_elem.x_off;
      auto& y_off = glyphs_elem.y_off;

      // width
      buf.Write(&width);

      // height
      buf.Write(&height);

      // x
      buf.Write(&x);

      // y
      buf.Write(&y);

      // x_off
      buf.Write(&x_off);

      // y_off
      buf.Write(&y_off);
    }
  }

  // data
  DCHECK_EQ(static_cast<size_t>(data_len), data.size());
  for (auto& data_elem : data) {
    // data_elem
    buf.Write(&data_elem);
  }

  Align(&buf, 4);

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

Future<void> Render::AddGlyphs(const GlyphSet& glyphset,
                               const std::vector<uint32_t>& glyphids,
                               const std::vector<GlyphInfo>& glyphs,
                               const std::vector<uint8_t>& data) {
  return Render::AddGlyphs(
      Render::AddGlyphsRequest{glyphset, glyphids, glyphs, data});
}

Future<void> Render::FreeGlyphs(const Render::FreeGlyphsRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& glyphset = request.glyphset;
  auto& glyphs = request.glyphs;
  size_t glyphs_len = glyphs.size();

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

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

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

  // glyphset
  buf.Write(&glyphset);

  // glyphs
  DCHECK_EQ(static_cast<size_t>(glyphs_len), glyphs.size());
  for (auto& glyphs_elem : glyphs) {
    // glyphs_elem
    buf.Write(&glyphs_elem);
  }

  Align(&buf, 4);

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

Future<void> Render::FreeGlyphs(const GlyphSet& glyphset,
                                const std::vector<Glyph>& glyphs) {
  return Render::FreeGlyphs(Render::FreeGlyphsRequest{glyphset, glyphs});
}

Future<void> Render::CompositeGlyphs8(
    const Render::CompositeGlyphs8Request& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& op = request.op;
  auto& src = request.src;
  auto& dst = request.dst;
  auto& mask_format = request.mask_format;
  auto& glyphset = request.glyphset;
  auto& src_x = request.src_x;
  auto& src_y = request.src_y;
  auto& glyphcmds = request.glyphcmds;
  size_t glyphcmds_len = glyphcmds.size();

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

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

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

  // op
  uint8_t tmp17;
  tmp17 = static_cast<uint8_t>(op);
  buf.Write(&tmp17);

  // pad0
  Pad(&buf, 3);

  // src
  buf.Write(&src);

  // dst
  buf.Write(&dst);

  // mask_format
  buf.Write(&mask_format);

  // glyphset
  buf.Write(&glyphset);

  // src_x
  buf.Write(&src_x);

  // src_y
  buf.Write(&src_y);

  // glyphcmds
  DCHECK_EQ(static_cast<size_t>(glyphcmds_len), glyphcmds.size());
  for (auto& glyphcmds_elem : glyphcmds) {
    // glyphcmds_elem
    buf.Write(&glyphcmds_elem);
  }

  Align(&buf, 4);

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

Future<void> Render::CompositeGlyphs8(const PictOp& op,
                                      const Picture& src,
                                      const Picture& dst,
                                      const PictFormat& mask_format,
                                      const GlyphSet& glyphset,
                                      const int16_t& src_x,
                                      const int16_t& src_y,
                                      const std::vector<uint8_t>& glyphcmds) {
  return Render::CompositeGlyphs8(Render::CompositeGlyphs8Request{
      op, src, dst, mask_format, glyphset, src_x, src_y, glyphcmds});
}

Future<void> Render::CompositeGlyphs16(
    const Render::CompositeGlyphs16Request& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& op = request.op;
  auto& src = request.src;
  auto& dst = request.dst;
  auto& mask_format = request.mask_format;
  auto& glyphset = request.glyphset;
  auto& src_x = request.src_x;
  auto& src_y = request.src_y;
  auto& glyphcmds = request.glyphcmds;
  size_t glyphcmds_len = glyphcmds.size();

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

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

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

  // op
  uint8_t tmp18;
  tmp18 = static_cast<uint8_t>(op);
  buf.Write(&tmp18);

  // pad0
  Pad(&buf, 3);

  // src
  buf.Write(&src);

  // dst
  buf.Write(&dst);

  // mask_format
  buf.Write(&mask_format);

  // glyphset
  buf.Write(&glyphset);

  // src_x
  buf.Write(&src_x);

  // src_y
  buf.Write(&src_y);

  // glyphcmds
  DCHECK_EQ(static_cast<size_t>(glyphcmds_len), glyphcmds.size());
  for (auto& glyphcmds_elem : glyphcmds) {
    // glyphcmds_elem
    buf.Write(&glyphcmds_elem);
  }

  Align(&buf, 4);

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

Future<void> Render::CompositeGlyphs16(const PictOp& op,
                                       const Picture& src,
                                       const Picture& dst,
                                       const PictFormat& mask_format,
                                       const GlyphSet& glyphset,
                                       const int16_t& src_x,
                                       const int16_t& src_y,
                                       const std::vector<uint8_t>& glyphcmds) {
  return Render::CompositeGlyphs16(Render::CompositeGlyphs16Request{
      op, src, dst, mask_format, glyphset, src_x, src_y, glyphcmds});
}

Future<void> Render::CompositeGlyphs32(
    const Render::CompositeGlyphs32Request& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& op = request.op;
  auto& src = request.src;
  auto& dst = request.dst;
  auto& mask_format = request.mask_format;
  auto& glyphset = request.glyphset;
  auto& src_x = request.src_x;
  auto& src_y = request.src_y;
  auto& glyphcmds = request.glyphcmds;
  size_t glyphcmds_len = glyphcmds.size();

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

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

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

  // op
  uint8_t tmp19;
  tmp19 = static_cast<uint8_t>(op);
  buf.Write(&tmp19);

  // pad0
  Pad(&buf, 3);

  // src
  buf.Write(&src);

  // dst
  buf.Write(&dst);

  // mask_format
  buf.Write(&mask_format);

  // glyphset
  buf.Write(&glyphset);

  // src_x
  buf.Write(&src_x);

  // src_y
  buf.Write(&src_y);

  // glyphcmds
  DCHECK_EQ(static_cast<size_t>(glyphcmds_len), glyphcmds.size());
  for (auto& glyphcmds_elem : glyphcmds) {
    // glyphcmds_elem
    buf.Write(&glyphcmds_elem);
  }

  Align(&buf, 4);

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

Future<void> Render::CompositeGlyphs32(const PictOp& op,
                                       const Picture& src,
                                       const Picture& dst,
                                       const PictFormat& mask_format,
                                       const GlyphSet& glyphset,
                                       const int16_t& src_x,
                                       const int16_t& src_y,
                                       const std::vector<uint8_t>& glyphcmds) {
  return Render::CompositeGlyphs32(Render::CompositeGlyphs32Request{
      op, src, dst, mask_format, glyphset, src_x, src_y, glyphcmds});
}

Future<void> Render::FillRectangles(
    const Render::FillRectanglesRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& op = request.op;
  auto& dst = request.dst;
  auto& color = request.color;
  auto& rects = request.rects;
  size_t rects_len = rects.size();

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

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

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

  // op
  uint8_t tmp20;
  tmp20 = static_cast<uint8_t>(op);
  buf.Write(&tmp20);

  // pad0
  Pad(&buf, 3);

  // dst
  buf.Write(&dst);

  // color
  {
    auto& red = color.red;
    auto& green = color.green;
    auto& blue = color.blue;
    auto& alpha = color.alpha;

    // red
    buf.Write(&red);

    // green
    buf.Write(&green);

    // blue
    buf.Write(&blue);

    // alpha
    buf.Write(&alpha);
  }

  // rects
  DCHECK_EQ(static_cast<size_t>(rects_len), rects.size());
  for (auto& rects_elem : rects) {
    // rects_elem
    {
      auto& x = rects_elem.x;
      auto& y = rects_elem.y;
      auto& width = rects_elem.width;
      auto& height = rects_elem.height;

      // x
      buf.Write(&x);

      // y
      buf.Write(&y);

      // width
      buf.Write(&width);

      // height
      buf.Write(&height);
    }
  }

  Align(&buf, 4);

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

Future<void> Render::FillRectangles(const PictOp& op,
                                    const Picture& dst,
                                    const Color& color,
                                    const std::vector<Rectangle>& rects) {
  return Render::FillRectangles(
      Render::FillRectanglesRequest{op, dst, color, rects});
}

Future<void> Render::CreateCursor(const Render::CreateCursorRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& cid = request.cid;
  auto& source = request.source;
  auto& x = request.x;
  auto& y = request.y;

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

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

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

  // cid
  buf.Write(&cid);

  // source
  buf.Write(&source);

  // x
  buf.Write(&x);

  // y
  buf.Write(&y);

  Align(&buf, 4);

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

Future<void> Render::CreateCursor(const Cursor& cid,
                                  const Picture& source,
                                  const uint16_t& x,
                                  const uint16_t& y) {
  return Render::CreateCursor(Render::CreateCursorRequest{cid, source, x, y});
}

Future<void> Render::SetPictureTransform(
    const Render::SetPictureTransformRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& picture = request.picture;
  auto& transform = request.transform;

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

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

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

  // picture
  buf.Write(&picture);

  // transform
  {
    auto& matrix11 = transform.matrix11;
    auto& matrix12 = transform.matrix12;
    auto& matrix13 = transform.matrix13;
    auto& matrix21 = transform.matrix21;
    auto& matrix22 = transform.matrix22;
    auto& matrix23 = transform.matrix23;
    auto& matrix31 = transform.matrix31;
    auto& matrix32 = transform.matrix32;
    auto& matrix33 = transform.matrix33;

    // matrix11
    buf.Write(&matrix11);

    // matrix12
    buf.Write(&matrix12);

    // matrix13
    buf.Write(&matrix13);

    // matrix21
    buf.Write(&matrix21);

    // matrix22
    buf.Write(&matrix22);

    // matrix23
    buf.Write(&matrix23);

    // matrix31
    buf.Write(&matrix31);

    // matrix32
    buf.Write(&matrix32);

    // matrix33
    buf.Write(&matrix33);
  }

  Align(&buf, 4);

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

Future<void> Render::SetPictureTransform(const Picture& picture,
                                         const Transform& transform) {
  return Render::SetPictureTransform(
      Render::SetPictureTransformRequest{picture, transform});
}

Future<Render::QueryFiltersReply> Render::QueryFilters(
    const Render::QueryFiltersRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& drawable = request.drawable;

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

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

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

  // drawable
  buf.Write(&drawable);

  Align(&buf, 4);

  return connection_->SendRequest<Render::QueryFiltersReply>(
      &buf, "Render::QueryFilters", false);
}

Future<Render::QueryFiltersReply> Render::QueryFilters(
    const Drawable& drawable) {
  return Render::QueryFilters(Render::QueryFiltersRequest{drawable});
}

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

  auto& sequence = (*reply).sequence;
  uint32_t num_aliases{};
  uint32_t num_filters{};
  auto& aliases = (*reply).aliases;
  size_t aliases_len = aliases.size();
  auto& filters = (*reply).filters;
  size_t filters_len = filters.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);

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

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

  // pad1
  Pad(&buf, 16);

  // aliases
  aliases.resize(num_aliases);
  for (auto& aliases_elem : aliases) {
    // aliases_elem
    Read(&aliases_elem, &buf);
  }

  // filters
  filters.resize(num_filters);
  for (auto& filters_elem : filters) {
    // filters_elem
    {
      uint8_t name_len{};
      auto& name = filters_elem.name;

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

      // name
      name.resize(name_len);
      for (auto& name_elem : name) {
        // name_elem
        Read(&name_elem, &buf);
      }
    }
  }

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

  return reply;
}

Future<void> Render::SetPictureFilter(
    const Render::SetPictureFilterRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& picture = request.picture;
  uint16_t filter_len{};
  auto& filter = request.filter;
  auto& values = request.values;
  size_t values_len = values.size();

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

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

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

  // picture
  buf.Write(&picture);

  // filter_len
  filter_len = filter.size();
  buf.Write(&filter_len);

  // pad0
  Pad(&buf, 2);

  // filter
  DCHECK_EQ(static_cast<size_t>(filter_len), filter.size());
  for (auto& filter_elem : filter) {
    // filter_elem
    buf.Write(&filter_elem);
  }

  // pad1
  Align(&buf, 4);

  // values
  DCHECK_EQ(static_cast<size_t>(values_len), values.size());
  for (auto& values_elem : values) {
    // values_elem
    buf.Write(&values_elem);
  }

  Align(&buf, 4);

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

Future<void> Render::SetPictureFilter(const Picture& picture,
                                      const std::string& filter,
                                      const std::vector<Fixed>& values) {
  return Render::SetPictureFilter(
      Render::SetPictureFilterRequest{picture, filter, values});
}

Future<void> Render::CreateAnimCursor(
    const Render::CreateAnimCursorRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& cid = request.cid;
  auto& cursors = request.cursors;
  size_t cursors_len = cursors.size();

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

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

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

  // cid
  buf.Write(&cid);

  // cursors
  DCHECK_EQ(static_cast<size_t>(cursors_len), cursors.size());
  for (auto& cursors_elem : cursors) {
    // cursors_elem
    {
      auto& cursor = cursors_elem.cursor;
      auto& delay = cursors_elem.delay;

      // cursor
      buf.Write(&cursor);

      // delay
      buf.Write(&delay);
    }
  }

  Align(&buf, 4);

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

Future<void> Render::CreateAnimCursor(
    const Cursor& cid,
    const std::vector<AnimationCursorElement>& cursors) {
  return Render::CreateAnimCursor(
      Render::CreateAnimCursorRequest{cid, cursors});
}

Future<void> Render::AddTraps(const Render::AddTrapsRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& picture = request.picture;
  auto& x_off = request.x_off;
  auto& y_off = request.y_off;
  auto& traps = request.traps;
  size_t traps_len = traps.size();

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

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

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

  // picture
  buf.Write(&picture);

  // x_off
  buf.Write(&x_off);

  // y_off
  buf.Write(&y_off);

  // traps
  DCHECK_EQ(static_cast<size_t>(traps_len), traps.size());
  for (auto& traps_elem : traps) {
    // traps_elem
    {
      auto& top = traps_elem.top;
      auto& bot = traps_elem.bot;

      // top
      {
        auto& l = top.l;
        auto& r = top.r;
        auto& y = top.y;

        // l
        buf.Write(&l);

        // r
        buf.Write(&r);

        // y
        buf.Write(&y);
      }

      // bot
      {
        auto& l = bot.l;
        auto& r = bot.r;
        auto& y = bot.y;

        // l
        buf.Write(&l);

        // r
        buf.Write(&r);

        // y
        buf.Write(&y);
      }
    }
  }

  Align(&buf, 4);

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

Future<void> Render::AddTraps(const Picture& picture,
                              const int16_t& x_off,
                              const int16_t& y_off,
                              const std::vector<Trap>& traps) {
  return Render::AddTraps(
      Render::AddTrapsRequest{picture, x_off, y_off, traps});
}

Future<void> Render::CreateSolidFill(
    const Render::CreateSolidFillRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& picture = request.picture;
  auto& color = request.color;

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

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

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

  // picture
  buf.Write(&picture);

  // color
  {
    auto& red = color.red;
    auto& green = color.green;
    auto& blue = color.blue;
    auto& alpha = color.alpha;

    // red
    buf.Write(&red);

    // green
    buf.Write(&green);

    // blue
    buf.Write(&blue);

    // alpha
    buf.Write(&alpha);
  }

  Align(&buf, 4);

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

Future<void> Render::CreateSolidFill(const Picture& picture,
                                     const Color& color) {
  return Render::CreateSolidFill(
      Render::CreateSolidFillRequest{picture, color});
}

Future<void> Render::CreateLinearGradient(
    const Render::CreateLinearGradientRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& picture = request.picture;
  auto& p1 = request.p1;
  auto& p2 = request.p2;
  uint32_t num_stops{};
  auto& stops = request.stops;
  size_t stops_len = stops.size();
  auto& colors = request.colors;
  size_t colors_len = colors.size();

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

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

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

  // picture
  buf.Write(&picture);

  // p1
  {
    auto& x = p1.x;
    auto& y = p1.y;

    // x
    buf.Write(&x);

    // y
    buf.Write(&y);
  }

  // p2
  {
    auto& x = p2.x;
    auto& y = p2.y;

    // x
    buf.Write(&x);

    // y
    buf.Write(&y);
  }

  // num_stops
  num_stops = stops.size();
  buf.Write(&num_stops);

  // stops
  DCHECK_EQ(static_cast<size_t>(num_stops), stops.size());
  for (auto& stops_elem : stops) {
    // stops_elem
    buf.Write(&stops_elem);
  }

  // colors
  DCHECK_EQ(static_cast<size_t>(num_stops), colors.size());
  for (auto& colors_elem : colors) {
    // colors_elem
    {
      auto& red = colors_elem.red;
      auto& green = colors_elem.green;
      auto& blue = colors_elem.blue;
      auto& alpha = colors_elem.alpha;

      // red
      buf.Write(&red);

      // green
      buf.Write(&green);

      // blue
      buf.Write(&blue);

      // alpha
      buf.Write(&alpha);
    }
  }

  Align(&buf, 4);

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

Future<void> Render::CreateLinearGradient(const Picture& picture,
                                          const PointFix& p1,
                                          const PointFix& p2,
                                          const std::vector<Fixed>& stops,
                                          const std::vector<Color>& colors) {
  return Render::CreateLinearGradient(
      Render::CreateLinearGradientRequest{picture, p1, p2, stops, colors});
}

Future<void> Render::CreateRadialGradient(
    const Render::CreateRadialGradientRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& picture = request.picture;
  auto& inner = request.inner;
  auto& outer = request.outer;
  auto& inner_radius = request.inner_radius;
  auto& outer_radius = request.outer_radius;
  uint32_t num_stops{};
  auto& stops = request.stops;
  size_t stops_len = stops.size();
  auto& colors = request.colors;
  size_t colors_len = colors.size();

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

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

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

  // picture
  buf.Write(&picture);

  // inner
  {
    auto& x = inner.x;
    auto& y = inner.y;

    // x
    buf.Write(&x);

    // y
    buf.Write(&y);
  }

  // outer
  {
    auto& x = outer.x;
    auto& y = outer.y;

    // x
    buf.Write(&x);

    // y
    buf.Write(&y);
  }

  // inner_radius
  buf.Write(&inner_radius);

  // outer_radius
  buf.Write(&outer_radius);

  // num_stops
  num_stops = stops.size();
  buf.Write(&num_stops);

  // stops
  DCHECK_EQ(static_cast<size_t>(num_stops), stops.size());
  for (auto& stops_elem : stops) {
    // stops_elem
    buf.Write(&stops_elem);
  }

  // colors
  DCHECK_EQ(static_cast<size_t>(num_stops), colors.size());
  for (auto& colors_elem : colors) {
    // colors_elem
    {
      auto& red = colors_elem.red;
      auto& green = colors_elem.green;
      auto& blue = colors_elem.blue;
      auto& alpha = colors_elem.alpha;

      // red
      buf.Write(&red);

      // green
      buf.Write(&green);

      // blue
      buf.Write(&blue);

      // alpha
      buf.Write(&alpha);
    }
  }

  Align(&buf, 4);

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

Future<void> Render::CreateRadialGradient(const Picture& picture,
                                          const PointFix& inner,
                                          const PointFix& outer,
                                          const Fixed& inner_radius,
                                          const Fixed& outer_radius,
                                          const std::vector<Fixed>& stops,
                                          const std::vector<Color>& colors) {
  return Render::CreateRadialGradient(Render::CreateRadialGradientRequest{
      picture, inner, outer, inner_radius, outer_radius, stops, colors});
}

Future<void> Render::CreateConicalGradient(
    const Render::CreateConicalGradientRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& picture = request.picture;
  auto& center = request.center;
  auto& angle = request.angle;
  uint32_t num_stops{};
  auto& stops = request.stops;
  size_t stops_len = stops.size();
  auto& colors = request.colors;
  size_t colors_len = colors.size();

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

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

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

  // picture
  buf.Write(&picture);

  // center
  {
    auto& x = center.x;
    auto& y = center.y;

    // x
    buf.Write(&x);

    // y
    buf.Write(&y);
  }

  // angle
  buf.Write(&angle);

  // num_stops
  num_stops = stops.size();
  buf.Write(&num_stops);

  // stops
  DCHECK_EQ(static_cast<size_t>(num_stops), stops.size());
  for (auto& stops_elem : stops) {
    // stops_elem
    buf.Write(&stops_elem);
  }

  // colors
  DCHECK_EQ(static_cast<size_t>(num_stops), colors.size());
  for (auto& colors_elem : colors) {
    // colors_elem
    {
      auto& red = colors_elem.red;
      auto& green = colors_elem.green;
      auto& blue = colors_elem.blue;
      auto& alpha = colors_elem.alpha;

      // red
      buf.Write(&red);

      // green
      buf.Write(&green);

      // blue
      buf.Write(&blue);

      // alpha
      buf.Write(&alpha);
    }
  }

  Align(&buf, 4);

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

Future<void> Render::CreateConicalGradient(const Picture& picture,
                                           const PointFix& center,
                                           const Fixed& angle,
                                           const std::vector<Fixed>& stops,
                                           const std::vector<Color>& colors) {
  return Render::CreateConicalGradient(Render::CreateConicalGradientRequest{
      picture, center, angle, stops, colors});
}

}  // namespace x11