mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-09-08 16:58:38 +09:00
import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo
This commit is contained in:
Roy Tam
commit
dcd9973243
150858 changed files with 23884658 additions and 0 deletions
494
xpcom/base/CycleCollectedJSContext.h
Normal file
494
xpcom/base/CycleCollectedJSContext.h
Normal file
|
|
@ -0,0 +1,494 @@
|
|||
/* -*- 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 mozilla_CycleCollectedJSContext_h__
|
||||
#define mozilla_CycleCollectedJSContext_h__
|
||||
|
||||
#include <queue>
|
||||
|
||||
#include "mozilla/DeferredFinalize.h"
|
||||
#include "mozilla/mozalloc.h"
|
||||
#include "mozilla/MemoryReporting.h"
|
||||
#include "mozilla/SegmentedVector.h"
|
||||
#include "jsapi.h"
|
||||
#include "jsfriendapi.h"
|
||||
|
||||
#include "nsCycleCollectionParticipant.h"
|
||||
#include "nsDataHashtable.h"
|
||||
#include "nsHashKeys.h"
|
||||
#include "nsTArray.h"
|
||||
#include "nsTHashtable.h"
|
||||
|
||||
class nsCycleCollectionNoteRootCallback;
|
||||
class nsIException;
|
||||
class nsIRunnable;
|
||||
class nsThread;
|
||||
class nsWrapperCache;
|
||||
|
||||
namespace js {
|
||||
struct Class;
|
||||
} // namespace js
|
||||
|
||||
namespace mozilla {
|
||||
|
||||
class JSGCThingParticipant: public nsCycleCollectionParticipant
|
||||
{
|
||||
public:
|
||||
NS_IMETHOD_(void) Root(void*) override
|
||||
{
|
||||
MOZ_ASSERT(false, "Don't call Root on GC things");
|
||||
}
|
||||
|
||||
NS_IMETHOD_(void) Unlink(void*) override
|
||||
{
|
||||
MOZ_ASSERT(false, "Don't call Unlink on GC things, as they may be dead");
|
||||
}
|
||||
|
||||
NS_IMETHOD_(void) Unroot(void*) override
|
||||
{
|
||||
MOZ_ASSERT(false, "Don't call Unroot on GC things, as they may be dead");
|
||||
}
|
||||
|
||||
NS_IMETHOD_(void) DeleteCycleCollectable(void* aPtr) override
|
||||
{
|
||||
MOZ_ASSERT(false, "Can't directly delete a cycle collectable GC thing");
|
||||
}
|
||||
|
||||
NS_IMETHOD Traverse(void* aPtr, nsCycleCollectionTraversalCallback& aCb)
|
||||
override;
|
||||
|
||||
NS_DECL_CYCLE_COLLECTION_CLASS_NAME_METHOD(JSGCThingParticipant)
|
||||
};
|
||||
|
||||
class JSZoneParticipant : public nsCycleCollectionParticipant
|
||||
{
|
||||
public:
|
||||
constexpr JSZoneParticipant(): nsCycleCollectionParticipant()
|
||||
{
|
||||
}
|
||||
|
||||
NS_IMETHOD_(void) Root(void*) override
|
||||
{
|
||||
MOZ_ASSERT(false, "Don't call Root on GC things");
|
||||
}
|
||||
|
||||
NS_IMETHOD_(void) Unlink(void*) override
|
||||
{
|
||||
MOZ_ASSERT(false, "Don't call Unlink on GC things, as they may be dead");
|
||||
}
|
||||
|
||||
NS_IMETHOD_(void) Unroot(void*) override
|
||||
{
|
||||
MOZ_ASSERT(false, "Don't call Unroot on GC things, as they may be dead");
|
||||
}
|
||||
|
||||
NS_IMETHOD_(void) DeleteCycleCollectable(void*) override
|
||||
{
|
||||
MOZ_ASSERT(false, "Can't directly delete a cycle collectable GC thing");
|
||||
}
|
||||
|
||||
NS_IMETHOD Traverse(void* aPtr, nsCycleCollectionTraversalCallback& aCb)
|
||||
override;
|
||||
|
||||
NS_DECL_CYCLE_COLLECTION_CLASS_NAME_METHOD(JSZoneParticipant)
|
||||
};
|
||||
|
||||
class IncrementalFinalizeRunnable;
|
||||
|
||||
// Contains various stats about the cycle collection.
|
||||
struct CycleCollectorResults
|
||||
{
|
||||
CycleCollectorResults()
|
||||
{
|
||||
// Initialize here so when we increment mNumSlices the first time we're
|
||||
// not using uninitialized memory.
|
||||
Init();
|
||||
}
|
||||
|
||||
void Init()
|
||||
{
|
||||
mForcedGC = false;
|
||||
mMergedZones = false;
|
||||
mAnyManual = false;
|
||||
mVisitedRefCounted = 0;
|
||||
mVisitedGCed = 0;
|
||||
mFreedRefCounted = 0;
|
||||
mFreedGCed = 0;
|
||||
mFreedJSZones = 0;
|
||||
mNumSlices = 1;
|
||||
// mNumSlices is initialized to one, because we call Init() after the
|
||||
// per-slice increment of mNumSlices has already occurred.
|
||||
}
|
||||
|
||||
bool mForcedGC;
|
||||
bool mMergedZones;
|
||||
bool mAnyManual; // true if any slice of the CC was manually triggered, or at shutdown.
|
||||
uint32_t mVisitedRefCounted;
|
||||
uint32_t mVisitedGCed;
|
||||
uint32_t mFreedRefCounted;
|
||||
uint32_t mFreedGCed;
|
||||
uint32_t mFreedJSZones;
|
||||
uint32_t mNumSlices;
|
||||
};
|
||||
|
||||
class CycleCollectedJSContext
|
||||
{
|
||||
friend class JSGCThingParticipant;
|
||||
friend class JSZoneParticipant;
|
||||
friend class IncrementalFinalizeRunnable;
|
||||
protected:
|
||||
CycleCollectedJSContext();
|
||||
virtual ~CycleCollectedJSContext();
|
||||
|
||||
MOZ_IS_CLASS_INIT
|
||||
nsresult Initialize(JSContext* aParentContext,
|
||||
uint32_t aMaxBytes,
|
||||
uint32_t aMaxNurseryBytes);
|
||||
|
||||
size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
||||
void UnmarkSkippableJSHolders();
|
||||
|
||||
virtual void
|
||||
TraverseAdditionalNativeRoots(nsCycleCollectionNoteRootCallback& aCb) {}
|
||||
virtual void TraceAdditionalNativeGrayRoots(JSTracer* aTracer) {}
|
||||
|
||||
virtual void CustomGCCallback(JSGCStatus aStatus) {}
|
||||
virtual void CustomOutOfMemoryCallback() {}
|
||||
virtual void CustomLargeAllocationFailureCallback() {}
|
||||
|
||||
std::queue<nsCOMPtr<nsIRunnable>> mPromiseMicroTaskQueue;
|
||||
std::queue<nsCOMPtr<nsIRunnable>> mDebuggerPromiseMicroTaskQueue;
|
||||
|
||||
private:
|
||||
void
|
||||
DescribeGCThing(bool aIsMarked, JS::GCCellPtr aThing,
|
||||
nsCycleCollectionTraversalCallback& aCb) const;
|
||||
|
||||
virtual bool
|
||||
DescribeCustomObjects(JSObject* aObject, const js::Class* aClasp,
|
||||
char (&aName)[72]) const
|
||||
{
|
||||
return false; // We did nothing.
|
||||
}
|
||||
|
||||
void
|
||||
NoteGCThingJSChildren(JS::GCCellPtr aThing,
|
||||
nsCycleCollectionTraversalCallback& aCb) const;
|
||||
|
||||
void
|
||||
NoteGCThingXPCOMChildren(const js::Class* aClasp, JSObject* aObj,
|
||||
nsCycleCollectionTraversalCallback& aCb) const;
|
||||
|
||||
virtual bool
|
||||
NoteCustomGCThingXPCOMChildren(const js::Class* aClasp, JSObject* aObj,
|
||||
nsCycleCollectionTraversalCallback& aCb) const
|
||||
{
|
||||
return false; // We did nothing.
|
||||
}
|
||||
|
||||
enum TraverseSelect {
|
||||
TRAVERSE_CPP,
|
||||
TRAVERSE_FULL
|
||||
};
|
||||
|
||||
void
|
||||
TraverseGCThing(TraverseSelect aTs, JS::GCCellPtr aThing,
|
||||
nsCycleCollectionTraversalCallback& aCb);
|
||||
|
||||
void
|
||||
TraverseZone(JS::Zone* aZone, nsCycleCollectionTraversalCallback& aCb);
|
||||
|
||||
static void
|
||||
TraverseObjectShim(void* aData, JS::GCCellPtr aThing);
|
||||
|
||||
void TraverseNativeRoots(nsCycleCollectionNoteRootCallback& aCb);
|
||||
|
||||
static void TraceBlackJS(JSTracer* aTracer, void* aData);
|
||||
static void TraceGrayJS(JSTracer* aTracer, void* aData);
|
||||
static void GCCallback(JSContext* aContext, JSGCStatus aStatus, void* aData);
|
||||
static void GCSliceCallback(JSContext* aContext, JS::GCProgress aProgress,
|
||||
const JS::GCDescription& aDesc);
|
||||
static void GCNurseryCollectionCallback(JSContext* aContext,
|
||||
JS::GCNurseryProgress aProgress,
|
||||
JS::gcreason::Reason aReason);
|
||||
static void OutOfMemoryCallback(JSContext* aContext, void* aData);
|
||||
static void LargeAllocationFailureCallback(void* aData);
|
||||
static bool ContextCallback(JSContext* aCx, unsigned aOperation,
|
||||
void* aData);
|
||||
static JSObject* GetIncumbentGlobalCallback(JSContext* aCx);
|
||||
static bool EnqueuePromiseJobCallback(JSContext* aCx,
|
||||
JS::HandleObject aJob,
|
||||
JS::HandleObject aAllocationSite,
|
||||
JS::HandleObject aIncumbentGlobal,
|
||||
void* aData);
|
||||
#ifdef SPIDERMONKEY_PROMISE
|
||||
static void PromiseRejectionTrackerCallback(JSContext* aCx,
|
||||
JS::HandleObject aPromise,
|
||||
PromiseRejectionHandlingState state,
|
||||
void* aData);
|
||||
#endif // SPIDERMONKEY_PROMISE
|
||||
|
||||
virtual void TraceNativeBlackRoots(JSTracer* aTracer) { };
|
||||
void TraceNativeGrayRoots(JSTracer* aTracer);
|
||||
|
||||
void AfterProcessMicrotask(uint32_t aRecursionDepth);
|
||||
public:
|
||||
void ProcessStableStateQueue();
|
||||
private:
|
||||
void ProcessMetastableStateQueue(uint32_t aRecursionDepth);
|
||||
|
||||
public:
|
||||
enum DeferredFinalizeType {
|
||||
FinalizeIncrementally,
|
||||
FinalizeNow,
|
||||
};
|
||||
|
||||
void FinalizeDeferredThings(DeferredFinalizeType aType);
|
||||
|
||||
// Two conditions, JSOutOfMemory and JSLargeAllocationFailure, are noted in
|
||||
// crash reports. Here are the values that can appear in the reports:
|
||||
enum class OOMState : uint32_t {
|
||||
// The condition has never happened. No entry appears in the crash report.
|
||||
OK,
|
||||
|
||||
// We are currently reporting the given condition.
|
||||
//
|
||||
// Suppose a crash report contains "JSLargeAllocationFailure:
|
||||
// Reporting". This means we crashed while executing memory-pressure
|
||||
// observers, trying to shake loose some memory. The large allocation in
|
||||
// question did not return null: it is still on the stack. Had we not
|
||||
// crashed, it would have been retried.
|
||||
Reporting,
|
||||
|
||||
// The condition has been reported since the last GC.
|
||||
//
|
||||
// If a crash report contains "JSOutOfMemory: Reported", that means a small
|
||||
// allocation failed, and then we crashed, probably due to buggy
|
||||
// error-handling code that ran after allocation returned null.
|
||||
//
|
||||
// This contrasts with "Reporting" which means that no error-handling code
|
||||
// had executed yet.
|
||||
Reported,
|
||||
|
||||
// The condition has happened, but a GC cycle ended since then.
|
||||
//
|
||||
// GC is taken as a proxy for "we've been banging on the heap a good bit
|
||||
// now and haven't crashed; the OOM was probably handled correctly".
|
||||
Recovered
|
||||
};
|
||||
|
||||
private:
|
||||
void AnnotateAndSetOutOfMemory(OOMState* aStatePtr, OOMState aNewState);
|
||||
void OnGC(JSGCStatus aStatus);
|
||||
void OnOutOfMemory();
|
||||
void OnLargeAllocationFailure();
|
||||
|
||||
public:
|
||||
void AddJSHolder(void* aHolder, nsScriptObjectTracer* aTracer);
|
||||
void RemoveJSHolder(void* aHolder);
|
||||
#ifdef DEBUG
|
||||
bool IsJSHolder(void* aHolder);
|
||||
void AssertNoObjectsToTrace(void* aPossibleJSHolder);
|
||||
#endif
|
||||
|
||||
already_AddRefed<nsIException> GetPendingException() const;
|
||||
void SetPendingException(nsIException* aException);
|
||||
|
||||
std::queue<nsCOMPtr<nsIRunnable>>& GetPromiseMicroTaskQueue();
|
||||
std::queue<nsCOMPtr<nsIRunnable>>& GetDebuggerPromiseMicroTaskQueue();
|
||||
|
||||
nsCycleCollectionParticipant* GCThingParticipant();
|
||||
nsCycleCollectionParticipant* ZoneParticipant();
|
||||
|
||||
nsresult TraverseRoots(nsCycleCollectionNoteRootCallback& aCb);
|
||||
virtual bool UsefulToMergeZones() const;
|
||||
void FixWeakMappingGrayBits() const;
|
||||
bool AreGCGrayBitsValid() const;
|
||||
void GarbageCollect(uint32_t aReason) const;
|
||||
|
||||
void NurseryWrapperAdded(nsWrapperCache* aCache);
|
||||
void NurseryWrapperPreserved(JSObject* aWrapper);
|
||||
void JSObjectsTenured();
|
||||
|
||||
void DeferredFinalize(DeferredFinalizeAppendFunction aAppendFunc,
|
||||
DeferredFinalizeFunction aFunc,
|
||||
void* aThing);
|
||||
void DeferredFinalize(nsISupports* aSupports);
|
||||
|
||||
void DumpJSHeap(FILE* aFile);
|
||||
|
||||
virtual void PrepareForForgetSkippable() = 0;
|
||||
virtual void BeginCycleCollectionCallback() = 0;
|
||||
virtual void EndCycleCollectionCallback(CycleCollectorResults& aResults) = 0;
|
||||
virtual void DispatchDeferredDeletion(bool aContinuation, bool aPurge = false) = 0;
|
||||
|
||||
JSContext* Context() const
|
||||
{
|
||||
MOZ_ASSERT(mJSContext);
|
||||
return mJSContext;
|
||||
}
|
||||
|
||||
JS::RootingContext* RootingCx() const
|
||||
{
|
||||
MOZ_ASSERT(mJSContext);
|
||||
return JS::RootingContext::get(mJSContext);
|
||||
}
|
||||
|
||||
bool MicroTaskCheckpointDisabled() const
|
||||
{
|
||||
return mDisableMicroTaskCheckpoint;
|
||||
}
|
||||
|
||||
void DisableMicroTaskCheckpoint(bool aDisable)
|
||||
{
|
||||
mDisableMicroTaskCheckpoint = aDisable;
|
||||
}
|
||||
|
||||
class MOZ_RAII AutoDisableMicroTaskCheckpoint
|
||||
{
|
||||
public:
|
||||
AutoDisableMicroTaskCheckpoint()
|
||||
: mCCJSCX(CycleCollectedJSContext::Get())
|
||||
{
|
||||
mOldValue = mCCJSCX->MicroTaskCheckpointDisabled();
|
||||
mCCJSCX->DisableMicroTaskCheckpoint(true);
|
||||
}
|
||||
|
||||
~AutoDisableMicroTaskCheckpoint()
|
||||
{
|
||||
mCCJSCX->DisableMicroTaskCheckpoint(mOldValue);
|
||||
}
|
||||
|
||||
CycleCollectedJSContext* mCCJSCX;
|
||||
bool mOldValue;
|
||||
};
|
||||
|
||||
protected:
|
||||
JSContext* MaybeContext() const { return mJSContext; }
|
||||
|
||||
public:
|
||||
// nsThread entrypoints
|
||||
virtual void BeforeProcessTask(bool aMightBlock) { };
|
||||
virtual void AfterProcessTask(uint32_t aRecursionDepth);
|
||||
|
||||
// microtask processor entry point
|
||||
void AfterProcessMicrotask();
|
||||
|
||||
uint32_t RecursionDepth();
|
||||
|
||||
// Run in stable state (call through nsContentUtils)
|
||||
void RunInStableState(already_AddRefed<nsIRunnable>&& aRunnable);
|
||||
// This isn't in the spec at all yet, but this gets the behavior we want for IDB.
|
||||
// Runs after the current microtask completes.
|
||||
void RunInMetastableState(already_AddRefed<nsIRunnable>&& aRunnable);
|
||||
|
||||
// Get the current thread's CycleCollectedJSContext. Returns null if there
|
||||
// isn't one.
|
||||
static CycleCollectedJSContext* Get();
|
||||
|
||||
// Add aZone to the set of zones waiting for a GC.
|
||||
void AddZoneWaitingForGC(JS::Zone* aZone)
|
||||
{
|
||||
mZonesWaitingForGC.PutEntry(aZone);
|
||||
}
|
||||
|
||||
// Prepare any zones for GC that have been passed to AddZoneWaitingForGC()
|
||||
// since the last GC or since the last call to PrepareWaitingZonesForGC(),
|
||||
// whichever was most recent. If there were no such zones, prepare for a
|
||||
// full GC.
|
||||
void PrepareWaitingZonesForGC();
|
||||
|
||||
// Queue an async microtask to the current main or worker thread.
|
||||
virtual void DispatchToMicroTask(already_AddRefed<nsIRunnable> aRunnable);
|
||||
|
||||
// Storage for watching rejected promises waiting for some client to
|
||||
// consume their rejection.
|
||||
#ifdef SPIDERMONKEY_PROMISE
|
||||
// Promises in this list have been rejected in the last turn of the
|
||||
// event loop without the rejection being handled.
|
||||
// Note that this can contain nullptrs in place of promises removed because
|
||||
// they're consumed before it'd be reported.
|
||||
JS::PersistentRooted<JS::GCVector<JSObject*, 0, js::SystemAllocPolicy>> mUncaughtRejections;
|
||||
|
||||
// Promises in this list have previously been reported as rejected
|
||||
// (because they were in the above list), but the rejection was handled
|
||||
// in the last turn of the event loop.
|
||||
JS::PersistentRooted<JS::GCVector<JSObject*, 0, js::SystemAllocPolicy>> mConsumedRejections;
|
||||
#else
|
||||
// We store values as `nsISupports` to avoid adding compile-time dependencies
|
||||
// from xpcom to dom/promise, but they can really only have a single concrete
|
||||
// type.
|
||||
nsTArray<nsCOMPtr<nsISupports /* Promise */>> mUncaughtRejections;
|
||||
nsTArray<nsCOMPtr<nsISupports /* Promise */ >> mConsumedRejections;
|
||||
#endif // SPIDERMONKEY_PROMISE
|
||||
nsTArray<nsCOMPtr<nsISupports /* UncaughtRejectionObserver */ >> mUncaughtRejectionObservers;
|
||||
|
||||
private:
|
||||
JSGCThingParticipant mGCThingCycleCollectorGlobal;
|
||||
|
||||
JSZoneParticipant mJSZoneCycleCollectorGlobal;
|
||||
|
||||
JSContext* mJSContext;
|
||||
|
||||
JS::GCSliceCallback mPrevGCSliceCallback;
|
||||
JS::GCNurseryCollectionCallback mPrevGCNurseryCollectionCallback;
|
||||
|
||||
nsDataHashtable<nsPtrHashKey<void>, nsScriptObjectTracer*> mJSHolders;
|
||||
|
||||
typedef nsDataHashtable<nsFuncPtrHashKey<DeferredFinalizeFunction>, void*>
|
||||
DeferredFinalizerTable;
|
||||
DeferredFinalizerTable mDeferredFinalizerTable;
|
||||
|
||||
RefPtr<IncrementalFinalizeRunnable> mFinalizeRunnable;
|
||||
|
||||
nsCOMPtr<nsIException> mPendingException;
|
||||
nsThread* mOwningThread; // Manual refcounting to avoid include hell.
|
||||
|
||||
struct RunInMetastableStateData
|
||||
{
|
||||
nsCOMPtr<nsIRunnable> mRunnable;
|
||||
uint32_t mRecursionDepth;
|
||||
};
|
||||
|
||||
nsTArray<nsCOMPtr<nsIRunnable>> mStableStateEvents;
|
||||
nsTArray<RunInMetastableStateData> mMetastableStateEvents;
|
||||
uint32_t mBaseRecursionDepth;
|
||||
bool mDoingStableStates;
|
||||
|
||||
bool mDisableMicroTaskCheckpoint;
|
||||
|
||||
OOMState mOutOfMemoryState;
|
||||
OOMState mLargeAllocationFailureState;
|
||||
|
||||
static const size_t kSegmentSize = 512;
|
||||
SegmentedVector<nsWrapperCache*, kSegmentSize, InfallibleAllocPolicy>
|
||||
mNurseryObjects;
|
||||
SegmentedVector<JS::PersistentRooted<JSObject*>, kSegmentSize,
|
||||
InfallibleAllocPolicy>
|
||||
mPreservedNurseryObjects;
|
||||
|
||||
nsTHashtable<nsPtrHashKey<JS::Zone>> mZonesWaitingForGC;
|
||||
|
||||
struct EnvironmentPreparer : public js::ScriptEnvironmentPreparer {
|
||||
void invoke(JS::HandleObject scope, Closure& closure) override;
|
||||
};
|
||||
EnvironmentPreparer mEnvironmentPreparer;
|
||||
};
|
||||
|
||||
void TraceScriptHolder(nsISupports* aHolder, JSTracer* aTracer);
|
||||
|
||||
// Returns true if the JS::TraceKind is one the cycle collector cares about.
|
||||
inline bool AddToCCKind(JS::TraceKind aKind)
|
||||
{
|
||||
return aKind == JS::TraceKind::Object || aKind == JS::TraceKind::Script || aKind == JS::TraceKind::Scope;
|
||||
}
|
||||
|
||||
bool
|
||||
GetBuildId(JS::BuildIdCharVector* aBuildID);
|
||||
|
||||
} // namespace mozilla
|
||||
|
||||
#endif // mozilla_CycleCollectedJSContext_h__
|
||||
Loading…
Add table
Add a link
Reference in a new issue