blob: 93f12204126752ed8390dd5ec0c30155100451a0 (
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
// Copyright 2012 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 SKIA_EXT_REFPTR_H_
#define SKIA_EXT_REFPTR_H_
#include <algorithm>
#include <cstddef>
#include "third_party/skia/include/core/SkRefCnt.h"
namespace skia {
// When creating/receiving a ref-counted pointer from Skia, wrap that pointer in
// this class to avoid dealing with the ref-counting and prevent leaks/crashes
// due to ref-counting bugs.
//
// Example of creating a new SkShader* and setting it on a SkPaint:
// skia::RefPtr<SkShader> shader = skia::AdoptRef(SkGradientShader::Create());
// paint.setShader(shader.get());
//
// When passing around a ref-counted pointer to methods outside of Skia, always
// pass around the skia::RefPtr instead of the raw pointer. An example method
// that takes a SkShader* parameter and saves the SkShader* in the class.
// void AMethodThatSavesAShader(const skia::RefPtr<SkShader>& shader) {
// member_refptr_ = shader;
// }
// skia::RefPtr<SkShader> member_refptr_;
//
// When returning a ref-counted pointer, also return the skia::RefPtr instead.
// An example method that creates an SkShader* and returns it:
// skia::RefPtr<SkShader> MakeAShader() {
// return skia::AdoptRef(SkGradientShader::Create());
// }
//
// To take a scoped reference to an object whose references are all owned
// by other objects (i.e. does not have one that needs to be adopted) use the
// skia::SharePtr helper:
//
// skia::RefPtr<SkShader> shader = skia::SharePtr(paint.getShader());
//
// To pass a reference while clearing the pointer (without changing the ref
// count):
//
// skia::RefPtr<SkShader> shader = ...;
// UseThisShader(shader.Pass());
//
// Never call ref() or unref() on the underlying ref-counted pointer. If you
// AdoptRef() the raw pointer immediately into a skia::RefPtr and always work
// with skia::RefPtr instances instead, the ref-counting will be taken care of
// for you.
template<typename T>
class RefPtr {
public:
RefPtr() : ptr_(nullptr) {}
RefPtr(std::nullptr_t) : ptr_(nullptr) {}
// Copy constructor.
RefPtr(const RefPtr& other)
: ptr_(other.get()) {
SkSafeRef(ptr_);
}
// Copy conversion constructor.
template<typename U>
RefPtr(const RefPtr<U>& other)
: ptr_(other.get()) {
SkSafeRef(ptr_);
}
// Move constructor. This is required in addition to the conversion
// constructor below in order for clang to warn about pessimizing moves.
RefPtr(RefPtr&& other) : ptr_(other.get()) { other.ptr_ = nullptr; }
// Move conversion constructor.
template <typename U>
RefPtr(RefPtr<U>&& other)
: ptr_(other.get()) {
other.ptr_ = nullptr;
}
~RefPtr() {
clear();
}
RefPtr& operator=(std::nullptr_t) {
clear();
return *this;
}
RefPtr& operator=(const RefPtr& other) {
SkRefCnt_SafeAssign(ptr_, other.get());
return *this;
}
template<typename U>
RefPtr& operator=(const RefPtr<U>& other) {
SkRefCnt_SafeAssign(ptr_, other.get());
return *this;
}
template <typename U>
RefPtr& operator=(RefPtr<U>&& other) {
RefPtr<T> temp(std::move(other));
std::swap(ptr_, temp.ptr_);
return *this;
}
void clear() {
T* to_unref = ptr_;
ptr_ = nullptr;
SkSafeUnref(to_unref);
}
T* get() const { return ptr_; }
T& operator*() const { return *ptr_; }
T* operator->() const { return ptr_; }
typedef T* RefPtr::*unspecified_bool_type;
operator unspecified_bool_type() const {
return ptr_ ? &RefPtr::ptr_ : nullptr;
}
private:
T* ptr_;
// This function cannot be public because Skia starts its ref-counted
// objects at refcnt=1. This makes it impossible to differentiate
// between a newly created object (that doesn't need to be ref'd) or an
// already existing object with one owner (that does need to be ref'd so that
// this RefPtr can also manage its lifetime).
explicit RefPtr(T* ptr) : ptr_(ptr) {}
template<typename U>
friend RefPtr<U> AdoptRef(U* ptr);
template<typename U>
friend RefPtr<U> SharePtr(U* ptr);
template <typename U>
friend class RefPtr;
};
// For objects that have an unowned reference (such as newly created objects).
template<typename T>
RefPtr<T> AdoptRef(T* ptr) { return RefPtr<T>(ptr); }
// For objects that are already owned. This doesn't take ownership of existing
// references and adds a new one.
template<typename T>
RefPtr<T> SharePtr(T* ptr) { return RefPtr<T>(SkSafeRef(ptr)); }
} // namespace skia
#endif // SKIA_EXT_REFPTR_H_
|
