@devicelab/maestro-runner-darwin-arm64 1.1.27 → 1.1.28

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBTVNavigationTracker.m

@@ -10,6 +10,7 @@
 #import "FBTVNavigationTracker-Private.h"
 
 #import "FBMathUtils.h"
+#import "FBXCElementSnapshotWrapper.h"
 #import "XCUIElement+FBCaching.h"
 #import "XCUIElement+FBUtilities.h"
 #import "XCUIElement+FBWebDriverAttributes.h"
@@ -56,17 +57,49 @@
   self = [super init];
   if (self) {
     _targetElement = targetElement;
-    CGRect frame = targetElement.wdFrame;
-    _targetCenter = FBRectGetCenter(frame);
+    _targetCenter = FBRectGetCenter(targetElement.wdFrame);
     _navigationItems = [NSMutableDictionary dictionary];
   }
   return self;
 }
 
-- (FBTVDirection)directionToFocusedElement
+- (FBTVFocusState)pollFocusState:(FBTVDirection *)direction
 {
-  XCUIElement *focused = XCUIApplication.fb_activeApplication.fb_focusedElement;
+  *direction = FBTVDirectionNone;
 
+  // `hasFocus`/`exists` are cheap, single-element live checks - each round
+  // trip only has to serialize the state of one already-known element, not
+  // an unbounded subtree, so there's no snapshot-walk win to be had here.
+  if (self.targetElement.hasFocus) {
+    return FBTVFocusStateFocused;
+  }
+  if (!self.targetElement.exists) {
+    return FBTVFocusStateGone;
+  }
+
+  // Likewise, a `hasFocus == true` predicate query only has to serialize its
+  // (typically 0-1) matches back over the round trip, unlike a whole-app
+  // snapshot walk, whose cost scales with total app size/depth.
+  XCUIElement *focusedElement = (XCUIElement *)XCUIApplication.fb_activeApplication.fb_focusedElement;
+  if (nil == focusedElement) {
+    // Nothing is focused yet (e.g. right after the app became active) - let
+    // the caller retry on the next iteration.
+    return FBTVFocusStatePending;
+  }
+
+  // The snapshot was already taken as a side effect of resolving the query
+  // above, so grab it for free instead of paying for a new round trip.
+  id<FBXCElementSnapshot> focusedSnapshot = focusedElement.lastSnapshot
+    ?: focusedElement.fb_cachedSnapshot
+    ?: [focusedElement fb_customSnapshot];
+  *direction = [self directionTowardsTargetFromFocusedElementSnapshot:focusedSnapshot];
+
+  return FBTVFocusStatePending;
+}
+
+- (FBTVDirection)directionTowardsTargetFromFocusedElementSnapshot:(id<FBXCElementSnapshot>)focusedSnapshot
+{
+  FBXCElementSnapshotWrapper *focused = [FBXCElementSnapshotWrapper ensureWrapped:focusedSnapshot];
   CGPoint focusedCenter = FBRectGetCenter(focused.wdFrame);
   FBTVNavigationItem *item = [self navigationItemWithElement:focused];
   CGFloat yDelta = self.targetCenter.y - focusedCenter.y;
@@ -83,7 +116,6 @@
       direction = [self verticalDirectionWithItem:item andDelta:yDelta];
     }
   }
-
   return direction;
 }
 
@@ -99,7 +131,7 @@
   if (nil != item) {
     return item;
   }
-  
+
   item = [FBTVNavigationItem itemWithUid:uid];
   [self.navigationItems setObject:item forKey:uid];
   return item;
