ui/base/test/cocoa_helper.mm

// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#import "ui/base/test/cocoa_helper.h"

#include <objc/message.h>
#include <objc/runtime.h>

#include <set>
#include <vector>

#include "base/debug/debugger.h"
#include "base/logging.h"
#include "base/stl_util.h"
#include "base/strings/sys_string_conversions.h"
#include "base/test/mock_chrome_application_mac.h"
#include "base/test/test_timeouts.h"

@implementation CocoaTestHelperWindow

@synthesize pretendIsKeyWindow = _pretendIsKeyWindow;
@synthesize pretendIsOnActiveSpace = _pretendIsOnActiveSpace;
@synthesize pretendFullKeyboardAccessIsEnabled =
    _pretendFullKeyboardAccessIsEnabled;
@synthesize useDefaultConstraints = _useDefaultConstraints;

- (instancetype)initWithContentRect:(NSRect)contentRect {
  self = [super initWithContentRect:contentRect
                          styleMask:NSWindowStyleMaskBorderless
                            backing:NSBackingStoreBuffered
                              defer:NO];
  if (self) {
    _useDefaultConstraints = YES;
    _pretendIsOnActiveSpace = YES;
    self.releasedWhenClosed = NO;
  }
  return self;
}

- (instancetype)init {
  return [self initWithContentRect:NSMakeRect(0, 0, 800, 600)];
}

// Enables users to write debugging code to help diagnose failures to close
// CocoaTestHelperWindow. Debugging code is not usually committed in Chromium,
// but because it's difficult to correctly override retain/release in ARC, this
// is left in.
#if 0

+ (void)initialize {
  if (self == [CocoaTestHelperWindow self]) {
    Class test_class = [CocoaTestHelperWindow class];

    Method method = class_getInstanceMethod(test_class, @selector(debugRetain));
    ASSERT_TRUE(method);
    ASSERT_TRUE(class_addMethod(test_class, sel_registerName("retain"),
                                method_getImplementation(method),
                                method_getTypeEncoding(method)));

    method = class_getInstanceMethod(test_class, @selector(debugRelease));
    ASSERT_TRUE(method);
    ASSERT_TRUE(class_addMethod(test_class, sel_registerName("release"),
                                method_getImplementation(method),
                                method_getTypeEncoding(method)));
  }
}

- (void)dealloc {
  // Insert debugging code here.
}

- (instancetype)debugRetain {
  // Insert debugging code here.

  struct objc_super mySuper = {.receiver = self,
                               .super_class = [self superclass]};
  using retainSendSuper = id (*)(struct objc_super*, SEL);
  retainSendSuper sendSuper =
      reinterpret_cast<retainSendSuper>(objc_msgSendSuper);
  return sendSuper(&mySuper, _cmd);
}

- (oneway void)debugRelease {
  // Insert debugging code here.

  struct objc_super mySuper = {.receiver = self,
                               .super_class = [self superclass]};
  using releaseSendSuper = void (*)(struct objc_super*, SEL);
  releaseSendSuper sendSuper =
      reinterpret_cast<releaseSendSuper>(objc_msgSendSuper);
  return sendSuper(&mySuper, _cmd);
}

#endif

- (BOOL)isKeyWindow {
  return _pretendIsKeyWindow;
}

- (BOOL)isOnActiveSpace {
  return _pretendIsOnActiveSpace;
}

- (void)makePretendKeyWindowAndSetFirstResponder:(NSResponder*)responder {
  EXPECT_TRUE([self makeFirstResponder:responder]);
  self.pretendIsKeyWindow = YES;
}

- (void)clearPretendKeyWindowAndFirstResponder {
  self.pretendIsKeyWindow = NO;
  EXPECT_TRUE([self makeFirstResponder:NSApp]);
}

- (void)setPretendIsOnActiveSpace:(BOOL)pretendIsOnActiveSpace {
  _pretendIsOnActiveSpace = pretendIsOnActiveSpace;
  [NSWorkspace.sharedWorkspace.notificationCenter
      postNotificationName:NSWorkspaceActiveSpaceDidChangeNotification
                    object:NSWorkspace.sharedWorkspace];
}

