summaryrefslogtreecommitdiffstats
path: root/dom/base/nsWindowMemoryReporter.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/base/nsWindowMemoryReporter.cpp')
-rw-r--r--dom/base/nsWindowMemoryReporter.cpp861
1 files changed, 861 insertions, 0 deletions
diff --git a/dom/base/nsWindowMemoryReporter.cpp b/dom/base/nsWindowMemoryReporter.cpp
new file mode 100644
index 000000000..acec4acfb
--- /dev/null
+++ b/dom/base/nsWindowMemoryReporter.cpp
@@ -0,0 +1,861 @@
+/* -*- 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 "amIAddonManager.h"
+#include "nsWindowMemoryReporter.h"
+#include "nsGlobalWindow.h"
+#include "nsIDocument.h"
+#include "nsIDOMWindowCollection.h"
+#include "nsIEffectiveTLDService.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Services.h"
+#include "mozilla/StaticPtr.h"
+#include "nsNetCID.h"
+#include "nsPrintfCString.h"
+#include "XPCJSMemoryReporter.h"
+#include "js/MemoryMetrics.h"
+#include "nsQueryObject.h"
+#include "nsServiceManagerUtils.h"
+
+using namespace mozilla;
+
+StaticRefPtr<nsWindowMemoryReporter> sWindowReporter;
+
+/**
+ * Don't trigger a ghost window check when a DOM window is detached if we've
+ * run it this recently.
+ */
+const int32_t kTimeBetweenChecks = 45; /* seconds */
+
+nsWindowMemoryReporter::nsWindowMemoryReporter()
+ : mLastCheckForGhostWindows(TimeStamp::NowLoRes()),
+ mCycleCollectorIsRunning(false),
+ mCheckTimerWaitingForCCEnd(false)
+{
+}
+
+nsWindowMemoryReporter::~nsWindowMemoryReporter()
+{
+ KillCheckTimer();
+}
+
+NS_IMPL_ISUPPORTS(nsWindowMemoryReporter, nsIMemoryReporter, nsIObserver,
+ nsISupportsWeakReference)
+
+static nsresult
+AddNonJSSizeOfWindowAndItsDescendents(nsGlobalWindow* aWindow,
+ nsTabSizes* aSizes)
+{
+ // Measure the window.
+ nsWindowSizes windowSizes(moz_malloc_size_of);
+ aWindow->AddSizeOfIncludingThis(&windowSizes);
+ windowSizes.addToTabSizes(aSizes);
+
+ // Measure the inner window, if there is one.
+ nsWindowSizes innerWindowSizes(moz_malloc_size_of);
+ nsGlobalWindow* inner = aWindow->IsOuterWindow() ? aWindow->GetCurrentInnerWindowInternal()
+ : nullptr;
+ if (inner) {
+ inner->AddSizeOfIncludingThis(&innerWindowSizes);
+ innerWindowSizes.addToTabSizes(aSizes);
+ }
+
+ nsCOMPtr<nsIDOMWindowCollection> frames = aWindow->GetFrames();
+
+ uint32_t length;
+ nsresult rv = frames->GetLength(&length);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Measure this window's descendents.
+ for (uint32_t i = 0; i < length; i++) {
+ nsCOMPtr<mozIDOMWindowProxy> child;
+ rv = frames->Item(i, getter_AddRefs(child));
+ NS_ENSURE_SUCCESS(rv, rv);
+ NS_ENSURE_STATE(child);
+
+ nsGlobalWindow* childWin = nsGlobalWindow::Cast(child);
+
+ rv = AddNonJSSizeOfWindowAndItsDescendents(childWin, aSizes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ return NS_OK;
+}
+
+static nsresult
+NonJSSizeOfTab(nsPIDOMWindowOuter* aWindow, size_t* aDomSize, size_t* aStyleSize, size_t* aOtherSize)
+{
+ nsGlobalWindow* window = nsGlobalWindow::Cast(aWindow);
+
+ nsTabSizes sizes;
+ nsresult rv = AddNonJSSizeOfWindowAndItsDescendents(window, &sizes);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ *aDomSize = sizes.mDom;
+ *aStyleSize = sizes.mStyle;
+ *aOtherSize = sizes.mOther;
+ return NS_OK;
+}
+
+/* static */ void
+nsWindowMemoryReporter::Init()
+{
+ MOZ_ASSERT(!sWindowReporter);
+ sWindowReporter = new nsWindowMemoryReporter();
+ ClearOnShutdown(&sWindowReporter);
+ RegisterStrongMemoryReporter(sWindowReporter);
+ RegisterNonJSSizeOfTab(NonJSSizeOfTab);
+
+ nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+ if (os) {
+ os->AddObserver(sWindowReporter, "after-minimize-memory-usage",
+ /* weakRef = */ true);
+ os->AddObserver(sWindowReporter, "cycle-collector-begin",
+ /* weakRef = */ true);
+ os->AddObserver(sWindowReporter, "cycle-collector-end",
+ /* weakRef = */ true);
+ }
+
+ RegisterStrongMemoryReporter(new GhostWindowsReporter());
+ RegisterGhostWindowsDistinguishedAmount(GhostWindowsReporter::DistinguishedAmount);
+}
+
+/* static */ nsWindowMemoryReporter*
+nsWindowMemoryReporter::Get()
+{
+ return sWindowReporter;
+}
+
+static already_AddRefed<nsIURI>
+GetWindowURI(nsGlobalWindow* aWindow)
+{
+ NS_ENSURE_TRUE(aWindow, nullptr);
+
+ nsCOMPtr<nsIDocument> doc = aWindow->GetExtantDoc();
+ nsCOMPtr<nsIURI> uri;
+
+ if (doc) {
+ uri = doc->GetDocumentURI();
+ }
+
+ if (!uri) {
+ nsCOMPtr<nsIScriptObjectPrincipal> scriptObjPrincipal =
+ do_QueryObject(aWindow);
+ NS_ENSURE_TRUE(scriptObjPrincipal, nullptr);
+
+ // GetPrincipal() will print a warning if the window does not have an outer
+ // window, so check here for an outer window first. This code is
+ // functionally correct if we leave out the GetOuterWindow() check, but we
+ // end up printing a lot of warnings during debug mochitests.
+ if (aWindow->GetOuterWindow()) {
+ nsIPrincipal* principal = scriptObjPrincipal->GetPrincipal();
+ if (principal) {
+ principal->GetURI(getter_AddRefs(uri));
+ }
+ }
+ }
+
+ return uri.forget();
+}
+
+static void
+AppendWindowURI(nsGlobalWindow *aWindow, nsACString& aStr, bool aAnonymize)
+{
+ nsCOMPtr<nsIURI> uri = GetWindowURI(aWindow);
+
+ if (uri) {
+ if (aAnonymize && !aWindow->IsChromeWindow()) {
+ aStr.AppendPrintf("<anonymized-%llu>", aWindow->WindowID());
+ } else {
+ nsCString spec = uri->GetSpecOrDefault();
+
+ // A hack: replace forward slashes with '\\' so they aren't
+ // treated as path separators. Users of the reporters
+ // (such as about:memory) have to undo this change.
+ spec.ReplaceChar('/', '\\');
+
+ aStr += spec;
+ }
+ } else {
+ // If we're unable to find a URI, we're dealing with a chrome window with
+ // no document in it (or somesuch), so we call this a "system window".
+ aStr += NS_LITERAL_CSTRING("[system]");
+ }
+}
+
+MOZ_DEFINE_MALLOC_SIZE_OF(WindowsMallocSizeOf)
+
+// The key is the window ID.
+typedef nsDataHashtable<nsUint64HashKey, nsCString> WindowPaths;
+
+static void
+ReportAmount(const nsCString& aBasePath, const char* aPathTail,
+ size_t aAmount, const nsCString& aDescription,
+ uint32_t aKind, uint32_t aUnits,
+ nsIHandleReportCallback* aHandleReport,
+ nsISupports* aData)
+{
+ if (aAmount == 0) {
+ return;
+ }
+
+ nsAutoCString path(aBasePath);
+ path += aPathTail;
+
+ aHandleReport->Callback(
+ EmptyCString(), path, aKind, aUnits, aAmount, aDescription, aData);
+}
+
+static void
+ReportSize(const nsCString& aBasePath, const char* aPathTail,
+ size_t aAmount, const nsCString& aDescription,
+ nsIHandleReportCallback* aHandleReport,
+ nsISupports* aData)
+{
+ ReportAmount(aBasePath, aPathTail, aAmount, aDescription,
+ nsIMemoryReporter::KIND_HEAP, nsIMemoryReporter::UNITS_BYTES,
+ aHandleReport, aData);
+}
+
+static void
+ReportCount(const nsCString& aBasePath, const char* aPathTail,
+ size_t aAmount, const nsCString& aDescription,
+ nsIHandleReportCallback* aHandleReport,
+ nsISupports* aData)
+{
+ ReportAmount(aBasePath, aPathTail, aAmount, aDescription,
+ nsIMemoryReporter::KIND_OTHER, nsIMemoryReporter::UNITS_COUNT,
+ aHandleReport, aData);
+}
+
+static void
+CollectWindowReports(nsGlobalWindow *aWindow,
+ amIAddonManager *addonManager,
+ nsWindowSizes *aWindowTotalSizes,
+ nsTHashtable<nsUint64HashKey> *aGhostWindowIDs,
+ WindowPaths *aWindowPaths,
+ WindowPaths *aTopWindowPaths,
+ nsIHandleReportCallback *aHandleReport,
+ nsISupports *aData,
+ bool aAnonymize)
+{
+ nsAutoCString windowPath("explicit/");
+
+ // Avoid calling aWindow->GetTop() if there's no outer window. It will work
+ // just fine, but will spew a lot of warnings.
+ nsGlobalWindow *top = nullptr;
+ nsCOMPtr<nsIURI> location;
+ if (aWindow->GetOuterWindow()) {
+ // Our window should have a null top iff it has a null docshell.
+ MOZ_ASSERT(!!aWindow->GetTopInternal() == !!aWindow->GetDocShell());
+ top = aWindow->GetTopInternal();
+ if (top) {
+ location = GetWindowURI(top);
+ }
+ }
+ if (!location) {
+ location = GetWindowURI(aWindow);
+ }
+
+ if (addonManager && location) {
+ bool ok;
+ nsAutoCString id;
+ if (NS_SUCCEEDED(addonManager->MapURIToAddonID(location, id, &ok)) && ok) {
+ // Add-on names are not privacy-sensitive, so we can use them with
+ // impunity.
+ windowPath += NS_LITERAL_CSTRING("add-ons/") + id +
+ NS_LITERAL_CSTRING("/");
+ }
+ }
+
+ windowPath += NS_LITERAL_CSTRING("window-objects/");
+
+ if (top) {
+ windowPath += NS_LITERAL_CSTRING("top(");
+ AppendWindowURI(top, windowPath, aAnonymize);
+ windowPath.AppendPrintf(", id=%llu)", top->WindowID());
+
+ aTopWindowPaths->Put(aWindow->WindowID(), windowPath);
+
+ windowPath += aWindow->IsFrozen() ? NS_LITERAL_CSTRING("/cached/")
+ : NS_LITERAL_CSTRING("/active/");
+ } else {
+ if (aGhostWindowIDs->Contains(aWindow->WindowID())) {
+ windowPath += NS_LITERAL_CSTRING("top(none)/ghost/");
+ } else {
+ windowPath += NS_LITERAL_CSTRING("top(none)/detached/");
+ }
+ }
+
+ windowPath += NS_LITERAL_CSTRING("window(");
+ AppendWindowURI(aWindow, windowPath, aAnonymize);
+ windowPath += NS_LITERAL_CSTRING(")");
+
+ // Use |windowPath|, but replace "explicit/" with "event-counts/".
+ nsCString censusWindowPath(windowPath);
+ censusWindowPath.Replace(0, strlen("explicit"), "event-counts");
+
+ // Remember the path for later.
+ aWindowPaths->Put(aWindow->WindowID(), windowPath);
+
+#define REPORT_SIZE(_pathTail, _amount, _desc) \
+ ReportSize(windowPath, _pathTail, _amount, NS_LITERAL_CSTRING(_desc), \
+ aHandleReport, aData);
+
+#define REPORT_COUNT(_pathTail, _amount, _desc) \
+ ReportCount(censusWindowPath, _pathTail, _amount, NS_LITERAL_CSTRING(_desc), \
+ aHandleReport, aData);
+
+ nsWindowSizes windowSizes(WindowsMallocSizeOf);
+ aWindow->AddSizeOfIncludingThis(&windowSizes);
+
+ REPORT_SIZE("/dom/element-nodes", windowSizes.mDOMElementNodesSize,
+ "Memory used by the element nodes in a window's DOM.");
+ aWindowTotalSizes->mDOMElementNodesSize += windowSizes.mDOMElementNodesSize;
+
+ REPORT_SIZE("/dom/text-nodes", windowSizes.mDOMTextNodesSize,
+ "Memory used by the text nodes in a window's DOM.");
+ aWindowTotalSizes->mDOMTextNodesSize += windowSizes.mDOMTextNodesSize;
+
+ REPORT_SIZE("/dom/cdata-nodes", windowSizes.mDOMCDATANodesSize,
+ "Memory used by the CDATA nodes in a window's DOM.");
+ aWindowTotalSizes->mDOMCDATANodesSize += windowSizes.mDOMCDATANodesSize;
+
+ REPORT_SIZE("/dom/comment-nodes", windowSizes.mDOMCommentNodesSize,
+ "Memory used by the comment nodes in a window's DOM.");
+ aWindowTotalSizes->mDOMCommentNodesSize += windowSizes.mDOMCommentNodesSize;
+
+ REPORT_SIZE("/dom/event-targets", windowSizes.mDOMEventTargetsSize,
+ "Memory used by the event targets table in a window's DOM, and "
+ "the objects it points to, which include XHRs.");
+ aWindowTotalSizes->mDOMEventTargetsSize += windowSizes.mDOMEventTargetsSize;
+
+ REPORT_COUNT("/dom/event-targets", windowSizes.mDOMEventTargetsCount,
+ "Number of non-node event targets in the event targets table "
+ "in a window's DOM, such as XHRs.");
+ aWindowTotalSizes->mDOMEventTargetsCount +=
+ windowSizes.mDOMEventTargetsCount;
+
+ REPORT_COUNT("/dom/event-listeners", windowSizes.mDOMEventListenersCount,
+ "Number of event listeners in a window, including event "
+ "listeners on nodes and other event targets.");
+ aWindowTotalSizes->mDOMEventListenersCount +=
+ windowSizes.mDOMEventListenersCount;
+
+ REPORT_SIZE("/dom/other", windowSizes.mDOMOtherSize,
+ "Memory used by a window's DOM that isn't measured by the "
+ "other 'dom/' numbers.");
+ aWindowTotalSizes->mDOMOtherSize += windowSizes.mDOMOtherSize;
+
+ REPORT_SIZE("/property-tables",
+ windowSizes.mPropertyTablesSize,
+ "Memory used for the property tables within a window.");
+ aWindowTotalSizes->mPropertyTablesSize += windowSizes.mPropertyTablesSize;
+
+ REPORT_SIZE("/style-sheets", windowSizes.mStyleSheetsSize,
+ "Memory used by style sheets within a window.");
+ aWindowTotalSizes->mStyleSheetsSize += windowSizes.mStyleSheetsSize;
+
+ REPORT_SIZE("/layout/pres-shell", windowSizes.mLayoutPresShellSize,
+ "Memory used by layout's PresShell, along with any structures "
+ "allocated in its arena and not measured elsewhere, "
+ "within a window.");
+ aWindowTotalSizes->mLayoutPresShellSize += windowSizes.mLayoutPresShellSize;
+
+ REPORT_SIZE("/layout/line-boxes", windowSizes.mArenaStats.mLineBoxes,
+ "Memory used by line boxes within a window.");
+ aWindowTotalSizes->mArenaStats.mLineBoxes
+ += windowSizes.mArenaStats.mLineBoxes;
+
+ REPORT_SIZE("/layout/rule-nodes", windowSizes.mArenaStats.mRuleNodes,
+ "Memory used by CSS rule nodes within a window.");
+ aWindowTotalSizes->mArenaStats.mRuleNodes
+ += windowSizes.mArenaStats.mRuleNodes;
+
+ REPORT_SIZE("/layout/style-contexts", windowSizes.mArenaStats.mStyleContexts,
+ "Memory used by style contexts within a window.");
+ aWindowTotalSizes->mArenaStats.mStyleContexts
+ += windowSizes.mArenaStats.mStyleContexts;
+
+ REPORT_SIZE("/layout/style-structs", windowSizes.mArenaStats.mStyleStructs,
+ "Memory used by style structs within a window.");
+ aWindowTotalSizes->mArenaStats.mStyleStructs
+ += windowSizes.mArenaStats.mStyleStructs;
+
+ REPORT_SIZE("/layout/style-sets", windowSizes.mLayoutStyleSetsSize,
+ "Memory used by style sets within a window.");
+ aWindowTotalSizes->mLayoutStyleSetsSize += windowSizes.mLayoutStyleSetsSize;
+
+ REPORT_SIZE("/layout/text-runs", windowSizes.mLayoutTextRunsSize,
+ "Memory used for text-runs (glyph layout) in the PresShell's "
+ "frame tree, within a window.");
+ aWindowTotalSizes->mLayoutTextRunsSize += windowSizes.mLayoutTextRunsSize;
+
+ REPORT_SIZE("/layout/pres-contexts", windowSizes.mLayoutPresContextSize,
+ "Memory used for the PresContext in the PresShell's frame "
+ "within a window.");
+ aWindowTotalSizes->mLayoutPresContextSize +=
+ windowSizes.mLayoutPresContextSize;
+
+ // There are many different kinds of frames, but it is very likely
+ // that only a few matter. Implement a cutoff so we don't bloat
+ // about:memory with many uninteresting entries.
+ const size_t FRAME_SUNDRIES_THRESHOLD =
+ js::MemoryReportingSundriesThreshold();
+
+ size_t frameSundriesSize = 0;
+#define FRAME_ID(classname) \
+ { \
+ size_t frameSize \
+ = windowSizes.mArenaStats.FRAME_ID_STAT_FIELD(classname); \
+ if (frameSize < FRAME_SUNDRIES_THRESHOLD) { \
+ frameSundriesSize += frameSize; \
+ } else { \
+ REPORT_SIZE("/layout/frames/" # classname, frameSize, \
+ "Memory used by frames of " \
+ "type " #classname " within a window."); \
+ } \
+ aWindowTotalSizes->mArenaStats.FRAME_ID_STAT_FIELD(classname) \
+ += frameSize; \
+ }
+#include "nsFrameIdList.h"
+#undef FRAME_ID
+
+ if (frameSundriesSize > 0) {
+ REPORT_SIZE("/layout/frames/sundries", frameSundriesSize,
+ "The sum of all memory used by frames which were too small "
+ "to be shown individually.");
+ }
+
+#undef REPORT_SIZE
+#undef REPORT_COUNT
+}
+
+typedef nsTArray< RefPtr<nsGlobalWindow> > WindowArray;
+
+NS_IMETHODIMP
+nsWindowMemoryReporter::CollectReports(nsIHandleReportCallback* aHandleReport,
+ nsISupports* aData, bool aAnonymize)
+{
+ nsGlobalWindow::WindowByIdTable* windowsById =
+ nsGlobalWindow::GetWindowsTable();
+ NS_ENSURE_TRUE(windowsById, NS_OK);
+
+ // Hold on to every window in memory so that window objects can't be
+ // destroyed while we're calling the memory reporter callback.
+ WindowArray windows;
+ for (auto iter = windowsById->Iter(); !iter.Done(); iter.Next()) {
+ windows.AppendElement(iter.Data());
+ }
+
+ // Get the IDs of all the "ghost" windows, and call aHandleReport->Callback()
+ // for each one.
+ nsTHashtable<nsUint64HashKey> ghostWindows;
+ CheckForGhostWindows(&ghostWindows);
+ for (auto iter = ghostWindows.ConstIter(); !iter.Done(); iter.Next()) {
+ nsGlobalWindow::WindowByIdTable* windowsById =
+ nsGlobalWindow::GetWindowsTable();
+ if (!windowsById) {
+ NS_WARNING("Couldn't get window-by-id hashtable?");
+ continue;
+ }
+
+ nsGlobalWindow* window = windowsById->Get(iter.Get()->GetKey());
+ if (!window) {
+ NS_WARNING("Could not look up window?");
+ continue;
+ }
+
+ nsAutoCString path;
+ path.AppendLiteral("ghost-windows/");
+ AppendWindowURI(window, path, aAnonymize);
+
+ aHandleReport->Callback(
+ /* process = */ EmptyCString(),
+ path,
+ nsIMemoryReporter::KIND_OTHER,
+ nsIMemoryReporter::UNITS_COUNT,
+ /* amount = */ 1,
+ /* description = */ NS_LITERAL_CSTRING("A ghost window."),
+ aData);
+ }
+
+ WindowPaths windowPaths;
+ WindowPaths topWindowPaths;
+
+ // Collect window memory usage.
+ nsWindowSizes windowTotalSizes(nullptr);
+ nsCOMPtr<amIAddonManager> addonManager;
+ if (XRE_IsParentProcess()) {
+ // Only try to access the service from the main process.
+ addonManager = do_GetService("@mozilla.org/addons/integration;1");
+ }
+ for (uint32_t i = 0; i < windows.Length(); i++) {
+ CollectWindowReports(windows[i], addonManager,
+ &windowTotalSizes, &ghostWindows,
+ &windowPaths, &topWindowPaths, aHandleReport,
+ aData, aAnonymize);
+ }
+
+ // Report JS memory usage. We do this from here because the JS memory
+ // reporter needs to be passed |windowPaths|.
+ xpc::JSReporter::CollectReports(&windowPaths, &topWindowPaths,
+ aHandleReport, aData, aAnonymize);
+
+#define REPORT(_path, _amount, _desc) \
+ aHandleReport->Callback(EmptyCString(), NS_LITERAL_CSTRING(_path), \
+ KIND_OTHER, UNITS_BYTES, _amount, \
+ NS_LITERAL_CSTRING(_desc), aData);
+
+ REPORT("window-objects/dom/element-nodes", windowTotalSizes.mDOMElementNodesSize,
+ "This is the sum of all windows' 'dom/element-nodes' numbers.");
+
+ REPORT("window-objects/dom/text-nodes", windowTotalSizes.mDOMTextNodesSize,
+ "This is the sum of all windows' 'dom/text-nodes' numbers.");
+
+ REPORT("window-objects/dom/cdata-nodes", windowTotalSizes.mDOMCDATANodesSize,
+ "This is the sum of all windows' 'dom/cdata-nodes' numbers.");
+
+ REPORT("window-objects/dom/comment-nodes", windowTotalSizes.mDOMCommentNodesSize,
+ "This is the sum of all windows' 'dom/comment-nodes' numbers.");
+
+ REPORT("window-objects/dom/event-targets", windowTotalSizes.mDOMEventTargetsSize,
+ "This is the sum of all windows' 'dom/event-targets' numbers.");
+
+ REPORT("window-objects/dom/other", windowTotalSizes.mDOMOtherSize,
+ "This is the sum of all windows' 'dom/other' numbers.");
+
+ REPORT("window-objects/property-tables",
+ windowTotalSizes.mPropertyTablesSize,
+ "This is the sum of all windows' 'property-tables' numbers.");
+
+ REPORT("window-objects/style-sheets", windowTotalSizes.mStyleSheetsSize,
+ "This is the sum of all windows' 'style-sheets' numbers.");
+
+ REPORT("window-objects/layout/pres-shell", windowTotalSizes.mLayoutPresShellSize,
+ "This is the sum of all windows' 'layout/arenas' numbers.");
+
+ REPORT("window-objects/layout/line-boxes",
+ windowTotalSizes.mArenaStats.mLineBoxes,
+ "This is the sum of all windows' 'layout/line-boxes' numbers.");
+
+ REPORT("window-objects/layout/rule-nodes",
+ windowTotalSizes.mArenaStats.mRuleNodes,
+ "This is the sum of all windows' 'layout/rule-nodes' numbers.");
+
+ REPORT("window-objects/layout/style-contexts",
+ windowTotalSizes.mArenaStats.mStyleContexts,
+ "This is the sum of all windows' 'layout/style-contexts' numbers.");
+
+ REPORT("window-objects/layout/style-structs",
+ windowTotalSizes.mArenaStats.mStyleStructs,
+ "This is the sum of all windows' 'layout/style-structs' numbers.");
+
+ REPORT("window-objects/layout/style-sets", windowTotalSizes.mLayoutStyleSetsSize,
+ "This is the sum of all windows' 'layout/style-sets' numbers.");
+
+ REPORT("window-objects/layout/text-runs", windowTotalSizes.mLayoutTextRunsSize,
+ "This is the sum of all windows' 'layout/text-runs' numbers.");
+
+ REPORT("window-objects/layout/pres-contexts", windowTotalSizes.mLayoutPresContextSize,
+ "This is the sum of all windows' 'layout/pres-contexts' numbers.");
+
+ size_t frameTotal = 0;
+#define FRAME_ID(classname) \
+ frameTotal += windowTotalSizes.mArenaStats.FRAME_ID_STAT_FIELD(classname);
+#include "nsFrameIdList.h"
+#undef FRAME_ID
+
+ REPORT("window-objects/layout/frames", frameTotal,
+ "Memory used for layout frames within windows. "
+ "This is the sum of all windows' 'layout/frames/' numbers.");
+
+#undef REPORT
+
+ return NS_OK;
+}
+
+uint32_t
+nsWindowMemoryReporter::GetGhostTimeout()
+{
+ return Preferences::GetUint("memory.ghost_window_timeout_seconds", 60);
+}
+
+NS_IMETHODIMP
+nsWindowMemoryReporter::Observe(nsISupports *aSubject, const char *aTopic,
+ const char16_t *aData)
+{
+ if (!strcmp(aTopic, "after-minimize-memory-usage")) {
+ ObserveAfterMinimizeMemoryUsage();
+ } else if (!strcmp(aTopic, "cycle-collector-begin")) {
+ if (mCheckTimer) {
+ mCheckTimerWaitingForCCEnd = true;
+ KillCheckTimer();
+ }
+ mCycleCollectorIsRunning = true;
+ } else if (!strcmp(aTopic, "cycle-collector-end")) {
+ mCycleCollectorIsRunning = false;
+ if (mCheckTimerWaitingForCCEnd) {
+ mCheckTimerWaitingForCCEnd = false;
+ AsyncCheckForGhostWindows();
+ }
+ } else {
+ MOZ_ASSERT(false);
+ }
+
+ return NS_OK;
+}
+
+void
+nsWindowMemoryReporter::ObserveDOMWindowDetached(nsGlobalWindow* aWindow)
+{
+ nsWeakPtr weakWindow = do_GetWeakReference(static_cast<nsIDOMEventTarget*>(aWindow));
+ if (!weakWindow) {
+ NS_WARNING("Couldn't take weak reference to a window?");
+ return;
+ }
+
+ mDetachedWindows.Put(weakWindow, TimeStamp());
+
+ AsyncCheckForGhostWindows();
+}
+
+// static
+void
+nsWindowMemoryReporter::CheckTimerFired(nsITimer* aTimer, void* aData)
+{
+ if (sWindowReporter) {
+ MOZ_ASSERT(!sWindowReporter->mCycleCollectorIsRunning);
+ sWindowReporter->CheckForGhostWindows();
+ }
+}
+
+void
+nsWindowMemoryReporter::AsyncCheckForGhostWindows()
+{
+ if (mCheckTimer) {
+ return;
+ }
+
+ if (mCycleCollectorIsRunning) {
+ mCheckTimerWaitingForCCEnd = true;
+ return;
+ }
+
+ // If more than kTimeBetweenChecks seconds have elapsed since the last check,
+ // timerDelay is 0. Otherwise, it is kTimeBetweenChecks, reduced by the time
+ // since the last check. Reducing the delay by the time since the last check
+ // prevents the timer from being completely starved if it is repeatedly killed
+ // and restarted.
+ int32_t timeSinceLastCheck = (TimeStamp::NowLoRes() - mLastCheckForGhostWindows).ToSeconds();
+ int32_t timerDelay = (kTimeBetweenChecks - std::min(timeSinceLastCheck, kTimeBetweenChecks)) * PR_MSEC_PER_SEC;
+
+ mCheckTimer = do_CreateInstance("@mozilla.org/timer;1");
+
+ if (mCheckTimer) {
+ mCheckTimer->InitWithFuncCallback(CheckTimerFired, nullptr,
+ timerDelay, nsITimer::TYPE_ONE_SHOT);
+ }
+}
+
+void
+nsWindowMemoryReporter::ObserveAfterMinimizeMemoryUsage()
+{
+ // Someone claims they've done enough GC/CCs so that all eligible windows
+ // have been free'd. So we deem that any windows which satisfy ghost
+ // criteria (1) and (2) now satisfy criterion (3) as well.
+ //
+ // To effect this change, we'll backdate some of our timestamps.
+
+ TimeStamp minTimeStamp = TimeStamp::Now() -
+ TimeDuration::FromSeconds(GetGhostTimeout());
+
+ for (auto iter = mDetachedWindows.Iter(); !iter.Done(); iter.Next()) {
+ TimeStamp& timeStamp = iter.Data();
+ if (!timeStamp.IsNull() && timeStamp > minTimeStamp) {
+ timeStamp = minTimeStamp;
+ }
+ }
+}
+
+/**
+ * Iterate over mDetachedWindows and update it to reflect the current state of
+ * the world. In particular:
+ *
+ * - Remove weak refs to windows which no longer exist.
+ *
+ * - Remove references to windows which are no longer detached.
+ *
+ * - Reset the timestamp on detached windows which share a domain with a
+ * non-detached window (they no longer meet ghost criterion (2)).
+ *
+ * - If a window now meets ghost criterion (2) but didn't before, set its
+ * timestamp to now.
+ *
+ * Additionally, if aOutGhostIDs is not null, fill it with the window IDs of
+ * all ghost windows we found.
+ */
+void
+nsWindowMemoryReporter::CheckForGhostWindows(
+ nsTHashtable<nsUint64HashKey> *aOutGhostIDs /* = nullptr */)
+{
+ nsCOMPtr<nsIEffectiveTLDService> tldService = do_GetService(
+ NS_EFFECTIVETLDSERVICE_CONTRACTID);
+ if (!tldService) {
+ NS_WARNING("Couldn't get TLDService.");
+ return;
+ }
+
+ nsGlobalWindow::WindowByIdTable *windowsById =
+ nsGlobalWindow::GetWindowsTable();
+ if (!windowsById) {
+ NS_WARNING("GetWindowsTable returned null");
+ return;
+ }
+
+ mLastCheckForGhostWindows = TimeStamp::NowLoRes();
+ KillCheckTimer();
+
+ nsTHashtable<nsCStringHashKey> nonDetachedWindowDomains;
+
+ // Populate nonDetachedWindowDomains.
+ for (auto iter = windowsById->Iter(); !iter.Done(); iter.Next()) {
+ // Null outer window implies null top, but calling GetTop() when there's no
+ // outer window causes us to spew debug warnings.
+ nsGlobalWindow* window = iter.UserData();
+ if (!window->GetOuterWindow() || !window->GetTopInternal()) {
+ // This window is detached, so we don't care about its domain.
+ continue;
+ }
+
+ nsCOMPtr<nsIURI> uri = GetWindowURI(window);
+ nsAutoCString domain;
+ if (uri) {
+ tldService->GetBaseDomain(uri, 0, domain);
+ }
+ nonDetachedWindowDomains.PutEntry(domain);
+ }
+
+ // Update mDetachedWindows and write the ghost window IDs into aOutGhostIDs,
+ // if it's not null.
+ uint32_t ghostTimeout = GetGhostTimeout();
+ TimeStamp now = mLastCheckForGhostWindows;
+ for (auto iter = mDetachedWindows.Iter(); !iter.Done(); iter.Next()) {
+ nsWeakPtr weakKey = do_QueryInterface(iter.Key());
+ nsCOMPtr<mozIDOMWindow> iwindow = do_QueryReferent(weakKey);
+ if (!iwindow) {
+ // The window object has been destroyed. Stop tracking its weak ref in
+ // our hashtable.
+ iter.Remove();
+ continue;
+ }
+
+ nsPIDOMWindowInner* window = nsPIDOMWindowInner::From(iwindow);
+
+ // Avoid calling GetTop() if we have no outer window. Nothing will break if
+ // we do, but it will spew debug output, which can cause our test logs to
+ // overflow.
+ nsCOMPtr<nsPIDOMWindowOuter> top;
+ if (window->GetOuterWindow()) {
+ top = window->GetOuterWindow()->GetTop();
+ }
+
+ if (top) {
+ // The window is no longer detached, so we no longer want to track it.
+ iter.Remove();
+ continue;
+ }
+
+ nsCOMPtr<nsIURI> uri = GetWindowURI(nsGlobalWindow::Cast(window));
+
+ nsAutoCString domain;
+ if (uri) {
+ // GetBaseDomain works fine if |uri| is null, but it outputs a warning
+ // which ends up overrunning the mochitest logs.
+ tldService->GetBaseDomain(uri, 0, domain);
+ }
+
+ TimeStamp& timeStamp = iter.Data();
+
+ if (nonDetachedWindowDomains.Contains(domain)) {
+ // This window shares a domain with a non-detached window, so reset its
+ // clock.
+ timeStamp = TimeStamp();
+ } else {
+ // This window does not share a domain with a non-detached window, so it
+ // meets ghost criterion (2).
+ if (timeStamp.IsNull()) {
+ // This may become a ghost window later; start its clock.
+ timeStamp = now;
+ } else if ((now - timeStamp).ToSeconds() > ghostTimeout) {
+ // This definitely is a ghost window, so add it to aOutGhostIDs, if
+ // that is not null.
+ if (aOutGhostIDs && window) {
+ aOutGhostIDs->PutEntry(window->WindowID());
+ }
+ }
+ }
+ }
+}
+
+NS_IMPL_ISUPPORTS(nsWindowMemoryReporter::GhostWindowsReporter,
+ nsIMemoryReporter)
+
+/* static */ int64_t
+nsWindowMemoryReporter::GhostWindowsReporter::DistinguishedAmount()
+{
+ nsTHashtable<nsUint64HashKey> ghostWindows;
+ sWindowReporter->CheckForGhostWindows(&ghostWindows);
+ return ghostWindows.Count();
+}
+
+void
+nsWindowMemoryReporter::KillCheckTimer()
+{
+ if (mCheckTimer) {
+ mCheckTimer->Cancel();
+ mCheckTimer = nullptr;
+ }
+}
+
+#ifdef DEBUG
+/* static */ void
+nsWindowMemoryReporter::UnlinkGhostWindows()
+{
+ if (!sWindowReporter) {
+ return;
+ }
+
+ nsGlobalWindow::WindowByIdTable* windowsById =
+ nsGlobalWindow::GetWindowsTable();
+ if (!windowsById) {
+ return;
+ }
+
+ // Hold on to every window in memory so that window objects can't be
+ // destroyed while we're calling the UnlinkGhostWindows callback.
+ WindowArray windows;
+ for (auto iter = windowsById->Iter(); !iter.Done(); iter.Next()) {
+ windows.AppendElement(iter.Data());
+ }
+
+ // Get the IDs of all the "ghost" windows, and unlink them all.
+ nsTHashtable<nsUint64HashKey> ghostWindows;
+ sWindowReporter->CheckForGhostWindows(&ghostWindows);
+ for (auto iter = ghostWindows.ConstIter(); !iter.Done(); iter.Next()) {
+ nsGlobalWindow::WindowByIdTable* windowsById =
+ nsGlobalWindow::GetWindowsTable();
+ if (!windowsById) {
+ continue;
+ }
+
+ RefPtr<nsGlobalWindow> window = windowsById->Get(iter.Get()->GetKey());
+ if (window) {
+ window->RiskyUnlink();
+ }
+ }
+}
+#endif