The open-source Arc replacement for macOS. Spaces, pinned tabs, split view, Little Windows and Arc's shortcuts on Chromium, with your Arc sidebar imported in one go.
Background tabs give their GPU tiles back, as Chrome's do (#195)
Victor106adcc81f64
diff --git a/Packages/CraCore/Sources/CraCore/HiddenFrameRelease.swift b/Packages/CraCore/Sources/CraCore/HiddenFrameRelease.swiftnew file mode 100644index 0000000..3ba6143--- /dev/null+++ b/Packages/CraCore/Sources/CraCore/HiddenFrameRelease.swift@@ -0,0 +1,39 @@+import Foundation++/// Which hidden tabs' page windows draw once more so their last frame lets go of the page (#195).+///+/// Every Cra tab is its own Chromium window. A tab's window that is ordered out has its compositor+/// suspended with its last frame, and that frame keeps the page's surface, and the page's ~15 MB of+/// tiles, alive after Chromium evicts it. Chromium (HideDelegatedFrameHostMac) evicts a hidden page's+/// frame past its saved-frame cap (10, the most recently hidden first kept) and once it has been+/// hidden 5 minutes, on a 5-minute timer, so by 10 minutes. Chrome detaches a background tab from its+/// window instead, so nothing keeps it. A window that draws once after the eviction releases it.+public enum HiddenFrameRelease {+ /// Chromium's saved-frame cap with plenty of memory (FrameEvictionManager: 2 × 5).+ public static let savedFrames = 10+ /// Chromium's culling delay (5 min) plus one timer period: evicted by then whenever it was hidden.+ public static let evictedAfter: TimeInterval = 10 * 60 + 30++ public struct Tab: Equatable {+ public var id: UUID+ public var hiddenAt: Date+ /// The `hiddenAt` this tab's window last drew for, if it has since being hidden.+ public var releasedFor: Date?+ public init(id: UUID, hiddenAt: Date, releasedFor: Date?) {+ self.id = id+ self.hiddenAt = hiddenAt+ self.releasedFor = releasedFor+ }+ }++ /// The hidden tabs whose window should draw now: those Chromium has evicted, by count (beyond+ /// the `savedFrames - visible` most recently hidden) or by time, and that haven't drawn since.+ public static func due(_ hidden: [Tab], visible: Int, now: Date, evictedAfter: TimeInterval = evictedAfter) -> [UUID] {+ let kept = max(0, savedFrames - visible)+ let byRecency = hidden.sorted { $0.hiddenAt > $1.hiddenAt }+ return byRecency.enumerated().compactMap { i, t in+ guard t.releasedFor != t.hiddenAt else { return nil }+ return i >= kept || now.timeIntervalSince(t.hiddenAt) >= evictedAfter ? t.id : nil+ }+ }+}diff --git a/Packages/CraCore/Tests/CraCoreTests/HiddenFrameReleaseTests.swift b/Packages/CraCore/Tests/CraCoreTests/HiddenFrameReleaseTests.swiftnew file mode 100644index 0000000..fe6fc39--- /dev/null+++ b/Packages/CraCore/Tests/CraCoreTests/HiddenFrameReleaseTests.swift@@ -0,0 +1,35 @@+import CraCore+import Foundation+import Testing++/// Hidden tabs whose page windows draw once so Chromium's evicted frames release their tiles (#195).+struct HiddenFrameReleaseTests {+ private let now = Date(timeIntervalSince1970: 1_000_000)+ private func tab(_ n: Int, minutesAgo: Double, released: Bool = false) -> HiddenFrameRelease.Tab {+ let hidden = now.addingTimeInterval(-minutesAgo * 60)+ return .init(id: UUID(uuidString: String(format: "00000000-0000-0000-0000-%012d", n))!, hiddenAt: hidden, releasedFor: released ? hidden : nil)+ }++ @Test func recentTabsWithinTheCapKeepTheirFrames() {+ let hidden = (1...9).map { tab($0, minutesAgo: Double($0)) }+ #expect(HiddenFrameRelease.due(hidden, visible: 1, now: now).isEmpty)+ }++ /// Chromium keeps the 10 most recent frames (the visible tab's among them); older ones are evicted.+ @Test func tabsPastTheCapAreDueOldestFirst() {+ let hidden = (1...12).map { tab($0, minutesAgo: Double($0) / 10) }+ let due = HiddenFrameRelease.due(hidden, visible: 1, now: now)+ #expect(due == hidden.suffix(3).map(\.id))+ }++ @Test func tabsHiddenLongerThanTheCullAreDue() {+ let hidden = [tab(1, minutesAgo: 3), tab(2, minutesAgo: 11)]+ #expect(HiddenFrameRelease.due(hidden, visible: 1, now: now) == [hidden[1].id])+ }++ /// Once drawn for this hiding, a tab isn't done again until it has been shown and hidden again.+ @Test func eachHidingReleasesOnce() {+ let hidden = [tab(1, minutesAgo: 20, released: true), tab(2, minutesAgo: 20)]+ #expect(HiddenFrameRelease.due(hidden, visible: 1, now: now) == [hidden[1].id])+ }+}diff --git a/Sources/Cra/App/AppDelegate.swift b/Sources/Cra/App/AppDelegate.swiftindex 59cc7f8..c53c336 100644--- a/Sources/Cra/App/AppDelegate.swift+++ b/Sources/Cra/App/AppDelegate.swift@@ -202,6 +202,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuItemValidation {let settings = store.settingsfor w in mainWindows {w.browsers.freezeIdleTabs(hiddenLongerThan: freezeAfter)+ w.releaseHiddenFrames(now: composition.clock.now)if settings.tabSleepTimerEnabled { w.browsers.sleepIdleTabs(.timer(settings.tabSleepAfter)) }}sweepForMemoryPressure(PerfSystemSample.pressure(level: PerfSystemSampler.pressureLevel()))@@ -670,6 +671,8 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuItemValidation {}// Scenario hooks (scripts/scenario.sh): what a journey needs without a pointer.if dict["checkStore"] != nil { logSidebarProblems(); return }+ // releaseFrames: hidden tabs' page windows release Chromium's evicted frames now (#195).+ if dict["releaseFrames"] != nil { for w in mainWindows { w.releaseHiddenFrames(now: composition.clock.now) }; return }// A main-thread stall of this many milliseconds, for the performance recorder's tests.if let ms = dict["stall"].flatMap(Double.init) { usleep(useconds_t(min(max(ms, 0), 30_000) * 1000)); return }if let path = dict["perfReport"] {diff --git a/Sources/Cra/Services/BrowserManager.swift b/Sources/Cra/Services/BrowserManager.swiftindex ce3c76c..637015f 100644--- a/Sources/Cra/Services/BrowserManager.swift+++ b/Sources/Cra/Services/BrowserManager.swift@@ -27,6 +27,8 @@ final class TabRuntime {var freezeVoted = false/// When the page last went off screen (nil while shown); tab sleeping counts from here.var hiddenAt: Date?+ /// The `hiddenAt` its page window last drew for, so Chromium's evicted frame let go (HiddenFrameRelease, #195).+ var hiddenFrameReleasedFor: Date?/// When the page last started or stopped playing sound; tab sleeping waits as long after it.var audibleAt: Date?/// Tab sleeping discarded the page in place (Cra.discard): Chromium keeps its history anddiff --git a/Sources/Cra/UI/Windows/MainWindowController.swift b/Sources/Cra/UI/Windows/MainWindowController.swiftindex b02a474..6fa9915 100644--- a/Sources/Cra/UI/Windows/MainWindowController.swift+++ b/Sources/Cra/UI/Windows/MainWindowController.swift@@ -898,6 +898,11 @@ final class MainWindowController: NSWindowController, NSWindowDelegate, BrowserM// Hidden pages are not kept in step with the panes, so size this one before it shows.positionPageWindows(lastPaneFrames)w.contentView?.isHidden = false+ // Shown while drawing for releaseHiddenFrames: opaque and clickable again now.+ if releasingFrames.remove(id) != nil {+ w.alphaValue = 1+ w.ignoresMouseEvents = false+ }embedPage(id, from: w)// Ordering a window that is already showing is a window server round trip too.if !w.isVisible { w.orderFront(nil) }@@ -919,6 +924,39 @@ final class MainWindowController: NSWindowController, NSWindowDelegate, BrowserM}}+ /// Page windows drawing once, hidden, so their last frame lets go of an evicted page (#195).+ private var releasingFrames: Set<UUID> = []++ /// A hidden tab's page window is ordered out with its compositor suspended, and its last frame+ /// kept the page's surface, and the page's tiles in the GPU process (~15 MB a tab), alive after+ /// Chromium evicted it: every tab ever shown kept them. Chrome detaches a background tab from its+ /// one window instead. Ordered in for a moment, transparent and below this window, the page+ /// window draws a frame without the page and Chromium frees it (HiddenFrameRelease).+ func releaseHiddenFrames(now: Date) {+ let visible = Set(browsers.visibleTabIDs)+ let hidden = browsers.runtimes.values.compactMap { rt -> HiddenFrameRelease.Tab? in+ guard let at = rt.hiddenAt, rt.hostWindow != nil, !visible.contains(rt.tabID) else { return nil }+ return .init(id: rt.tabID, hiddenAt: at, releasedFor: rt.hiddenFrameReleasedFor)+ }+ guard let window else { return }+ for id in HiddenFrameRelease.due(hidden, visible: visible.count, now: now) {+ guard let rt = browsers.runtime(for: id), let w = rt.hostWindow, !w.isVisible, w.parent == nil,+ !releasingFrames.contains(id) else { continue }+ rt.hiddenFrameReleasedFor = rt.hiddenAt+ releasingFrames.insert(id)+ w.alphaValue = 0+ w.ignoresMouseEvents = true+ w.order(.below, relativeTo: window.windowNumber)+ // Two or three frames: the compositor unsuspends, paints and commits.+ DispatchQueue.main.asyncAfter(deadline: .now() + 0.25) { [weak self, weak w] in+ guard let self, let w, self.releasingFrames.remove(id) != nil else { return }+ w.alphaValue = 1+ w.ignoresMouseEvents = false+ if !self.browsers.visibleTabIDs.contains(id), w.parent == nil { w.orderOut(nil) }+ }+ }+ }+/// Moves the page's view from its Chrome window into its card (EmbeddedPages). With its/// DevTools open the page goes back: Chrome's docked frontend lays it out in its window.private func embedPage(_ id: UUID, from w: NSWindow) {diff --git a/Sources/CraCEF/CraCEF.mm b/Sources/CraCEF/CraCEF.mmindex d03507e..10c509c 100644--- a/Sources/CraCEF/CraCEF.mm+++ b/Sources/CraCEF/CraCEF.mm@@ -662,7 +662,12 @@ public:(enabled.empty() ? "" : enabled + ",") + "ForceWebRequestProxyForTest,"// Tab sleeping discards a page in place (Cra.discard), as Arc's Chromium does: the tab// keeps its back/forward list and scroll position, and loads again when shown (#153).- + "WebContentsDiscard");+ + "WebContentsDiscard,"+ // A hidden page's frame unlocks, so Chromium can evict it past its saved-frame cap or+ // after 5 minutes, as Chrome does for background tabs (Cra's are never detached from+ // their window, which is how Chrome gets there). Cra's page windows then let go of+ // it (MainWindowController.releaseHiddenFrames, #195).+ + "HideDelegatedFrameHostMac");// Kerberos/NTLM single sign-on (ADFS /adfs/ls/wia and the like). Chromium only sends// the OS ticket to allowlisted hosts, and IT sets that list as a Chrome or Edge policy,// which CEF never reads. Without it those logins fail with ERR_INVALID_AUTH_CREDENTIALS.