- (void)setPretendFullKeyboardAccessIsEnabled:(BOOL)enabled {
  EXPECT_TRUE([NSWindow
      instancesRespondToSelector:@selector(_allowsAnyValidResponder)]);
  _pretendFullKeyboardAccessIsEnabled = enabled;
  [self recalculateKeyViewLoop];
}

// Override of an undocumented AppKit method which controls call to check if
// full keyboard access is enabled. Its presence is verified in
// -setPretendFullKeyboardAccessIsEnabled:.
- (BOOL)_allowsAnyValidResponder {
  return _pretendFullKeyboardAccessIsEnabled;
}

- (NSArray<NSView*>*)validKeyViews {
  NSMutableArray<NSView*>* validKeyViews = [NSMutableArray array];
  NSView* contentView = self.contentView;
  if (contentView.canBecomeKeyView) {
    [validKeyViews addObject:contentView];
  }
  for (NSView* keyView = contentView.nextValidKeyView;
       keyView != nil && ![validKeyViews containsObject:keyView];
       keyView = keyView.nextValidKeyView) {
    [validKeyViews addObject:keyView];
  }
  return validKeyViews;
}

- (NSRect)constrainFrameRect:(NSRect)frameRect toScreen:(NSScreen*)screen {
  if (!_useDefaultConstraints) {
    return frameRect;
  }

  return [super constrainFrameRect:frameRect toScreen:screen];
}

@end

