optimizations

abelonogov-ld · abelonogov-ld · commit 3ac3fe6f6b16 · 2026-07-01T16:14:15.000-07:00
diff --git a/Sources/LaunchDarklySessionReplay/ScreenCapture/MaskCollector.swift b/Sources/LaunchDarklySessionReplay/ScreenCapture/MaskCollector.swift
@@ -101,8 +101,8 @@ final class MaskCollector {
         }
 
         // Returns `true` if a mask was emitted for this view (the caller should stop recursing).
-        func emitViewMask(view: UIView, layer: CALayer, viewType: AnyClass, effectiveFrame: CGRect, resolvedExplicitMask: Bool?) -> Bool {
-            let shouldMask = policy.shouldMask(view, viewType: viewType, resolvedExplicitMask: resolvedExplicitMask)
+        func emitViewMask(view: UIView, layer: CALayer, viewType: AnyClass, className: String, effectiveFrame: CGRect, resolvedExplicitMask: Bool?) -> Bool {
+            let shouldMask = policy.shouldMask(view, viewType: viewType, className: className, resolvedExplicitMask: resolvedExplicitMask)
 
             if shouldMask, let mask = MaskGeometry.createMask(rPresentation: rPresentation, layer: layer, scale: scale) {
                 var operation = MaskOperation(mask: mask, effectiveFrame: effectiveFrame)
@@ -133,26 +133,24 @@ final class MaskCollector {
         // backing UIView, so the UIView-based path can't see them. Match by layer class name
         // while still honouring an inherited or marker-area explicit state.
         // Returns `true` if a mask was emitted (the caller should stop recursing).
-        func emitLayerOnlyMask(layer: CALayer, effectiveFrame: CGRect, resolvedExplicitMask: Bool?) -> Bool {
-            let shouldMask = resolvedExplicitMask ?? policy.shouldMaskLayer(layer)
+        func emitLayerOnlyMask(layerClassName: String, layer: CALayer, effectiveFrame: CGRect, resolvedExplicitMask: Bool?) -> Bool {
+            let shouldMask = resolvedExplicitMask ?? policy.shouldMaskLayer(className: layerClassName)
             guard shouldMask, let mask = MaskGeometry.createMask(rPresentation: rPresentation, layer: layer, scale: scale) else {
                 return false
             }
             operations.append(MaskOperation(mask: mask, effectiveFrame: effectiveFrame))
             return true
         }
 
-        func visit(layer: CALayer, inheritedExplicitMask: Bool?) {
+        func visit(layer: CALayer, layerClassName: String, inheritedExplicitMask: Bool?) {
             // On iOS 26+, CameraUI private CALayer subclasses (e.g. ModeLoupeLayer) do not
             // implement init(layer:). Guard at the very top — before ANY property access —
             // because even isHidden/opacity access can trigger CA::Layer::presentation_layer()
-            // on a layer that lacks the initializer. The same guard is applied at every
-            // sublayer iteration site so CameraUI layers are never passed to visit() at all;
-            // this check is belt-and-suspenders for any path not covered there.
-            if NSStringFromClass(type(of: layer)).hasPrefix("CameraUI") { return }
+            // on a layer that lacks the initializer. `layerClassName` is computed once by
+            // the caller so we never call NSStringFromClass twice for the same layer.
+            if policy.shouldSkipLayer(className: layerClassName) { return }
 
             guard !layer.isHidden, layer.opacity >= policy.minimumAlpha else { return }
-            if policy.shouldSkipLayer(layer) { return }
 
             // Frame in root coords is needed both for marker-area lookup
             // and for `effectiveFrame`/`MaskOperation`. Compute it once.
@@ -175,8 +173,9 @@ final class MaskCollector {
                 }
 
                 let viewType: AnyClass = type(of: view)
+                let viewClassName = NSStringFromClass(viewType)
 
-                if policy.shouldIgnore(view, viewType: viewType) || markerOverrideForLayer?.ignore == true {
+                if policy.shouldIgnore(view, viewType: viewType, className: viewClassName) || markerOverrideForLayer?.ignore == true {
                     return
                 }
 
@@ -186,7 +185,12 @@ final class MaskCollector {
                     inheritedExplicitMask: inheritedExplicitMask,
                     markerMask: markerOverrideForLayer?.mask
                 )
-                if emitViewMask(view: view, layer: layer, viewType: viewType, effectiveFrame: effectiveFrame, resolvedExplicitMask: resolvedExplicitMask) {
+                if emitViewMask(view: view,
+                                layer: layer,
+                                viewType: viewType,
+                                className: viewClassName,
+                                effectiveFrame: effectiveFrame,
+                                resolvedExplicitMask: resolvedExplicitMask) {
                     return
                 }
                 childInheritedMask = resolvedExplicitMask
@@ -199,7 +203,7 @@ final class MaskCollector {
                 } else {
                     resolvedExplicitMask = inheritedExplicitMask ?? markerOverrideForLayer?.mask
                 }
-                if emitLayerOnlyMask(layer: layer, effectiveFrame: effectiveFrame, resolvedExplicitMask: resolvedExplicitMask) {
+                if emitLayerOnlyMask(layerClassName: layerClassName, layer: layer, effectiveFrame: effectiveFrame, resolvedExplicitMask: resolvedExplicitMask) {
                     return
                 }
                 childInheritedMask = resolvedExplicitMask
@@ -215,31 +219,41 @@ final class MaskCollector {
             // layers avoids this. Mask positions may be slightly off during active
             // animations, but correctness under normal (non-animating) state is preserved.
             guard let modelSublayers = layer.model().sublayers, !modelSublayers.isEmpty else { return }
-            let safeSublayers = modelSublayers.filter {
-                !NSStringFromClass(type(of: $0)).hasPrefix("CameraUI")
+            var safeSublayers: [(CALayer, String)] = []
+            safeSublayers.reserveCapacity(modelSublayers.count)
+            for sublayer in modelSublayers {
+                let sublayerClassName = NSStringFromClass(type(of: sublayer))
+                if !policy.shouldSkipLayer(className: sublayerClassName) {
+                    safeSublayers.append((sublayer, sublayerClassName))
+                }
             }
             guard !safeSublayers.isEmpty else { return }
             if safeSublayers.count == 1 {
-                visit(layer: safeSublayers[0], inheritedExplicitMask: childInheritedMask)
+                visit(layer: safeSublayers[0].0, layerClassName: safeSublayers[0].1, inheritedExplicitMask: childInheritedMask)
             } else {
-                safeSublayers.sorted { $0.zPosition < $1.zPosition }
-                    .forEach { visit(layer: $0, inheritedExplicitMask: childInheritedMask) }
+                safeSublayers.sorted { $0.0.zPosition < $1.0.zPosition }
+                    .forEach { visit(layer: $0.0, layerClassName: $0.1, inheritedExplicitMask: childInheritedMask) }
             }
         }
 
         // Use model sublayers at the root level for the same reason: .sublayers on a
         // presentation layer creates presentation copies of all children, crashing on
         // iOS 26 if any child is or contains CameraUI.ModeLoupeLayer.
         let rootModelSublayers = rPresentation.model().sublayers ?? []
-        let safeRootSublayers = rootModelSublayers.filter {
-            !NSStringFromClass(type(of: $0)).hasPrefix("CameraUI")
+        var safeRootSublayers: [(CALayer, String)] = []
+        safeRootSublayers.reserveCapacity(rootModelSublayers.count)
+        for sublayer in rootModelSublayers {
+            let sublayerClassName = NSStringFromClass(type(of: sublayer))
+            if !policy.shouldSkipLayer(className: sublayerClassName) {
+                safeRootSublayers.append((sublayer, sublayerClassName))
+            }
         }
         if !safeRootSublayers.isEmpty {
             if safeRootSublayers.count == 1 {
-                visit(layer: safeRootSublayers[0], inheritedExplicitMask: nil)
+                visit(layer: safeRootSublayers[0].0, layerClassName: safeRootSublayers[0].1, inheritedExplicitMask: nil)
             } else {
-                safeRootSublayers.sorted { $0.zPosition < $1.zPosition }
-                    .forEach { visit(layer: $0, inheritedExplicitMask: nil) }
+                safeRootSublayers.sorted { $0.0.zPosition < $1.0.zPosition }
+                    .forEach { visit(layer: $0.0, layerClassName: $0.1, inheritedExplicitMask: nil) }
             }
         }
 
diff --git a/Sources/LaunchDarklySessionReplay/ScreenCapture/MaskingPolicy.swift b/Sources/LaunchDarklySessionReplay/ScreenCapture/MaskingPolicy.swift
@@ -22,15 +22,21 @@ import Common
 final class MaskingPolicy {
     enum Constants {
         // Private iOS 26 camera UI views whose layer subtrees contain CALayer
-        // subclasses (e.g. `ModeLoupeLayer`) that trap on `init(layer:)` when
-        // session replay walks or snapshots the hierarchy. Mask the enclosing
-        // view and stop recursing so those layers are never touched.
+        // subclasses that trap on `init(layer:)` when session replay walks the
+        // hierarchy. Mask the enclosing view and stop recursing.
         static let maskiOS26ViewTypes = Set(["CameraUI.ChromeSwiftUIView"])
 
-        // Layer-only nodes in the same subtrees that must not be traversed when
-        // reached without a backing UIView (the pre-refactor collector skipped
-        // all layer-only nodes; the iOS 26 layer walk must still skip these).
-        static let maskiOS26LayerTypes = Set(["CameraUI.ModeLoupeLayer"])
+        // Private iOS 26 camera UI layers that must not be traversed — they lack
+        // `init(layer:)` and crash when Core Animation copies them.
+        static let skipiOS26LayerTypes = Set(["CameraUI.ModeLoupeLayer"])
+
+        static func isCameraUIView(className: String) -> Bool {
+            maskiOS26ViewTypes.contains(className)
+        }
+
+        static func isCameraUILayer(className: String) -> Bool {
+            skipiOS26LayerTypes.contains(className)
+        }
 
         // Private UIKit view types SwiftUI uses to render `Text` on iOS <= 18
         // (Core Graphics drawn content). Matching by type name because these
@@ -88,13 +94,13 @@ final class MaskingPolicy {
         self.ignoreAccessibilityIdentifiers = Set(privacySettings.ignoreAccessibilityIdentifiers)
     }
 
-    func shouldIgnore(_ view: UIView, viewType: AnyClass) -> Bool {
+    func shouldIgnore(_ view: UIView, viewType: AnyClass, className: String) -> Bool {
         // Skip entire CameraUI subtrees on iOS 26+. CameraUI.ModeLoupeLayer (a private
         // CALayer subclass in this hierarchy) does not implement init(layer:). Accessing
         // .sublayers on its parent causes CA::Layer::presentation_layer() to call the
         // missing initializer, producing a fatal EXC_BREAKPOINT crash. Returning true
         // here stops recursion into the subtree before we ever reach that layer.
-        if String(describing: viewType).hasPrefix("CameraUI") { return true }
+        if Constants.isCameraUIView(className: className) { return true }
 
         if SessionReplayAssociatedObjects.shouldIgnoreUIView(view) == true {
             return true
@@ -140,19 +146,15 @@ final class MaskingPolicy {
         return false
     }
 
-    func shouldMaskFromGlobalConfig(_ view: UIView, viewType: AnyClass) -> Bool {
-        let stringViewType = String(describing: viewType)
-
+    func shouldMaskFromGlobalConfig(_ view: UIView, className: String) -> Bool {
         // Checked first so iOS 26 camera chrome is always masked regardless of
         // other privacy toggles. Masking stops subtree traversal, avoiding
         // `init(layer:)` crashes in private CameraUI layers.
-        if Constants.maskiOS26ViewTypes.contains(stringViewType) {
-            return true
-        }
+        if Constants.isCameraUIView(className: className) { return true }
 
         // Cheap concrete-type checks first; these short-circuit the
         // common cases (`UILabel`, `UIImageView`, `WKWebView`, plain
-        // `UITextField`/`UITextView`) without recomputing `stringViewType`.
+        // `UITextField`/`UITextView`) without further string lookups.
         if maskWebViews {
 #if canImport(WebKit)
             if view is WKWebView {
@@ -169,23 +171,23 @@ final class MaskingPolicy {
             return true
         }
 
-        // `UITextInput` is a protocol; reuse `stringViewType` for the
+        // `UITextInput` is a protocol; reuse `className` for the
         // `WKContentView` discrimination below.
         if maskTextInputs, view is UITextInput {
 #if canImport(WebKit)
-            if stringViewType != "WKContentView" {
+            if className != "WKContentView" {
                 return true
             }
 #else
             return true
 #endif
         }
 
-        if maskTextInputs, stringViewType == "UIKeyboard" {
+        if maskTextInputs, className == "UIKeyboard" {
             return true
         }
 
-        if maskLabels, Constants.swiftUITextViewTypes.contains(stringViewType) {
+        if maskLabels, Constants.swiftUITextViewTypes.contains(className) {
             return true
         }
 
@@ -213,16 +215,15 @@ final class MaskingPolicy {
     }
 
     /// Final precedence: an explicit (resolved) state wins; otherwise fall back to global config.
-    func shouldMask(_ view: UIView, viewType: AnyClass, resolvedExplicitMask: Bool?) -> Bool {
-        return resolvedExplicitMask ?? shouldMaskFromGlobalConfig(view, viewType: viewType)
+    func shouldMask(_ view: UIView, viewType: AnyClass, className: String, resolvedExplicitMask: Bool?) -> Bool {
+        return resolvedExplicitMask ?? shouldMaskFromGlobalConfig(view, className: className)
     }
 
     /// Private iOS 26 camera layers that trap when session replay walks or
-    /// snapshots them. The pre-refactor collector never descended into
-    /// layer-only nodes; skip these outright instead of calling geometry
+    /// snapshots them. Skip these outright instead of calling geometry
     /// helpers that can trigger `init(layer:)`.
-    func shouldSkipLayer(_ layer: CALayer) -> Bool {
-        Constants.maskiOS26LayerTypes.contains(String(describing: type(of: layer)))
+    func shouldSkipLayer(className: String) -> Bool {
+        Constants.isCameraUILayer(className: className)
     }
 
     /// Evaluates whether a `CALayer` that has no backing `UIView` should be masked.
@@ -231,12 +232,11 @@ final class MaskingPolicy {
     /// Symbols directly as private `CALayer` subclasses without wrapping them in
     /// `UIView`s. The usual `shouldMask(_ view:)` path can't see these, so we
     /// match by the layer's class name.
-    func shouldMaskLayer(_ layer: CALayer) -> Bool {
-        let layerType = String(describing: type(of: layer))
-        if maskLabels, Constants.swiftUITextLayerTypes.contains(layerType) {
+    func shouldMaskLayer(className: String) -> Bool {
+        if maskLabels, Constants.swiftUITextLayerTypes.contains(className) {
             return true
         }
-        if maskImages, Constants.swiftUIImageLayerTypes.contains(layerType) {
+        if maskImages, Constants.swiftUIImageLayerTypes.contains(className) {
             return true
         }
         return false
diff --git a/Tests/SessionReplayTests/MaskCollectorPrecedenceTests.swift b/Tests/SessionReplayTests/MaskCollectorPrecedenceTests.swift
@@ -99,21 +99,24 @@ struct MaskCollectorPrecedenceTests {
     @Test("shouldMask returns true when the resolved explicit state is true")
     func shouldMaskExplicitMaskWins() {
         let view = UIView()
-        #expect(makeSettings().shouldMask(view, viewType: type(of: view), resolvedExplicitMask: true) == true)
+        let className = NSStringFromClass(type(of: view))
+        #expect(makeSettings().shouldMask(view, viewType: type(of: view), className: className, resolvedExplicitMask: true) == true)
     }
 
     @Test("shouldMask: resolved unmask overrides a global rule that would otherwise mask")
     func shouldMaskExplicitUnmaskOverridesGlobal() {
         let settings = makeSettings(.init(maskLabels: true))
         let view = UILabel()
-        #expect(settings.shouldMask(view, viewType: type(of: view), resolvedExplicitMask: false) == false)
+        let className = NSStringFromClass(type(of: view))
+        #expect(settings.shouldMask(view, viewType: type(of: view), className: className, resolvedExplicitMask: false) == false)
     }
 
     @Test("shouldMask: with no explicit rule, the global config decides")
     func shouldMaskGlobalFallback() {
         let settings = makeSettings(.init(maskLabels: true))
         let view = UILabel()
-        #expect(settings.shouldMask(view, viewType: type(of: view), resolvedExplicitMask: nil) == true)
+        let className = NSStringFromClass(type(of: view))
+        #expect(settings.shouldMask(view, viewType: type(of: view), className: className, resolvedExplicitMask: nil) == true)
     }
 
     // MARK: - iOS 26 camera UI (ModeLoupeLayer crash regression)
@@ -133,13 +136,15 @@ struct MaskCollectorPrecedenceTests {
         ))
         guard let cameraClass = NSClassFromString("CameraUI.ChromeSwiftUIView") else { return }
         let view = (cameraClass as! UIView.Type).init()
-        #expect(settings.shouldMask(view, viewType: cameraClass, resolvedExplicitMask: nil) == true)
+        let className = NSStringFromClass(cameraClass)
+        #expect(settings.shouldMask(view, viewType: cameraClass, className: className, resolvedExplicitMask: nil) == true)
     }
 
     @Test("shouldSkipLayer skips CameraUI.ModeLoupeLayer")
     func skipsIOS26CameraLayers() {
         let settings = makeSettings()
-        #expect(MaskingPolicy.Constants.maskiOS26LayerTypes.contains("CameraUI.ModeLoupeLayer"))
-        #expect(settings.shouldSkipLayer(CALayer()) == false)
+        #expect(MaskingPolicy.Constants.skipiOS26LayerTypes.contains("CameraUI.ModeLoupeLayer"))
+        #expect(settings.shouldSkipLayer(className: "CameraUI.ModeLoupeLayer"))
+        #expect(settings.shouldSkipLayer(className: NSStringFromClass(type(of: CALayer()))) == false)
     }
 }
