chromium/out/Default/gen/ui/gfx/x/dri3.cc

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

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

#include "dri3.h"

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

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

namespace x11 {

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

Future<Dri3::QueryVersionReply> Dri3::QueryVersion(
    const Dri3::QueryVersionRequest& request) { … }

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

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Dri3::QueryVersionReply> detail::ReadReply<
    Dri3::QueryVersionReply>(ReadBuffer* buffer) { … }

Future<Dri3::OpenReply> Dri3::Open(const Dri3::OpenRequest& request) { … }

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

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Dri3::OpenReply> detail::ReadReply<Dri3::OpenReply>(
    ReadBuffer* buffer) { … }

Future<void> Dri3::PixmapFromBuffer(
    const Dri3::PixmapFromBufferRequest& request) { … }

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

Future<Dri3::BufferFromPixmapReply> Dri3::BufferFromPixmap(
    const Dri3::BufferFromPixmapRequest& request) { … }

Future<Dri3::BufferFromPixmapReply> Dri3::BufferFromPixmap(
    const Pixmap& pixmap) { … }

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Dri3::BufferFromPixmapReply> detail::ReadReply<
    Dri3::BufferFromPixmapReply>(ReadBuffer* buffer) { … }

Future<void> Dri3::FenceFromFD(const Dri3::FenceFromFDRequest& request) { … }

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

Future<Dri3::FDFromFenceReply> Dri3::FDFromFence(
    const Dri3::FDFromFenceRequest& request) { … }

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

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Dri3::FDFromFenceReply> detail::ReadReply<
    Dri3::FDFromFenceReply>(ReadBuffer* buffer) { … }

Future<Dri3::GetSupportedModifiersReply> Dri3::GetSupportedModifiers(
    const Dri3::GetSupportedModifiersRequest& request) { … }

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

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Dri3::GetSupportedModifiersReply> detail::ReadReply<
    Dri3::GetSupportedModifiersReply>(ReadBuffer* buffer) { … }

Future<void> Dri3::PixmapFromBuffers(
    const Dri3::PixmapFromBuffersRequest& request) { … }

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

Future<Dri3::BuffersFromPixmapReply> Dri3::BuffersFromPixmap(
    const Dri3::BuffersFromPixmapRequest& request) { … }

Future<Dri3::BuffersFromPixmapReply> Dri3::BuffersFromPixmap(
    const Pixmap& pixmap) { … }

template <>
COMPONENT_EXPORT(X11)
std::unique_ptr<Dri3::BuffersFromPixmapReply> detail::ReadReply<
    Dri3::BuffersFromPixmapReply>(ReadBuffer* buffer) { … }

Future<void> Dri3::SetDRMDeviceInUse(
    const Dri3::SetDRMDeviceInUseRequest& request) { … }

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

Future<void> Dri3::ImportSyncobj(const Dri3::ImportSyncobjRequest& request) { … }

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

Future<void> Dri3::FreeSyncobj(const Dri3::FreeSyncobjRequest& request) { … }

Future<void> Dri3::FreeSyncobj(const Syncobj& syncobj) { … }

}  // namespace x11