mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-07 05:15:09 +00:00
01583602a9
The bulk of this commit was generated with a script, executed at the top level of a typical source code checkout. The only non-machine-generated part was modifying MFBT's moz.build to reflect the new naming. CLOSED TREE makes big refactorings like this a piece of cake. # The main substitution. find . -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.mm' -o -name '*.idl'| \ xargs perl -p -i -e ' s/nsRefPtr\.h/RefPtr\.h/g; # handle includes s/nsRefPtr ?</RefPtr</g; # handle declarations and variables ' # Handle a special friend declaration in gfx/layers/AtomicRefCountedWithFinalize.h. perl -p -i -e 's/::nsRefPtr;/::RefPtr;/' gfx/layers/AtomicRefCountedWithFinalize.h # Handle nsRefPtr.h itself, a couple places that define constructors # from nsRefPtr, and code generators specially. We do this here, rather # than indiscriminantly s/nsRefPtr/RefPtr/, because that would rename # things like nsRefPtrHashtable. perl -p -i -e 's/nsRefPtr/RefPtr/g' \ mfbt/nsRefPtr.h \ xpcom/glue/nsCOMPtr.h \ xpcom/base/OwningNonNull.h \ ipc/ipdl/ipdl/lower.py \ ipc/ipdl/ipdl/builtin.py \ dom/bindings/Codegen.py \ python/lldbutils/lldbutils/utils.py # In our indiscriminate substitution above, we renamed # nsRefPtrGetterAddRefs, the class behind getter_AddRefs. Fix that up. find . -name '*.cpp' -o -name '*.h' -o -name '*.idl' | \ xargs perl -p -i -e 's/nsRefPtrGetterAddRefs/RefPtrGetterAddRefs/g' if [ -d .git ]; then git mv mfbt/nsRefPtr.h mfbt/RefPtr.h else hg mv mfbt/nsRefPtr.h mfbt/RefPtr.h fi --HG-- rename : mfbt/nsRefPtr.h => mfbt/RefPtr.h
251 lines
7.9 KiB
C++
251 lines
7.9 KiB
C++
/* -*- 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/. */
|
|
|
|
/**
|
|
* CopyOnWrite<T> allows code to safely read from a data structure without
|
|
* worrying that reentrant code will modify it.
|
|
*/
|
|
|
|
#ifndef mozilla_image_CopyOnWrite_h
|
|
#define mozilla_image_CopyOnWrite_h
|
|
|
|
#include "mozilla/RefPtr.h"
|
|
#include "MainThreadUtils.h"
|
|
#include "nsISupportsImpl.h"
|
|
|
|
namespace mozilla {
|
|
namespace image {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Implementation Details
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
namespace detail {
|
|
|
|
template <typename T>
|
|
class CopyOnWriteValue final
|
|
{
|
|
public:
|
|
NS_INLINE_DECL_REFCOUNTING(CopyOnWriteValue)
|
|
|
|
explicit CopyOnWriteValue(T* aValue) : mValue(aValue) { }
|
|
explicit CopyOnWriteValue(already_AddRefed<T>& aValue) : mValue(aValue) { }
|
|
explicit CopyOnWriteValue(already_AddRefed<T>&& aValue) : mValue(aValue) { }
|
|
explicit CopyOnWriteValue(const RefPtr<T>& aValue) : mValue(aValue) { }
|
|
explicit CopyOnWriteValue(RefPtr<T>&& aValue) : mValue(aValue) { }
|
|
|
|
T* get() { return mValue.get(); }
|
|
const T* get() const { return mValue.get(); }
|
|
|
|
bool HasReaders() const { return mReaders > 0; }
|
|
bool HasWriter() const { return mWriter; }
|
|
bool HasUsers() const { return HasReaders() || HasWriter(); }
|
|
|
|
void LockForReading() { MOZ_ASSERT(!HasWriter()); mReaders++; }
|
|
void UnlockForReading() { MOZ_ASSERT(HasReaders()); mReaders--; }
|
|
|
|
struct MOZ_STACK_CLASS AutoReadLock
|
|
{
|
|
explicit AutoReadLock(CopyOnWriteValue* aValue)
|
|
: mValue(aValue)
|
|
{
|
|
mValue->LockForReading();
|
|
}
|
|
~AutoReadLock() { mValue->UnlockForReading(); }
|
|
CopyOnWriteValue<T>* mValue;
|
|
};
|
|
|
|
void LockForWriting() { MOZ_ASSERT(!HasUsers()); mWriter = true; }
|
|
void UnlockForWriting() { MOZ_ASSERT(HasWriter()); mWriter = false; }
|
|
|
|
struct MOZ_STACK_CLASS AutoWriteLock
|
|
{
|
|
explicit AutoWriteLock(CopyOnWriteValue* aValue)
|
|
: mValue(aValue)
|
|
{
|
|
mValue->LockForWriting();
|
|
}
|
|
~AutoWriteLock() { mValue->UnlockForWriting(); }
|
|
CopyOnWriteValue<T>* mValue;
|
|
};
|
|
|
|
private:
|
|
CopyOnWriteValue(const CopyOnWriteValue&) = delete;
|
|
CopyOnWriteValue(CopyOnWriteValue&&) = delete;
|
|
|
|
~CopyOnWriteValue() { }
|
|
|
|
RefPtr<T> mValue;
|
|
uint64_t mReaders = 0;
|
|
bool mWriter = false;
|
|
};
|
|
|
|
} // namespace detail
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Public API
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* CopyOnWrite<T> allows code to safely read from a data structure without
|
|
* worrying that reentrant code will modify it. If reentrant code would modify
|
|
* the data structure while other code is reading from it, a copy is made so
|
|
* that readers can continue to use the old version.
|
|
*
|
|
* Note that it's legal to nest a writer inside any number of readers, but
|
|
* nothing can be nested inside a writer. This is because it's assumed that the
|
|
* state of the contained data structure may not be consistent during the write.
|
|
*
|
|
* This is a main-thread-only data structure.
|
|
*
|
|
* To work with CopyOnWrite<T>, a type T needs to be reference counted and to
|
|
* support copy construction.
|
|
*/
|
|
template <typename T>
|
|
class CopyOnWrite final
|
|
{
|
|
typedef detail::CopyOnWriteValue<T> CopyOnWriteValue;
|
|
|
|
public:
|
|
explicit CopyOnWrite(T* aValue)
|
|
: mValue(new CopyOnWriteValue(aValue))
|
|
{ }
|
|
|
|
explicit CopyOnWrite(already_AddRefed<T>& aValue)
|
|
: mValue(new CopyOnWriteValue(aValue))
|
|
{ }
|
|
|
|
explicit CopyOnWrite(already_AddRefed<T>&& aValue)
|
|
: mValue(new CopyOnWriteValue(aValue))
|
|
{ }
|
|
|
|
explicit CopyOnWrite(const RefPtr<T>& aValue)
|
|
: mValue(new CopyOnWriteValue(aValue))
|
|
{ }
|
|
|
|
explicit CopyOnWrite(RefPtr<T>&& aValue)
|
|
: mValue(new CopyOnWriteValue(aValue))
|
|
{ }
|
|
|
|
/// @return true if it's safe to read at this time.
|
|
bool CanRead() const { return !mValue->HasWriter(); }
|
|
|
|
/**
|
|
* Read from the contained data structure using the function @aReader.
|
|
* @aReader will be passed a pointer of type |const T*|. It's not legal to
|
|
* call this while a writer is active.
|
|
*
|
|
* @return whatever value @aReader returns, or nothing if @aReader is a void
|
|
* function.
|
|
*/
|
|
template <typename ReadFunc>
|
|
auto Read(ReadFunc aReader) const
|
|
-> decltype(aReader(static_cast<const T*>(nullptr)))
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(CanRead());
|
|
|
|
// Run the provided function while holding a read lock.
|
|
RefPtr<CopyOnWriteValue> cowValue = mValue;
|
|
typename CopyOnWriteValue::AutoReadLock lock(cowValue);
|
|
return aReader(cowValue->get());
|
|
}
|
|
|
|
/**
|
|
* Read from the contained data structure using the function @aReader.
|
|
* @aReader will be passed a pointer of type |const T*|. If it's currently not
|
|
* possible to read because a writer is currently active, @aOnError will be
|
|
* called instead.
|
|
*
|
|
* @return whatever value @aReader or @aOnError returns (their return types
|
|
* must be consistent), or nothing if the provided functions are void.
|
|
*/
|
|
template <typename ReadFunc, typename ErrorFunc>
|
|
auto Read(ReadFunc aReader, ErrorFunc aOnError) const
|
|
-> decltype(aReader(static_cast<const T*>(nullptr)))
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (!CanRead()) {
|
|
return aOnError();
|
|
}
|
|
|
|
return Read(aReader);
|
|
}
|
|
|
|
/// @return true if it's safe to write at this time.
|
|
bool CanWrite() const { return !mValue->HasWriter(); }
|
|
|
|
/**
|
|
* Write to the contained data structure using the function @aWriter.
|
|
* @aWriter will be passed a pointer of type |T*|. It's not legal to call this
|
|
* while another writer is active.
|
|
*
|
|
* If readers are currently active, they will be able to continue reading from
|
|
* a copy of the old version of the data structure. The copy will be destroyed
|
|
* when all its readers finish. Later readers and writers will see the
|
|
* version of the data structure produced by the most recent call to Write().
|
|
*
|
|
* @return whatever value @aWriter returns, or nothing if @aWriter is a void
|
|
* function.
|
|
*/
|
|
template <typename WriteFunc>
|
|
auto Write(WriteFunc aWriter)
|
|
-> decltype(aWriter(static_cast<T*>(nullptr)))
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(CanWrite());
|
|
|
|
// If there are readers, we need to copy first.
|
|
if (mValue->HasReaders()) {
|
|
mValue = new CopyOnWriteValue(new T(*mValue->get()));
|
|
}
|
|
|
|
// Run the provided function while holding a write lock.
|
|
RefPtr<CopyOnWriteValue> cowValue = mValue;
|
|
typename CopyOnWriteValue::AutoWriteLock lock(cowValue);
|
|
return aWriter(cowValue->get());
|
|
}
|
|
|
|
/**
|
|
* Write to the contained data structure using the function @aWriter.
|
|
* @aWriter will be passed a pointer of type |T*|. If it's currently not
|
|
* possible to write because a writer is currently active, @aOnError will be
|
|
* called instead.
|
|
*
|
|
* If readers are currently active, they will be able to continue reading from
|
|
* a copy of the old version of the data structure. The copy will be destroyed
|
|
* when all its readers finish. Later readers and writers will see the
|
|
* version of the data structure produced by the most recent call to Write().
|
|
*
|
|
* @return whatever value @aWriter or @aOnError returns (their return types
|
|
* must be consistent), or nothing if the provided functions are void.
|
|
*/
|
|
template <typename WriteFunc, typename ErrorFunc>
|
|
auto Write(WriteFunc aWriter, ErrorFunc aOnError)
|
|
-> decltype(aWriter(static_cast<T*>(nullptr)))
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (!CanWrite()) {
|
|
return aOnError();
|
|
}
|
|
|
|
return Write(aWriter);
|
|
}
|
|
|
|
private:
|
|
CopyOnWrite(const CopyOnWrite&) = delete;
|
|
CopyOnWrite(CopyOnWrite&&) = delete;
|
|
|
|
RefPtr<CopyOnWriteValue> mValue;
|
|
};
|
|
|
|
} // namespace image
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_image_CopyOnWrite_h
|