• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2016 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #ifndef CORE_FXCRT_RETAIN_PTR_H_
6 #define CORE_FXCRT_RETAIN_PTR_H_
7 
8 #include <functional>
9 #include <memory>
10 #include <utility>
11 
12 #include "core/fxcrt/fx_system.h"
13 #include "core/fxcrt/unowned_ptr.h"
14 
15 namespace fxcrt {
16 
17 // Used with std::unique_ptr to Release() objects that can't be deleted.
18 template <class T>
19 struct ReleaseDeleter {
operatorReleaseDeleter20   inline void operator()(T* ptr) const { ptr->Release(); }
21 };
22 
23 // Analogous to base's scoped_refptr.
24 template <class T>
25 class RetainPtr {
26  public:
RetainPtr(T * pObj)27   explicit RetainPtr(T* pObj) : m_pObj(pObj) {
28     if (m_pObj)
29       m_pObj->Retain();
30   }
31 
32   RetainPtr() = default;
RetainPtr(const RetainPtr & that)33   RetainPtr(const RetainPtr& that) : RetainPtr(that.Get()) {}
34 
35   // Move-construct a RetainPtr. After construction, |that| will be NULL.
RetainPtr(RetainPtr && that)36   RetainPtr(RetainPtr&& that) noexcept { Swap(that); }
37 
38   // Deliberately implicit to allow returning nullptrs.
39   // NOLINTNEXTLINE(runtime/explicit)
RetainPtr(std::nullptr_t ptr)40   RetainPtr(std::nullptr_t ptr) {}
41 
42   template <class U>
RetainPtr(const RetainPtr<U> & that)43   RetainPtr(const RetainPtr<U>& that) : RetainPtr(that.Get()) {}
44 
45   template <class U>
As()46   RetainPtr<U> As() const {
47     return RetainPtr<U>(static_cast<U*>(Get()));
48   }
49 
50   void Reset(T* obj = nullptr) {
51     if (obj)
52       obj->Retain();
53     m_pObj.reset(obj);
54   }
55 
Get()56   T* Get() const { return m_pObj.get(); }
BackPointer()57   UnownedPtr<T> BackPointer() const { return UnownedPtr<T>(Get()); }
Swap(RetainPtr & that)58   void Swap(RetainPtr& that) { m_pObj.swap(that.m_pObj); }
59 
60   // Useful for passing notion of object ownership across a C API.
Leak()61   T* Leak() { return m_pObj.release(); }
Unleak(T * ptr)62   void Unleak(T* ptr) { m_pObj.reset(ptr); }
63 
64   RetainPtr& operator=(const RetainPtr& that) {
65     if (*this != that)
66       Reset(that.Get());
67     return *this;
68   }
69 
70   // Move-assign a RetainPtr. After assignment, |that| will be NULL.
71   RetainPtr& operator=(RetainPtr&& that) {
72     m_pObj.reset(that.Leak());
73     return *this;
74   }
75 
76   // Assigment from raw pointers is intentially not provided to make
77   // reference count churn more visible where possible.
78 
79   bool operator==(const RetainPtr& that) const { return Get() == that.Get(); }
80   bool operator!=(const RetainPtr& that) const { return !(*this == that); }
81 
82   template <typename U>
83   bool operator==(const U& that) const {
84     return Get() == that;
85   }
86 
87   template <typename U>
88   bool operator!=(const U& that) const {
89     return !(*this == that);
90   }
91 
92   bool operator<(const RetainPtr& that) const {
93     return std::less<T*>()(Get(), that.Get());
94   }
95 
96   explicit operator bool() const { return !!m_pObj; }
97   T& operator*() const { return *m_pObj; }
98   T* operator->() const { return m_pObj.get(); }
99 
100  private:
101   std::unique_ptr<T, ReleaseDeleter<T>> m_pObj;
102 };
103 
104 // Trivial implementation - internal ref count with virtual destructor.
105 class Retainable {
106  public:
107   Retainable() = default;
108 
HasOneRef()109   bool HasOneRef() const { return m_nRefCount == 1; }
110 
111  protected:
112   virtual ~Retainable() = default;
113 
114  private:
115   template <typename U>
116   friend struct ReleaseDeleter;
117 
118   template <typename U>
119   friend class RetainPtr;
120 
121   Retainable(const Retainable& that) = delete;
122   Retainable& operator=(const Retainable& that) = delete;
123 
Retain()124   void Retain() const { ++m_nRefCount; }
Release()125   void Release() const {
126     ASSERT(m_nRefCount > 0);
127     if (--m_nRefCount == 0)
128       delete this;
129   }
130 
131   mutable intptr_t m_nRefCount = 0;
132 };
133 
134 template <typename T, typename U>
135 inline bool operator==(const U* lhs, const RetainPtr<T>& rhs) {
136   return rhs == lhs;
137 }
138 
139 template <typename T, typename U>
140 inline bool operator!=(const U* lhs, const RetainPtr<T>& rhs) {
141   return rhs != lhs;
142 }
143 
144 }  // namespace fxcrt
145 
146 using fxcrt::ReleaseDeleter;
147 using fxcrt::Retainable;
148 using fxcrt::RetainPtr;
149 
150 namespace pdfium {
151 
152 // Helper to make a RetainPtr along the lines of std::make_unique<>(),
153 // or pdfium::MakeUnique<>(). Arguments are forwarded to T's constructor.
154 // Classes managed by RetainPtr should have protected (or private)
155 // constructors, and should friend this function.
156 template <typename T, typename... Args>
MakeRetain(Args &&...args)157 RetainPtr<T> MakeRetain(Args&&... args) {
158   return RetainPtr<T>(new T(std::forward<Args>(args)...));
159 }
160 
161 // Type-deducing wrapper to make a RetainPtr from an ordinary pointer.
162 template <typename T>
WrapRetain(T * that)163 RetainPtr<T> WrapRetain(T* that) {
164   return RetainPtr<T>(that);
165 }
166 
167 }  // namespace pdfium
168 
169 #endif  // CORE_FXCRT_RETAIN_PTR_H_
170