diff options
Diffstat (limited to 'dom/base/nsWindowMemoryReporter.cpp')
| -rw-r--r-- | dom/base/nsWindowMemoryReporter.cpp | 861 |
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 |