chromium/out/Default/gen/ui/gfx/x/shm.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 "shm.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 {

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

template <>
COMPONENT_EXPORT(X11)
void ReadEvent<Shm::CompletionEvent>(Shm::CompletionEvent* event_,
                                     ReadBuffer* buffer) { … }

std::string Shm::BadSegError::ToString() const { … }

template <>
void ReadError<Shm::BadSegError>(Shm::BadSegError* error_, ReadBuffer* buffer) { … }

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

Future<Shm::QueryVersionReply> Shm::QueryVersion() { … }

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

Future<void> Shm::Attach(const Shm::AttachRequest& request) { … }

Future<void> Shm::Attach(const Seg& shmseg,
                         const uint32_t& shmid,
                         const uint8_t& read_only) { … }

Future<void> Shm::Detach(const Shm::DetachRequest& request) { … }

Future<void> Shm::Detach(const Seg& shmseg) { … }

Future<void> Shm::PutImage(const Shm::PutImageRequest& request) { … }

Future<void> Shm::PutImage(const Drawable& drawable,
                           const GraphicsContext& gc,
                           const uint16_t& total_width,
                           const uint16_t& total_height,
                           const uint16_t& src_x,
                           const uint16_t& src_y,
                           const uint16_t& src_width,
                           const uint16_t& src_height,
                           const int16_t& dst_x,
                           const int16_t& dst_y,
                           const uint8_t& depth,
                           const ImageFormat& format,
                           const uint8_t& send_event,
                           const Seg& shmseg,
                           const uint32_t& offset) { … }

Future<Shm::GetImageReply> Shm::GetImage(const Shm::GetImageRequest& request) { … }

Future<Shm::GetImageReply> Shm::GetImage(const Drawable& drawable,
                                         const int16_t& x,
                                         const int16_t& y,
                                         const uint16_t& width,
                                         const uint16_t& height,
                                         const uint32_t& plane_mask,
                                         const uint8_t& format,
                                         const Seg& shmseg,
                                         const uint32_t& offset) { … }

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

Future<void> Shm::CreatePixmap(const Shm::CreatePixmapRequest& request) { … }

Future<void> Shm::CreatePixmap(const Pixmap& pid,
                               const Drawable& drawable,
                               const uint16_t& width,
                               const uint16_t& height,
                               const uint8_t& depth,
                               const Seg& shmseg,
                               const uint32_t& offset) { … }

Future<void> Shm::AttachFd(const Shm::AttachFdRequest& request) { … }

Future<void> Shm::AttachFd(const Seg& shmseg,
                           const RefCountedFD& shm_fd,
                           const uint8_t& read_only) { … }

Future<Shm::CreateSegmentReply> Shm::CreateSegment(
    const Shm::CreateSegmentRequest& request) { … }

Future<Shm::CreateSegmentReply> Shm::CreateSegment(const Seg& shmseg,
                                                   const uint32_t& size,
                                                   const uint8_t& read_only) { … }

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

}  // namespace x11