mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-25 05:41:12 +00:00
4024c1e21e
Differential Revision: https://phabricator.services.mozilla.com/D2121 --HG-- extra : moz-landing-system : lando
312 lines
8.6 KiB
C++
312 lines
8.6 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 mozilla_CycleCollectedJSContext_h
|
|
#define mozilla_CycleCollectedJSContext_h
|
|
|
|
#include <queue>
|
|
|
|
#include "mozilla/DeferredFinalize.h"
|
|
#include "mozilla/LinkedList.h"
|
|
#include "mozilla/mozalloc.h"
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "mozilla/dom/AtomList.h"
|
|
#include "jsapi.h"
|
|
#include "jsfriendapi.h"
|
|
|
|
#include "nsCOMPtr.h"
|
|
#include "nsCycleCollectionParticipant.h"
|
|
#include "nsTArray.h"
|
|
|
|
class nsCycleCollectionNoteRootCallback;
|
|
class nsIRunnable;
|
|
class nsThread;
|
|
class nsWrapperCache;
|
|
|
|
namespace mozilla {
|
|
class AutoSlowOperation;
|
|
|
|
class CycleCollectedJSRuntime;
|
|
|
|
namespace dom {
|
|
class Exception;
|
|
class WorkerJSContext;
|
|
class WorkletJSContext;
|
|
} // namespace dom
|
|
|
|
// 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 MicroTaskRunnable
|
|
{
|
|
public:
|
|
MicroTaskRunnable() {}
|
|
NS_INLINE_DECL_REFCOUNTING(MicroTaskRunnable)
|
|
virtual void Run(AutoSlowOperation& aAso) = 0;
|
|
virtual bool Suppressed() { return false; }
|
|
protected:
|
|
virtual ~MicroTaskRunnable() {}
|
|
};
|
|
|
|
class CycleCollectedJSContext
|
|
: dom::PerThreadAtomCache
|
|
, public LinkedListElement<CycleCollectedJSContext>
|
|
{
|
|
friend class CycleCollectedJSRuntime;
|
|
|
|
protected:
|
|
CycleCollectedJSContext();
|
|
virtual ~CycleCollectedJSContext();
|
|
|
|
MOZ_IS_CLASS_INIT
|
|
nsresult Initialize(JSRuntime* aParentRuntime,
|
|
uint32_t aMaxBytes,
|
|
uint32_t aMaxNurseryBytes);
|
|
|
|
// See explanation in mIsPrimaryContext.
|
|
MOZ_IS_CLASS_INIT
|
|
nsresult InitializeNonPrimary(CycleCollectedJSContext* aPrimaryContext);
|
|
|
|
virtual CycleCollectedJSRuntime* CreateRuntime(JSContext* aCx) = 0;
|
|
|
|
size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
|
|
|
|
private:
|
|
MOZ_IS_CLASS_INIT
|
|
void InitializeCommon();
|
|
|
|
static JSObject* GetIncumbentGlobalCallback(JSContext* aCx);
|
|
static bool EnqueuePromiseJobCallback(JSContext* aCx,
|
|
JS::HandleObject aJob,
|
|
JS::HandleObject aAllocationSite,
|
|
JS::HandleObject aIncumbentGlobal,
|
|
void* aData);
|
|
static void PromiseRejectionTrackerCallback(JSContext* aCx,
|
|
JS::HandleObject aPromise,
|
|
JS::PromiseRejectionHandlingState state,
|
|
void* aData);
|
|
|
|
void AfterProcessMicrotasks();
|
|
public:
|
|
void ProcessStableStateQueue();
|
|
private:
|
|
void CleanupIDBTransactions(uint32_t aRecursionDepth);
|
|
|
|
public:
|
|
enum DeferredFinalizeType {
|
|
FinalizeIncrementally,
|
|
FinalizeNow,
|
|
};
|
|
|
|
virtual dom::WorkerJSContext* GetAsWorkerJSContext() { return nullptr; }
|
|
virtual dom::WorkletJSContext* GetAsWorkletJSContext() { return nullptr; }
|
|
|
|
CycleCollectedJSRuntime* Runtime() const
|
|
{
|
|
MOZ_ASSERT(mRuntime);
|
|
return mRuntime;
|
|
}
|
|
|
|
already_AddRefed<dom::Exception> GetPendingException() const;
|
|
void SetPendingException(dom::Exception* aException);
|
|
|
|
std::queue<RefPtr<MicroTaskRunnable>>& GetMicroTaskQueue();
|
|
std::queue<RefPtr<MicroTaskRunnable>>& GetDebuggerMicroTaskQueue();
|
|
|
|
JSContext* Context() const
|
|
{
|
|
MOZ_ASSERT(mJSContext);
|
|
return mJSContext;
|
|
}
|
|
|
|
JS::RootingContext* RootingCx() const
|
|
{
|
|
MOZ_ASSERT(mJSContext);
|
|
return JS::RootingContext::get(mJSContext);
|
|
}
|
|
|
|
void SetTargetedMicroTaskRecursionDepth(uint32_t aDepth)
|
|
{
|
|
mTargetedMicroTaskRecursionDepth = aDepth;
|
|
}
|
|
|
|
protected:
|
|
JSContext* MaybeContext() const { return mJSContext; }
|
|
|
|
public:
|
|
// nsThread entrypoints
|
|
virtual void BeforeProcessTask(bool aMightBlock);
|
|
virtual void AfterProcessTask(uint32_t aRecursionDepth);
|
|
|
|
// Check whether we need an idle GC task.
|
|
void IsIdleGCTaskNeeded();
|
|
|
|
uint32_t RecursionDepth();
|
|
|
|
// Run in stable state (call through nsContentUtils)
|
|
void RunInStableState(already_AddRefed<nsIRunnable>&& aRunnable);
|
|
|
|
void AddPendingIDBTransaction(already_AddRefed<nsIRunnable>&& aTransaction);
|
|
|
|
// Get the CycleCollectedJSContext for a JSContext.
|
|
// Returns null only if Initialize() has not completed on or during
|
|
// destruction of the CycleCollectedJSContext.
|
|
static CycleCollectedJSContext* GetFor(JSContext* aCx);
|
|
|
|
// Get the current thread's CycleCollectedJSContext. Returns null if there
|
|
// isn't one.
|
|
static CycleCollectedJSContext* Get();
|
|
|
|
// Queue an async microtask to the current main or worker thread.
|
|
virtual void DispatchToMicroTask(already_AddRefed<MicroTaskRunnable> aRunnable);
|
|
|
|
// Call EnterMicroTask when you're entering JS execution.
|
|
// Usually the best way to do this is to use nsAutoMicroTask.
|
|
void EnterMicroTask()
|
|
{
|
|
++mMicroTaskLevel;
|
|
}
|
|
|
|
void LeaveMicroTask()
|
|
{
|
|
if (--mMicroTaskLevel == 0) {
|
|
PerformMicroTaskCheckPoint();
|
|
}
|
|
}
|
|
|
|
bool IsInMicroTask()
|
|
{
|
|
return mMicroTaskLevel != 0;
|
|
}
|
|
|
|
uint32_t MicroTaskLevel()
|
|
{
|
|
return mMicroTaskLevel;
|
|
}
|
|
|
|
void SetMicroTaskLevel(uint32_t aLevel)
|
|
{
|
|
mMicroTaskLevel = aLevel;
|
|
}
|
|
|
|
bool PerformMicroTaskCheckPoint(bool aForce = false);
|
|
|
|
void PerformDebuggerMicroTaskCheckpoint();
|
|
|
|
bool IsInStableOrMetaStableState()
|
|
{
|
|
return mDoingStableStates;
|
|
}
|
|
|
|
// Storage for watching rejected promises waiting for some client to
|
|
// consume their rejection.
|
|
// 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;
|
|
nsTArray<nsCOMPtr<nsISupports /* UncaughtRejectionObserver */ >> mUncaughtRejectionObservers;
|
|
|
|
virtual bool IsSystemCaller() const = 0;
|
|
|
|
private:
|
|
// A primary context owns the mRuntime. Non-main-thread contexts should always
|
|
// be primary. On the main thread, the primary context should be the first one
|
|
// created and the last one destroyed. Non-primary contexts are used for
|
|
// cooperatively scheduled threads.
|
|
bool mIsPrimaryContext;
|
|
|
|
CycleCollectedJSRuntime* mRuntime;
|
|
|
|
JSContext* mJSContext;
|
|
|
|
nsCOMPtr<dom::Exception> mPendingException;
|
|
nsThread* mOwningThread; // Manual refcounting to avoid include hell.
|
|
|
|
struct PendingIDBTransactionData
|
|
{
|
|
nsCOMPtr<nsIRunnable> mTransaction;
|
|
uint32_t mRecursionDepth;
|
|
};
|
|
|
|
nsTArray<nsCOMPtr<nsIRunnable>> mStableStateEvents;
|
|
nsTArray<PendingIDBTransactionData> mPendingIDBTransactions;
|
|
uint32_t mBaseRecursionDepth;
|
|
bool mDoingStableStates;
|
|
|
|
// If set to none 0, microtasks will be processed only when recursion depth
|
|
// is the set value.
|
|
uint32_t mTargetedMicroTaskRecursionDepth;
|
|
|
|
uint32_t mMicroTaskLevel;
|
|
|
|
std::queue<RefPtr<MicroTaskRunnable>> mPendingMicroTaskRunnables;
|
|
std::queue<RefPtr<MicroTaskRunnable>> mDebuggerMicroTaskQueue;
|
|
|
|
uint32_t mMicroTaskRecursionDepth;
|
|
};
|
|
|
|
class MOZ_STACK_CLASS nsAutoMicroTask
|
|
{
|
|
public:
|
|
nsAutoMicroTask()
|
|
{
|
|
CycleCollectedJSContext* ccjs = CycleCollectedJSContext::Get();
|
|
if (ccjs) {
|
|
ccjs->EnterMicroTask();
|
|
}
|
|
}
|
|
~nsAutoMicroTask()
|
|
{
|
|
CycleCollectedJSContext* ccjs = CycleCollectedJSContext::Get();
|
|
if (ccjs) {
|
|
ccjs->LeaveMicroTask();
|
|
}
|
|
}
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_CycleCollectedJSContext_h
|