From b872a93e5cd940dc28ad960b13b0cf01a6db3400 Mon Sep 17 00:00:00 2001 From: Dan Sinclair Date: Thu, 21 Sep 2017 17:05:15 -0400 Subject: Move CFX_WeakPtr to WeakPtr This CL renames CFX_WeakPtr to WeakPtr and moves into the fxcrt namespace. Bug: pdfium:898 Change-Id: Ide50a8afeb1e987c48c8fbd103898745c9199d6a Reviewed-on: https://pdfium-review.googlesource.com/14621 Commit-Queue: dsinclair Commit-Queue: Tom Sepez Reviewed-by: Tom Sepez --- core/fxcrt/cfx_weak_ptr.h | 86 ----------------- core/fxcrt/cfx_weak_ptr_unittest.cpp | 173 ---------------------------------- core/fxcrt/weak_ptr.h | 92 ++++++++++++++++++ core/fxcrt/weak_ptr_unittest.cpp | 176 +++++++++++++++++++++++++++++++++++ 4 files changed, 268 insertions(+), 259 deletions(-) delete mode 100644 core/fxcrt/cfx_weak_ptr.h delete mode 100644 core/fxcrt/cfx_weak_ptr_unittest.cpp create mode 100644 core/fxcrt/weak_ptr.h create mode 100644 core/fxcrt/weak_ptr_unittest.cpp (limited to 'core/fxcrt') diff --git a/core/fxcrt/cfx_weak_ptr.h b/core/fxcrt/cfx_weak_ptr.h deleted file mode 100644 index da96000a1b..0000000000 --- a/core/fxcrt/cfx_weak_ptr.h +++ /dev/null @@ -1,86 +0,0 @@ -// 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. - -// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com - -#ifndef CORE_FXCRT_CFX_WEAK_PTR_H_ -#define CORE_FXCRT_CFX_WEAK_PTR_H_ - -#include -#include -#include - -#include "core/fxcrt/fx_system.h" -#include "core/fxcrt/retain_ptr.h" - -template > -class CFX_WeakPtr { - public: - CFX_WeakPtr() {} - CFX_WeakPtr(const CFX_WeakPtr& that) : m_pHandle(that.m_pHandle) {} - CFX_WeakPtr(CFX_WeakPtr&& that) noexcept { Swap(that); } - explicit CFX_WeakPtr(std::unique_ptr pObj) - : m_pHandle(new Handle(std::move(pObj))) {} - - // Deliberately implicit to allow passing nullptr. - // NOLINTNEXTLINE(runtime/explicit) - CFX_WeakPtr(std::nullptr_t arg) {} - - explicit operator bool() const { return m_pHandle && !!m_pHandle->Get(); } - bool HasOneRef() const { return m_pHandle && m_pHandle->HasOneRef(); } - T* operator->() { return m_pHandle->Get(); } - const T* operator->() const { return m_pHandle->Get(); } - CFX_WeakPtr& operator=(const CFX_WeakPtr& that) { - m_pHandle = that.m_pHandle; - return *this; - } - bool operator==(const CFX_WeakPtr& that) const { - return m_pHandle == that.m_pHandle; - } - bool operator!=(const CFX_WeakPtr& that) const { return !(*this == that); } - - T* Get() const { return m_pHandle ? m_pHandle->Get() : nullptr; } - void DeleteObject() { - if (m_pHandle) { - m_pHandle->Clear(); - m_pHandle.Reset(); - } - } - void Reset() { m_pHandle.Reset(); } - void Reset(std::unique_ptr pObj) { - m_pHandle.Reset(new Handle(std::move(pObj))); - } - void Swap(CFX_WeakPtr& that) { m_pHandle.Swap(that.m_pHandle); } - - private: - class Handle { - public: - explicit Handle(std::unique_ptr ptr) - : m_nCount(0), m_pObj(std::move(ptr)) {} - void Reset(std::unique_ptr ptr) { m_pObj = std::move(ptr); } - void Clear() { // Now you're all weak ptrs ... - m_pObj.reset(); // unique_ptr nulls first before invoking delete. - } - T* Get() const { return m_pObj.get(); } - T* Retain() { - ++m_nCount; - return m_pObj.get(); - } - void Release() { - if (--m_nCount == 0) - delete this; - } - bool HasOneRef() const { return m_nCount == 1; } - - private: - ~Handle() {} - - intptr_t m_nCount; - std::unique_ptr m_pObj; - }; - - RetainPtr m_pHandle; -}; - -#endif // CORE_FXCRT_CFX_WEAK_PTR_H_ diff --git a/core/fxcrt/cfx_weak_ptr_unittest.cpp b/core/fxcrt/cfx_weak_ptr_unittest.cpp deleted file mode 100644 index aafcf16b3d..0000000000 --- a/core/fxcrt/cfx_weak_ptr_unittest.cpp +++ /dev/null @@ -1,173 +0,0 @@ -// 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. - -#include "core/fxcrt/cfx_weak_ptr.h" - -#include -#include - -#include "core/fxcrt/fx_memory.h" -#include "testing/gtest/include/gtest/gtest.h" - -namespace { - -class PseudoDeletable; -using WeakPtr = CFX_WeakPtr>; -using UniquePtr = - std::unique_ptr>; - -class PseudoDeletable { - public: - PseudoDeletable() : delete_count_(0) {} - void Release() { - ++delete_count_; - next_.Reset(); - } - void SetNext(const WeakPtr& next) { next_ = next; } - int delete_count() const { return delete_count_; } - - private: - int delete_count_; - WeakPtr next_; -}; - -} // namespace - -TEST(fxcrt, WeakPtrNull) { - WeakPtr ptr1; - EXPECT_FALSE(ptr1); - - WeakPtr ptr2; - EXPECT_TRUE(ptr1 == ptr2); - EXPECT_FALSE(ptr1 != ptr2); - - WeakPtr ptr3(ptr1); - EXPECT_TRUE(ptr1 == ptr3); - EXPECT_FALSE(ptr1 != ptr3); - - WeakPtr ptr4 = ptr1; - EXPECT_TRUE(ptr1 == ptr4); - EXPECT_FALSE(ptr1 != ptr4); -} - -TEST(fxcrt, WeakPtrNonNull) { - PseudoDeletable thing; - EXPECT_EQ(0, thing.delete_count()); - { - UniquePtr unique(&thing); - WeakPtr ptr1(std::move(unique)); - EXPECT_TRUE(ptr1); - EXPECT_EQ(&thing, ptr1.Get()); - - WeakPtr ptr2; - EXPECT_FALSE(ptr1 == ptr2); - EXPECT_TRUE(ptr1 != ptr2); - { - WeakPtr ptr3(ptr1); - EXPECT_TRUE(ptr1 == ptr3); - EXPECT_FALSE(ptr1 != ptr3); - EXPECT_EQ(&thing, ptr3.Get()); - { - WeakPtr ptr4 = ptr1; - EXPECT_TRUE(ptr1 == ptr4); - EXPECT_FALSE(ptr1 != ptr4); - EXPECT_EQ(&thing, ptr4.Get()); - } - } - EXPECT_EQ(0, thing.delete_count()); - } - EXPECT_EQ(1, thing.delete_count()); -} - -TEST(fxcrt, WeakPtrResetNull) { - PseudoDeletable thing; - { - UniquePtr unique(&thing); - WeakPtr ptr1(std::move(unique)); - WeakPtr ptr2 = ptr1; - ptr1.Reset(); - EXPECT_FALSE(ptr1); - EXPECT_EQ(nullptr, ptr1.Get()); - EXPECT_TRUE(ptr2); - EXPECT_EQ(&thing, ptr2.Get()); - EXPECT_FALSE(ptr1 == ptr2); - EXPECT_TRUE(ptr1 != ptr2); - EXPECT_EQ(0, thing.delete_count()); - } - EXPECT_EQ(1, thing.delete_count()); -} - -TEST(fxcrt, WeakPtrResetNonNull) { - PseudoDeletable thing1; - PseudoDeletable thing2; - { - UniquePtr unique1(&thing1); - WeakPtr ptr1(std::move(unique1)); - WeakPtr ptr2 = ptr1; - UniquePtr unique2(&thing2); - ptr2.Reset(std::move(unique2)); - EXPECT_TRUE(ptr1); - EXPECT_EQ(&thing1, ptr1.Get()); - EXPECT_TRUE(ptr2); - EXPECT_EQ(&thing2, ptr2.Get()); - EXPECT_FALSE(ptr1 == ptr2); - EXPECT_TRUE(ptr1 != ptr2); - EXPECT_EQ(0, thing1.delete_count()); - EXPECT_EQ(0, thing2.delete_count()); - } - EXPECT_EQ(1, thing1.delete_count()); - EXPECT_EQ(1, thing2.delete_count()); -} - -TEST(fxcrt, WeakPtrDeleteObject) { - PseudoDeletable thing; - { - UniquePtr unique(&thing); - WeakPtr ptr1(std::move(unique)); - WeakPtr ptr2 = ptr1; - ptr1.DeleteObject(); - EXPECT_FALSE(ptr1); - EXPECT_EQ(nullptr, ptr1.Get()); - EXPECT_FALSE(ptr2); - EXPECT_EQ(nullptr, ptr2.Get()); - EXPECT_FALSE(ptr1 == ptr2); - EXPECT_TRUE(ptr1 != ptr2); - EXPECT_EQ(1, thing.delete_count()); - } - EXPECT_EQ(1, thing.delete_count()); -} - -TEST(fxcrt, WeakPtrCyclic) { - PseudoDeletable thing1; - PseudoDeletable thing2; - { - UniquePtr unique1(&thing1); - UniquePtr unique2(&thing2); - WeakPtr ptr1(std::move(unique1)); - WeakPtr ptr2(std::move(unique2)); - ptr1->SetNext(ptr2); - ptr2->SetNext(ptr1); - } - // Leaks without explicit clear. - EXPECT_EQ(0, thing1.delete_count()); - EXPECT_EQ(0, thing2.delete_count()); -} - -TEST(fxcrt, WeakPtrCyclicDeleteObject) { - PseudoDeletable thing1; - PseudoDeletable thing2; - { - UniquePtr unique1(&thing1); - UniquePtr unique2(&thing2); - WeakPtr ptr1(std::move(unique1)); - WeakPtr ptr2(std::move(unique2)); - ptr1->SetNext(ptr2); - ptr2->SetNext(ptr1); - ptr1.DeleteObject(); - EXPECT_EQ(1, thing1.delete_count()); - EXPECT_EQ(0, thing2.delete_count()); - } - EXPECT_EQ(1, thing1.delete_count()); - EXPECT_EQ(1, thing2.delete_count()); -} diff --git a/core/fxcrt/weak_ptr.h b/core/fxcrt/weak_ptr.h new file mode 100644 index 0000000000..eb8523bd3d --- /dev/null +++ b/core/fxcrt/weak_ptr.h @@ -0,0 +1,92 @@ +// 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. + +// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com + +#ifndef CORE_FXCRT_WEAK_PTR_H_ +#define CORE_FXCRT_WEAK_PTR_H_ + +#include +#include +#include + +#include "core/fxcrt/fx_system.h" +#include "core/fxcrt/retain_ptr.h" + +namespace fxcrt { + +template > +class WeakPtr { + public: + WeakPtr() {} + WeakPtr(const WeakPtr& that) : m_pHandle(that.m_pHandle) {} + WeakPtr(WeakPtr&& that) noexcept { Swap(that); } + explicit WeakPtr(std::unique_ptr pObj) + : m_pHandle(new Handle(std::move(pObj))) {} + + // Deliberately implicit to allow passing nullptr. + // NOLINTNEXTLINE(runtime/explicit) + WeakPtr(std::nullptr_t arg) {} + + explicit operator bool() const { return m_pHandle && !!m_pHandle->Get(); } + bool HasOneRef() const { return m_pHandle && m_pHandle->HasOneRef(); } + T* operator->() { return m_pHandle->Get(); } + const T* operator->() const { return m_pHandle->Get(); } + WeakPtr& operator=(const WeakPtr& that) { + m_pHandle = that.m_pHandle; + return *this; + } + bool operator==(const WeakPtr& that) const { + return m_pHandle == that.m_pHandle; + } + bool operator!=(const WeakPtr& that) const { return !(*this == that); } + + T* Get() const { return m_pHandle ? m_pHandle->Get() : nullptr; } + void DeleteObject() { + if (m_pHandle) { + m_pHandle->Clear(); + m_pHandle.Reset(); + } + } + void Reset() { m_pHandle.Reset(); } + void Reset(std::unique_ptr pObj) { + m_pHandle.Reset(new Handle(std::move(pObj))); + } + void Swap(WeakPtr& that) { m_pHandle.Swap(that.m_pHandle); } + + private: + class Handle { + public: + explicit Handle(std::unique_ptr ptr) + : m_nCount(0), m_pObj(std::move(ptr)) {} + void Reset(std::unique_ptr ptr) { m_pObj = std::move(ptr); } + void Clear() { // Now you're all weak ptrs ... + m_pObj.reset(); // unique_ptr nulls first before invoking delete. + } + T* Get() const { return m_pObj.get(); } + T* Retain() { + ++m_nCount; + return m_pObj.get(); + } + void Release() { + if (--m_nCount == 0) + delete this; + } + bool HasOneRef() const { return m_nCount == 1; } + + private: + ~Handle() {} + + intptr_t m_nCount; + std::unique_ptr m_pObj; + }; + + RetainPtr m_pHandle; +}; + +} // namespace fxcrt + +using fxcrt::WeakPtr; + +#endif // CORE_FXCRT_WEAK_PTR_H_ diff --git a/core/fxcrt/weak_ptr_unittest.cpp b/core/fxcrt/weak_ptr_unittest.cpp new file mode 100644 index 0000000000..22a723043b --- /dev/null +++ b/core/fxcrt/weak_ptr_unittest.cpp @@ -0,0 +1,176 @@ +// 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. + +#include "core/fxcrt/weak_ptr.h" + +#include +#include + +#include "core/fxcrt/fx_memory.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace fxcrt { +namespace { + +class PseudoDeletable; +using WeakTestPtr = WeakPtr>; +using UniqueTestPtr = + std::unique_ptr>; + +class PseudoDeletable { + public: + PseudoDeletable() : delete_count_(0) {} + void Release() { + ++delete_count_; + next_.Reset(); + } + void SetNext(const WeakTestPtr& next) { next_ = next; } + int delete_count() const { return delete_count_; } + + private: + int delete_count_; + WeakTestPtr next_; +}; + +} // namespace + +TEST(WeakPtr, Null) { + WeakTestPtr ptr1; + EXPECT_FALSE(ptr1); + + WeakTestPtr ptr2; + EXPECT_TRUE(ptr1 == ptr2); + EXPECT_FALSE(ptr1 != ptr2); + + WeakTestPtr ptr3(ptr1); + EXPECT_TRUE(ptr1 == ptr3); + EXPECT_FALSE(ptr1 != ptr3); + + WeakTestPtr ptr4 = ptr1; + EXPECT_TRUE(ptr1 == ptr4); + EXPECT_FALSE(ptr1 != ptr4); +} + +TEST(WeakPtr, NonNull) { + PseudoDeletable thing; + EXPECT_EQ(0, thing.delete_count()); + { + UniqueTestPtr unique(&thing); + WeakTestPtr ptr1(std::move(unique)); + EXPECT_TRUE(ptr1); + EXPECT_EQ(&thing, ptr1.Get()); + + WeakTestPtr ptr2; + EXPECT_FALSE(ptr1 == ptr2); + EXPECT_TRUE(ptr1 != ptr2); + { + WeakTestPtr ptr3(ptr1); + EXPECT_TRUE(ptr1 == ptr3); + EXPECT_FALSE(ptr1 != ptr3); + EXPECT_EQ(&thing, ptr3.Get()); + { + WeakTestPtr ptr4 = ptr1; + EXPECT_TRUE(ptr1 == ptr4); + EXPECT_FALSE(ptr1 != ptr4); + EXPECT_EQ(&thing, ptr4.Get()); + } + } + EXPECT_EQ(0, thing.delete_count()); + } + EXPECT_EQ(1, thing.delete_count()); +} + +TEST(WeakPtr, ResetNull) { + PseudoDeletable thing; + { + UniqueTestPtr unique(&thing); + WeakTestPtr ptr1(std::move(unique)); + WeakTestPtr ptr2 = ptr1; + ptr1.Reset(); + EXPECT_FALSE(ptr1); + EXPECT_EQ(nullptr, ptr1.Get()); + EXPECT_TRUE(ptr2); + EXPECT_EQ(&thing, ptr2.Get()); + EXPECT_FALSE(ptr1 == ptr2); + EXPECT_TRUE(ptr1 != ptr2); + EXPECT_EQ(0, thing.delete_count()); + } + EXPECT_EQ(1, thing.delete_count()); +} + +TEST(WeakPtr, ResetNonNull) { + PseudoDeletable thing1; + PseudoDeletable thing2; + { + UniqueTestPtr unique1(&thing1); + WeakTestPtr ptr1(std::move(unique1)); + WeakTestPtr ptr2 = ptr1; + UniqueTestPtr unique2(&thing2); + ptr2.Reset(std::move(unique2)); + EXPECT_TRUE(ptr1); + EXPECT_EQ(&thing1, ptr1.Get()); + EXPECT_TRUE(ptr2); + EXPECT_EQ(&thing2, ptr2.Get()); + EXPECT_FALSE(ptr1 == ptr2); + EXPECT_TRUE(ptr1 != ptr2); + EXPECT_EQ(0, thing1.delete_count()); + EXPECT_EQ(0, thing2.delete_count()); + } + EXPECT_EQ(1, thing1.delete_count()); + EXPECT_EQ(1, thing2.delete_count()); +} + +TEST(WeakPtr, DeleteObject) { + PseudoDeletable thing; + { + UniqueTestPtr unique(&thing); + WeakTestPtr ptr1(std::move(unique)); + WeakTestPtr ptr2 = ptr1; + ptr1.DeleteObject(); + EXPECT_FALSE(ptr1); + EXPECT_EQ(nullptr, ptr1.Get()); + EXPECT_FALSE(ptr2); + EXPECT_EQ(nullptr, ptr2.Get()); + EXPECT_FALSE(ptr1 == ptr2); + EXPECT_TRUE(ptr1 != ptr2); + EXPECT_EQ(1, thing.delete_count()); + } + EXPECT_EQ(1, thing.delete_count()); +} + +TEST(WeakPtr, Cyclic) { + PseudoDeletable thing1; + PseudoDeletable thing2; + { + UniqueTestPtr unique1(&thing1); + UniqueTestPtr unique2(&thing2); + WeakTestPtr ptr1(std::move(unique1)); + WeakTestPtr ptr2(std::move(unique2)); + ptr1->SetNext(ptr2); + ptr2->SetNext(ptr1); + } + // Leaks without explicit clear. + EXPECT_EQ(0, thing1.delete_count()); + EXPECT_EQ(0, thing2.delete_count()); +} + +TEST(WeakPtr, CyclicDeleteObject) { + PseudoDeletable thing1; + PseudoDeletable thing2; + { + UniqueTestPtr unique1(&thing1); + UniqueTestPtr unique2(&thing2); + WeakTestPtr ptr1(std::move(unique1)); + WeakTestPtr ptr2(std::move(unique2)); + ptr1->SetNext(ptr2); + ptr2->SetNext(ptr1); + ptr1.DeleteObject(); + EXPECT_EQ(1, thing1.delete_count()); + EXPECT_EQ(0, thing2.delete_count()); + } + EXPECT_EQ(1, thing1.delete_count()); + EXPECT_EQ(1, thing2.delete_count()); +} + +} // namespace fxcrt -- cgit v1.2.3