mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-22 17:55:50 +00:00
e7b3b3140d
Everything that goes in a PLDHashtable (and its derivatives, like nsTHashtable) needs to inherit from PLDHashEntryHdr. But through a lack of enforcement, copy constructors for these derived classes didn't explicitly invoke the copy constructor for PLDHashEntryHdr (and the compiler didn't invoke the copy constructor for us). Instead, PLDHashTable explicitly copied around the bits that the copy constructor would have. The current setup has two problems: 1) Derived classes should be using move construction, not copy construction, since anything that's shuffling hash table keys/entries around will be using move construction. 2) Derived classes should take responsibility for transferring bits of superclass state around, and not rely on something else to handle that. The second point is not a huge problem for PLDHashTable (PLDHashTable only has to copy PLDHashEntryHdr's bits in a single place), but future hash table implementations that might move entries around more aggressively would have to insert compensation code all over the place. Additionally, if moving entries is implemented via memcpy (which is quite common), PLDHashTable copying around bits *again* is inefficient. Let's fix all these problems in one go, by: 1) Explicitly declaring the set of constructors that PLDHashEntryHdr implements (and does not implement). In particular, the copy constructor is deleted, so any derived classes that attempt to make themselves copyable will be detected at compile time: the compiler will complain that the superclass type is not copyable. This change on its own will result in many compiler errors, so... 2) Change any derived classes to implement move constructors instead of copy constructors. Note that some of these move constructors are, strictly speaking, unnecessary, since the relevant classes are moved via memcpy in nsTHashtable and its derivatives.
101 lines
2.8 KiB
C++
101 lines
2.8 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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/. */
|
|
|
|
#ifndef nsObserverList_h___
|
|
#define nsObserverList_h___
|
|
|
|
#include "nsISupports.h"
|
|
#include "nsTArray.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsCOMArray.h"
|
|
#include "nsIObserver.h"
|
|
#include "nsIWeakReference.h"
|
|
#include "nsHashKeys.h"
|
|
#include "nsSimpleEnumerator.h"
|
|
#include "mozilla/Attributes.h"
|
|
|
|
struct ObserverRef
|
|
{
|
|
ObserverRef(const ObserverRef& aO) : isWeakRef(aO.isWeakRef), ref(aO.ref) {}
|
|
explicit ObserverRef(nsIObserver* aObserver) : isWeakRef(false), ref(aObserver) {}
|
|
explicit ObserverRef(nsIWeakReference* aWeak) : isWeakRef(true), ref(aWeak) {}
|
|
|
|
bool isWeakRef;
|
|
nsCOMPtr<nsISupports> ref;
|
|
|
|
nsIObserver* asObserver()
|
|
{
|
|
NS_ASSERTION(!isWeakRef, "Isn't a strong ref.");
|
|
return static_cast<nsIObserver*>((nsISupports*)ref);
|
|
}
|
|
|
|
nsIWeakReference* asWeak()
|
|
{
|
|
NS_ASSERTION(isWeakRef, "Isn't a weak ref.");
|
|
return static_cast<nsIWeakReference*>((nsISupports*)ref);
|
|
}
|
|
|
|
bool operator==(nsISupports* aRhs) const { return ref == aRhs; }
|
|
};
|
|
|
|
class nsObserverList : public nsCharPtrHashKey
|
|
{
|
|
friend class nsObserverService;
|
|
|
|
public:
|
|
explicit nsObserverList(const char* aKey) : nsCharPtrHashKey(aKey)
|
|
{
|
|
MOZ_COUNT_CTOR(nsObserverList);
|
|
}
|
|
|
|
nsObserverList(nsObserverList&& aOther)
|
|
: nsCharPtrHashKey(std::move(aOther))
|
|
, mObservers(std::move(aOther.mObservers))
|
|
{
|
|
}
|
|
|
|
~nsObserverList()
|
|
{
|
|
MOZ_COUNT_DTOR(nsObserverList);
|
|
}
|
|
|
|
MOZ_MUST_USE nsresult AddObserver(nsIObserver* aObserver, bool aOwnsWeak);
|
|
MOZ_MUST_USE nsresult RemoveObserver(nsIObserver* aObserver);
|
|
|
|
void NotifyObservers(nsISupports* aSubject,
|
|
const char* aTopic,
|
|
const char16_t* aSomeData);
|
|
void GetObserverList(nsISimpleEnumerator** aEnumerator);
|
|
|
|
// Fill an array with the observers of this category.
|
|
// The array is filled in last-added-first order.
|
|
void FillObserverArray(nsCOMArray<nsIObserver>& aArray);
|
|
|
|
// Like FillObserverArray(), but only for strongly held observers.
|
|
void AppendStrongObservers(nsCOMArray<nsIObserver>& aArray);
|
|
|
|
private:
|
|
nsTArray<ObserverRef> mObservers;
|
|
};
|
|
|
|
class nsObserverEnumerator final : public nsSimpleEnumerator
|
|
{
|
|
public:
|
|
NS_DECL_NSISIMPLEENUMERATOR
|
|
|
|
explicit nsObserverEnumerator(nsObserverList* aObserverList);
|
|
|
|
const nsID& DefaultInterface() override { return NS_GET_IID(nsIObserver); }
|
|
|
|
private:
|
|
~nsObserverEnumerator() override = default;
|
|
|
|
int32_t mIndex; // Counts up from 0
|
|
nsCOMArray<nsIObserver> mObservers;
|
|
};
|
|
|
|
#endif /* nsObserverList_h___ */
|