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

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

template <>
COMPONENT_EXPORT(X11)
void ReadEvent<Present::GenericEvent>(Present::GenericEvent* event_,
                                      ReadBuffer* buffer) {
  auto& buf = *buffer;

  auto& extension = (*event_).extension;
  auto& sequence = (*event_).sequence;
  auto& length = (*event_).length;
  auto& evtype = (*event_).evtype;
  auto& event = (*event_).event;

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

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

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

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

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

  // pad0
  Pad(&buf, 2);

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

  DCHECK_LE(buf.offset, 32ul);
}

template <>
COMPONENT_EXPORT(X11)
void ReadEvent<Present::ConfigureNotifyEvent>(
    Present::ConfigureNotifyEvent* event_,
    ReadBuffer* buffer) {
  auto& buf = *buffer;

  auto& sequence = (*event_).sequence;
  auto& event = (*event_).event;
  auto& window = (*event_).window;
  auto& x = (*event_).x;
  auto& y = (*event_).y;
  auto& width = (*event_).width;
  auto& height = (*event_).height;
  auto& off_x = (*event_).off_x;
  auto& off_y = (*event_).off_y;
  auto& pixmap_width = (*event_).pixmap_width;
  auto& pixmap_height = (*event_).pixmap_height;
  auto& pixmap_flags = (*event_).pixmap_flags;

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

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

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

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

  // event_type
  uint16_t event_type;
  Read(&event_type, &buf);

  // pad0
  Pad(&buf, 2);

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

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

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

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

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

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

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

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

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

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

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

  Align(&buf, 4);
  DCHECK_EQ(buf.offset, 32 + 4 * length);
}

template <>
COMPONENT_EXPORT(X11)
void ReadEvent<Present::CompleteNotifyEvent>(
    Present::CompleteNotifyEvent* event_,
    ReadBuffer* buffer) {
  auto& buf = *buffer;

  auto& sequence = (*event_).sequence;
  auto& kind = (*event_).kind;
  auto& mode = (*event_).mode;
  auto& event = (*event_).event;
  auto& window = (*event_).window;
  auto& serial = (*event_).serial;
  auto& ust = (*event_).ust;
  auto& msc = (*event_).msc;

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

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

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

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

  // event_type
  uint16_t event_type;
  Read(&event_type, &buf);

  // kind
  uint8_t tmp0;
  Read(&tmp0, &buf);
  kind = static_cast<Present::CompleteKind>(tmp0);

  // mode
  uint8_t tmp1;
  Read(&tmp1, &buf);
  mode = static_cast<Present::CompleteMode>(tmp1);

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

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

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

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

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

  Align(&buf, 4);
  DCHECK_EQ(buf.offset, 32 + 4 * length);
}

template <>
COMPONENT_EXPORT(X11)
void ReadEvent<Present::IdleNotifyEvent>(Present::IdleNotifyEvent* event_,
                                         ReadBuffer* buffer) {
  auto& buf = *buffer;

  auto& sequence = (*event_).sequence;
  auto& event = (*event_).event;
  auto& window = (*event_).window;
  auto& serial = (*event_).serial;
  auto& pixmap = (*event_).pixmap;
  auto& idle_fence = (*event_).idle_fence;

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

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

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

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

  // event_type
  uint16_t event_type;
  Read(&event_type, &buf);

  // pad0
  Pad(&buf, 2);

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

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

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

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

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

  Align(&buf, 4);
  DCHECK_EQ(buf.offset, 32 + 4 * length);
}