namespace ui {

CocoaTestHelper::CocoaTestHelper() {
  // If a test suite hasn't already initialized NSApp, register the mock one
  // now.
  if (!NSApp) {
    mock_cr_app::RegisterMockCrApp();
  }

  // Set the duration of AppKit-evaluated animations (such as frame changes)
  // to zero for testing purposes. That way they take effect immediately.
  NSAnimationContext.currentContext.duration = 0.0;

  // The above does not affect window-resize time, such as for an
  // attached sheet dropping in.  Set that duration for the current
  // process (this is not persisted).  Empirically, the value of 0.0
  // is ignored.
  NSDictionary* dict = @{@"NSWindowResizeTime" : @"0.01"};
  [NSUserDefaults.standardUserDefaults registerDefaults:dict];

  MarkCurrentWindowsAsInitial();
}

CocoaTestHelper::~CocoaTestHelper() {
  // Call close on the test_window to clean it up if one was opened.
  [test_window_ clearPretendKeyWindowAndFirstResponder];
  [test_window_ close];
  test_window_ = nil;

  // Recycle the pool to clean up any stuff that was put on the
  // autorelease pool due to window or window controller closures.
  pool_.Recycle();

  // Some controls (NSTextFields, NSComboboxes etc) use
  // performSelector:withDelay: to clean up drag handlers and other
  // things (Radar 5851458 "Closing a window with a NSTextView in it
  // should get rid of it immediately").  The event loop must be spun
  // to get everything cleaned up correctly.  It normally only takes
  // one to two spins through the event loop to see a change.

  // NOTE(shess): Under valgrind, -nextEventMatchingMask:* in one test
  // needed to run twice, once taking .2 seconds, the next time .6
  // seconds.  The loop exit condition attempts to be scalable.

  // Get the set of windows which weren't present when the test
  // started.
  WeakWindowVector windows_left = WindowsLeft();

  while (!windows_left.empty()) {
    // Cover delayed actions by spinning the loop at least once after
    // this timeout.
    const NSTimeInterval kCloseTimeoutSeconds =
        TestTimeouts::action_timeout().InSecondsF();

    // Cover chains of delayed actions by spinning the loop at least
    // this many times.
    const int kCloseSpins = 3;

    // Track the set of remaining windows so that everything can be
    // reset if progress is made.
    WeakWindowVector still_left = windows_left;

    NSDate* start_date = [NSDate date];
    bool one_more_time = true;
    int spins = 0;
    while (still_left.size() == windows_left.size() &&
           (spins < kCloseSpins || one_more_time)) {
      // Check the timeout before pumping events, so that we'll spin
      // the loop once after the timeout.
      one_more_time = start_date.timeIntervalSinceNow > -kCloseTimeoutSeconds;

      // Autorelease anything thrown up by the event loop.
      @autoreleasepool {
        ++spins;
        NSEvent* next_event = [NSApp nextEventMatchingMask:NSEventMaskAny
                                                 untilDate:nil
                                                    inMode:NSDefaultRunLoopMode
                                                   dequeue:YES];
        [NSApp sendEvent:next_event];
        [NSApp updateWindows];
      }

      // Refresh the outstanding windows.
      still_left = WindowsLeft();
    }

    // If no progress is being made, log a failure and continue.
    if (still_left.size() == windows_left.size()) {
      // NOTE(shess): Failing this expectation means that the test
      // opened windows which have not been fully released.  Either
      // there is a leak, or perhaps one of |kCloseTimeoutSeconds| or
      // |kCloseSpins| needs adjustment.
      EXPECT_EQ(0U, windows_left.size());
      for (NSWindow* __weak window : windows_left) {
        LOG(WARNING) << "Didn't close window "
                     << base::SysNSStringToUTF8(window.description);
      }
      break;
    }

    windows_left = still_left;
  }
}

void CocoaTestHelper::MarkCurrentWindowsAsInitial() {
  // Collect the list of windows that were open when the test started so
  // that we don't wait for them to close in TearDown. Has to be done
  // after BootstrapCocoa is called.
  initial_windows_ = ApplicationWindows();
}

CocoaTestHelperWindow* CocoaTestHelper::test_window() {
  if (!test_window_) {
    test_window_ = [[CocoaTestHelperWindow alloc] init];
    if (base::debug::BeingDebugged()) {
      [test_window_ orderFront:nil];
    } else {
      [test_window_ orderBack:nil];
    }
  }
  return test_window_;
}

// Returns a vector of currently open windows.
CocoaTestHelper::WeakWindowVector CocoaTestHelper::ApplicationWindows() {
  WeakWindowVector windows;

  // Must create a pool here because [NSApp windows] has created an array which
  // retains all the windows in it.
  @autoreleasepool {
    for (NSWindow* window in NSApp.windows) {
      windows.push_back(window);
    }
    return windows;
  }
}

CocoaTestHelper::WeakWindowVector CocoaTestHelper::WindowsLeft() {
  // Window pointers can go nil only when the run loop is going, so it's safe to
  // use sets within this function, just not outside it.
  using WeakWindowSet = std::set<NSWindow * __weak>;

  WeakWindowVector windows = ApplicationWindows();
  WeakWindowSet windows_set(windows.begin(), windows.end());

  // Ignore TextInputUIMacHelper.framework created TUINSWindow. We have no
  // control or documentation about these windows, ignoring them seems like the
  // best approach.
  std::erase_if(windows_set, [](NSWindow* __weak set_window) {
    return [set_window isKindOfClass:NSClassFromString(@"TUINSWindow")];
  });

  // Subtract away the initial windows. The current window set will not have any
  // nil values, as it was just obtained, so subtracting away the nil from any
  // initial windows that have been closed is safe.
  WeakWindowSet initial_windows_set(initial_windows_.begin(),
                                    initial_windows_.end());

  WeakWindowSet windows_left_set =
      base::STLSetDifference<WeakWindowSet>(windows_set, initial_windows_set);
  return std::vector(windows_left_set.begin(), windows_left_set.end());
}

CocoaTest::CocoaTest() : helper_(std::make_unique<CocoaTestHelper>()) {}
CocoaTest::~CocoaTest() {
  CHECK(!helper_);
}

void CocoaTest::TearDown() {
  helper_.reset();
  PlatformTest::TearDown();
}

void CocoaTest::MarkCurrentWindowsAsInitial() {
  helper_->MarkCurrentWindowsAsInitial();
}

}  // namespace ui