| // 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 |
| |
| #ifndef UI_GFX_X_GENERATED_PROTOS_XF86DRI_H_ |
| #define UI_GFX_X_GENERATED_PROTOS_XF86DRI_H_ |
| |
| #include <array> |
| #include <cstddef> |
| #include <cstdint> |
| #include <cstring> |
| #include <vector> |
| |
| #include "base/component_export.h" |
| #include "base/files/scoped_file.h" |
| #include "base/memory/ref_counted_memory.h" |
| #include "base/memory/scoped_refptr.h" |
| #include "third_party/abseil-cpp/absl/types/optional.h" |
| #include "ui/gfx/x/error.h" |
| #include "ui/gfx/x/ref_counted_fd.h" |
| #include "xproto.h" |
| |
| namespace x11 { |
| |
| class Connection; |
| |
| template <typename Reply> |
| struct Response; |
| |
| template <typename Reply> |
| class Future; |
| |
| class COMPONENT_EXPORT(X11) XF86Dri { |
| public: |
| static constexpr unsigned major_version = 4; |
| static constexpr unsigned minor_version = 1; |
| |
| XF86Dri(Connection* connection, const x11::QueryExtensionReply& info); |
| |
| uint8_t present() const { return info_.present; } |
| uint8_t major_opcode() const { return info_.major_opcode; } |
| uint8_t first_event() const { return info_.first_event; } |
| uint8_t first_error() const { return info_.first_error; } |
| |
| Connection* connection() const { return connection_; } |
| |
| struct DrmClipRect { |
| int16_t x1{}; |
| int16_t y1{}; |
| int16_t x2{}; |
| int16_t x3{}; |
| }; |
| |
| struct QueryVersionRequest {}; |
| |
| struct QueryVersionReply { |
| uint16_t sequence{}; |
| uint16_t dri_major_version{}; |
| uint16_t dri_minor_version{}; |
| uint32_t dri_minor_patch{}; |
| }; |
| |
| using QueryVersionResponse = Response<QueryVersionReply>; |
| |
| Future<QueryVersionReply> QueryVersion(const QueryVersionRequest& request); |
| |
| Future<QueryVersionReply> QueryVersion(); |
| |
| struct QueryDirectRenderingCapableRequest { |
| uint32_t screen{}; |
| }; |
| |
| struct QueryDirectRenderingCapableReply { |
| uint16_t sequence{}; |
| uint8_t is_capable{}; |
| }; |
| |
| using QueryDirectRenderingCapableResponse = |
| Response<QueryDirectRenderingCapableReply>; |
| |
| Future<QueryDirectRenderingCapableReply> QueryDirectRenderingCapable( |
| const QueryDirectRenderingCapableRequest& request); |
| |
| Future<QueryDirectRenderingCapableReply> QueryDirectRenderingCapable( |
| const uint32_t& screen = {}); |
| |
| struct OpenConnectionRequest { |
| uint32_t screen{}; |
| }; |
| |
| struct OpenConnectionReply { |
| uint16_t sequence{}; |
| uint32_t sarea_handle_low{}; |
| uint32_t sarea_handle_high{}; |
| std::string bus_id{}; |
| }; |
| |
| using OpenConnectionResponse = Response<OpenConnectionReply>; |
| |
| Future<OpenConnectionReply> OpenConnection( |
| const OpenConnectionRequest& request); |
| |
| Future<OpenConnectionReply> OpenConnection(const uint32_t& screen = {}); |
| |
| struct CloseConnectionRequest { |
| uint32_t screen{}; |
| }; |
| |
| using CloseConnectionResponse = Response<void>; |
| |
| Future<void> CloseConnection(const CloseConnectionRequest& request); |
| |
| Future<void> CloseConnection(const uint32_t& screen = {}); |
| |
| struct GetClientDriverNameRequest { |
| uint32_t screen{}; |
| }; |
| |
| struct GetClientDriverNameReply { |
| uint16_t sequence{}; |
| uint32_t client_driver_major_version{}; |
| uint32_t client_driver_minor_version{}; |
| uint32_t client_driver_patch_version{}; |
| std::string client_driver_name{}; |
| }; |
| |
| using GetClientDriverNameResponse = Response<GetClientDriverNameReply>; |
| |
| Future<GetClientDriverNameReply> GetClientDriverName( |
| const GetClientDriverNameRequest& request); |
| |
| Future<GetClientDriverNameReply> GetClientDriverName( |
| const uint32_t& screen = {}); |
| |
| struct CreateContextRequest { |
| uint32_t screen{}; |
| uint32_t visual{}; |
| uint32_t context{}; |
| }; |
| |
| struct CreateContextReply { |
| uint16_t sequence{}; |
| uint32_t hw_context{}; |
| }; |
| |
| using CreateContextResponse = Response<CreateContextReply>; |
| |
| Future<CreateContextReply> CreateContext(const CreateContextRequest& request); |
| |
| Future<CreateContextReply> CreateContext(const uint32_t& screen = {}, |
| const uint32_t& visual = {}, |
| const uint32_t& context = {}); |
| |
| struct DestroyContextRequest { |
| uint32_t screen{}; |
| uint32_t context{}; |
| }; |
| |
| using DestroyContextResponse = Response<void>; |
| |
| Future<void> DestroyContext(const DestroyContextRequest& request); |
| |
| Future<void> DestroyContext(const uint32_t& screen = {}, |
| const uint32_t& context = {}); |
| |
| struct CreateDrawableRequest { |
| uint32_t screen{}; |
| uint32_t drawable{}; |
| }; |
| |
| struct CreateDrawableReply { |
| uint16_t sequence{}; |
| uint32_t hw_drawable_handle{}; |
| }; |
| |
| using CreateDrawableResponse = Response<CreateDrawableReply>; |
| |
| Future<CreateDrawableReply> CreateDrawable( |
| const CreateDrawableRequest& request); |
| |
| Future<CreateDrawableReply> CreateDrawable(const uint32_t& screen = {}, |
| const uint32_t& drawable = {}); |
| |
| struct DestroyDrawableRequest { |
| uint32_t screen{}; |
| uint32_t drawable{}; |
| }; |
| |
| using DestroyDrawableResponse = Response<void>; |
| |
| Future<void> DestroyDrawable(const DestroyDrawableRequest& request); |
| |
| Future<void> DestroyDrawable(const uint32_t& screen = {}, |
| const uint32_t& drawable = {}); |
| |
| struct GetDrawableInfoRequest { |
| uint32_t screen{}; |
| uint32_t drawable{}; |
| }; |
| |
| struct GetDrawableInfoReply { |
| uint16_t sequence{}; |
| uint32_t drawable_table_index{}; |
| uint32_t drawable_table_stamp{}; |
| int16_t drawable_origin_X{}; |
| int16_t drawable_origin_Y{}; |
| int16_t drawable_size_W{}; |
| int16_t drawable_size_H{}; |
| int16_t back_x{}; |
| int16_t back_y{}; |
| std::vector<DrmClipRect> clip_rects{}; |
| std::vector<DrmClipRect> back_clip_rects{}; |
| }; |
| |
| using GetDrawableInfoResponse = Response<GetDrawableInfoReply>; |
| |
| Future<GetDrawableInfoReply> GetDrawableInfo( |
| const GetDrawableInfoRequest& request); |
| |
| Future<GetDrawableInfoReply> GetDrawableInfo(const uint32_t& screen = {}, |
| const uint32_t& drawable = {}); |
| |
| struct GetDeviceInfoRequest { |
| uint32_t screen{}; |
| }; |
| |
| struct GetDeviceInfoReply { |
| uint16_t sequence{}; |
| uint32_t framebuffer_handle_low{}; |
| uint32_t framebuffer_handle_high{}; |
| uint32_t framebuffer_origin_offset{}; |
| uint32_t framebuffer_size{}; |
| uint32_t framebuffer_stride{}; |
| std::vector<uint32_t> device_private{}; |
| }; |
| |
| using GetDeviceInfoResponse = Response<GetDeviceInfoReply>; |
| |
| Future<GetDeviceInfoReply> GetDeviceInfo(const GetDeviceInfoRequest& request); |
| |
| Future<GetDeviceInfoReply> GetDeviceInfo(const uint32_t& screen = {}); |
| |
| struct AuthConnectionRequest { |
| uint32_t screen{}; |
| uint32_t magic{}; |
| }; |
| |
| struct AuthConnectionReply { |
| uint16_t sequence{}; |
| uint32_t authenticated{}; |
| }; |
| |
| using AuthConnectionResponse = Response<AuthConnectionReply>; |
| |
| Future<AuthConnectionReply> AuthConnection( |
| const AuthConnectionRequest& request); |
| |
| Future<AuthConnectionReply> AuthConnection(const uint32_t& screen = {}, |
| const uint32_t& magic = {}); |
| |
| private: |
| Connection* const connection_; |
| x11::QueryExtensionReply info_{}; |
| }; |
| |
| } // namespace x11 |
| |
| #endif // UI_GFX_X_GENERATED_PROTOS_XF86DRI_H_ |