template <>
COMPONENT_EXPORT(X11)
void ReadEvent<Present::RedirectNotifyEvent>(
    Present::RedirectNotifyEvent* event_,
    ReadBuffer* buffer) {
  auto& buf = *buffer;

  auto& sequence = (*event_).sequence;
  auto& update_window = (*event_).update_window;
  auto& event = (*event_).event;
  auto& event_window = (*event_).event_window;
  auto& window = (*event_).window;
  auto& pixmap = (*event_).pixmap;
  auto& serial = (*event_).serial;
  auto& valid_region = (*event_).valid_region;
  auto& update_region = (*event_).update_region;
  auto& valid_rect = (*event_).valid_rect;
  auto& update_rect = (*event_).update_rect;
  auto& x_off = (*event_).x_off;
  auto& y_off = (*event_).y_off;
  auto& target_crtc = (*event_).target_crtc;
  auto& wait_fence = (*event_).wait_fence;
  auto& idle_fence = (*event_).idle_fence;
  auto& options = (*event_).options;
  auto& target_msc = (*event_).target_msc;
  auto& divisor = (*event_).divisor;
  auto& remainder = (*event_).remainder;
  auto& notifies = (*event_).notifies;
  size_t notifies_len = notifies.size();

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

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

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

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

  // event_type
  uint16_t event_type;
  Read(&event_type, &buf);

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

  // pad0
  Pad(&buf, 1);

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

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

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

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

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

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

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

  // valid_rect
  {
    auto& x = valid_rect.x;
    auto& y = valid_rect.y;
    auto& width = valid_rect.width;
    auto& height = valid_rect.height;

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

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

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

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

  // update_rect
  {
    auto& x = update_rect.x;
    auto& y = update_rect.y;
    auto& width = update_rect.width;
    auto& height = update_rect.height;

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

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

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

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

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

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

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

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

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

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

  // pad1
  Pad(&buf, 4);

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

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

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

  // notifies
  notifies.resize(notifies_len);
  for (auto& notifies_elem : notifies) {
    // notifies_elem
    {
      auto& window = notifies_elem.window;
      auto& serial = notifies_elem.serial;

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

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

  Align(&buf, 4);
  DCHECK_EQ(buf.offset, 32 + 4 * length);
}

Future<Present::QueryVersionReply> Present::QueryVersion(
    const Present::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<Present::QueryVersionReply>(
      &buf, "Present::QueryVersion", false);
}

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

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Present::QueryVersionReply> detail::ReadReply<
    Present::QueryVersionReply>(ReadBuffer* buffer) {
  auto& buf = *buffer;
  auto reply = std::make_unique<Present::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);
  DCHECK_EQ(buf.offset < 32 ? 0 : buf.offset - 32, 4 * length);

  return reply;
}

Future<void> Present::PresentPixmap(
    const Present::PresentPixmapRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& window = request.window;
  auto& pixmap = request.pixmap;
  auto& serial = request.serial;
  auto& valid = request.valid;
  auto& update = request.update;
  auto& x_off = request.x_off;
  auto& y_off = request.y_off;
  auto& target_crtc = request.target_crtc;
  auto& wait_fence = request.wait_fence;
  auto& idle_fence = request.idle_fence;
  auto& options = request.options;
  auto& target_msc = request.target_msc;
  auto& divisor = request.divisor;
  auto& remainder = request.remainder;
  auto& notifies = request.notifies;
  size_t notifies_len = notifies.size();

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

  // window
  buf.Write(&window);

  // pixmap
  buf.Write(&pixmap);

  // serial
  buf.Write(&serial);

  // valid
  buf.Write(&valid);

  // update
  buf.Write(&update);

  // x_off
  buf.Write(&x_off);

  // y_off
  buf.Write(&y_off);

  // target_crtc
  buf.Write(&target_crtc);

  // wait_fence
  buf.Write(&wait_fence);

  // idle_fence
  buf.Write(&idle_fence);

  // options
  buf.Write(&options);

  // pad0
  Pad(&buf, 4);

  // target_msc
  buf.Write(&target_msc);

  // divisor
  buf.Write(&divisor);

  // remainder
  buf.Write(&remainder);

  // notifies
  DCHECK_EQ(static_cast<size_t>(notifies_len), notifies.size());
  for (auto& notifies_elem : notifies) {
    // notifies_elem
    {
      auto& window = notifies_elem.window;
      auto& serial = notifies_elem.serial;

      // window
      buf.Write(&window);

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

  Align(&buf, 4);

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

Future<void> Present::PresentPixmap(const Window& window,
                                    const Pixmap& pixmap,
                                    const uint32_t& serial,
                                    const XFixes::Region& valid,
                                    const XFixes::Region& update,
                                    const int16_t& x_off,
                                    const int16_t& y_off,
                                    const RandR::Crtc& target_crtc,
                                    const Sync::Fence& wait_fence,
                                    const Sync::Fence& idle_fence,
                                    const uint32_t& options,
                                    const uint64_t& target_msc,
                                    const uint64_t& divisor,
                                    const uint64_t& remainder,
                                    const std::vector<Notify>& notifies) {
  return Present::PresentPixmap(Present::PresentPixmapRequest{
      window, pixmap, serial, valid, update, x_off, y_off, target_crtc,
      wait_fence, idle_fence, options, target_msc, divisor, remainder,
      notifies});
}

Future<void> Present::NotifyMSC(const Present::NotifyMSCRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& window = request.window;
  auto& serial = request.serial;
  auto& target_msc = request.target_msc;
  auto& divisor = request.divisor;
  auto& remainder = request.remainder;

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

  // window
  buf.Write(&window);

  // serial
  buf.Write(&serial);

  // pad0
  Pad(&buf, 4);

  // target_msc
  buf.Write(&target_msc);

  // divisor
  buf.Write(&divisor);

  // remainder
  buf.Write(&remainder);

  Align(&buf, 4);

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

Future<void> Present::NotifyMSC(const Window& window,
                                const uint32_t& serial,
                                const uint64_t& target_msc,
                                const uint64_t& divisor,
                                const uint64_t& remainder) {
  return Present::NotifyMSC(Present::NotifyMSCRequest{
      window, serial, target_msc, divisor, remainder});
}

Future<void> Present::SelectInput(const Present::SelectInputRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& eid = request.eid;
  auto& window = request.window;
  auto& event_mask = request.event_mask;

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

  // eid
  buf.Write(&eid);

  // window
  buf.Write(&window);

  // event_mask
  uint32_t tmp2;
  tmp2 = static_cast<uint32_t>(event_mask);
  buf.Write(&tmp2);

  Align(&buf, 4);

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

Future<void> Present::SelectInput(const Event& eid,
                                  const Window& window,
                                  const EventMask& event_mask) {
  return Present::SelectInput(
      Present::SelectInputRequest{eid, window, event_mask});
}

Future<Present::QueryCapabilitiesReply> Present::QueryCapabilities(
    const Present::QueryCapabilitiesRequest& request) {
  if (!connection_->Ready() || !present())
    return {};

  WriteBuffer buf;

  auto& target = request.target;

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

  // target
  buf.Write(&target);

  Align(&buf, 4);

  return connection_->SendRequest<Present::QueryCapabilitiesReply>(
      &buf, "Present::QueryCapabilities", false);
}

Future<Present::QueryCapabilitiesReply> Present::QueryCapabilities(
    const uint32_t& target) {
  return Present::QueryCapabilities(Present::QueryCapabilitiesRequest{target});
}

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

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

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

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

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

  return reply;
}

}  // namespace x11