@@ -107,32 +139,35 @@
 
 - (FBTVDirection)horizontalDirectionWithItem:(FBTVNavigationItem *)item andDelta:(CGFloat)delta
 {
-  // GCFloat is double in 64bit. tvOS is only for arm64
-  if (delta > DBL_EPSILON &&
-      ![item.directions containsObject: [NSNumber numberWithInteger: FBTVDirectionRight]]) {
-    [item.directions addObject: [NSNumber numberWithInteger: FBTVDirectionRight]];
-    return FBTVDirectionRight;
-  }
-  if (delta < -DBL_EPSILON &&
-      ![item.directions containsObject: [NSNumber numberWithInteger: FBTVDirectionLeft]]) {
-    [item.directions addObject: [NSNumber numberWithInteger: FBTVDirectionLeft]];
-    return FBTVDirectionLeft;
-  }
-  return FBTVDirectionNone;
+  return [self directionWithItem:item
+                            delta:delta
+                positiveDirection:FBTVDirectionRight
+                negativeDirection:FBTVDirectionLeft];
 }
 
 - (FBTVDirection)verticalDirectionWithItem:(FBTVNavigationItem *)item andDelta:(CGFloat)delta
 {
-  // GCFloat is double in 64bit. tvOS is only for arm64
-  if (delta > DBL_EPSILON &&
-      ![item.directions containsObject: [NSNumber numberWithInteger: FBTVDirectionDown]]) {
-    [item.directions addObject: [NSNumber numberWithInteger: FBTVDirectionDown]];
-    return FBTVDirectionDown;
+  return [self directionWithItem:item
+                            delta:delta
+                positiveDirection:FBTVDirectionDown
+                negativeDirection:FBTVDirectionUp];
+}
+
+- (FBTVDirection)directionWithItem:(FBTVNavigationItem *)item
+                              delta:(CGFloat)delta
+                  positiveDirection:(FBTVDirection)positiveDirection
+                  negativeDirection:(FBTVDirection)negativeDirection
+{
+  // CGFloat is double in 64bit. tvOS is only for arm64
+  NSNumber *positiveDirectionNumber = [NSNumber numberWithInteger:positiveDirection];
+  NSNumber *negativeDirectionNumber = [NSNumber numberWithInteger:negativeDirection];
+  if (delta > DBL_EPSILON && ![item.directions containsObject:positiveDirectionNumber]) {
+    [item.directions addObject:positiveDirectionNumber];
+    return positiveDirection;
   }
-  if (delta < -DBL_EPSILON &&
-      ![item.directions containsObject: [NSNumber numberWithInteger: FBTVDirectionUp]]) {
-    [item.directions addObject: [NSNumber numberWithInteger: FBTVDirectionUp]];
-    return FBTVDirectionUp;
+  if (delta < -DBL_EPSILON && ![item.directions containsObject:negativeDirectionNumber]) {
+    [item.directions addObject:negativeDirectionNumber];
+    return negativeDirection;
   }
   return FBTVDirectionNone;
 }

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBW3CActionsSynthesizer.h

@@ -10,7 +10,7 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-#if !TARGET_OS_TV
+#if !TARGET_OS_TV && !TARGET_OS_WATCH
 @interface FBW3CActionsSynthesizer : FBBaseActionsSynthesizer
 
 @end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBW3CActionsSynthesizer.m

@@ -63,7 +63,7 @@ static NSString *const FB_KEY_PARAMETERS = @"parameters";
 static NSString *const FB_KEY_ACTIONS = @"actions";
 
 
-#if !TARGET_OS_TV
+#if !TARGET_OS_TV && !TARGET_OS_WATCH
 @interface FBW3CGestureItem : FBBaseGestureItem
 
 @property (nullable, readonly, nonatomic) FBBaseGestureItem *previousItem;
@@ -133,7 +133,8 @@ static NSString *const FB_KEY_ACTIONS = @"actions";
     }
     self.duration = durationObj.doubleValue;
     XCUICoordinate *position = [self positionWithError:error];
-    if (nil == position) {
+    // A pause may legally have no position yet (nil position, no error set)
+    if (nil == position && error && nil != *error) {
       return nil;
     }
     self.atPosition = position;
@@ -143,7 +144,7 @@ static NSString *const FB_KEY_ACTIONS = @"actions";
 
 - (nullable XCUICoordinate *)positionWithError:(NSError **)error
 {
-  if (nil == self.previousItem) {
+  if (nil == self.previousItem || nil == self.previousItem.atPosition) {
     NSString *errorDescription = [NSString stringWithFormat:@"The '%@' action item must be preceded by %@ item", self.actionItem, FB_ACTION_ITEM_TYPE_POINTER_MOVE];
     if (error) {
       *error = [[FBErrorBuilder.builder withDescription:errorDescription] build];
@@ -161,7 +162,7 @@ static NSString *const FB_KEY_ACTIONS = @"actions";
     return [super hitpointWithElement:element positionOffset:positionOffset error:error];
   }
 
-  // An offset relative to the element is defined
+  // An offset relative to the element is defined.
   if (CGRectIsEmpty(element.frame)) {
     [FBLogger log:self.application.fb_descriptionRepresentation];
     NSString *description = [NSString stringWithFormat:@"The element '%@' is not visible on the screen and thus is not interactable",
@@ -173,9 +174,9 @@ static NSString *const FB_KEY_ACTIONS = @"actions";
   }
 
   // W3C standard requires that relative element coordinates start at the center of the element's rectangle
-  CGVector offset = CGVectorMake(positionOffset.CGPointValue.x, positionOffset.CGPointValue.y);
   // TODO: Shall we throw an exception if hitPoint is out of the element frame?
-  return [[element coordinateWithNormalizedOffset:CGVectorMake(0.5, 0.5)] coordinateWithOffset:offset];
+  CGVector offset = CGVectorMake(positionOffset.CGPointValue.x, positionOffset.CGPointValue.y);
+  return FBCoordinateWithAnchorOffset((XCUIElement *)element, CGVectorMake(0.5, 0.5), offset, error);
 }
 
 @end
@@ -205,9 +206,19 @@ static NSString *const FB_KEY_ACTIONS = @"actions";
                                  currentItemIndex:(NSUInteger)currentItemIndex
                                             error:(NSError **)error
 {
-  if (nil != eventPath && currentItemIndex == 1) {
+  if (nil != eventPath && currentItemIndex >= 1) {
     FBW3CGestureItem *preceedingItem = [allItems objectAtIndex:currentItemIndex - 1];
-    if ([preceedingItem isKindOfClass:FBPointerMoveItem.class]) {
+    // Only skip creating a new touch if the preceding pointerMove is the one that
+    // implicitly opened this touch, i.e. nothing but (possibly zero-duration) pauses
+    // came before it. Pauses never create an event path themselves.
+    BOOL isPreceedingMoveTheFirstRealItem = YES;
+    for (NSInteger index = (NSInteger)currentItemIndex - 2; index >= 0; index--) {
+      if (![[allItems objectAtIndex:index] isKindOfClass:FBPointerPauseItem.class]) {
+        isPreceedingMoveTheFirstRealItem = NO;
+        break;
+      }
+    }
+    if ([preceedingItem isKindOfClass:FBPointerMoveItem.class] && isPreceedingMoveTheFirstRealItem) {
       return @[];
     }
   }
@@ -280,7 +291,7 @@ static NSString *const FB_KEY_ACTIONS = @"actions";
   }
   
   // origin == FB_ORIGIN_TYPE_POINTER
-  if (nil == self.previousItem) {
+  if (nil == self.previousItem || nil == self.previousItem.atPosition) {
     NSString *errorDescription = [NSString stringWithFormat:@"There is no previous item for '%@' action item, however %@ is set to '%@'", self.actionItem, FB_ACTION_ITEM_KEY_ORIGIN, FB_ORIGIN_TYPE_POINTER];
     if (error) {
       *error = [[FBErrorBuilder.builder withDescription:errorDescription] build];
@@ -320,6 +331,13 @@ static NSString *const FB_KEY_ACTIONS = @"actions";
   return FB_ACTION_ITEM_TYPE_PAUSE;
 }
 
+- (nullable XCUICoordinate *)positionWithError:(NSError **)error
+{
+  // A pause has no position of its own; proxy whatever real move preceded
+  // it, or nil (not a fabricated point) if none has run yet
+  return self.previousItem.atPosition;
+}
+
 - (NSArray<XCPointerEventPath *> *)addToEventPath:(XCPointerEventPath *)eventPath
                                          allItems:(NSArray *)allItems
                                  currentItemIndex:(NSUInteger)currentItemIndex
@@ -472,7 +490,7 @@ static NSString *const FB_KEY_ACTIONS = @"actions";
   XCPointerEventPath *resultPath = [[XCPointerEventPath alloc] initForTextInput];
   [resultPath typeText:text
               atOffset:offset
-           typingSpeed:FBConfiguration.maxTypingFrequency
+           typingSpeed:FBConfiguration.sharedInstance.maxTypingFrequency
           shouldRedact:YES];
   return @[resultPath];
 }

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBXCAXClientProxy.h

@@ -22,8 +22,6 @@ NS_ASSUME_NONNULL_BEGIN
 
 + (instancetype)sharedClient;
 
-- (BOOL)setAXTimeout:(NSTimeInterval)timeout error:(NSError **)error;
-
 - (nullable id<FBXCElementSnapshot>)snapshotForElement:(id<FBXCAccessibilityElement>)element
                                             attributes:(nullable NSArray<NSString *> *)attributes
                                                inDepth:(BOOL)inDepth
@@ -38,12 +36,136 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)notifyWhenNoAnimationsAreActiveForApplication:(XCUIApplication *)application
                                                 reply:(void (^)(void))reply;
 
+/**
+ Wraps the private -[XCAXClient_iOS notifyWhenEventLoopIsIdleForApplication:reply:],
+ used to check run loop responsiveness before a snapshot request (#1210).
+ `reply` may fire more than once per call; `error` is non-nil only if monitoring
+ itself could not be started.
+ */
+- (void)notifyWhenEventLoopIsIdleForApplication:(XCUIApplication *)application
+                                           reply:(void (^)(id _Nullable result, NSError * _Nullable error))reply;
+
 - (nullable NSDictionary *)attributesForElement:(id<FBXCAccessibilityElement>)element
                                      attributes:(NSArray *)attributes
                                           error:(NSError**)error;
 
 - (nullable XCUIApplication *)monitoredApplicationWithProcessIdentifier:(int)pid;
 
+/**
+ Runs `block` synchronously with AXTimeout (the "AXTimeout" property of
+ XCAXClient_iOS/XCUIAccessibilityInterface, backed by the private `_XCTAXIPCTimeout`
+ global) temporarily set to `timeout`, restoring the previous value once `block`
+ returns (even if it throws). Bounds how long a single accessibility (AX) request
+ issued by this process is allowed to wait for a reply from the AX server. Every
+ AX-backed call funneled through this proxy - systemApplication, activeApplications,
+ snapshotForElement:..., attributesForElement:... - is an in-process call into
+ XCAXClient_iOS and is bounded by this single, process-wide value; there is no
+ per-call override. Defaults to 60 seconds.
+
+ These XCAXClient_iOS calls are themselves wrapped in
+ `+[XCTFuture futureWithTimeout:description:block:]`, but that wrapper's own timeout
+ is `_XCTAXClientWrapperTimeout()` - AXTimeout plus a fixed 5-second margin, not
+ +withXPCRequestTimeout:do:'s `_XCTXPCRequestTimeout`. That margin exists so the AX
+ layer's own timeout has a chance to fire and produce a clean error before XCTFuture's
+ wrapper would cut if off anyway; it is not independently tunable. AXTimeout is
+ therefore the only knob that matters for every call this proxy wraps.
+
+ Important: this only bounds how long the CALLING thread waits for a reply. The AX
+ server itself is not told to cancel the request when this timeout elapses - the
+ request keeps running/queued on the AX side regardless of whether this process gave
+ up waiting on it. All AX requests from this process share one serial channel to the
+ AX server, so if the target app's UI is genuinely unresponsive, lowering this value
+ does not reduce the amount of queued work or make the server itself more responsive -
+ it only makes each individual caller give up sooner, while requests already abandoned
+ by their callers keep occupying the channel and can still delay whatever is queued
+ behind them by their original, un-shortened duration.
+
+ The whole scope is serialized behind a dedicated lock, so overlapping calls from
+ different threads nest/queue instead of racing to restore the global.
+
+ If installing `timeout` fails, `block` is not run, this returns NO, and `error` (if
+ given) is populated with the underlying failure. A failure while restoring the
+ previous value is logged and reported via `error` independently of the return value,
+ which always reflects `block`'s completion, sampled immediately after it returns and
+ before the restore attempt.
+ */
+- (BOOL)withAXTimeout:(NSTimeInterval)timeout do:(void (^)(void))block error:(NSError **)error;
+
+/**
+ Runs `block` synchronously with the XCTest automation-session XPC request timeout
+ (the private `_XCTXPCRequestTimeout`/`_XCTSetXPCRequestTimeout` globals) temporarily
+ set to `timeout`, restoring the previous value once `block` returns (even if it
+ throws). Defaults to 30 seconds.
+
+ This does NOT bound anything else in this proxy - despite the similar shape, it is
+ not the XCTest-level analog of -withAXTimeout:do: for the calls above. AXTimeout and
+ the XPC request timeout gate two structurally different, non-nested call paths:
+ XCAXClient_iOS (what this proxy wraps) makes its AX-server round trips in-process,
+ bounded solely by AXTimeout (see -withAXTimeout:do:); XCTRunnerAutomationSession -
+ a separate class WDA does not go through here - makes its calls over a real
+ NSXPCConnection (`remoteObjectProxyWithErrorHandler:`) to another process, bounded by
+ this timeout instead. `-[XCTRunnerAutomationSession matchesForQuery:error:]` (the
+ primitive behind XCUIElementQuery/most element-finding lookups) and that class's own,
+ identically-named `attributesForElement:attributes:error:` are the calls this timeout
+ actually bounds - not -[XCAXClient_iOS attributesForElement:attributes:error:] above.
+
+ `futureWithTimeout:description:block:` is a synchronous wait wrapper: it starts the
+ real (asynchronous) XPC request and blocks the calling thread until either the reply
+ arrives or this timeout elapses, then returns either way - but elapsing the timeout
+ does NOT cancel the underlying XPC request. It keeps running to completion on the
+ same serial channel regardless of whether anyone is still waiting on it.
+
+ Practical consequence: all XPC-bounded requests from this process share one queue to
+ the automation session. If the target app's main thread/run loop is genuinely stuck,
+ lowering this timeout does not shrink the backlog or make the target more responsive
+ - it only makes the CALLER give up sooner. A request issued right after an earlier
+ one "times out" still has to wait behind that earlier request's real completion (which
+ keeps consuming the channel in the background), so it can take just as long, or longer,
+ to be serviced - repeatedly retrying after a timeout adds more queued work rather than
+ freeing up the channel, and can never be used to reliably bound end-to-end latency
+ while the target is unresponsive.
+
+ A class-level method: it only touches the XPC request timeout global, never the AX
+ client, so calling it does not trigger AX subsystem initialization. The scope is
+ serialized behind a dedicated lock, so overlapping calls nest/queue instead of racing
+ to restore the global. The returned completion result is sampled immediately after
+ `block` returns and before the previous value is restored.
+
+ Returns YES if `block` returned within `timeout`, NO otherwise.
+ */
++ (BOOL)withXPCRequestTimeout:(NSTimeInterval)timeout do:(void (^)(void))block;
+
+/**
+ Runs `block` synchronously with the XCTest application-state timeout (the private
+ `_XCTApplicationStateTimeout`/`_XCTSetApplicationStateTimeout` globals) temporarily
+ set to `timeout`, restoring the previous value once `block` returns (even if it
+ throws). Defaults to 60 seconds, though it may be pre-seeded once from a
+ NSUserDefaults override the first time it is read, before any of this process's own
+ +withApplicationStateTimeout:do: calls run.
+
+ Unlike AXTimeout/the XPC request timeout above, this one is not scoped to a single
+ request/response round trip - it bounds `[XCTWaiter waitForExpectations:timeout:]`
+ inside `-[XCUIApplicationProcess waitForQuiescenceIncludingAnimationsIdle:...]`,
+ which WDA's own XCUIApplicationProcess+FBQuiescence.m swizzle already targets for the
+ per-tap pre/post-event quiescence wait. That wait is gated by a *compound OR*
+ expectation over two independently-notified flags - `eventLoopHasIdled` and (when
+ requested) `animationsHaveFinished` - so it can return as soon as either one changes,
+ not necessarily both; this timeout only bounds how long that race is allowed to run
+ before giving up on both. The same global also bounds XCTest's app-launch/foreground
+ state-transition waits (see -[FBSessionCommands launchApplication:...],
+ +[FBSessionCommands openDeepLink:withApplication:timeout:]), which are a different,
+ non-quiescence consumer of this same timeout.
+
+ A class-level method: it only touches the application-state timeout global, never the
+ AX client, so calling it does not trigger AX subsystem initialization. The scope is
+ serialized behind a dedicated lock, so overlapping calls nest/queue instead of racing
+ to restore the global. The returned completion result is sampled immediately after
+ `block` returns and before the previous value is restored.
+
+ Returns YES if `block` returned within `timeout`, NO otherwise.
+ */
++ (BOOL)withApplicationStateTimeout:(NSTimeInterval)timeout do:(void (^)(void))block;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBXCAXClientProxy.m

@@ -8,6 +8,7 @@
 
 #import "FBXCAXClientProxy.h"
 
+#import "CDStructures.h"
 #import "FBXCAccessibilityElement.h"
 #import "FBLogger.h"
 #import "FBMacros.h"
@@ -17,9 +18,43 @@
 
 static id FBAXClient = nil;
 
+// Guards -withAXTimeout:do:'s save/set/restore of the process-wide AXTimeout global.
+static NSRecursiveLock *FBAXTimeoutLock(void)
+{
+  static NSRecursiveLock *lock;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    lock = [NSRecursiveLock new];
+  });
+  return lock;
+}
+
+// Guards +withXPCRequestTimeout:do:'s save/set/restore of the process-wide XPC request timeout global.
+static NSRecursiveLock *FBXPCRequestTimeoutLock(void)
+{
+  static NSRecursiveLock *lock;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    lock = [NSRecursiveLock new];
+  });
+  return lock;
+}
+
+// Guards +withApplicationStateTimeout:do:'s save/set/restore of the process-wide application-state timeout global.
+static NSRecursiveLock *FBApplicationStateTimeoutLock(void)
+{
+  static NSRecursiveLock *lock;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    lock = [NSRecursiveLock new];
+  });
+  return lock;
+}
+
 @interface FBXCAXClientProxy ()
 
 @property (nonatomic) NSMutableDictionary<NSNumber *, XCUIApplication *> *appsCache;
+@property (nonatomic, nullable) id<FBXCAccessibilityElement> cachedSystemApplication;
 
 @end
 
@@ -37,9 +72,80 @@ static id FBAXClient = nil;
   return instance;
 }
 
