summaryrefslogtreecommitdiff
path: root/core/fxcrt/retain_ptr.h
diff options
context:
space:
mode:
authorDan Sinclair <dsinclair@chromium.org>2017-09-21 15:49:49 -0400
committerChromium commit bot <commit-bot@chromium.org>2017-09-21 20:17:31 +0000
commit0b95042db2e6dab5876abd12ce485fff0a8e08fe (patch)
tree02132ed53945fde30bfbf230ff4e9b5308dd7732 /core/fxcrt/retain_ptr.h
parenta5eb9f05b7c3f82630784e043ccf75c4e019b18f (diff)
downloadpdfium-0b95042db2e6dab5876abd12ce485fff0a8e08fe.tar.xz
Rename CFX_RetainPtr to RetainPtr
This CL renames CFX_RetainPtr to RetainPtr and places in the fxcrt namespace. Bug: pdfium:898 Change-Id: I8798a9f79cb0840d3f037e8d04937cedd742914e Reviewed-on: https://pdfium-review.googlesource.com/14616 Reviewed-by: Tom Sepez <tsepez@chromium.org> Commit-Queue: dsinclair <dsinclair@chromium.org>
Diffstat (limited to 'core/fxcrt/retain_ptr.h')
-rw-r--r--core/fxcrt/retain_ptr.h130
1 files changed, 130 insertions, 0 deletions
diff --git a/core/fxcrt/retain_ptr.h b/core/fxcrt/retain_ptr.h
new file mode 100644
index 0000000000..481bfbba56
--- /dev/null
+++ b/core/fxcrt/retain_ptr.h
@@ -0,0 +1,130 @@
+// Copyright 2016 PDFium 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 CORE_FXCRT_RETAIN_PTR_H_
+#define CORE_FXCRT_RETAIN_PTR_H_
+
+#include <functional>
+#include <memory>
+#include <utility>
+
+#include "core/fxcrt/fx_system.h"
+
+namespace fxcrt {
+
+// Used with std::unique_ptr to Release() objects that can't be deleted.
+template <class T>
+struct ReleaseDeleter {
+ inline void operator()(T* ptr) const { ptr->Release(); }
+};
+
+// Analogous to base's scoped_refptr.
+template <class T>
+class RetainPtr {
+ public:
+ explicit RetainPtr(T* pObj) : m_pObj(pObj) {
+ if (m_pObj)
+ m_pObj->Retain();
+ }
+
+ RetainPtr() {}
+ RetainPtr(const RetainPtr& that) : RetainPtr(that.Get()) {}
+ RetainPtr(RetainPtr&& that) noexcept { Swap(that); }
+
+ // Deliberately implicit to allow returning nullptrs.
+ // NOLINTNEXTLINE(runtime/explicit)
+ RetainPtr(std::nullptr_t ptr) {}
+
+ template <class U>
+ RetainPtr(const RetainPtr<U>& that) : RetainPtr(that.Get()) {}
+
+ template <class U>
+ RetainPtr<U> As() const {
+ return RetainPtr<U>(static_cast<U*>(Get()));
+ }
+
+ void Reset(T* obj = nullptr) {
+ if (obj)
+ obj->Retain();
+ m_pObj.reset(obj);
+ }
+
+ T* Get() const { return m_pObj.get(); }
+ void Swap(RetainPtr& that) { m_pObj.swap(that.m_pObj); }
+
+ // Useful for passing notion of object ownership across a C API.
+ T* Leak() { return m_pObj.release(); }
+ void Unleak(T* ptr) { m_pObj.reset(ptr); }
+
+ RetainPtr& operator=(const RetainPtr& that) {
+ if (*this != that)
+ Reset(that.Get());
+ return *this;
+ }
+
+ RetainPtr& operator=(RetainPtr&& that) {
+ m_pObj.reset(that.Leak());
+ return *this;
+ }
+
+ bool operator==(const RetainPtr& that) const { return Get() == that.Get(); }
+ bool operator!=(const RetainPtr& that) const { return !(*this == that); }
+
+ bool operator<(const RetainPtr& that) const {
+ return std::less<T*>()(Get(), that.Get());
+ }
+
+ explicit operator bool() const { return !!m_pObj; }
+ T& operator*() const { return *m_pObj.get(); }
+ T* operator->() const { return m_pObj.get(); }
+
+ private:
+ std::unique_ptr<T, ReleaseDeleter<T>> m_pObj;
+};
+
+// Trivial implementation - internal ref count with virtual destructor.
+class Retainable {
+ public:
+ bool HasOneRef() const { return m_nRefCount == 1; }
+
+ protected:
+ virtual ~Retainable() {}
+
+ private:
+ template <typename U>
+ friend struct ReleaseDeleter;
+
+ template <typename U>
+ friend class RetainPtr;
+
+ void Retain() { ++m_nRefCount; }
+ void Release() {
+ ASSERT(m_nRefCount > 0);
+ if (--m_nRefCount == 0)
+ delete this;
+ }
+
+ intptr_t m_nRefCount = 0;
+};
+
+} // namespace fxcrt
+
+using fxcrt::ReleaseDeleter;
+using fxcrt::RetainPtr;
+using fxcrt::Retainable;
+
+namespace pdfium {
+
+// Helper to make a RetainPtr along the lines of std::make_unique<>(),
+// or pdfium::MakeUnique<>(). Arguments are forwarded to T's constructor.
+// Classes managed by RetainPtr should have protected (or private)
+// constructors, and should friend this function.
+template <typename T, typename... Args>
+RetainPtr<T> MakeRetain(Args&&... args) {
+ return RetainPtr<T>(new T(std::forward<Args>(args)...));
+}
+
+} // namespace pdfium
+
+#endif // CORE_FXCRT_RETAIN_PTR_H_