summaryrefslogtreecommitdiffstats
path: root/dom/base/nsJSEnvironment.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/base/nsJSEnvironment.cpp')
-rw-r--r--dom/base/nsJSEnvironment.cpp2448
1 files changed, 2448 insertions, 0 deletions
diff --git a/dom/base/nsJSEnvironment.cpp b/dom/base/nsJSEnvironment.cpp
new file mode 100644
index 0000000000..1d2eb16885
--- /dev/null
+++ b/dom/base/nsJSEnvironment.cpp
@@ -0,0 +1,2448 @@
+/* -*- 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/. */
+
+#include "nsError.h"
+#include "nsJSEnvironment.h"
+#include "nsIScriptGlobalObject.h"
+#include "nsIScriptObjectPrincipal.h"
+#include "nsPIDOMWindow.h"
+#include "nsDOMCID.h"
+#include "nsIXPConnect.h"
+#include "nsCOMPtr.h"
+#include "nsISupportsPrimitives.h"
+#include "nsReadableUtils.h"
+#include "nsDOMJSUtils.h"
+#include "nsJSUtils.h"
+#include "nsIDocShell.h"
+#include "nsIDocShellTreeItem.h"
+#include "nsPresContext.h"
+#include "nsIConsoleService.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIObserverService.h"
+#include "nsITimer.h"
+#include "nsAtom.h"
+#include "nsContentUtils.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/HoldDropJSObjects.h"
+#include "nsIContent.h"
+#include "nsCycleCollector.h"
+#include "nsXPCOMCIDInternal.h"
+#include "nsServiceManagerUtils.h"
+#include "nsTextFormatter.h"
+#ifdef XP_WIN
+# include <process.h>
+# define getpid _getpid
+#else
+# include <unistd.h> // for getpid()
+#endif
+#include "xpcpublic.h"
+
+#include "jsapi.h"
+#include "js/Array.h" // JS::NewArrayObject
+#include "js/PropertyAndElement.h" // JS_DefineProperty
+#include "js/PropertySpec.h"
+#include "js/SliceBudget.h"
+#include "js/Wrapper.h"
+#include "nsIArray.h"
+#include "CCGCScheduler.h"
+#include "WrapperFactory.h"
+#include "nsGlobalWindowInner.h"
+#include "nsGlobalWindowOuter.h"
+#include "mozilla/AutoRestore.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/SchedulerGroup.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/StaticPrefs_javascript.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/dom/BrowsingContext.h"
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/DOMExceptionBinding.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/ErrorEvent.h"
+#include "mozilla/dom/FetchUtil.h"
+#include "mozilla/dom/RootedDictionary.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/dom/SerializedStackHolder.h"
+#include "mozilla/CycleCollectedJSRuntime.h"
+#include "nsRefreshDriver.h"
+#include "nsJSPrincipals.h"
+#include "AccessCheck.h"
+#include "mozilla/Logging.h"
+#include "prthread.h"
+
+#include "mozilla/Preferences.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/CanvasRenderingContext2DBinding.h"
+#include "mozilla/ContentEvents.h"
+#include "mozilla/CycleCollectedJSContext.h"
+#include "nsCycleCollectionNoteRootCallback.h"
+#include "nsViewManager.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/ProfilerMarkers.h"
+#if defined(MOZ_MEMORY)
+# include "mozmemory.h"
+#endif
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+// Thank you Microsoft!
+#ifdef CompareString
+# undef CompareString
+#endif
+
+static JS::GCSliceCallback sPrevGCSliceCallback;
+
+static bool sIncrementalCC = false;
+
+static bool sIsInitialized;
+static bool sShuttingDown;
+
+static CCGCScheduler* sScheduler = nullptr;
+static std::aligned_storage_t<sizeof(*sScheduler)> sSchedulerStorage;
+
+struct CycleCollectorStats {
+ constexpr CycleCollectorStats() = default;
+ void Init();
+ void Clear();
+ void PrepareForCycleCollection(TimeStamp aNow);
+ void AfterPrepareForCycleCollectionSlice(TimeStamp aDeadline,
+ TimeStamp aBeginTime,
+ TimeStamp aMaybeAfterGCTime);
+ void AfterCycleCollectionSlice();
+ void AfterSyncForgetSkippable(TimeStamp beginTime);
+ void AfterForgetSkippable(TimeDuration duration, uint32_t aRemovedPurples);
+ void AfterCycleCollection();
+
+ void SendTelemetry(TimeDuration aCCNowDuration, TimeStamp aPrevCCEnd) const;
+ void MaybeLogStats(const CycleCollectorResults& aResults,
+ uint32_t aCleanups) const;
+ void MaybeNotifyStats(const CycleCollectorResults& aResults,
+ TimeDuration aCCNowDuration, uint32_t aCleanups) const;
+
+ // Time the current slice began, including any GC finishing.
+ TimeStamp mBeginSliceTime;
+
+ // Time the previous slice of the current CC ended.
+ TimeStamp mEndSliceTime;
+
+ // Time the current cycle collection began.
+ TimeStamp mBeginTime;
+
+ // The longest GC finishing duration for any slice of the current CC.
+ TimeDuration mMaxGCDuration;
+
+ // True if we ran sync forget skippable in any slice of the current CC.
+ bool mRanSyncForgetSkippable = false;
+
+ // Number of suspected objects at the start of the current CC.
+ uint32_t mSuspected = 0;
+
+ // The longest duration spent on sync forget skippable in any slice of the
+ // current CC.
+ TimeDuration mMaxSkippableDuration;
+
+ // The longest pause of any slice in the current CC.
+ TimeDuration mMaxSliceTime;
+
+ // The longest slice time since ClearMaxCCSliceTime() was called.
+ TimeDuration mMaxSliceTimeSinceClear;
+
+ // The total amount of time spent actually running the current CC.
+ TimeDuration mTotalSliceTime;
+
+ // True if we were locked out by the GC in any slice of the current CC.
+ bool mAnyLockedOut = false;
+
+ // A file to dump CC activity to; set by MOZ_CCTIMER environment variable.
+ FILE* mFile = nullptr;
+
+ // In case CC slice was triggered during idle time, set to the end of the idle
+ // period.
+ TimeStamp mIdleDeadline;
+
+ TimeDuration mMinForgetSkippableTime;
+ TimeDuration mMaxForgetSkippableTime;
+ TimeDuration mTotalForgetSkippableTime;
+ uint32_t mForgetSkippableBeforeCC = 0;
+
+ uint32_t mRemovedPurples = 0;
+};
+
+static CycleCollectorStats sCCStats;
+
+static const char* ProcessNameForCollectorLog() {
+ return XRE_GetProcessType() == GeckoProcessType_Default ? "default"
+ : "content";
+}
+
+namespace xpc {
+
+// This handles JS Exceptions (via ExceptionStackOrNull), DOM and XPC
+// Exceptions, and arbitrary values that were associated with a stack by the
+// JS engine when they were thrown, as specified by exceptionStack.
+//
+// Note that the returned stackObj and stackGlobal are _not_ wrapped into the
+// compartment of exceptionValue.
+void FindExceptionStackForConsoleReport(
+ nsPIDOMWindowInner* win, JS::Handle<JS::Value> exceptionValue,
+ JS::Handle<JSObject*> exceptionStack, JS::MutableHandle<JSObject*> stackObj,
+ JS::MutableHandle<JSObject*> stackGlobal) {
+ stackObj.set(nullptr);
+ stackGlobal.set(nullptr);
+
+ if (!exceptionValue.isObject()) {
+ // Use the stack provided by the JS engine, if available. This will not be
+ // a wrapper.
+ if (exceptionStack) {
+ stackObj.set(exceptionStack);
+ stackGlobal.set(JS::GetNonCCWObjectGlobal(exceptionStack));
+ }
+ return;
+ }
+
+ if (win && win->AsGlobal()->IsDying()) {
+ // Pretend like we have no stack, so we don't end up keeping the global
+ // alive via the stack.
+ return;
+ }
+
+ JS::RootingContext* rcx = RootingCx();
+ JS::Rooted<JSObject*> exceptionObject(rcx, &exceptionValue.toObject());
+ if (JSObject* excStack = JS::ExceptionStackOrNull(exceptionObject)) {
+ // At this point we know exceptionObject is a possibly-wrapped
+ // js::ErrorObject that has excStack as stack. excStack might also be a CCW,
+ // but excStack must be same-compartment with the unwrapped ErrorObject.
+ // Return the ErrorObject's global as stackGlobal. This matches what we do
+ // in the ErrorObject's |.stack| getter and ensures stackObj and stackGlobal
+ // are same-compartment.
+ JSObject* unwrappedException = js::UncheckedUnwrap(exceptionObject);
+ stackObj.set(excStack);
+ stackGlobal.set(JS::GetNonCCWObjectGlobal(unwrappedException));
+ return;
+ }
+
+ // It is not a JS Exception, try DOM Exception.
+ RefPtr<Exception> exception;
+ UNWRAP_OBJECT(DOMException, exceptionObject, exception);
+ if (!exception) {
+ // Not a DOM Exception, try XPC Exception.
+ UNWRAP_OBJECT(Exception, exceptionObject, exception);
+ if (!exception) {
+ // As above, use the stack provided by the JS engine, if available.
+ if (exceptionStack) {
+ stackObj.set(exceptionStack);
+ stackGlobal.set(JS::GetNonCCWObjectGlobal(exceptionStack));
+ }
+ return;
+ }
+ }
+
+ nsCOMPtr<nsIStackFrame> stack = exception->GetLocation();
+ if (!stack) {
+ return;
+ }
+ JS::Rooted<JS::Value> value(rcx);
+ stack->GetNativeSavedFrame(&value);
+ if (value.isObject()) {
+ stackObj.set(&value.toObject());
+ MOZ_ASSERT(JS::IsUnwrappedSavedFrame(stackObj));
+ stackGlobal.set(JS::GetNonCCWObjectGlobal(stackObj));
+ return;
+ }
+}
+
+} /* namespace xpc */
+
+static TimeDuration GetCollectionTimeDelta() {
+ static TimeStamp sFirstCollectionTime;
+ TimeStamp now = TimeStamp::Now();
+ if (sFirstCollectionTime) {
+ return now - sFirstCollectionTime;
+ }
+ sFirstCollectionTime = now;
+ return TimeDuration();
+}
+
+class nsJSEnvironmentObserver final : public nsIObserver {
+ ~nsJSEnvironmentObserver() = default;
+
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIOBSERVER
+};
+
+NS_IMPL_ISUPPORTS(nsJSEnvironmentObserver, nsIObserver)
+
+NS_IMETHODIMP
+nsJSEnvironmentObserver::Observe(nsISupports* aSubject, const char* aTopic,
+ const char16_t* aData) {
+ if (!nsCRT::strcmp(aTopic, "memory-pressure")) {
+ if (StaticPrefs::javascript_options_gc_on_memory_pressure()) {
+ if (sShuttingDown) {
+ // Don't GC/CC if we're already shutting down.
+ return NS_OK;
+ }
+ nsDependentString data(aData);
+ if (data.EqualsLiteral("low-memory-ongoing")) {
+ // Don't GC/CC if we are in an ongoing low-memory state since its very
+ // slow and it likely won't help us anyway.
+ return NS_OK;
+ }
+ if (data.EqualsLiteral("heap-minimize")) {
+ // heap-minimize notifiers expect this to run synchronously
+ nsJSContext::DoLowMemoryGC();
+ return NS_OK;
+ }
+ if (data.EqualsLiteral("low-memory")) {
+ nsJSContext::SetLowMemoryState(true);
+ }
+ // Asynchronously GC.
+ nsJSContext::LowMemoryGC();
+ }
+ } else if (!nsCRT::strcmp(aTopic, "memory-pressure-stop")) {
+ nsJSContext::SetLowMemoryState(false);
+ } else if (!nsCRT::strcmp(aTopic, "user-interaction-inactive")) {
+ sScheduler->UserIsInactive();
+ } else if (!nsCRT::strcmp(aTopic, "user-interaction-active")) {
+ sScheduler->UserIsActive();
+ } else if (!nsCRT::strcmp(aTopic, "quit-application") ||
+ !nsCRT::strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) ||
+ !nsCRT::strcmp(aTopic, "content-child-will-shutdown")) {
+ sShuttingDown = true;
+ sScheduler->Shutdown();
+ }
+
+ return NS_OK;
+}
+
+/****************************************************************
+ ************************** AutoFree ****************************
+ ****************************************************************/
+
+class AutoFree {
+ public:
+ explicit AutoFree(void* aPtr) : mPtr(aPtr) {}
+ ~AutoFree() {
+ if (mPtr) free(mPtr);
+ }
+ void Invalidate() { mPtr = nullptr; }
+
+ private:
+ void* mPtr;
+};
+
+// A utility function for script languages to call. Although it looks small,
+// the use of nsIDocShell and nsPresContext triggers a huge number of
+// dependencies that most languages would not otherwise need.
+// XXXmarkh - This function is mis-placed!
+bool NS_HandleScriptError(nsIScriptGlobalObject* aScriptGlobal,
+ const ErrorEventInit& aErrorEventInit,
+ nsEventStatus* aStatus) {
+ bool called = false;
+ nsCOMPtr<nsPIDOMWindowInner> win(do_QueryInterface(aScriptGlobal));
+ nsIDocShell* docShell = win ? win->GetDocShell() : nullptr;
+ if (docShell) {
+ RefPtr<nsPresContext> presContext = docShell->GetPresContext();
+
+ static int32_t errorDepth; // Recursion prevention
+ ++errorDepth;
+
+ if (errorDepth < 2) {
+ // Dispatch() must be synchronous for the recursion block
+ // (errorDepth) to work.
+ RefPtr<ErrorEvent> event = ErrorEvent::Constructor(
+ nsGlobalWindowInner::Cast(win), u"error"_ns, aErrorEventInit);
+ event->SetTrusted(true);
+
+ // MOZ_KnownLive due to bug 1506441
+ EventDispatcher::DispatchDOMEvent(
+ MOZ_KnownLive(nsGlobalWindowInner::Cast(win)), nullptr, event,
+ presContext, aStatus);
+ called = true;
+ }
+ --errorDepth;
+ }
+ return called;
+}
+
+class ScriptErrorEvent : public Runnable {
+ public:
+ ScriptErrorEvent(nsPIDOMWindowInner* aWindow, JS::RootingContext* aRootingCx,
+ xpc::ErrorReport* aReport, JS::Handle<JS::Value> aError,
+ JS::Handle<JSObject*> aErrorStack)
+ : mozilla::Runnable("ScriptErrorEvent"),
+ mWindow(aWindow),
+ mReport(aReport),
+ mError(aRootingCx, aError),
+ mErrorStack(aRootingCx, aErrorStack) {}
+
+ // TODO: Convert this to MOZ_CAN_RUN_SCRIPT (bug 1415230, bug 1535398)
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() override {
+ nsEventStatus status = nsEventStatus_eIgnore;
+ nsCOMPtr<nsPIDOMWindowInner> win = mWindow;
+ MOZ_ASSERT(win);
+ MOZ_ASSERT(NS_IsMainThread());
+ // First, notify the DOM that we have a script error, but only if
+ // our window is still the current inner.
+ JS::RootingContext* rootingCx = RootingCx();
+ if (win->IsCurrentInnerWindow() && win->GetDocShell() &&
+ !sHandlingScriptError) {
+ AutoRestore<bool> recursionGuard(sHandlingScriptError);
+ sHandlingScriptError = true;
+
+ RefPtr<nsPresContext> presContext = win->GetDocShell()->GetPresContext();
+
+ RootedDictionary<ErrorEventInit> init(rootingCx);
+ init.mCancelable = true;
+ init.mFilename = mReport->mFileName;
+ init.mBubbles = true;
+
+ constexpr auto xoriginMsg = u"Script error."_ns;
+ if (!mReport->mIsMuted) {
+ init.mMessage = mReport->mErrorMsg;
+ init.mLineno = mReport->mLineNumber;
+ init.mColno = mReport->mColumn;
+ init.mError = mError;
+ } else {
+ NS_WARNING("Not same origin error!");
+ init.mMessage = xoriginMsg;
+ init.mLineno = 0;
+ }
+
+ RefPtr<ErrorEvent> event = ErrorEvent::Constructor(
+ nsGlobalWindowInner::Cast(win), u"error"_ns, init);
+ event->SetTrusted(true);
+
+ // MOZ_KnownLive due to bug 1506441
+ EventDispatcher::DispatchDOMEvent(
+ MOZ_KnownLive(nsGlobalWindowInner::Cast(win)), nullptr, event,
+ presContext, &status);
+ }
+
+ if (status != nsEventStatus_eConsumeNoDefault) {
+ JS::Rooted<JSObject*> stack(rootingCx);
+ JS::Rooted<JSObject*> stackGlobal(rootingCx);
+ xpc::FindExceptionStackForConsoleReport(win, mError, mErrorStack, &stack,
+ &stackGlobal);
+ JS::Rooted<Maybe<JS::Value>> exception(rootingCx, Some(mError));
+ nsGlobalWindowInner* inner = nsGlobalWindowInner::Cast(win);
+ mReport->LogToConsoleWithStack(inner, exception, stack, stackGlobal);
+ }
+
+ return NS_OK;
+ }
+
+ private:
+ nsCOMPtr<nsPIDOMWindowInner> mWindow;
+ RefPtr<xpc::ErrorReport> mReport;
+ JS::PersistentRooted<JS::Value> mError;
+ JS::PersistentRooted<JSObject*> mErrorStack;
+
+ static bool sHandlingScriptError;
+};
+
+bool ScriptErrorEvent::sHandlingScriptError = false;
+
+// This temporarily lives here to avoid code churn. It will go away entirely
+// soon.
+namespace xpc {
+
+void DispatchScriptErrorEvent(nsPIDOMWindowInner* win,
+ JS::RootingContext* rootingCx,
+ xpc::ErrorReport* xpcReport,
+ JS::Handle<JS::Value> exception,
+ JS::Handle<JSObject*> exceptionStack) {
+ nsContentUtils::AddScriptRunner(new ScriptErrorEvent(
+ win, rootingCx, xpcReport, exception, exceptionStack));
+}
+
+} /* namespace xpc */
+
+#ifdef DEBUG
+// A couple of useful functions to call when you're debugging.
+nsGlobalWindowInner* JSObject2Win(JSObject* obj) {
+ return xpc::WindowOrNull(obj);
+}
+
+template <typename T>
+void PrintWinURI(T* win) {
+ if (!win) {
+ printf("No window passed in.\n");
+ return;
+ }
+
+ nsCOMPtr<Document> doc = win->GetExtantDoc();
+ if (!doc) {
+ printf("No document in the window.\n");
+ return;
+ }
+
+ nsIURI* uri = doc->GetDocumentURI();
+ if (!uri) {
+ printf("Document doesn't have a URI.\n");
+ return;
+ }
+
+ printf("%s\n", uri->GetSpecOrDefault().get());
+}
+
+void PrintWinURIInner(nsGlobalWindowInner* aWin) { return PrintWinURI(aWin); }
+
+void PrintWinURIOuter(nsGlobalWindowOuter* aWin) { return PrintWinURI(aWin); }
+
+template <typename T>
+void PrintWinCodebase(T* win) {
+ if (!win) {
+ printf("No window passed in.\n");
+ return;
+ }
+
+ nsIPrincipal* prin = win->GetPrincipal();
+ if (!prin) {
+ printf("Window doesn't have principals.\n");
+ return;
+ }
+ if (prin->IsSystemPrincipal()) {
+ printf("No URI, it's the system principal.\n");
+ return;
+ }
+ nsCString spec;
+ prin->GetAsciiSpec(spec);
+ printf("%s\n", spec.get());
+}
+
+void PrintWinCodebaseInner(nsGlobalWindowInner* aWin) {
+ return PrintWinCodebase(aWin);
+}
+
+void PrintWinCodebaseOuter(nsGlobalWindowOuter* aWin) {
+ return PrintWinCodebase(aWin);
+}
+
+void DumpString(const nsAString& str) {
+ printf("%s\n", NS_ConvertUTF16toUTF8(str).get());
+}
+#endif
+
+nsJSContext::nsJSContext(bool aGCOnDestruction,
+ nsIScriptGlobalObject* aGlobalObject)
+ : mWindowProxy(nullptr),
+ mGCOnDestruction(aGCOnDestruction),
+ mGlobalObjectRef(aGlobalObject) {
+ EnsureStatics();
+
+ mProcessingScriptTag = false;
+ HoldJSObjects(this);
+}
+
+nsJSContext::~nsJSContext() {
+ mGlobalObjectRef = nullptr;
+
+ Destroy();
+}
+
+void nsJSContext::Destroy() {
+ if (mGCOnDestruction) {
+ sScheduler->PokeGC(JS::GCReason::NSJSCONTEXT_DESTROY, mWindowProxy);
+ }
+
+ DropJSObjects(this);
+}
+
+// QueryInterface implementation for nsJSContext
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsJSContext)
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(nsJSContext)
+ NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mWindowProxy)
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsJSContext)
+ tmp->mGCOnDestruction = false;
+ tmp->mWindowProxy = nullptr;
+ tmp->Destroy();
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mGlobalObjectRef)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsJSContext)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGlobalObjectRef)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsJSContext)
+ NS_INTERFACE_MAP_ENTRY(nsIScriptContext)
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsJSContext)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsJSContext)
+
+#ifdef DEBUG
+bool AtomIsEventHandlerName(nsAtom* aName) {
+ const char16_t* name = aName->GetUTF16String();
+
+ const char16_t* cp;
+ char16_t c;
+ for (cp = name; *cp != '\0'; ++cp) {
+ c = *cp;
+ if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z')) return false;
+ }
+
+ return true;
+}
+#endif
+
+nsIScriptGlobalObject* nsJSContext::GetGlobalObject() {
+ // Note: this could probably be simplified somewhat more; see bug 974327
+ // comments 1 and 3.
+ if (!mWindowProxy) {
+ return nullptr;
+ }
+
+ MOZ_ASSERT(mGlobalObjectRef);
+ return mGlobalObjectRef;
+}
+
+nsresult nsJSContext::SetProperty(JS::Handle<JSObject*> aTarget,
+ const char* aPropName, nsISupports* aArgs) {
+ AutoJSAPI jsapi;
+ if (NS_WARN_IF(!jsapi.Init(GetGlobalObject()))) {
+ return NS_ERROR_FAILURE;
+ }
+ JSContext* cx = jsapi.cx();
+
+ JS::RootedVector<JS::Value> args(cx);
+
+ JS::Rooted<JSObject*> global(cx, GetWindowProxy());
+ nsresult rv = ConvertSupportsTojsvals(cx, aArgs, global, &args);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // got the arguments, now attach them.
+
+ for (uint32_t i = 0; i < args.length(); ++i) {
+ if (!JS_WrapValue(cx, args[i])) {
+ return NS_ERROR_FAILURE;
+ }
+ }
+
+ JS::Rooted<JSObject*> array(cx, JS::NewArrayObject(cx, args));
+ if (!array) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return JS_DefineProperty(cx, aTarget, aPropName, array, 0) ? NS_OK
+ : NS_ERROR_FAILURE;
+}
+
+nsresult nsJSContext::ConvertSupportsTojsvals(
+ JSContext* aCx, nsISupports* aArgs, JS::Handle<JSObject*> aScope,
+ JS::MutableHandleVector<JS::Value> aArgsOut) {
+ nsresult rv = NS_OK;
+
+ // If the array implements nsIJSArgArray, copy the contents and return.
+ nsCOMPtr<nsIJSArgArray> fastArray = do_QueryInterface(aArgs);
+ if (fastArray) {
+ uint32_t argc;
+ JS::Value* argv;
+ rv = fastArray->GetArgs(&argc, reinterpret_cast<void**>(&argv));
+ if (NS_SUCCEEDED(rv) && !aArgsOut.append(argv, argc)) {
+ rv = NS_ERROR_OUT_OF_MEMORY;
+ }
+ return rv;
+ }
+
+ // Take the slower path converting each item.
+ // Handle only nsIArray and nsIVariant. nsIArray is only needed for
+ // SetProperty('arguments', ...);
+
+ nsIXPConnect* xpc = nsContentUtils::XPConnect();
+ NS_ENSURE_TRUE(xpc, NS_ERROR_UNEXPECTED);
+
+ if (!aArgs) return NS_OK;
+ uint32_t argCount;
+ // This general purpose function may need to convert an arg array
+ // (window.arguments, event-handler args) and a generic property.
+ nsCOMPtr<nsIArray> argsArray(do_QueryInterface(aArgs));
+
+ if (argsArray) {
+ rv = argsArray->GetLength(&argCount);
+ NS_ENSURE_SUCCESS(rv, rv);
+ if (argCount == 0) return NS_OK;
+ } else {
+ argCount = 1; // the nsISupports which is not an array
+ }
+
+ // Use the caller's auto guards to release and unroot.
+ if (!aArgsOut.resize(argCount)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (argsArray) {
+ for (uint32_t argCtr = 0; argCtr < argCount && NS_SUCCEEDED(rv); argCtr++) {
+ nsCOMPtr<nsISupports> arg;
+ JS::MutableHandle<JS::Value> thisVal = aArgsOut[argCtr];
+ argsArray->QueryElementAt(argCtr, NS_GET_IID(nsISupports),
+ getter_AddRefs(arg));
+ if (!arg) {
+ thisVal.setNull();
+ continue;
+ }
+ nsCOMPtr<nsIVariant> variant(do_QueryInterface(arg));
+ if (variant != nullptr) {
+ rv = xpc->VariantToJS(aCx, aScope, variant, thisVal);
+ } else {
+ // And finally, support the nsISupportsPrimitives supplied
+ // by the AppShell. It generally will pass only strings, but
+ // as we have code for handling all, we may as well use it.
+ rv = AddSupportsPrimitiveTojsvals(aCx, arg, thisVal.address());
+ if (rv == NS_ERROR_NO_INTERFACE) {
+ // something else - probably an event object or similar -
+ // just wrap it.
+#ifdef DEBUG
+ // but first, check its not another nsISupportsPrimitive, as
+ // these are now deprecated for use with script contexts.
+ nsCOMPtr<nsISupportsPrimitive> prim(do_QueryInterface(arg));
+ NS_ASSERTION(prim == nullptr,
+ "Don't pass nsISupportsPrimitives - use nsIVariant!");
+#endif
+ JSAutoRealm ar(aCx, aScope);
+ rv = nsContentUtils::WrapNative(aCx, arg, thisVal);
+ }
+ }
+ }
+ } else {
+ nsCOMPtr<nsIVariant> variant = do_QueryInterface(aArgs);
+ if (variant) {
+ rv = xpc->VariantToJS(aCx, aScope, variant, aArgsOut[0]);
+ } else {
+ NS_ERROR("Not an array, not an interface?");
+ rv = NS_ERROR_UNEXPECTED;
+ }
+ }
+ return rv;
+}
+
+// This really should go into xpconnect somewhere...
+nsresult nsJSContext::AddSupportsPrimitiveTojsvals(JSContext* aCx,
+ nsISupports* aArg,
+ JS::Value* aArgv) {
+ MOZ_ASSERT(aArg, "Empty arg");
+
+ nsCOMPtr<nsISupportsPrimitive> argPrimitive(do_QueryInterface(aArg));
+ if (!argPrimitive) return NS_ERROR_NO_INTERFACE;
+
+ uint16_t type;
+ argPrimitive->GetType(&type);
+
+ switch (type) {
+ case nsISupportsPrimitive::TYPE_CSTRING: {
+ nsCOMPtr<nsISupportsCString> p(do_QueryInterface(argPrimitive));
+ NS_ENSURE_TRUE(p, NS_ERROR_UNEXPECTED);
+
+ nsAutoCString data;
+
+ p->GetData(data);
+
+ JSString* str = ::JS_NewStringCopyN(aCx, data.get(), data.Length());
+ NS_ENSURE_TRUE(str, NS_ERROR_OUT_OF_MEMORY);
+
+ aArgv->setString(str);
+
+ break;
+ }
+ case nsISupportsPrimitive::TYPE_STRING: {
+ nsCOMPtr<nsISupportsString> p(do_QueryInterface(argPrimitive));
+ NS_ENSURE_TRUE(p, NS_ERROR_UNEXPECTED);
+
+ nsAutoString data;
+
+ p->GetData(data);
+
+ // cast is probably safe since wchar_t and char16_t are expected
+ // to be equivalent; both unsigned 16-bit entities
+ JSString* str = ::JS_NewUCStringCopyN(aCx, data.get(), data.Length());
+ NS_ENSURE_TRUE(str, NS_ERROR_OUT_OF_MEMORY);
+
+ aArgv->setString(str);
+ break;
+ }
+ case nsISupportsPrimitive::TYPE_PRBOOL: {
+ nsCOMPtr<nsISupportsPRBool> p(do_QueryInterface(argPrimitive));
+ NS_ENSURE_TRUE(p, NS_ERROR_UNEXPECTED);
+
+ bool data;
+
+ p->GetData(&data);
+
+ aArgv->setBoolean(data);
+
+ break;
+ }
+ case nsISupportsPrimitive::TYPE_PRUINT8: {
+ nsCOMPtr<nsISupportsPRUint8> p(do_QueryInterface(argPrimitive));
+ NS_ENSURE_TRUE(p, NS_ERROR_UNEXPECTED);
+
+ uint8_t data;
+
+ p->GetData(&data);
+
+ aArgv->setInt32(data);
+
+ break;
+ }
+ case nsISupportsPrimitive::TYPE_PRUINT16: {
+ nsCOMPtr<nsISupportsPRUint16> p(do_QueryInterface(argPrimitive));
+ NS_ENSURE_TRUE(p, NS_ERROR_UNEXPECTED);
+
+ uint16_t data;
+
+ p->GetData(&data);
+
+ aArgv->setInt32(data);
+
+ break;
+ }
+ case nsISupportsPrimitive::TYPE_PRUINT32: {
+ nsCOMPtr<nsISupportsPRUint32> p(do_QueryInterface(argPrimitive));
+ NS_ENSURE_TRUE(p, NS_ERROR_UNEXPECTED);
+
+ uint32_t data;
+
+ p->GetData(&data);
+
+ aArgv->setInt32(data);
+
+ break;
+ }
+ case nsISupportsPrimitive::TYPE_CHAR: {
+ nsCOMPtr<nsISupportsChar> p(do_QueryInterface(argPrimitive));
+ NS_ENSURE_TRUE(p, NS_ERROR_UNEXPECTED);
+
+ char data;
+
+ p->GetData(&data);
+
+ JSString* str = ::JS_NewStringCopyN(aCx, &data, 1);
+ NS_ENSURE_TRUE(str, NS_ERROR_OUT_OF_MEMORY);
+
+ aArgv->setString(str);
+
+ break;
+ }
+ case nsISupportsPrimitive::TYPE_PRINT16: {
+ nsCOMPtr<nsISupportsPRInt16> p(do_QueryInterface(argPrimitive));
+ NS_ENSURE_TRUE(p, NS_ERROR_UNEXPECTED);
+
+ int16_t data;
+
+ p->GetData(&data);
+
+ aArgv->setInt32(data);
+
+ break;
+ }
+ case nsISupportsPrimitive::TYPE_PRINT32: {
+ nsCOMPtr<nsISupportsPRInt32> p(do_QueryInterface(argPrimitive));
+ NS_ENSURE_TRUE(p, NS_ERROR_UNEXPECTED);
+
+ int32_t data;
+
+ p->GetData(&data);
+
+ aArgv->setInt32(data);
+
+ break;
+ }
+ case nsISupportsPrimitive::TYPE_FLOAT: {
+ nsCOMPtr<nsISupportsFloat> p(do_QueryInterface(argPrimitive));
+ NS_ENSURE_TRUE(p, NS_ERROR_UNEXPECTED);
+
+ float data;
+
+ p->GetData(&data);
+
+ *aArgv = ::JS_NumberValue(data);
+
+ break;
+ }
+ case nsISupportsPrimitive::TYPE_DOUBLE: {
+ nsCOMPtr<nsISupportsDouble> p(do_QueryInterface(argPrimitive));
+ NS_ENSURE_TRUE(p, NS_ERROR_UNEXPECTED);
+
+ double data;
+
+ p->GetData(&data);
+
+ *aArgv = ::JS_NumberValue(data);
+
+ break;
+ }
+ case nsISupportsPrimitive::TYPE_INTERFACE_POINTER: {
+ nsCOMPtr<nsISupportsInterfacePointer> p(do_QueryInterface(argPrimitive));
+ NS_ENSURE_TRUE(p, NS_ERROR_UNEXPECTED);
+
+ nsCOMPtr<nsISupports> data;
+ nsIID* iid = nullptr;
+
+ p->GetData(getter_AddRefs(data));
+ p->GetDataIID(&iid);
+ NS_ENSURE_TRUE(iid, NS_ERROR_UNEXPECTED);
+
+ AutoFree iidGuard(iid); // Free iid upon destruction.
+
+ JS::Rooted<JSObject*> scope(aCx, GetWindowProxy());
+ JS::Rooted<JS::Value> v(aCx);
+ JSAutoRealm ar(aCx, scope);
+ nsresult rv = nsContentUtils::WrapNative(aCx, data, iid, &v);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *aArgv = v;
+
+ break;
+ }
+ case nsISupportsPrimitive::TYPE_ID:
+ case nsISupportsPrimitive::TYPE_PRUINT64:
+ case nsISupportsPrimitive::TYPE_PRINT64:
+ case nsISupportsPrimitive::TYPE_PRTIME: {
+ NS_WARNING("Unsupported primitive type used");
+ aArgv->setNull();
+ break;
+ }
+ default: {
+ NS_WARNING("Unknown primitive type used");
+ aArgv->setNull();
+ break;
+ }
+ }
+ return NS_OK;
+}
+
+#ifdef MOZ_JPROF
+
+# include <signal.h>
+
+inline bool IsJProfAction(struct sigaction* action) {
+ return (action->sa_sigaction &&
+ (action->sa_flags & (SA_RESTART | SA_SIGINFO)) ==
+ (SA_RESTART | SA_SIGINFO));
+}
+
+void NS_JProfStartProfiling();
+void NS_JProfStopProfiling();
+void NS_JProfClearCircular();
+
+static bool JProfStartProfilingJS(JSContext* cx, unsigned argc, JS::Value* vp) {
+ NS_JProfStartProfiling();
+ return true;
+}
+
+void NS_JProfStartProfiling() {
+ // Figure out whether we're dealing with SIGPROF, SIGALRM, or
+ // SIGPOLL profiling (SIGALRM for JP_REALTIME, SIGPOLL for
+ // JP_RTC_HZ)
+ struct sigaction action;
+
+ // Must check ALRM before PROF since both are enabled for real-time
+ sigaction(SIGALRM, nullptr, &action);
+ // printf("SIGALRM: %p, flags = %x\n",action.sa_sigaction,action.sa_flags);
+ if (IsJProfAction(&action)) {
+ // printf("Beginning real-time jprof profiling.\n");
+ raise(SIGALRM);
+ return;
+ }
+
+ sigaction(SIGPROF, nullptr, &action);
+ // printf("SIGPROF: %p, flags = %x\n",action.sa_sigaction,action.sa_flags);
+ if (IsJProfAction(&action)) {
+ // printf("Beginning process-time jprof profiling.\n");
+ raise(SIGPROF);
+ return;
+ }
+
+ sigaction(SIGPOLL, nullptr, &action);
+ // printf("SIGPOLL: %p, flags = %x\n",action.sa_sigaction,action.sa_flags);
+ if (IsJProfAction(&action)) {
+ // printf("Beginning rtc-based jprof profiling.\n");
+ raise(SIGPOLL);
+ return;
+ }
+
+ printf("Could not start jprof-profiling since JPROF_FLAGS was not set.\n");
+}
+
+static bool JProfStopProfilingJS(JSContext* cx, unsigned argc, JS::Value* vp) {
+ NS_JProfStopProfiling();
+ return true;
+}
+
+void NS_JProfStopProfiling() {
+ raise(SIGUSR1);
+ // printf("Stopped jprof profiling.\n");
+}
+
+static bool JProfClearCircularJS(JSContext* cx, unsigned argc, JS::Value* vp) {
+ NS_JProfClearCircular();
+ return true;
+}
+
+void NS_JProfClearCircular() {
+ raise(SIGUSR2);
+ // printf("cleared jprof buffer\n");
+}
+
+static bool JProfSaveCircularJS(JSContext* cx, unsigned argc, JS::Value* vp) {
+ // Not ideal...
+ NS_JProfStopProfiling();
+ NS_JProfStartProfiling();
+ return true;
+}
+
+static const JSFunctionSpec JProfFunctions[] = {
+ JS_FN("JProfStartProfiling", JProfStartProfilingJS, 0, 0),
+ JS_FN("JProfStopProfiling", JProfStopProfilingJS, 0, 0),
+ JS_FN("JProfClearCircular", JProfClearCircularJS, 0, 0),
+ JS_FN("JProfSaveCircular", JProfSaveCircularJS, 0, 0), JS_FS_END};
+
+#endif /* defined(MOZ_JPROF) */
+
+nsresult nsJSContext::InitClasses(JS::Handle<JSObject*> aGlobalObj) {
+ AutoJSAPI jsapi;
+ jsapi.Init();
+ JSContext* cx = jsapi.cx();
+ JSAutoRealm ar(cx, aGlobalObj);
+
+#ifdef MOZ_JPROF
+ // Attempt to initialize JProf functions
+ ::JS_DefineFunctions(cx, aGlobalObj, JProfFunctions);
+#endif
+
+ return NS_OK;
+}
+
+bool nsJSContext::GetProcessingScriptTag() { return mProcessingScriptTag; }
+
+void nsJSContext::SetProcessingScriptTag(bool aFlag) {
+ mProcessingScriptTag = aFlag;
+}
+
+// static
+void nsJSContext::SetLowMemoryState(bool aState) {
+ JSContext* cx = danger::GetJSContext();
+ JS::SetLowMemoryState(cx, aState);
+}
+
+static void GarbageCollectImpl(JS::GCReason aReason,
+ nsJSContext::IsShrinking aShrinking,
+ const js::SliceBudget& aBudget) {
+ AUTO_PROFILER_LABEL_DYNAMIC_CSTR_NONSENSITIVE(
+ "nsJSContext::GarbageCollectNow", GCCC, JS::ExplainGCReason(aReason));
+
+ bool wantIncremental = !aBudget.isUnlimited();
+
+ // We use danger::GetJSContext() since AutoJSAPI will assert if the current
+ // thread's context is null (such as during shutdown).
+ JSContext* cx = danger::GetJSContext();
+
+ if (!nsContentUtils::XPConnect() || !cx) {
+ return;
+ }
+
+ if (sScheduler->InIncrementalGC() && wantIncremental) {
+ // We're in the middle of incremental GC. Do another slice.
+ JS::PrepareForIncrementalGC(cx);
+ JS::IncrementalGCSlice(cx, aReason, aBudget);
+ return;
+ }
+
+ JS::GCOptions options = aShrinking == nsJSContext::ShrinkingGC
+ ? JS::GCOptions::Shrink
+ : JS::GCOptions::Normal;
+
+ if (!wantIncremental || aReason == JS::GCReason::FULL_GC_TIMER) {
+ sScheduler->SetNeedsFullGC();
+ }
+
+ if (sScheduler->NeedsFullGC()) {
+ JS::PrepareForFullGC(cx);
+ }
+
+ if (wantIncremental) {
+ // Incremental GC slices will be triggered by the GC Runner. If one doesn't
+ // already exist, create it in the GC_SLICE_END callback for the first
+ // slice being executed here.
+ JS::StartIncrementalGC(cx, options, aReason, aBudget);
+ } else {
+ JS::NonIncrementalGC(cx, options, aReason);
+ }
+}
+
+// static
+void nsJSContext::GarbageCollectNow(JS::GCReason aReason,
+ IsShrinking aShrinking) {
+ GarbageCollectImpl(aReason, aShrinking, js::SliceBudget::unlimited());
+}
+
+// static
+void nsJSContext::RunIncrementalGCSlice(JS::GCReason aReason,
+ IsShrinking aShrinking,
+ js::SliceBudget& aBudget) {
+ AUTO_PROFILER_LABEL_RELEVANT_FOR_JS("Incremental GC", GCCC);
+ GarbageCollectImpl(aReason, aShrinking, aBudget);
+}
+
+static void FinishAnyIncrementalGC() {
+ AUTO_PROFILER_LABEL("FinishAnyIncrementalGC", GCCC);
+
+ if (sScheduler->InIncrementalGC()) {
+ AutoJSAPI jsapi;
+ jsapi.Init();
+
+ // We're in the middle of an incremental GC, so finish it.
+ JS::PrepareForIncrementalGC(jsapi.cx());
+ JS::FinishIncrementalGC(jsapi.cx(), JS::GCReason::CC_FORCED);
+ }
+}
+
+namespace geckoprofiler::markers {
+class CCSliceMarker : public BaseMarkerType<CCSliceMarker> {
+ public:
+ static constexpr const char* Name = "CCSlice";
+ static constexpr const char* Description =
+ "Information for an individual CC slice.";
+
+ using MS = MarkerSchema;
+ static constexpr MS::PayloadField PayloadFields[] = {
+ {"idle", MS::InputType::Boolean, "Idle", MS::Format::Integer}};
+
+ static constexpr MS::Location Locations[] = {MS::Location::MarkerChart,
+ MS::Location::MarkerTable,
+ MS::Location::TimelineMemory};
+ static constexpr const char* AllLabels =
+ "{marker.name} (idle={marker.data.idle})";
+
+ static constexpr MS::ETWMarkerGroup Group = MS::ETWMarkerGroup::Memory;
+
+ static void StreamJSONMarkerData(
+ mozilla::baseprofiler::SpliceableJSONWriter& aWriter,
+ bool aIsDuringIdle) {
+ StreamJSONMarkerDataImpl(aWriter, aIsDuringIdle);
+ }
+};
+} // namespace geckoprofiler::markers
+
+static void FireForgetSkippable(bool aRemoveChildless, TimeStamp aDeadline) {
+ TimeStamp startTimeStamp = TimeStamp::Now();
+ FinishAnyIncrementalGC();
+
+ uint32_t suspectedBefore = nsCycleCollector_suspectedCount();
+ js::SliceBudget budget =
+ sScheduler->ComputeForgetSkippableBudget(startTimeStamp, aDeadline);
+ bool earlyForgetSkippable = sScheduler->IsEarlyForgetSkippable();
+ nsCycleCollector_forgetSkippable(budget, aRemoveChildless,
+ earlyForgetSkippable);
+ TimeStamp now = TimeStamp::Now();
+ uint32_t removedPurples = sScheduler->NoteForgetSkippableComplete(
+ now, suspectedBefore, nsCycleCollector_suspectedCount());
+
+ TimeDuration duration = now - startTimeStamp;
+
+ sCCStats.AfterForgetSkippable(duration, removedPurples);
+
+ if (duration.ToSeconds()) {
+ TimeDuration idleDuration;
+ if (!aDeadline.IsNull()) {
+ if (aDeadline < now) {
+ // This slice overflowed the idle period.
+ if (aDeadline > startTimeStamp) {
+ idleDuration = aDeadline - startTimeStamp;
+ }
+ } else {
+ idleDuration = duration;
+ }
+ }
+
+ uint32_t percent =
+ uint32_t(idleDuration.ToSeconds() / duration.ToSeconds() * 100);
+ Telemetry::Accumulate(Telemetry::FORGET_SKIPPABLE_DURING_IDLE, percent);
+ }
+
+ PROFILER_MARKER("ForgetSkippable", GCCC,
+ MarkerTiming::IntervalUntilNowFrom(startTimeStamp),
+ CCSliceMarker, !aDeadline.IsNull());
+}
+
+MOZ_ALWAYS_INLINE
+static TimeDuration TimeBetween(TimeStamp aStart, TimeStamp aEnd) {
+ MOZ_ASSERT(aEnd >= aStart);
+ return aEnd - aStart;
+}
+
+static TimeDuration TimeUntilNow(TimeStamp start) {
+ if (start.IsNull()) {
+ return TimeDuration();
+ }
+ return TimeBetween(start, TimeStamp::Now());
+}
+
+void CycleCollectorStats::Init() {
+ Clear();
+
+ char* env = getenv("MOZ_CCTIMER");
+ if (!env) {
+ return;
+ }
+ if (strcmp(env, "none") == 0) {
+ mFile = nullptr;
+ } else if (strcmp(env, "stdout") == 0) {
+ mFile = stdout;
+ } else if (strcmp(env, "stderr") == 0) {
+ mFile = stderr;
+ } else {
+ mFile = fopen(env, "a");
+ if (!mFile) {
+ MOZ_CRASH("Failed to open MOZ_CCTIMER log file.");
+ }
+ }
+}
+
+void CycleCollectorStats::Clear() {
+ if (mFile && mFile != stdout && mFile != stderr) {
+ fclose(mFile);
+ }
+ *this = CycleCollectorStats();
+}
+
+void CycleCollectorStats::AfterCycleCollectionSlice() {
+ if (mBeginSliceTime.IsNull()) {
+ // We already called this method from EndCycleCollectionCallback for this
+ // slice.
+ return;
+ }
+
+ mEndSliceTime = TimeStamp::Now();
+ TimeDuration duration = mEndSliceTime - mBeginSliceTime;
+
+ PROFILER_MARKER(
+ "CCSlice", GCCC, MarkerTiming::Interval(mBeginSliceTime, mEndSliceTime),
+ CCSliceMarker, !mIdleDeadline.IsNull() && mIdleDeadline >= mEndSliceTime);
+
+ if (duration.ToSeconds()) {
+ TimeDuration idleDuration;
+ if (!mIdleDeadline.IsNull()) {
+ if (mIdleDeadline < mEndSliceTime) {
+ // This slice overflowed the idle period.
+ if (mIdleDeadline > mBeginSliceTime) {
+ idleDuration = mIdleDeadline - mBeginSliceTime;
+ }
+ } else {
+ idleDuration = duration;
+ }
+ }
+
+ uint32_t percent =
+ uint32_t(idleDuration.ToSeconds() / duration.ToSeconds() * 100);
+ Telemetry::Accumulate(Telemetry::CYCLE_COLLECTOR_SLICE_DURING_IDLE,
+ percent);
+ }
+
+ TimeDuration sliceTime = TimeBetween(mBeginSliceTime, mEndSliceTime);
+ mMaxSliceTime = std::max(mMaxSliceTime, sliceTime);
+ mMaxSliceTimeSinceClear = std::max(mMaxSliceTimeSinceClear, sliceTime);
+ mTotalSliceTime += sliceTime;
+ mBeginSliceTime = TimeStamp();
+}
+
+void CycleCollectorStats::PrepareForCycleCollection(TimeStamp aNow) {
+ mBeginTime = aNow;
+ mSuspected = nsCycleCollector_suspectedCount();
+}
+
+void CycleCollectorStats::AfterPrepareForCycleCollectionSlice(
+ TimeStamp aDeadline, TimeStamp aBeginTime, TimeStamp aMaybeAfterGCTime) {
+ mBeginSliceTime = aBeginTime;
+ mIdleDeadline = aDeadline;
+
+ if (!aMaybeAfterGCTime.IsNull()) {
+ mAnyLockedOut = true;
+ mMaxGCDuration = std::max(mMaxGCDuration, aMaybeAfterGCTime - aBeginTime);
+ }
+}
+
+void CycleCollectorStats::AfterSyncForgetSkippable(TimeStamp beginTime) {
+ mMaxSkippableDuration =
+ std::max(mMaxSkippableDuration, TimeUntilNow(beginTime));
+ mRanSyncForgetSkippable = true;
+}
+
+void CycleCollectorStats::AfterForgetSkippable(TimeDuration duration,
+ uint32_t aRemovedPurples) {
+ if (!mMinForgetSkippableTime || mMinForgetSkippableTime > duration) {
+ mMinForgetSkippableTime = duration;
+ }
+ if (!mMaxForgetSkippableTime || mMaxForgetSkippableTime < duration) {
+ mMaxForgetSkippableTime = duration;
+ }
+ mTotalForgetSkippableTime += duration;
+ ++mForgetSkippableBeforeCC;
+
+ mRemovedPurples += aRemovedPurples;
+}
+
+void CycleCollectorStats::SendTelemetry(TimeDuration aCCNowDuration,
+ TimeStamp aPrevCCEnd) const {
+ Telemetry::Accumulate(Telemetry::CYCLE_COLLECTOR_FINISH_IGC, mAnyLockedOut);
+ Telemetry::Accumulate(Telemetry::CYCLE_COLLECTOR_SYNC_SKIPPABLE,
+ mRanSyncForgetSkippable);
+ Telemetry::Accumulate(Telemetry::CYCLE_COLLECTOR_FULL,
+ aCCNowDuration.ToMilliseconds());
+ Telemetry::Accumulate(Telemetry::CYCLE_COLLECTOR_MAX_PAUSE,
+ mMaxSliceTime.ToMilliseconds());
+
+ if (!aPrevCCEnd.IsNull()) {
+ TimeDuration timeBetween = TimeBetween(aPrevCCEnd, mBeginTime);
+ Telemetry::Accumulate(Telemetry::CYCLE_COLLECTOR_TIME_BETWEEN,
+ timeBetween.ToSeconds());
+ }
+
+ Telemetry::Accumulate(Telemetry::FORGET_SKIPPABLE_MAX,
+ mMaxForgetSkippableTime.ToMilliseconds());
+}
+
+void CycleCollectorStats::MaybeLogStats(const CycleCollectorResults& aResults,
+ uint32_t aCleanups) const {
+ if (!StaticPrefs::javascript_options_mem_log() && !sCCStats.mFile) {
+ return;
+ }
+
+ TimeDuration delta = GetCollectionTimeDelta();
+
+ nsCString mergeMsg;
+ if (aResults.mMergedZones) {
+ mergeMsg.AssignLiteral(" merged");
+ }
+
+ nsCString gcMsg;
+ if (aResults.mForcedGC) {
+ gcMsg.AssignLiteral(", forced a GC");
+ }
+
+ const char16_t* kFmt =
+ u"CC(T+%.1f)[%s-%i] max pause: %.fms, total time: %.fms, slices: %lu, "
+ u"suspected: %lu, visited: %lu RCed and %lu%s GCed, collected: %lu "
+ u"RCed and %lu GCed (%lu|%lu|%lu waiting for GC)%s\n"
+ u"ForgetSkippable %lu times before CC, min: %.f ms, max: %.f ms, avg: "
+ u"%.f ms, total: %.f ms, max sync: %.f ms, removed: %lu";
+ nsString msg;
+ nsTextFormatter::ssprintf(
+ msg, kFmt, delta.ToMicroseconds() / PR_USEC_PER_SEC,
+ ProcessNameForCollectorLog(), getpid(), mMaxSliceTime.ToMilliseconds(),
+ mTotalSliceTime.ToMilliseconds(), aResults.mNumSlices, mSuspected,
+ aResults.mVisitedRefCounted, aResults.mVisitedGCed, mergeMsg.get(),
+ aResults.mFreedRefCounted, aResults.mFreedGCed,
+ sScheduler->mCCollectedWaitingForGC,
+ sScheduler->mCCollectedZonesWaitingForGC,
+ sScheduler->mLikelyShortLivingObjectsNeedingGC, gcMsg.get(),
+ mForgetSkippableBeforeCC, mMinForgetSkippableTime.ToMilliseconds(),
+ mMaxForgetSkippableTime.ToMilliseconds(),
+ mTotalForgetSkippableTime.ToMilliseconds() / aCleanups,
+ mTotalForgetSkippableTime.ToMilliseconds(),
+ mMaxSkippableDuration.ToMilliseconds(), mRemovedPurples);
+ if (StaticPrefs::javascript_options_mem_log()) {
+ nsCOMPtr<nsIConsoleService> cs =
+ do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+ if (cs) {
+ cs->LogStringMessage(msg.get());
+ }
+ }
+ if (mFile) {
+ fprintf(mFile, "%s\n", NS_ConvertUTF16toUTF8(msg).get());
+ }
+}
+
+void CycleCollectorStats::MaybeNotifyStats(
+ const CycleCollectorResults& aResults, TimeDuration aCCNowDuration,
+ uint32_t aCleanups) const {
+ if (!StaticPrefs::javascript_options_mem_notify()) {
+ return;
+ }
+
+ const char16_t* kJSONFmt =
+ u"{ \"timestamp\": %llu, "
+ u"\"duration\": %.f, "
+ u"\"max_slice_pause\": %.f, "
+ u"\"total_slice_pause\": %.f, "
+ u"\"max_finish_gc_duration\": %.f, "
+ u"\"max_sync_skippable_duration\": %.f, "
+ u"\"suspected\": %lu, "
+ u"\"visited\": { "
+ u"\"RCed\": %lu, "
+ u"\"GCed\": %lu }, "
+ u"\"collected\": { "
+ u"\"RCed\": %lu, "
+ u"\"GCed\": %lu }, "
+ u"\"waiting_for_gc\": %lu, "
+ u"\"zones_waiting_for_gc\": %lu, "
+ u"\"short_living_objects_waiting_for_gc\": %lu, "
+ u"\"forced_gc\": %d, "
+ u"\"forget_skippable\": { "
+ u"\"times_before_cc\": %lu, "
+ u"\"min\": %.f, "
+ u"\"max\": %.f, "
+ u"\"avg\": %.f, "
+ u"\"total\": %.f, "
+ u"\"removed\": %lu } "
+ u"}";
+
+ nsString json;
+ nsTextFormatter::ssprintf(
+ json, kJSONFmt, PR_Now(), aCCNowDuration.ToMilliseconds(),
+ mMaxSliceTime.ToMilliseconds(), mTotalSliceTime.ToMilliseconds(),
+ mMaxGCDuration.ToMilliseconds(), mMaxSkippableDuration.ToMilliseconds(),
+ mSuspected, aResults.mVisitedRefCounted, aResults.mVisitedGCed,
+ aResults.mFreedRefCounted, aResults.mFreedGCed,
+ sScheduler->mCCollectedWaitingForGC,
+ sScheduler->mCCollectedZonesWaitingForGC,
+ sScheduler->mLikelyShortLivingObjectsNeedingGC, aResults.mForcedGC,
+ mForgetSkippableBeforeCC, mMinForgetSkippableTime.ToMilliseconds(),
+ mMaxForgetSkippableTime.ToMilliseconds(),
+ mTotalForgetSkippableTime.ToMilliseconds() / aCleanups,
+ mTotalForgetSkippableTime.ToMilliseconds(), mRemovedPurples);
+ nsCOMPtr<nsIObserverService> observerService =
+ mozilla::services::GetObserverService();
+ if (observerService) {
+ observerService->NotifyObservers(nullptr, "cycle-collection-statistics",
+ json.get());
+ }
+}
+
+// static
+void nsJSContext::CycleCollectNow(CCReason aReason,
+ nsICycleCollectorListener* aListener) {
+ if (!NS_IsMainThread()) {
+ return;
+ }
+
+ AUTO_PROFILER_LABEL("nsJSContext::CycleCollectNow", GCCC);
+
+ PrepareForCycleCollectionSlice(aReason, TimeStamp());
+ nsCycleCollector_collect(aReason, aListener);
+ sCCStats.AfterCycleCollectionSlice();
+}
+
+// static
+void nsJSContext::PrepareForCycleCollectionSlice(CCReason aReason,
+ TimeStamp aDeadline) {
+ TimeStamp beginTime = TimeStamp::Now();
+
+ // Before we begin the cycle collection, make sure there is no active GC.
+ TimeStamp afterGCTime;
+ if (sScheduler->InIncrementalGC()) {
+ FinishAnyIncrementalGC();
+ afterGCTime = TimeStamp::Now();
+ }
+
+ if (!sScheduler->IsCollectingCycles()) {
+ sCCStats.PrepareForCycleCollection(beginTime);
+ sScheduler->NoteCCBegin(aReason, beginTime,
+ sCCStats.mForgetSkippableBeforeCC,
+ sCCStats.mSuspected, sCCStats.mRemovedPurples);
+ }
+
+ sCCStats.AfterPrepareForCycleCollectionSlice(aDeadline, beginTime,
+ afterGCTime);
+}
+
+// static
+void nsJSContext::RunCycleCollectorSlice(CCReason aReason,
+ TimeStamp aDeadline) {
+ if (!NS_IsMainThread()) {
+ return;
+ }
+
+ PrepareForCycleCollectionSlice(aReason, aDeadline);
+
+ // Decide how long we want to budget for this slice.
+ if (sIncrementalCC) {
+ bool preferShorterSlices;
+ js::SliceBudget budget = sScheduler->ComputeCCSliceBudget(
+ aDeadline, sCCStats.mBeginTime, sCCStats.mEndSliceTime,
+ TimeStamp::Now(), &preferShorterSlices);
+ nsCycleCollector_collectSlice(budget, aReason, preferShorterSlices);
+ } else {
+ js::SliceBudget budget = js::SliceBudget::unlimited();
+ nsCycleCollector_collectSlice(budget, aReason, false);
+ }
+
+ sCCStats.AfterCycleCollectionSlice();
+}
+
+// static
+void nsJSContext::RunCycleCollectorWorkSlice(int64_t aWorkBudget) {
+ if (!NS_IsMainThread()) {
+ return;
+ }
+
+ AUTO_PROFILER_LABEL("nsJSContext::RunCycleCollectorWorkSlice", GCCC);
+
+ PrepareForCycleCollectionSlice(CCReason::API, TimeStamp());
+
+ js::SliceBudget budget = js::SliceBudget(js::WorkBudget(aWorkBudget));
+ nsCycleCollector_collectSlice(budget, CCReason::API);
+
+ sCCStats.AfterCycleCollectionSlice();
+}
+
+void nsJSContext::ClearMaxCCSliceTime() {
+ sCCStats.mMaxSliceTimeSinceClear = TimeDuration();
+}
+
+uint32_t nsJSContext::GetMaxCCSliceTimeSinceClear() {
+ return sCCStats.mMaxSliceTimeSinceClear.ToMilliseconds();
+}
+
+// static
+void nsJSContext::BeginCycleCollectionCallback(CCReason aReason) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ TimeStamp startTime = TimeStamp::Now();
+ sCCStats.PrepareForCycleCollection(startTime);
+
+ // Run forgetSkippable synchronously to reduce the size of the CC graph. This
+ // is particularly useful if we recently finished a GC.
+ if (sScheduler->IsEarlyForgetSkippable()) {
+ while (sScheduler->IsEarlyForgetSkippable()) {
+ FireForgetSkippable(false, TimeStamp());
+ }
+ sCCStats.AfterSyncForgetSkippable(startTime);
+ }
+
+ if (sShuttingDown) {
+ return;
+ }
+
+ sScheduler->InitCCRunnerStateMachine(
+ mozilla::CCGCScheduler::CCRunnerState::CycleCollecting, aReason);
+ sScheduler->EnsureCCRunner(kICCIntersliceDelay, kIdleICCSliceBudget);
+}
+
+// static
+void nsJSContext::EndCycleCollectionCallback(
+ const CycleCollectorResults& aResults) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ sScheduler->KillCCRunner();
+
+ // Update timing information for the current slice before we log it, if
+ // we previously called PrepareForCycleCollectionSlice(). During shutdown
+ // CCs, this won't happen.
+ sCCStats.AfterCycleCollectionSlice();
+
+ TimeStamp endCCTimeStamp = TimeStamp::Now();
+ TimeDuration ccNowDuration = TimeBetween(sCCStats.mBeginTime, endCCTimeStamp);
+ TimeStamp prevCCEnd = sScheduler->GetLastCCEndTime();
+
+ sScheduler->NoteCCEnd(aResults, endCCTimeStamp, sCCStats.mMaxSliceTime);
+
+ // Log information about the CC via telemetry, JSON and the console.
+
+ sCCStats.SendTelemetry(ccNowDuration, prevCCEnd);
+
+ uint32_t cleanups = std::max(sCCStats.mForgetSkippableBeforeCC, 1u);
+
+ sCCStats.MaybeLogStats(aResults, cleanups);
+
+ sCCStats.MaybeNotifyStats(aResults, ccNowDuration, cleanups);
+
+ // Update global state to indicate we have just run a cycle collection.
+ sCCStats.Clear();
+
+ // If we need a GC after this CC (typically because lots of GCed objects or
+ // zones have been collected in the CC), schedule it.
+
+ if (sScheduler->NeedsGCAfterCC()) {
+ MOZ_ASSERT(
+ TimeDuration::FromMilliseconds(
+ StaticPrefs::javascript_options_gc_delay()) > kMaxICCDuration,
+ "A max duration ICC shouldn't reduce GC delay to 0");
+
+ TimeDuration delay;
+ if (aResults.mFreedGCed > 10000 && aResults.mFreedRefCounted > 10000) {
+ // If we collected lots of objects, trigger the next GC sooner so that
+ // GC can cut JS-to-native edges and native objects can be then deleted.
+ delay = TimeDuration::FromMilliseconds(
+ StaticPrefs::javascript_options_gc_delay_interslice());
+ } else {
+ delay = TimeDuration::FromMilliseconds(
+ StaticPrefs::javascript_options_gc_delay()) -
+ std::min(ccNowDuration, kMaxICCDuration);
+ }
+
+ sScheduler->PokeGC(JS::GCReason::CC_FINISHED, nullptr, delay);
+ }
+#if defined(MOZ_MEMORY)
+ else if (
+ StaticPrefs::
+ dom_memory_foreground_content_processes_have_larger_page_cache()) {
+ jemalloc_free_dirty_pages();
+ }
+#endif
+}
+
+/* static */
+bool CCGCScheduler::CCRunnerFired(TimeStamp aDeadline) {
+ AUTO_PROFILER_LABEL_RELEVANT_FOR_JS("Incremental CC", GCCC);
+
+ bool didDoWork = false;
+
+ // The CC/GC scheduler (sScheduler) decides what action(s) to take during
+ // this invocation of the CC runner.
+ //
+ // This may be zero, one, or multiple actions. (Zero is when CC is blocked by
+ // incremental GC, or when the scheduler determined that a CC is no longer
+ // needed.) Loop until the scheduler finishes this invocation by returning
+ // `Yield` in step.mYield.
+ CCRunnerStep step;
+ do {
+ step = sScheduler->AdvanceCCRunner(aDeadline, TimeStamp::Now(),
+ nsCycleCollector_suspectedCount());
+ switch (step.mAction) {
+ case CCRunnerAction::None:
+ break;
+
+ case CCRunnerAction::MinorGC:
+ JS::MaybeRunNurseryCollection(CycleCollectedJSRuntime::Get()->Runtime(),
+ step.mParam.mReason);
+ sScheduler->NoteMinorGCEnd();
+ break;
+
+ case CCRunnerAction::ForgetSkippable:
+ // 'Forget skippable' only, then end this invocation.
+ FireForgetSkippable(bool(step.mParam.mRemoveChildless), aDeadline);
+ break;
+
+ case CCRunnerAction::CleanupContentUnbinder:
+ // Clear content unbinder before the first actual CC slice.
+ Element::ClearContentUnbinder();
+ break;
+
+ case CCRunnerAction::CleanupDeferred:
+ // and if time still permits, perform deferred deletions.
+ nsCycleCollector_doDeferredDeletion();
+ break;
+
+ case CCRunnerAction::CycleCollect:
+ // Cycle collection slice.
+ nsJSContext::RunCycleCollectorSlice(step.mParam.mCCReason, aDeadline);
+ break;
+
+ case CCRunnerAction::StopRunning:
+ // End this CC, either because we have run a cycle collection slice, or
+ // because a CC is no longer needed.
+ sScheduler->KillCCRunner();
+ break;
+ }
+
+ if (step.mAction != CCRunnerAction::None) {
+ didDoWork = true;
+ }
+ } while (step.mYield == CCRunnerYield::Continue);
+
+ return didDoWork;
+}
+
+// static
+bool nsJSContext::HasHadCleanupSinceLastGC() {
+ return sScheduler->IsEarlyForgetSkippable(1);
+}
+
+// static
+void nsJSContext::RunNextCollectorTimer(JS::GCReason aReason,
+ mozilla::TimeStamp aDeadline) {
+ sScheduler->RunNextCollectorTimer(aReason, aDeadline);
+}
+
+// static
+void nsJSContext::MaybeRunNextCollectorSlice(nsIDocShell* aDocShell,
+ JS::GCReason aReason) {
+ if (!aDocShell || !XRE_IsContentProcess()) {
+ return;
+ }
+
+ BrowsingContext* bc = aDocShell->GetBrowsingContext();
+ if (!bc) {
+ return;
+ }
+
+ BrowsingContext* root = bc->Top();
+ if (bc == root) {
+ // We don't want to run collectors when loading the top level page.
+ return;
+ }
+
+ nsIDocShell* rootDocShell = root->GetDocShell();
+ if (!rootDocShell) {
+ return;
+ }
+
+ Document* rootDocument = rootDocShell->GetDocument();
+ if (!rootDocument ||
+ rootDocument->GetReadyStateEnum() != Document::READYSTATE_COMPLETE ||
+ rootDocument->IsInBackgroundWindow()) {
+ return;
+ }
+
+ PresShell* presShell = rootDocument->GetPresShell();
+ if (!presShell) {
+ return;
+ }
+
+ nsViewManager* vm = presShell->GetViewManager();
+ if (!vm) {
+ return;
+ }
+
+ if (!sScheduler->IsUserActive()) {
+ if (sScheduler->InIncrementalGC() || sScheduler->IsCollectingCycles()) {
+ Maybe<TimeStamp> next = nsRefreshDriver::GetNextTickHint();
+ if (next.isSome()) {
+ // Try to not delay the next RefreshDriver tick, so give a reasonable
+ // deadline for collectors.
+ sScheduler->RunNextCollectorTimer(aReason, next.value());
+ }
+ } else {
+ nsCOMPtr<nsIDocShell> shell = aDocShell;
+ NS_DispatchToCurrentThreadQueue(
+ NS_NewRunnableFunction(
+ "nsJSContext::MaybeRunNextCollectorSlice",
+ [shell] {
+ nsIDocShell::BusyFlags busyFlags = nsIDocShell::BUSY_FLAGS_NONE;
+ shell->GetBusyFlags(&busyFlags);
+ if (busyFlags == nsIDocShell::BUSY_FLAGS_NONE) {
+ return;
+ }
+
+ // In order to improve performance on the next page, run a minor
+ // GC. The 16ms limit ensures it isn't called all the time if
+ // there are for example multiple iframes loading at the same
+ // time.
+ JS::RunNurseryCollection(
+ CycleCollectedJSRuntime::Get()->Runtime(),
+ JS::GCReason::PREPARE_FOR_PAGELOAD,
+ mozilla::TimeDuration::FromMilliseconds(16));
+ }),
+ EventQueuePriority::Idle);
+ }
+ }
+}
+
+// static
+void nsJSContext::PokeGC(JS::GCReason aReason, JSObject* aObj,
+ TimeDuration aDelay) {
+ sScheduler->PokeGC(aReason, aObj, aDelay);
+}
+
+// static
+void nsJSContext::MaybePokeGC() {
+ if (sShuttingDown) {
+ return;
+ }
+
+ JSRuntime* rt = CycleCollectedJSRuntime::Get()->Runtime();
+ JS::GCReason reason = JS::WantEagerMinorGC(rt);
+ if (reason != JS::GCReason::NO_REASON) {
+ MOZ_ASSERT(reason == JS::GCReason::EAGER_NURSERY_COLLECTION);
+ sScheduler->PokeMinorGC(reason);
+ }
+
+ // Bug 1772638: For now, only do eager minor GCs. Eager major GCs regress some
+ // benchmarks. Hopefully that will be worked out and this will check for
+ // whether an eager major GC is needed.
+}
+
+void nsJSContext::DoLowMemoryGC() {
+ if (sShuttingDown) {
+ return;
+ }
+ nsJSContext::GarbageCollectNow(JS::GCReason::MEM_PRESSURE,
+ nsJSContext::ShrinkingGC);
+ nsJSContext::CycleCollectNow(CCReason::MEM_PRESSURE);
+ if (sScheduler->NeedsGCAfterCC()) {
+ nsJSContext::GarbageCollectNow(JS::GCReason::MEM_PRESSURE,
+ nsJSContext::ShrinkingGC);
+ }
+}
+
+// static
+void nsJSContext::LowMemoryGC() {
+ RefPtr<CCGCScheduler::MayGCPromise> mbPromise =
+ CCGCScheduler::MayGCNow(JS::GCReason::MEM_PRESSURE);
+ if (!mbPromise) {
+ // Normally when the promise is null it means that IPC failed, that probably
+ // means that something bad happened, don't bother with the GC.
+ return;
+ }
+ mbPromise->Then(
+ GetMainThreadSerialEventTarget(), __func__,
+ [](bool aIgnored) { DoLowMemoryGC(); },
+ [](mozilla::ipc::ResponseRejectReason r) {});
+}
+
+// static
+void nsJSContext::MaybePokeCC() {
+ sScheduler->MaybePokeCC(TimeStamp::NowLoRes(),
+ nsCycleCollector_suspectedCount());
+}
+
+static void DOMGCSliceCallback(JSContext* aCx, JS::GCProgress aProgress,
+ const JS::GCDescription& aDesc) {
+ NS_ASSERTION(NS_IsMainThread(), "GCs must run on the main thread");
+
+ static TimeStamp sCurrentGCStartTime;
+
+ switch (aProgress) {
+ case JS::GC_CYCLE_BEGIN: {
+ // Prevent cycle collections and shrinking during incremental GC.
+ sScheduler->NoteGCBegin(aDesc.reason_);
+ sCurrentGCStartTime = TimeStamp::Now();
+ break;
+ }
+
+ case JS::GC_CYCLE_END: {
+ TimeDuration delta = GetCollectionTimeDelta();
+
+ if (StaticPrefs::javascript_options_mem_log()) {
+ nsString gcstats;
+ gcstats.Adopt(aDesc.formatSummaryMessage(aCx));
+ nsAutoString prefix;
+ nsTextFormatter::ssprintf(prefix, u"GC(T+%.1f)[%s-%i] ",
+ delta.ToSeconds(),
+ ProcessNameForCollectorLog(), getpid());
+ nsString msg = prefix + gcstats;
+ nsCOMPtr<nsIConsoleService> cs =
+ do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+ if (cs) {
+ cs->LogStringMessage(msg.get());
+ }
+ }
+
+ sScheduler->NoteGCEnd();
+
+ // May need to kill the GC runner
+ sScheduler->KillGCRunner();
+
+ nsJSContext::MaybePokeCC();
+
+#if defined(MOZ_MEMORY)
+ bool freeDirty = false;
+#endif
+ if (aDesc.isZone_) {
+ sScheduler->PokeFullGC();
+ } else {
+#if defined(MOZ_MEMORY)
+ freeDirty = true;
+#endif
+ sScheduler->SetNeedsFullGC(false);
+ sScheduler->KillFullGCTimer();
+ }
+
+ if (sScheduler->IsCCNeeded(TimeStamp::Now(),
+ nsCycleCollector_suspectedCount()) !=
+ CCReason::NO_REASON) {
+#if defined(MOZ_MEMORY)
+ // We're likely to free the dirty pages after CC.
+ freeDirty = false;
+#endif
+ nsCycleCollector_dispatchDeferredDeletion();
+ }
+
+ Telemetry::Accumulate(Telemetry::GC_IN_PROGRESS_MS,
+ TimeUntilNow(sCurrentGCStartTime).ToMilliseconds());
+
+#if defined(MOZ_MEMORY)
+ if (freeDirty &&
+ StaticPrefs::
+ dom_memory_foreground_content_processes_have_larger_page_cache()) {
+ jemalloc_free_dirty_pages();
+ }
+#endif
+ break;
+ }
+
+ case JS::GC_SLICE_BEGIN:
+ break;
+
+ case JS::GC_SLICE_END:
+ sScheduler->NoteGCSliceEnd(aDesc.lastSliceStart(aCx),
+ aDesc.lastSliceEnd(aCx));
+
+ if (sShuttingDown) {
+ sScheduler->KillGCRunner();
+ } else {
+ // If incremental GC wasn't triggered by GCTimerFired, we may not have a
+ // runner to ensure all the slices are handled. So, create the runner
+ // here.
+ sScheduler->EnsureOrResetGCRunner();
+ }
+
+ if (sScheduler->IsCCNeeded(TimeStamp::Now(),
+ nsCycleCollector_suspectedCount()) !=
+ CCReason::NO_REASON) {
+ nsCycleCollector_dispatchDeferredDeletion();
+ }
+
+ if (StaticPrefs::javascript_options_mem_log()) {
+ nsString gcstats;
+ gcstats.Adopt(aDesc.formatSliceMessage(aCx));
+ nsAutoString prefix;
+ nsTextFormatter::ssprintf(prefix, u"[%s-%i] ",
+ ProcessNameForCollectorLog(), getpid());
+ nsString msg = prefix + gcstats;
+ nsCOMPtr<nsIConsoleService> cs =
+ do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+ if (cs) {
+ cs->LogStringMessage(msg.get());
+ }
+ }
+
+ break;
+
+ default:
+ MOZ_CRASH("Unexpected GCProgress value");
+ }
+
+ if (sPrevGCSliceCallback) {
+ (*sPrevGCSliceCallback)(aCx, aProgress, aDesc);
+ }
+}
+
+void nsJSContext::SetWindowProxy(JS::Handle<JSObject*> aWindowProxy) {
+ mWindowProxy = aWindowProxy;
+}
+
+JSObject* nsJSContext::GetWindowProxy() { return mWindowProxy; }
+
+void nsJSContext::LikelyShortLivingObjectCreated() {
+ ++sScheduler->mLikelyShortLivingObjectsNeedingGC;
+}
+
+void mozilla::dom::StartupJSEnvironment() {
+ // initialize all our statics, so that we can restart XPCOM
+ sIsInitialized = false;
+ sShuttingDown = false;
+ sCCStats.Init();
+}
+
+static void SetGCParameter(JSGCParamKey aParam, uint32_t aValue) {
+ AutoJSAPI jsapi;
+ jsapi.Init();
+ JS_SetGCParameter(jsapi.cx(), aParam, aValue);
+}
+
+static void ResetGCParameter(JSGCParamKey aParam) {
+ AutoJSAPI jsapi;
+ jsapi.Init();
+ JS_ResetGCParameter(jsapi.cx(), aParam);
+}
+
+static void SetMemoryPrefChangedCallbackMB(const char* aPrefName,
+ void* aClosure) {
+ int32_t prefMB = Preferences::GetInt(aPrefName, -1);
+ // handle overflow and negative pref values
+ CheckedInt<int32_t> prefB = CheckedInt<int32_t>(prefMB) * 1024 * 1024;
+ if (prefB.isValid() && prefB.value() >= 0) {
+ SetGCParameter((JSGCParamKey)(uintptr_t)aClosure, prefB.value());
+ } else {
+ ResetGCParameter((JSGCParamKey)(uintptr_t)aClosure);
+ }
+}
+
+static void SetMemoryNurseryPrefChangedCallback(const char* aPrefName,
+ void* aClosure) {
+ int32_t prefKB = Preferences::GetInt(aPrefName, -1);
+ // handle overflow and negative pref values
+ CheckedInt<int32_t> prefB = CheckedInt<int32_t>(prefKB) * 1024;
+ if (prefB.isValid() && prefB.value() >= 0) {
+ SetGCParameter((JSGCParamKey)(uintptr_t)aClosure, prefB.value());
+ } else {
+ ResetGCParameter((JSGCParamKey)(uintptr_t)aClosure);
+ }
+}
+
+static void SetMemoryPrefChangedCallbackInt(const char* aPrefName,
+ void* aClosure) {
+ int32_t pref = Preferences::GetInt(aPrefName, -1);
+ // handle overflow and negative pref values
+ if (pref >= 0 && pref < 10000) {
+ SetGCParameter((JSGCParamKey)(uintptr_t)aClosure, pref);
+ } else {
+ ResetGCParameter((JSGCParamKey)(uintptr_t)aClosure);
+ }
+}
+
+static void SetMemoryPrefChangedCallbackBool(const char* aPrefName,
+ void* aClosure) {
+ bool pref = Preferences::GetBool(aPrefName);
+ SetGCParameter((JSGCParamKey)(uintptr_t)aClosure, pref);
+}
+
+static void SetMemoryGCSliceTimePrefChangedCallback(const char* aPrefName,
+ void* aClosure) {
+ int32_t pref = Preferences::GetInt(aPrefName, -1);
+ // handle overflow and negative pref values
+ if (pref > 0 && pref < 100000) {
+ sScheduler->SetActiveIntersliceGCBudget(
+ TimeDuration::FromMilliseconds(pref));
+ SetGCParameter(JSGC_SLICE_TIME_BUDGET_MS, pref);
+ } else {
+ ResetGCParameter(JSGC_SLICE_TIME_BUDGET_MS);
+ }
+}
+
+static void SetIncrementalCCPrefChangedCallback(const char* aPrefName,
+ void* aClosure) {
+ bool pref = Preferences::GetBool(aPrefName);
+ sIncrementalCC = pref;
+}
+
+class JSDispatchableRunnable final : public Runnable {
+ ~JSDispatchableRunnable() { MOZ_ASSERT(!mDispatchable); }
+
+ public:
+ explicit JSDispatchableRunnable(JS::Dispatchable* aDispatchable)
+ : mozilla::Runnable("JSDispatchableRunnable"),
+ mDispatchable(aDispatchable) {
+ MOZ_ASSERT(mDispatchable);
+ }
+
+ protected:
+ NS_IMETHOD Run() override {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ AutoJSAPI jsapi;
+ jsapi.Init();
+
+ JS::Dispatchable::MaybeShuttingDown maybeShuttingDown =
+ sShuttingDown ? JS::Dispatchable::ShuttingDown
+ : JS::Dispatchable::NotShuttingDown;
+
+ mDispatchable->run(jsapi.cx(), maybeShuttingDown);
+ mDispatchable = nullptr; // mDispatchable may delete itself
+
+ return NS_OK;
+ }
+
+ private:
+ JS::Dispatchable* mDispatchable;
+};
+
+static bool DispatchToEventLoop(void* closure,
+ JS::Dispatchable* aDispatchable) {
+ MOZ_ASSERT(!closure);
+
+ // This callback may execute either on the main thread or a random JS-internal
+ // helper thread. This callback can be called during shutdown so we cannot
+ // simply NS_DispatchToMainThread. Failure during shutdown is expected and
+ // properly handled by the JS engine.
+
+ nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadSerialEventTarget();
+ if (!mainTarget) {
+ return false;
+ }
+
+ RefPtr<JSDispatchableRunnable> r = new JSDispatchableRunnable(aDispatchable);
+ MOZ_ALWAYS_SUCCEEDS(mainTarget->Dispatch(r.forget(), NS_DISPATCH_NORMAL));
+ return true;
+}
+
+static bool ConsumeStream(JSContext* aCx, JS::Handle<JSObject*> aObj,
+ JS::MimeType aMimeType,
+ JS::StreamConsumer* aConsumer) {
+ return FetchUtil::StreamResponseToJS(aCx, aObj, aMimeType, aConsumer,
+ nullptr);
+}
+
+static js::SliceBudget CreateGCSliceBudget(JS::GCReason aReason,
+ int64_t aMillis) {
+ return sScheduler->CreateGCSliceBudget(
+ mozilla::TimeDuration::FromMilliseconds(aMillis), false, false);
+}
+
+void nsJSContext::EnsureStatics() {
+ if (sIsInitialized) {
+ if (!nsContentUtils::XPConnect()) {
+ MOZ_CRASH();
+ }
+ return;
+ }
+
+ // Let's make sure that our main thread is the same as the xpcom main thread.
+ MOZ_ASSERT(NS_IsMainThread());
+
+ sScheduler =
+ new (&sSchedulerStorage) CCGCScheduler(); // Reset the scheduler state.
+
+ AutoJSAPI jsapi;
+ jsapi.Init();
+
+ sPrevGCSliceCallback = JS::SetGCSliceCallback(jsapi.cx(), DOMGCSliceCallback);
+
+ JS::SetCreateGCSliceBudgetCallback(jsapi.cx(), CreateGCSliceBudget);
+
+ JS::InitDispatchToEventLoop(jsapi.cx(), DispatchToEventLoop, nullptr);
+ JS::InitConsumeStreamCallback(jsapi.cx(), ConsumeStream,
+ FetchUtil::ReportJSStreamError);
+
+ // Set these global xpconnect options...
+ Preferences::RegisterCallbackAndCall(SetMemoryPrefChangedCallbackMB,
+ "javascript.options.mem.max",
+ (void*)JSGC_MAX_BYTES);
+ Preferences::RegisterCallbackAndCall(SetMemoryNurseryPrefChangedCallback,
+ "javascript.options.mem.nursery.min_kb",
+ (void*)JSGC_MIN_NURSERY_BYTES);
+ Preferences::RegisterCallbackAndCall(SetMemoryNurseryPrefChangedCallback,
+ "javascript.options.mem.nursery.max_kb",
+ (void*)JSGC_MAX_NURSERY_BYTES);
+
+ Preferences::RegisterCallbackAndCall(SetMemoryPrefChangedCallbackBool,
+ "javascript.options.mem.gc_per_zone",
+ (void*)JSGC_PER_ZONE_GC_ENABLED);
+
+ Preferences::RegisterCallbackAndCall(SetMemoryPrefChangedCallbackBool,
+ "javascript.options.mem.gc_incremental",
+ (void*)JSGC_INCREMENTAL_GC_ENABLED);
+
+ Preferences::RegisterCallbackAndCall(SetMemoryPrefChangedCallbackBool,
+ "javascript.options.mem.gc_compacting",
+ (void*)JSGC_COMPACTING_ENABLED);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackBool,
+ "javascript.options.mem.gc_parallel_marking",
+ (void*)JSGC_PARALLEL_MARKING_ENABLED);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_parallel_marking_threshold_mb",
+ (void*)JSGC_PARALLEL_MARKING_THRESHOLD_MB);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryGCSliceTimePrefChangedCallback,
+ "javascript.options.mem.gc_incremental_slice_ms");
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackBool,
+ "javascript.options.mem.incremental_weakmap",
+ (void*)JSGC_INCREMENTAL_WEAKMAP_ENABLED);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_high_frequency_time_limit_ms",
+ (void*)JSGC_HIGH_FREQUENCY_TIME_LIMIT);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_low_frequency_heap_growth",
+ (void*)JSGC_LOW_FREQUENCY_HEAP_GROWTH);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_high_frequency_large_heap_growth",
+ (void*)JSGC_HIGH_FREQUENCY_LARGE_HEAP_GROWTH);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_high_frequency_small_heap_growth",
+ (void*)JSGC_HIGH_FREQUENCY_SMALL_HEAP_GROWTH);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackBool,
+ "javascript.options.mem.gc_balanced_heap_limits",
+ (void*)JSGC_BALANCED_HEAP_LIMITS_ENABLED);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_heap_growth_factor",
+ (void*)JSGC_HEAP_GROWTH_FACTOR);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_small_heap_size_max_mb",
+ (void*)JSGC_SMALL_HEAP_SIZE_MAX);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_large_heap_size_min_mb",
+ (void*)JSGC_LARGE_HEAP_SIZE_MIN);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_allocation_threshold_mb",
+ (void*)JSGC_ALLOCATION_THRESHOLD);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_malloc_threshold_base_mb",
+ (void*)JSGC_MALLOC_THRESHOLD_BASE);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_small_heap_incremental_limit",
+ (void*)JSGC_SMALL_HEAP_INCREMENTAL_LIMIT);
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_large_heap_incremental_limit",
+ (void*)JSGC_LARGE_HEAP_INCREMENTAL_LIMIT);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_urgent_threshold_mb",
+ (void*)JSGC_URGENT_THRESHOLD_MB);
+
+ Preferences::RegisterCallbackAndCall(SetIncrementalCCPrefChangedCallback,
+ "dom.cycle_collector.incremental");
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_min_empty_chunk_count",
+ (void*)JSGC_MIN_EMPTY_CHUNK_COUNT);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_max_empty_chunk_count",
+ (void*)JSGC_MAX_EMPTY_CHUNK_COUNT);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_helper_thread_ratio",
+ (void*)JSGC_HELPER_THREAD_RATIO);
+
+ Preferences::RegisterCallbackAndCall(
+ SetMemoryPrefChangedCallbackInt,
+ "javascript.options.mem.gc_max_helper_threads",
+ (void*)JSGC_MAX_HELPER_THREADS);
+
+ nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+ if (!obs) {
+ MOZ_CRASH();
+ }
+
+ nsIObserver* observer = new nsJSEnvironmentObserver();
+ obs->AddObserver(observer, "memory-pressure", false);
+ obs->AddObserver(observer, "user-interaction-inactive", false);
+ obs->AddObserver(observer, "user-interaction-active", false);
+ obs->AddObserver(observer, "quit-application", false);
+ obs->AddObserver(observer, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
+ obs->AddObserver(observer, "content-child-will-shutdown", false);
+
+ sIsInitialized = true;
+}
+
+void mozilla::dom::ShutdownJSEnvironment() {
+ sShuttingDown = true;
+ sScheduler->Shutdown();
+}
+
+AsyncErrorReporter::AsyncErrorReporter(xpc::ErrorReport* aReport)
+ : Runnable("dom::AsyncErrorReporter"), mReport(aReport) {}
+
+void AsyncErrorReporter::SerializeStack(JSContext* aCx,
+ JS::Handle<JSObject*> aStack) {
+ mStackHolder = MakeUnique<SerializedStackHolder>();
+ mStackHolder->SerializeMainThreadOrWorkletStack(aCx, aStack);
+}
+
+void AsyncErrorReporter::SetException(JSContext* aCx,
+ JS::Handle<JS::Value> aException) {
+ MOZ_ASSERT(NS_IsMainThread());
+ mException.init(aCx, aException);
+ mHasException = true;
+}
+
+NS_IMETHODIMP AsyncErrorReporter::Run() {
+ AutoJSAPI jsapi;
+ // We're only using this context to deserialize a stack to report to the
+ // console, so the scope we use doesn't matter. Stack frame filtering happens
+ // based on the principal encoded into the frame and the caller compartment,
+ // not the compartment of the frame object, and the console reporting code
+ // will not be using our context, and therefore will not care what compartment
+ // it has entered.
+ DebugOnly<bool> ok = jsapi.Init(xpc::PrivilegedJunkScope());
+ MOZ_ASSERT(ok, "Problem with system global?");
+ JSContext* cx = jsapi.cx();
+ JS::Rooted<JSObject*> stack(cx);
+ JS::Rooted<JSObject*> stackGlobal(cx);
+ if (mStackHolder) {
+ stack = mStackHolder->ReadStack(cx);
+ if (stack) {
+ stackGlobal = JS::CurrentGlobalOrNull(cx);
+ }
+ }
+
+ JS::Rooted<Maybe<JS::Value>> exception(cx, Nothing());
+ if (mHasException) {
+ MOZ_ASSERT(NS_IsMainThread());
+ exception = Some(mException);
+ // Remove our reference to the exception.
+ mException.setUndefined();
+ mHasException = false;
+ }
+
+ mReport->LogToConsoleWithStack(nullptr, exception, stack, stackGlobal);
+ return NS_OK;
+}
+
+// A fast-array class for JS. This class supports both nsIJSScriptArray and
+// nsIArray. If it is JS itself providing and consuming this class, all work
+// can be done via nsIJSScriptArray, and avoid the conversion of elements
+// to/from nsISupports.
+// When consumed by non-JS (eg, another script language), conversion is done
+// on-the-fly.
+class nsJSArgArray final : public nsIJSArgArray {
+ public:
+ nsJSArgArray(JSContext* aContext, uint32_t argc, const JS::Value* argv,
+ nsresult* prv);
+
+ // nsISupports
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsJSArgArray,
+ nsIJSArgArray)
+
+ // nsIArray
+ NS_DECL_NSIARRAY
+
+ // nsIJSArgArray
+ nsresult GetArgs(uint32_t* argc, void** argv) override;
+
+ void ReleaseJSObjects();
+
+ protected:
+ ~nsJSArgArray();
+ JSContext* mContext;
+ JS::Heap<JS::Value>* mArgv;
+ uint32_t mArgc;
+};
+
+nsJSArgArray::nsJSArgArray(JSContext* aContext, uint32_t argc,
+ const JS::Value* argv, nsresult* prv)
+ : mContext(aContext), mArgv(nullptr), mArgc(argc) {
+ // copy the array - we don't know its lifetime, and ours is tied to xpcom
+ // refcounting.
+ if (argc) {
+ mArgv = new (fallible) JS::Heap<JS::Value>[argc];
+ if (!mArgv) {
+ *prv = NS_ERROR_OUT_OF_MEMORY;
+ return;
+ }
+ }
+
+ // Callers are allowed to pass in a null argv even for argc > 0. They can
+ // then use GetArgs to initialize the values.
+ if (argv) {
+ for (uint32_t i = 0; i < argc; ++i) mArgv[i] = argv[i];
+ }
+
+ if (argc > 0) {
+ mozilla::HoldJSObjects(this);
+ }
+
+ *prv = NS_OK;
+}
+
+nsJSArgArray::~nsJSArgArray() { ReleaseJSObjects(); }
+
+void nsJSArgArray::ReleaseJSObjects() {
+ delete[] mArgv;
+
+ if (mArgc > 0) {
+ mArgc = 0;
+ mozilla::DropJSObjects(this);
+ }
+}
+
+// QueryInterface implementation for nsJSArgArray
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsJSArgArray)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsJSArgArray)
+ tmp->ReleaseJSObjects();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsJSArgArray)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(nsJSArgArray)
+ if (tmp->mArgv) {
+ for (uint32_t i = 0; i < tmp->mArgc; ++i) {
+ NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mArgv[i])
+ }
+ }
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsJSArgArray)
+ NS_INTERFACE_MAP_ENTRY(nsIArray)
+ NS_INTERFACE_MAP_ENTRY(nsIJSArgArray)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIJSArgArray)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsJSArgArray)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsJSArgArray)
+
+nsresult nsJSArgArray::GetArgs(uint32_t* argc, void** argv) {
+ *argv = (void*)mArgv;
+ *argc = mArgc;
+ return NS_OK;
+}
+
+// nsIArray impl
+NS_IMETHODIMP nsJSArgArray::GetLength(uint32_t* aLength) {
+ *aLength = mArgc;
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsJSArgArray::QueryElementAt(uint32_t index, const nsIID& uuid,
+ void** result) {
+ *result = nullptr;
+ if (index >= mArgc) return NS_ERROR_INVALID_ARG;
+
+ if (uuid.Equals(NS_GET_IID(nsIVariant)) ||
+ uuid.Equals(NS_GET_IID(nsISupports))) {
+ // Have to copy a Heap into a Rooted to work with it.
+ JS::Rooted<JS::Value> val(mContext, mArgv[index]);
+ return nsContentUtils::XPConnect()->JSToVariant(mContext, val,
+ (nsIVariant**)result);
+ }
+ NS_WARNING("nsJSArgArray only handles nsIVariant");
+ return NS_ERROR_NO_INTERFACE;
+}
+
+NS_IMETHODIMP nsJSArgArray::IndexOf(uint32_t startIndex, nsISupports* element,
+ uint32_t* _retval) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsJSArgArray::ScriptedEnumerate(const nsIID& aElemIID,
+ uint8_t aArgc,
+ nsISimpleEnumerator** aResult) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP nsJSArgArray::EnumerateImpl(const nsID& aEntryIID,
+ nsISimpleEnumerator** _retval) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+// The factory function
+nsresult NS_CreateJSArgv(JSContext* aContext, uint32_t argc,
+ const JS::Value* argv, nsIJSArgArray** aArray) {
+ nsresult rv;
+ nsCOMPtr<nsIJSArgArray> ret = new nsJSArgArray(aContext, argc, argv, &rv);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ ret.forget(aArray);
+ return NS_OK;
+}