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
|
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_OZONE_PLATFORM_WAYLAND_TEST_SERVER_OBJECT_H_
#define UI_OZONE_PLATFORM_WAYLAND_TEST_SERVER_OBJECT_H_
#include <memory>
#include <type_traits>
#include <utility>
#include <wayland-server-core.h>
#include "base/memory/raw_ptr.h"
struct wl_client;
struct wl_resource;
namespace wl {
// Base class for managing the life cycle of server objects.
class ServerObject {
public:
explicit ServerObject(wl_resource* resource);
ServerObject(const ServerObject&) = delete;
ServerObject& operator=(const ServerObject&) = delete;
virtual ~ServerObject();
wl_resource* resource() const { return resource_; }
static void OnResourceDestroyed(wl_resource* resource);
private:
raw_ptr<wl_resource> resource_;
};
template <class T>
T* GetUserDataAs(wl_resource* resource) {
return static_cast<T*>(wl_resource_get_user_data(resource));
}
template <class T>
std::unique_ptr<T> TakeUserDataAs(wl_resource* resource) {
std::unique_ptr<T> user_data(GetUserDataAs<T>(resource));
if (std::is_base_of<ServerObject, T>::value) {
// Make sure ServerObject doesn't try to destroy the resource twice.
ServerObject::OnResourceDestroyed(resource);
}
wl_resource_set_user_data(resource, nullptr);
return user_data;
}
template <class T>
void DestroyUserData(wl_resource* resource) {
TakeUserDataAs<T>(resource);
}
template <class T>
void SetImplementation(wl_resource* resource,
const void* implementation,
std::unique_ptr<T> user_data) {
wl_resource_set_implementation(resource, implementation, user_data.release(),
DestroyUserData<T>);
}
template <typename ImplClass, typename... ImplArgs>
wl_resource* CreateResourceWithImpl(wl_client* client,
const struct wl_interface* interface,
int version,
const void* implementation,
uint32_t id,
ImplArgs&&... impl_args) {
wl_resource* resource = wl_resource_create(client, interface, version, id);
if (!resource) {
wl_client_post_no_memory(client);
return nullptr;
}
SetImplementation(resource, implementation,
std::make_unique<ImplClass>(
resource, std::forward<ImplArgs&&>(impl_args)...));
return resource;
}
// Does not transfer ownership of the user_data. Use with caution. The only
// legitimate purpose is setting more than one implementation to the same user
// data.
template <class T>
void SetImplementationUnretained(wl_resource* resource,
const void* implementation,
T* user_data) {
static_assert(std::is_base_of<ServerObject, T>::value,
"Only types derived from ServerObject are supported!");
wl_resource_set_implementation(resource, implementation, user_data,
&ServerObject::OnResourceDestroyed);
}
bool ResourceHasImplementation(wl_resource* resource,
const wl_interface* interface,
const void* impl);
void DestroyResource(wl_client* client, wl_resource* resource);
} // namespace wl
#endif // UI_OZONE_PLATFORM_WAYLAND_TEST_SERVER_OBJECT_H_
|
