diff options
Diffstat (limited to 'dom/base/nsWindowMemoryReporter.h')
| -rw-r--r-- | dom/base/nsWindowMemoryReporter.h | 263 |
1 files changed, 263 insertions, 0 deletions
diff --git a/dom/base/nsWindowMemoryReporter.h b/dom/base/nsWindowMemoryReporter.h new file mode 100644 index 000000000..b9e986959 --- /dev/null +++ b/dom/base/nsWindowMemoryReporter.h @@ -0,0 +1,263 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef nsWindowMemoryReporter_h__ +#define nsWindowMemoryReporter_h__ + +#include "nsGlobalWindow.h" +#include "nsIMemoryReporter.h" +#include "nsIObserver.h" +#include "nsITimer.h" +#include "nsDataHashtable.h" +#include "nsWeakReference.h" +#include "mozilla/Attributes.h" +#include "mozilla/Assertions.h" +#include "mozilla/MemoryReporting.h" +#include "mozilla/PodOperations.h" +#include "mozilla/TimeStamp.h" +#include "nsArenaMemoryStats.h" + +class nsWindowSizes { +#define FOR_EACH_SIZE(macro) \ + macro(DOM, mDOMElementNodesSize) \ + macro(DOM, mDOMTextNodesSize) \ + macro(DOM, mDOMCDATANodesSize) \ + macro(DOM, mDOMCommentNodesSize) \ + macro(DOM, mDOMEventTargetsSize) \ + macro(DOM, mDOMOtherSize) \ + macro(Style, mStyleSheetsSize) \ + macro(Other, mLayoutPresShellSize) \ + macro(Style, mLayoutStyleSetsSize) \ + macro(Other, mLayoutTextRunsSize) \ + macro(Other, mLayoutPresContextSize) \ + macro(Other, mPropertyTablesSize) \ + +public: + explicit nsWindowSizes(mozilla::MallocSizeOf aMallocSizeOf) + : + #define ZERO_SIZE(kind, mSize) mSize(0), + FOR_EACH_SIZE(ZERO_SIZE) + #undef ZERO_SIZE + mDOMEventTargetsCount(0), + mDOMEventListenersCount(0), + mArenaStats(), + mMallocSizeOf(aMallocSizeOf) + {} + + void addToTabSizes(nsTabSizes *sizes) const { + #define ADD_TO_TAB_SIZES(kind, mSize) sizes->add(nsTabSizes::kind, mSize); + FOR_EACH_SIZE(ADD_TO_TAB_SIZES) + #undef ADD_TO_TAB_SIZES + mArenaStats.addToTabSizes(sizes); + } + + size_t getTotalSize() const + { + size_t total = 0; + #define ADD_TO_TOTAL_SIZE(kind, mSize) total += mSize; + FOR_EACH_SIZE(ADD_TO_TOTAL_SIZE) + #undef ADD_TO_TOTAL_SIZE + total += mArenaStats.getTotalSize(); + return total; + } + + #define DECL_SIZE(kind, mSize) size_t mSize; + FOR_EACH_SIZE(DECL_SIZE); + #undef DECL_SIZE + + uint32_t mDOMEventTargetsCount; + uint32_t mDOMEventListenersCount; + + nsArenaMemoryStats mArenaStats; + mozilla::MallocSizeOf mMallocSizeOf; + +#undef FOR_EACH_SIZE +}; + +/** + * nsWindowMemoryReporter is responsible for the 'explicit/window-objects' + * memory reporter. + * + * We classify DOM window objects into one of three categories: + * + * - "active" windows, which are displayed in a tab (as the top-level window + * or an iframe), + * + * - "cached" windows, which are in the fastback cache (aka the bfcache), and + * + * - "detached" windows, which have a null docshell. A window becomes + * detached when its <iframe> or tab containing the window is destroyed -- + * i.e., when the window is no longer active or cached. + * + * Additionally, we classify a subset of detached windows as "ghost" windows. + * Although ghost windows can happen legitimately (a page can hold a reference + * to a cross-domain window and then close its container), the presence of + * ghost windows is often indicative of a memory leak. + * + * A window is a ghost if it meets the following three criteria: + * + * 1) The window is detached. + * + * 2) There exist no non-detached windows with the same base domain as + * the window's principal. (For example, the base domain of + * "wiki.mozilla.co.uk" is "mozilla.co.uk".) This criterion makes us less + * likely to flag a legitimately held-alive detached window as a ghost. + * + * 3) The window has met criteria (1) and (2) above for at least + * memory.ghost_window_timeout_seconds. This criterion is in place so we + * don't immediately declare a window a ghost before the GC/CC has had a + * chance to run. + * + * nsWindowMemoryReporter observes window detachment and uses mDetachedWindows + * to remember when a window first met criteria (1) and (2). When we generate + * a memory report, we use this accounting to determine which windows are + * ghosts. + * + * + * We use the following memory reporter path for active and cached windows: + * + * explicit/window-objects/top(<top-outer-uri>, id=<top-outer-id>)/<category>/window(<window-uri>)/... + * + * For detached and ghost windows, we use + * + * explicit/window-objects/top(none)/<category>/window(<window-uri>)/... + * + * Where + * + * - <category> is "active", "cached", "detached", or "ghost", as described + * above. + * + * - <top-outer-id> is the window id of the top outer window (i.e. the tab, or + * the top level chrome window). Exposing this ensures that each tab gets + * its own sub-tree, even if multiple tabs are showing the same URI. + * + * - <top-uri> is the URI of the top window. Excepting special windows (such + * as browser.xul or hiddenWindow.html) it's what the address bar shows for + * the tab. + * + */ +class nsWindowMemoryReporter final : public nsIMemoryReporter, + public nsIObserver, + public nsSupportsWeakReference +{ +public: + NS_DECL_ISUPPORTS + NS_DECL_NSIMEMORYREPORTER + NS_DECL_NSIOBSERVER + + static void Init(); + +#ifdef DEBUG + /** + * Unlink all known ghost windows, to enable investigating what caused them + * to become ghost windows in the first place. + */ + static void UnlinkGhostWindows(); +#endif + + static nsWindowMemoryReporter* Get(); + void ObserveDOMWindowDetached(nsGlobalWindow* aWindow); + +private: + ~nsWindowMemoryReporter(); + + /** + * nsGhostWindowReporter generates the "ghost-windows" report, which counts + * the number of ghost windows present. + */ + class GhostWindowsReporter final : public nsIMemoryReporter + { + ~GhostWindowsReporter() {} + public: + NS_DECL_ISUPPORTS + + static int64_t DistinguishedAmount(); + + NS_IMETHOD + CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData, + bool aAnonymize) override + { + MOZ_COLLECT_REPORT( + "ghost-windows", KIND_OTHER, UNITS_COUNT, DistinguishedAmount(), +"The number of ghost windows present (the number of nodes underneath " +"explicit/window-objects/top(none)/ghost, modulo race conditions). A ghost " +"window is not shown in any tab, does not share a domain with any non-detached " +"windows, and has met these criteria for at least " +"memory.ghost_window_timeout_seconds, or has survived a round of " +"about:memory's minimize memory usage button.\n\n" +"Ghost windows can happen legitimately, but they are often indicative of " +"leaks in the browser or add-ons."); + + return NS_OK; + } + }; + + // Protect ctor, use Init() instead. + nsWindowMemoryReporter(); + + /** + * Get the number of seconds for which a window must satisfy ghost criteria + * (1) and (2) before we deem that it satisfies criterion (3). + */ + uint32_t GetGhostTimeout(); + + void ObserveAfterMinimizeMemoryUsage(); + + /** + * Iterate over all weak window pointers in mDetachedWindows and update our + * accounting of which windows meet ghost criterion (2). + * + * This method also cleans up mDetachedWindows, removing entries for windows + * which have been destroyed or are no longer detached. + * + * If aOutGhostIDs is non-null, we populate it with the Window IDs of the + * ghost windows. + * + * This is called asynchronously after we observe a DOM window being detached + * from its docshell, and also right before we generate a memory report. + */ + void CheckForGhostWindows(nsTHashtable<nsUint64HashKey> *aOutGhostIDs = nullptr); + + /** + * Eventually do a check for ghost windows, if we haven't done one recently + * and we aren't already planning to do one soon. + */ + void AsyncCheckForGhostWindows(); + + /** + * Kill the check timer, if it exists. + */ + void KillCheckTimer(); + + static void CheckTimerFired(nsITimer* aTimer, void* aClosure); + + /** + * Maps a weak reference to a detached window (nsIWeakReference) to the time + * when we observed that the window met ghost criterion (2) above. + * + * If the window has not yet met criterion (2) it maps to the null timestamp. + * + * (Although windows are not added to this table until they're detached, it's + * possible for a detached window to become non-detached, and we won't + * remove it from the table until CheckForGhostWindows runs.) + */ + nsDataHashtable<nsISupportsHashKey, mozilla::TimeStamp> mDetachedWindows; + + /** + * Track the last time we ran CheckForGhostWindows(), to avoid running it + * too often after a DOM window is detached. + */ + mozilla::TimeStamp mLastCheckForGhostWindows; + + nsCOMPtr<nsITimer> mCheckTimer; + + bool mCycleCollectorIsRunning; + + bool mCheckTimerWaitingForCCEnd; +}; + +#endif // nsWindowMemoryReporter_h__ + |