wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-09 01:08:39 +09:00
Code Issues Projects Releases Packages Wiki Activity

Issue #2488 - Part 5: Remove HandleRefPtr (exclusively used by smart pointer classes)

Browse source
This commit is contained in:
FranklinDM 2024-03-29 16:09:57 +08:00 • committed by roytam1
commit 81f77f18a0
2 changed files with 0 additions and 133 deletions
Download patch file Download diff file Expand all files Collapse all files

132
layout/style/HandleRefPtr.h
View file

@ -1,132 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
/* smart pointer for strong references to objects through pointer-like
* "handle" objects */
#include <algorithm>
#include "mozilla/Assertions.h"
#ifndef mozilla_HandleRefPtr_h
#define mozilla_HandleRefPtr_h
namespace mozilla {
/**
* A class for holding strong references to handle-managed objects.
*
* This is intended for use with objects like RestyleManagerHandle,
* where the handle type is not a pointer but which can still have
* ->AddRef() and ->Release() called on it.
*/
template<typename T>
class HandleRefPtr
{
public:
HandleRefPtr() {}
HandleRefPtr(HandleRefPtr<T>& aRhs)
{
assign(aRhs.mHandle);
}
HandleRefPtr(HandleRefPtr<T>&& aRhs)
{
std::swap(mHandle, aRhs.mHandle);
}
MOZ_IMPLICIT HandleRefPtr(T aRhs)
{
assign(aRhs);
}
HandleRefPtr<T>& operator=(HandleRefPtr<T>& aRhs)
{
assign(aRhs.mHandle);
return *this;
}
HandleRefPtr<T>& operator=(T aRhs)
{
assign(aRhs);
return *this;
}
~HandleRefPtr() { assign(nullptr); }
explicit operator bool() const { return !!mHandle; }
bool operator!() const { return !mHandle; }
operator T() const { return mHandle; }
T operator->() const { return mHandle; }
void swap(HandleRefPtr<T>& aOther)
{
std::swap(mHandle, aOther.mHandle);
}
private:
void assign(T aPtr)
{
// AddRef early so |aPtr| can't disappear underneath us.
if (aPtr) {
aPtr->AddRef();
}
// Don't release |mHandle| yet: if |mHandle| indirectly owns |this|,
// releasing would invalidate |this|. Swap |aPtr| for |mHandle| so that
// |aPtr| lives as long as |this|, then release the new |aPtr| (really the
// original |mHandle|) so that if |this| is invalidated, we're not using it
// any more.
std::swap(mHandle, aPtr);
if (aPtr) {
aPtr->Release();
}
}
T mHandle;
};
template<typename T>
inline bool operator==(const HandleRefPtr<T>& aLHS, const HandleRefPtr<T>& aRHS)
{
return static_cast<T>(aLHS) == static_cast<T>(aRHS);
}
template<typename T>
inline bool operator==(const HandleRefPtr<T>& aLHS, T aRHS)
{
return static_cast<T>(aLHS) == aRHS;
}
template<typename T>
inline bool operator==(T aLHS, const HandleRefPtr<T>& aRHS)
{
return aLHS == static_cast<T>(aRHS);
}
template<typename T>
inline bool operator!=(const HandleRefPtr<T>& aLHS, const HandleRefPtr<T>& aRHS)
{
return !(aLHS == aRHS);
}
template<typename T>
inline bool operator!=(const HandleRefPtr<T>& aLHS, T aRHS)
{
return !(aLHS == aRHS);
}
template<typename T>
inline bool operator!=(T aLHS, const HandleRefPtr<T>& aRHS)
{
return !(aLHS == aRHS);
}
} // namespace mozilla
#endif // mozilla_HandleRefPtr_h

1
layout/style/moz.build
View file

@ -80,7 +80,6 @@ EXPORTS.mozilla += [
'CSSVariableResolver.h',
'CSSVariableValues.h',
'DeprecatedUtils.h',
'HandleRefPtr.h',
'IncrementalClearCOMRuleArray.h',
'LayerAnimationInfo.h',
'RuleNodeCacheConditions.h',