-- (BOOL)setAXTimeout:(NSTimeInterval)timeout error:(NSError **)error
+- (BOOL)withAXTimeout:(NSTimeInterval)timeout do:(void (^)(void))block error:(NSError **)error
+{
+  NSRecursiveLock *lock = FBAXTimeoutLock();
+  [lock lock];
+  @try {
+    NSTimeInterval previousTimeout = [FBAXClient AXTimeout];
+    NSError *setError;
+    if (![FBAXClient _setAXTimeout:timeout error:&setError]) {
+      [FBLogger logFmt:@"Failed to set AXTimeout to %@: %@", @(timeout), setError];
+      if (nil != error) {
+        *error = setError;
+      }
+      return NO;
+    }
+    NSTimeInterval startTime = NSProcessInfo.processInfo.systemUptime;
+    BOOL completedInTime = NO;
+    @try {
+      block();
+      completedInTime = (NSProcessInfo.processInfo.systemUptime - startTime) < timeout;
+    } @finally {
+      NSError *restoreError;
+      if (![FBAXClient _setAXTimeout:previousTimeout error:&restoreError]) {
+        [FBLogger logFmt:@"Failed to restore AXTimeout to %@: %@", @(previousTimeout), restoreError];
+        if (nil != error) {
+          *error = restoreError;
+        }
+      }
+    }
+    return completedInTime;
+  } @finally {
+    [lock unlock];
+  }
+}
+
++ (BOOL)withXPCRequestTimeout:(NSTimeInterval)timeout do:(void (^)(void))block
 {
-  return [FBAXClient _setAXTimeout:timeout error:error];
+  NSRecursiveLock *lock = FBXPCRequestTimeoutLock();
+  [lock lock];
+  @try {
+    NSTimeInterval previousTimeout = _XCTXPCRequestTimeout();
+    _XCTSetXPCRequestTimeout(timeout);
+    NSTimeInterval startTime = NSProcessInfo.processInfo.systemUptime;
+    BOOL completedInTime = NO;
+    @try {
+      block();
+      completedInTime = (NSProcessInfo.processInfo.systemUptime - startTime) < timeout;
+    } @finally {
+      _XCTSetXPCRequestTimeout(previousTimeout);
+    }
+    return completedInTime;
+  } @finally {
+    [lock unlock];
+  }
+}
+
++ (BOOL)withApplicationStateTimeout:(NSTimeInterval)timeout do:(void (^)(void))block
+{
+  NSRecursiveLock *lock = FBApplicationStateTimeoutLock();
+  [lock lock];
+  @try {
+    NSTimeInterval previousTimeout = _XCTApplicationStateTimeout();
+    _XCTSetApplicationStateTimeout(timeout);
+    NSTimeInterval startTime = NSProcessInfo.processInfo.systemUptime;
+    BOOL completedInTime = NO;
+    @try {
+      block();
+      completedInTime = (NSProcessInfo.processInfo.systemUptime - startTime) < timeout;
+    } @finally {
+      _XCTSetApplicationStateTimeout(previousTimeout);
+    }
+    return completedInTime;
+  } @finally {
+    [lock unlock];
+  }
 }
 
 - (id<FBXCElementSnapshot>)snapshotForElement:(id<FBXCAccessibilityElement>)element
