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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
// 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.
#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_HEAP_TEST_OBJECTS_H_
#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_HEAP_TEST_OBJECTS_H_
#include "base/functional/callback_forward.h"
#include "third_party/blink/renderer/platform/heap/garbage_collected.h"
#include "third_party/blink/renderer/platform/heap/member.h"
#include "third_party/blink/renderer/platform/heap/visitor.h"
namespace blink {
template <typename T>
class ObjectWithCallbackBeforeInitializer
: public GarbageCollected<ObjectWithCallbackBeforeInitializer<T>> {
public:
ObjectWithCallbackBeforeInitializer(
base::OnceCallback<void(ObjectWithCallbackBeforeInitializer<T>*)>&& cb,
T* value)
: bool_(ExecuteCallbackReturnTrue(this, std::move(cb))), value_(value) {}
ObjectWithCallbackBeforeInitializer( // NOLINT
base::OnceCallback<void(ObjectWithCallbackBeforeInitializer<T>*)>&& cb)
: bool_(ExecuteCallbackReturnTrue(this, std::move(cb))) {}
virtual void Trace(Visitor* visitor) const { visitor->Trace(value_); }
T* value() const { return value_.Get(); }
private:
static bool ExecuteCallbackReturnTrue(
ObjectWithCallbackBeforeInitializer* thiz,
base::OnceCallback<void(ObjectWithCallbackBeforeInitializer<T>*)>&& cb) {
std::move(cb).Run(thiz);
return true;
}
bool bool_;
Member<T> value_;
};
template <typename T>
class MixinWithCallbackBeforeInitializer : public GarbageCollectedMixin {
public:
MixinWithCallbackBeforeInitializer(
base::OnceCallback<void(MixinWithCallbackBeforeInitializer<T>*)>&& cb,
T* value)
: bool_(ExecuteCallbackReturnTrue(this, std::move(cb))), value_(value) {}
MixinWithCallbackBeforeInitializer( // NOLINT
base::OnceCallback<void(MixinWithCallbackBeforeInitializer<T>*)>&& cb)
: bool_(ExecuteCallbackReturnTrue(this, std::move(cb))) {}
void Trace(Visitor* visitor) const override { visitor->Trace(value_); }
T* value() const { return value_.Get(); }
private:
static bool ExecuteCallbackReturnTrue(
MixinWithCallbackBeforeInitializer* thiz,
base::OnceCallback<void(MixinWithCallbackBeforeInitializer<T>*)>&& cb) {
std::move(cb).Run(thiz);
return true;
}
bool bool_;
Member<T> value_;
};
class BoolMixin {
protected:
bool bool_ = false;
};
template <typename T>
class ObjectWithMixinWithCallbackBeforeInitializer
: public GarbageCollected<ObjectWithMixinWithCallbackBeforeInitializer<T>>,
public BoolMixin,
public MixinWithCallbackBeforeInitializer<T> {
public:
using Mixin = MixinWithCallbackBeforeInitializer<T>;
ObjectWithMixinWithCallbackBeforeInitializer(
base::OnceCallback<void(Mixin*)>&& cb,
T* value)
: Mixin(std::move(cb), value) {}
ObjectWithMixinWithCallbackBeforeInitializer( // NOLINT
base::OnceCallback<void(Mixin*)>&& cb)
: Mixin(std::move(cb)) {}
void Trace(Visitor* visitor) const override { Mixin::Trace(visitor); }
};
// Simple linked object to be used in tests.
class LinkedObject : public GarbageCollected<LinkedObject> {
public:
LinkedObject() = default;
explicit LinkedObject(LinkedObject* next) : next_(next) {}
void set_next(LinkedObject* next) { next_ = next; }
LinkedObject* next() const { return next_.Get(); }
Member<LinkedObject>& next_ref() { return next_; }
virtual void Trace(Visitor* visitor) const { visitor->Trace(next_); }
private:
Member<LinkedObject> next_;
};
class IntegerObject : public GarbageCollected<IntegerObject> {
public:
static std::atomic_int destructor_calls;
explicit IntegerObject(int x) : x_(x) {}
virtual ~IntegerObject() {
destructor_calls.fetch_add(1, std::memory_order_relaxed);
}
virtual void Trace(Visitor* visitor) const {}
int Value() const { return x_; }
bool operator==(const IntegerObject& other) const {
return other.Value() == Value();
}
unsigned GetHash() { return WTF::GetHash(x_); }
private:
int x_;
};
struct IntegerObjectHash {
static unsigned GetHash(const IntegerObject& key) {
return WTF::HashInt(static_cast<uint32_t>(key.Value()));
}
static bool Equal(const IntegerObject& a, const IntegerObject& b) {
return a == b;
}
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_HEAP_TEST_OBJECTS_H_
|
