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
|
// Copyright 2015 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 THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_IMPL_TRACE_TRAITS_H_
#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_IMPL_TRACE_TRAITS_H_
#include "base/optional.h"
#include "third_party/blink/renderer/platform/heap/heap.h"
#include "third_party/blink/renderer/platform/heap/impl/gc_info.h"
#include "third_party/blink/renderer/platform/heap/impl/heap_page.h"
#include "third_party/blink/renderer/platform/heap/visitor.h"
#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
#include "third_party/blink/renderer/platform/wtf/assertions.h"
#include "third_party/blink/renderer/platform/wtf/hash_counted_set.h"
#include "third_party/blink/renderer/platform/wtf/hash_map.h"
#include "third_party/blink/renderer/platform/wtf/hash_set.h"
#include "third_party/blink/renderer/platform/wtf/hash_table.h"
#include "third_party/blink/renderer/platform/wtf/linked_hash_set.h"
#include "third_party/blink/renderer/platform/wtf/list_hash_set.h"
#include "third_party/blink/renderer/platform/wtf/type_traits.h"
namespace blink {
template <typename T>
struct TraceTrait;
template <typename T, bool = NeedsAdjustPointer<T>::value>
struct AdjustPointerTrait;
template <typename T>
struct AdjustPointerTrait<T, false> {
STATIC_ONLY(AdjustPointerTrait);
static TraceDescriptor GetTraceDescriptor(const void* self) {
return {self, TraceTrait<T>::Trace};
}
};
template <typename T>
struct AdjustPointerTrait<T, true> {
STATIC_ONLY(AdjustPointerTrait);
static TraceDescriptor GetTraceDescriptor(const void* self) {
// Tracing an object, and more specifically GetTraceDescriptor for an
// object, implies having a reference which means the object is at least in
// construction. Therefore it is guaranteed that the ObjectStartBitmap was
// already updated to include the object, and its HeapObjectHeader was
// already created.
HeapObjectHeader* const header = HeapObjectHeader::FromInnerAddress<
HeapObjectHeader::AccessMode::kAtomic>(self);
return {header->Payload(),
GCInfo::From(
header->GcInfoIndex<HeapObjectHeader::AccessMode::kAtomic>())
.trace};
}
};
template <typename T, bool = WTF::IsTraceable<T>::value>
struct TraceIfNeeded;
template <typename T>
struct TraceIfNeeded<T, false> {
STATIC_ONLY(TraceIfNeeded);
static void Trace(Visitor*, const T&) {}
};
template <typename T>
struct TraceIfNeeded<T, true> {
STATIC_ONLY(TraceIfNeeded);
static void Trace(Visitor* visitor, const T& t) { visitor->Trace(t); }
};
// The TraceTrait is used to specify how to trace and object for Oilpan and
// wrapper tracing.
//
//
// By default, the 'Trace' method implemented on an object itself is
// used to trace the pointers to other heap objects inside the object.
//
// However, the TraceTrait can be specialized to use a different
// implementation. A common case where a TraceTrait specialization is
// needed is when multiple inheritance leads to pointers that are not
// to the start of the object in the Blink garbage-collected heap. In
// that case the pointer has to be adjusted before marking.
template <typename T>
struct TraceTrait {
STATIC_ONLY(TraceTrait);
public:
static TraceDescriptor GetTraceDescriptor(const void* self) {
return AdjustPointerTrait<T>::GetTraceDescriptor(
static_cast<const T*>(self));
}
static TraceDescriptor GetWeakTraceDescriptor(const void* self) {
return {self, nullptr};
}
static void Trace(Visitor*, const void* self);
};
template <typename T>
struct TraceTrait<const T> : public TraceTrait<T> {};
template <typename T>
void TraceTrait<T>::Trace(Visitor* visitor, const void* self) {
static_assert(WTF::IsTraceable<T>::value, "T should be traceable");
static_cast<const T*>(self)->Trace(visitor);
}
// This trace trait for std::pair will null weak members if their referent is
// collected. If you have a collection that contain weakness it does not remove
// entries from the collection that contain nulled weak members.
template <typename T, typename U>
struct TraceTrait<std::pair<T, U>> {
STATIC_ONLY(TraceTrait);
public:
static void Trace(Visitor* visitor, const std::pair<T, U>* pair) {
TraceIfNeeded<T>::Trace(visitor, pair->first);
TraceIfNeeded<U>::Trace(visitor, pair->second);
}
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_PLATFORM_HEAP_IMPL_TRACE_TRAITS_H_
|