@@ -67,7 +173,14 @@ static id FBAXClient = nil;
 
 - (id<FBXCAccessibilityElement>)systemApplication
 {
-  return [FBAXClient systemApplication];
+  @synchronized (self) {
+    if (nil == self.cachedSystemApplication) {
+      // The system application's identity cannot change without it being killed,
+      // which takes WDA down with it, so it is safe to cache it forever.
+      self.cachedSystemApplication = [FBAXClient systemApplication];
+    }
+    return self.cachedSystemApplication;
+  }
 }
 
 - (NSDictionary *)defaultParameters
@@ -81,6 +194,12 @@ static id FBAXClient = nil;
   [FBAXClient notifyWhenNoAnimationsAreActiveForApplication:application reply:reply];
 }
 
+- (void)notifyWhenEventLoopIsIdleForApplication:(XCUIApplication *)application
+                                           reply:(void (^)(id _Nullable result, NSError * _Nullable error))reply
+{
+  [FBAXClient notifyWhenEventLoopIsIdleForApplication:application reply:reply];
+}
+
 - (NSDictionary *)attributesForElement:(id<FBXCAccessibilityElement>)element
                             attributes:(NSArray *)attributes
                                  error:(NSError**)error;
@@ -92,28 +211,30 @@ static id FBAXClient = nil;
 
 - (XCUIApplication *)monitoredApplicationWithProcessIdentifier:(int)pid
 {
-  NSMutableSet *terminatedAppIds = [NSMutableSet set];
-  for (NSNumber *appPid in self.appsCache) {
-    if (![self.appsCache[appPid] running]) {
-      [terminatedAppIds addObject:appPid];
+  @synchronized (self) {
+    NSMutableSet *terminatedAppIds = [NSMutableSet set];
+    for (NSNumber *appPid in self.appsCache) {
+      if (![self.appsCache[appPid] running]) {
+        [terminatedAppIds addObject:appPid];
+      }
+    }
+    for (NSNumber *appPid in terminatedAppIds) {
+      [self.appsCache removeObjectForKey:appPid];
     }
-  }
-  for (NSNumber *appPid in terminatedAppIds) {
-    [self.appsCache removeObjectForKey:appPid];
-  }
 
-  XCUIApplication *result = [self.appsCache objectForKey:@(pid)];
-  if (nil != result) {
-    return result;
-  }
+    XCUIApplication *result = [self.appsCache objectForKey:@(pid)];
+    if (nil != result) {
+      return result;
+    }
 
-  XCUIApplication *app = [[FBAXClient applicationProcessTracker]
-                          monitoredApplicationWithProcessIdentifier:pid];
-  if (nil == app) {
-    return nil;
+    XCUIApplication *app = [[FBAXClient applicationProcessTracker]
+                            monitoredApplicationWithProcessIdentifier:pid];
+    if (nil == app) {
+      return nil;
+    }
+    [self.appsCache setObject:app forKey:@(pid)];
+    return app;
   }
-  [self.appsCache setObject:app forKey:@(pid)];
-  return app;
 }
 
 @end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Utilities/FBXCTestDaemonsProxy.h

@@ -16,12 +16,12 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-@protocol XCTestManager_ManagerInterface;
+@protocol XCTMessagingChannel_RunnerToDaemon;
 @class FBScreenRecordingRequest, FBScreenRecordingPromise;
 
 @interface FBXCTestDaemonsProxy : NSObject
 
-+ (id<XCTestManager_ManagerInterface>)testRunnerProxy;
++ (id<XCTMessagingChannel_RunnerToDaemon>)testRunnerProxy;
 
 + (BOOL)synthesizeEventWithRecord:(XCSynthesizedEventRecord *)record
                             error:(NSError *__autoreleasing*)error;