blob: f591363f241b282c931d65bab0ce90d75ffffa06 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
// Copyright 2020 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.
#ifndef UI_GFX_X_XPROTO_TYPES_H_
#define UI_GFX_X_XPROTO_TYPES_H_
#include <cstdint>
#include <memory>
#include "base/bind.h"
#include "base/callback.h"
#include "base/component_export.h"
#include "base/memory/free_deleter.h"
#include "base/memory/ref_counted_memory.h"
#include "base/memory/scoped_refptr.h"
#include "base/optional.h"
namespace x11 {
class Error;
constexpr uint8_t kSendEventMask = 0x80;
namespace detail {
template <typename T>
void VerifyAlignment(T* t, size_t offset) {
// On the wire, X11 types are always aligned to their size. This is a sanity
// check to ensure padding etc are working properly.
if (sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8)
DCHECK_EQ(offset % sizeof(*t), 0UL);
}
} // namespace detail
// Wraps data read from the connection.
struct COMPONENT_EXPORT(X11) ReadBuffer {
explicit ReadBuffer(scoped_refptr<base::RefCountedMemory> data);
ReadBuffer(const ReadBuffer&) = delete;
ReadBuffer(ReadBuffer&&);
~ReadBuffer();
scoped_refptr<base::RefCountedMemory> ReadAndAdvance(size_t length);
int TakeFd();
scoped_refptr<base::RefCountedMemory> data;
size_t offset = 0;
const int* fds = nullptr;
};
// Wraps data to write to the connection.
class COMPONENT_EXPORT(X11) WriteBuffer {
public:
WriteBuffer();
WriteBuffer(const WriteBuffer&) = delete;
WriteBuffer(WriteBuffer&&);
~WriteBuffer();
void AppendBuffer(scoped_refptr<base::RefCountedMemory> buffer, size_t size);
std::vector<scoped_refptr<base::RefCountedMemory>>& GetBuffers();
size_t offset() const { return offset_; }
std::vector<int>& fds() { return fds_; }
template <typename T>
void Write(const T* t) {
static_assert(std::is_trivially_copyable<T>::value, "");
detail::VerifyAlignment(t, offset_);
const uint8_t* start = reinterpret_cast<const uint8_t*>(t);
std::copy(start, start + sizeof(*t), std::back_inserter(current_buffer_));
offset_ += sizeof(*t);
}
private:
void AppendCurrentBuffer();
std::vector<scoped_refptr<base::RefCountedMemory>> buffers_;
std::vector<uint8_t> current_buffer_;
size_t offset_ = 0;
std::vector<int> fds_;
};
namespace detail {
template <typename Reply>
std::unique_ptr<Reply> ReadReply(ReadBuffer* buffer);
} // namespace detail
template <class Reply>
class Future;
template <typename T>
T Read(ReadBuffer* buf);
template <typename T>
WriteBuffer Write(const T& t);
template <typename T>
void ReadEvent(T* event, ReadBuffer* buf);
template <typename Reply>
struct Response {
Response(std::unique_ptr<Reply> reply, std::unique_ptr<Error> error)
: reply(std::move(reply)), error(std::move(error)) {}
operator bool() const { return reply.get(); }
const Reply* operator->() const { return reply.get(); }
Reply* operator->() { return reply.get(); }
std::unique_ptr<Reply> reply;
std::unique_ptr<Error> error;
};
template <>
struct Response<void> {
std::unique_ptr<Error> error;
private:
friend class Future<void>;
explicit Response(std::unique_ptr<Error> error) : error(std::move(error)) {}
};
} // namespace x11
#endif // UI_GFX_X_XPROTO_TYPES_H_
|
