TestCocoaFilePickerQueue.mm

firefox-main/widget/tests/gtest/TestCocoaFilePickerQueue.mm (file symbol)

Enable keyboard shortcuts

Source code

File a bug in Core :: Widget

Revision control

Copy as Markdown

Other Tools

HG Web

/* Any copyright is dedicated to the Public Domain.

 * https://creativecommons.org/publicdomain/zero/1.0/ */

#import <Cocoa/Cocoa.h>

#import <objc/runtime.h>

#include "gfxPlatform.h"

#include "gtest/gtest.h"

#include "mozilla/Preferences.h"

#include "mozilla/RefPtr.h"

#include "mozilla/ScopeExit.h"

#include "mozilla/SpinEventLoopUntil.h"

#include "mozilla/dom/BrowsingContext.h"

#include "nsCocoaWindow.h"

#include "nsDirectoryServiceDefs.h"

#include "nsDirectoryServiceUtils.h"

#include "nsFilePicker.h"

#include "nsIFile.h"

#include "nsITimer.h"

#include "nsThreadUtils.h"

using namespace mozilla;

using namespace mozilla::dom;

using namespace mozilla::widget;

namespace {

NSMutableArray* sPresentedPanels;

class PickerCallback final : public nsIFilePickerShownCallback {

 public:

  NS_DECL_ISUPPORTS

  NS_IMETHOD Done(nsIFilePicker::ResultCode aResult) override {

    ++mCalls;

    mResult = aResult;

    if (mOnDone) {

      nsCOMPtr<nsIRunnable> onDone = mOnDone.forget();

      onDone->Run();

    return NS_OK;

  nsCOMPtr<nsIRunnable> mOnDone;

  uint32_t mCalls = 0;

  nsIFilePicker::ResultCode mResult = nsIFilePicker::returnCancel;

 private:

  ~PickerCallback() = default;

};

NS_IMPL_ISUPPORTS(PickerCallback, nsIFilePickerShownCallback)

}  // namespace

@interface MOZTestFilePickerPanel : NSSavePanel

@end

@implementation MOZTestFilePickerPanel

- (void)beginSheetModalForWindow:(NSWindow*)aWindow

               completionHandler:(void (^)(NSModalResponse))aHandler {

  [self beginWithCompletionHandler:aHandler];

- (void)beginWithCompletionHandler:(void (^)(NSModalResponse))aHandler {

  [sPresentedPanels addObject:@{

    @"panel" : self,

    @"handler" : [[aHandler copy] autorelease],

}];

- (NSURL*)URL {

  return [NSURL

      fileURLWithPath:[@"/tmp/"

                          stringByAppendingString:self.nameFieldStringValue]];

@end

namespace {

id CreatePanel(id, SEL) {

  return [[[MOZTestFilePickerPanel alloc] init] autorelease];

}  // namespace

class FilePickerTest : public testing::Test {

 protected:

  void SetUp() override {

    mAutoreleasePool = [[NSAutoreleasePool alloc] init];

    sPresentedPanels = [[NSMutableArray alloc] init];

    mFactoryMethod =

        class_getClassMethod([NSSavePanel class], @selector(savePanel));

    ASSERT_NE(mFactoryMethod, nullptr);

    mFactoryIMP = method_setImplementation(mFactoryMethod, (IMP)CreatePanel);

  void TearDown() override {

    while (sPresentedPanels.count) {

      Complete(0, NSModalResponseCancel);

    RestorePanelFactory();

    [sPresentedPanels release];

    sPresentedPanels = nil;

    [mAutoreleasePool drain];

  void RestorePanelFactory() {

    if (mFactoryIMP) {

      method_setImplementation(mFactoryMethod, mFactoryIMP);

      mFactoryIMP = nullptr;

  static NSSavePanel* NativePanel() {

    for (NSWindow* window in NSApp.windows) {

      if ([window isKindOfClass:[NSSavePanel class]] && window.visible) {

        NSSavePanel* panel = (NSSavePanel*)window;

        if ([panel.nameFieldStringValue

                hasPrefix:@"native-file-picker-queue-"]) {

          return panel;

    return nil;

  static RefPtr<nsCocoaWindow> CreateWindow() {

    RefPtr<nsCocoaWindow> window = MakeRefPtr<nsCocoaWindow>();

    InitData initData;

    if (NS_FAILED(window->Create(nullptr, DesktopIntRect(0, 0, 300, 300),

                                 initData))) {

      return nullptr;

    return window;

  static RefPtr<nsFilePicker> CreatePicker(nsIWidget* aParent,

                                           const nsAString& aFilename) {

    RefPtr<nsFilePicker> picker = MakeRefPtr<nsFilePicker>();

    picker->mParentWidget = aParent;

    picker->mMode = nsIFilePicker::modeSave;

    picker->mDefaultFilename = aFilename;

    picker->mBrowsingContext = BrowsingContext::CreateDetached(

        nullptr, nullptr, nullptr, EmptyString(), BrowsingContext::Type::Chrome,

        {});

    return picker;

  MOZ_CAN_RUN_SCRIPT_BOUNDARY static nsresult Open(

      nsFilePicker* aPicker, nsIFilePickerShownCallback* aCallback) {

    RefPtr<nsFilePicker> picker = aPicker;

    nsCOMPtr<nsIFilePickerShownCallback> callback = aCallback;

    return picker->Open(callback);

  static void ProcessEvents() { NS_ProcessPendingEvents(nullptr); }

  static void Complete(NSUInteger aIndex, NSModalResponse aResult) {

    NSDictionary* info = [sPresentedPanels objectAtIndex:aIndex];

    [info retain];

    [sPresentedPanels removeObjectAtIndex:aIndex];

    void (^handler)(NSModalResponse) = [info objectForKey:@"handler"];

    handler(aResult);

    [info release];

    ProcessEvents();

  static NSString* PresentedName(NSUInteger aIndex = 0) {

    NSSavePanel* panel =

        [[sPresentedPanels objectAtIndex:aIndex] objectForKey:@"panel"];

    return panel.nameFieldStringValue;

 private:

  NSAutoreleasePool* mAutoreleasePool = nil;

  Method mFactoryMethod = nullptr;

  IMP mFactoryIMP = nullptr;

};

TEST_F(FilePickerTest, QueuesConcurrentSaveRequests) {

  RefPtr<nsCocoaWindow> window = CreateWindow();

  ASSERT_NE(window, nullptr);

  RefPtr<nsFilePicker> first =

      CreatePicker(window, u"file-picker-queue-first.txt"_ns);

  RefPtr<nsFilePicker> second =

      CreatePicker(window, u"file-picker-queue-second.txt"_ns);

  RefPtr<nsFilePicker> third =

      CreatePicker(window, u"file-picker-queue-third.txt"_ns);

  RefPtr<PickerCallback> firstCallback = MakeRefPtr<PickerCallback>();

  RefPtr<PickerCallback> secondCallback = MakeRefPtr<PickerCallback>();

  RefPtr<PickerCallback> thirdCallback = MakeRefPtr<PickerCallback>();

  ASSERT_EQ(NS_OK, Open(first, firstCallback));

  ASSERT_EQ(NS_OK, Open(second, secondCallback));

  ASSERT_EQ(NS_OK, Open(third, thirdCallback));

  ProcessEvents();

  ASSERT_EQ(1u, sPresentedPanels.count);

  EXPECT_TRUE([PresentedName() isEqualToString:@"file-picker-queue-first.txt"]);

  EXPECT_EQ(0u, firstCallback->mCalls);

  EXPECT_EQ(0u, secondCallback->mCalls);

  EXPECT_EQ(0u, thirdCallback->mCalls);

  Complete(0, NSModalResponseOK);

  ASSERT_EQ(1u, sPresentedPanels.count);

  EXPECT_EQ(1u, firstCallback->mCalls);

  EXPECT_EQ(nsIFilePicker::returnOK, firstCallback->mResult);

  EXPECT_TRUE(

      [PresentedName() isEqualToString:@"file-picker-queue-second.txt"]);

  nsCOMPtr<nsIFile> file;

  ASSERT_EQ(NS_OK, first->GetFile(getter_AddRefs(file)));

  ASSERT_NE(file, nullptr);

  nsAutoString leafName;

  ASSERT_EQ(NS_OK, file->GetLeafName(leafName));

  EXPECT_EQ(u"file-picker-queue-first.txt"_ns, leafName);

  Complete(0, NSModalResponseCancel);

  ASSERT_EQ(1u, sPresentedPanels.count);

  EXPECT_EQ(1u, secondCallback->mCalls);

  EXPECT_EQ(nsIFilePicker::returnCancel, secondCallback->mResult);

  EXPECT_TRUE([PresentedName() isEqualToString:@"file-picker-queue-third.txt"]);

  Complete(0, NSModalResponseOK);

  EXPECT_EQ(0u, sPresentedPanels.count);

  EXPECT_EQ(1u, firstCallback->mCalls);

  EXPECT_EQ(1u, secondCallback->mCalls);

  EXPECT_EQ(1u, thirdCallback->mCalls);

  EXPECT_EQ(nsIFilePicker::returnOK, thirdCallback->mResult);

  window->Destroy();

TEST_F(FilePickerTest, SeparateWindowsRemainIndependent) {

  RefPtr<nsCocoaWindow> firstWindow = CreateWindow();

  RefPtr<nsCocoaWindow> secondWindow = CreateWindow();

  ASSERT_NE(firstWindow, nullptr);

  ASSERT_NE(secondWindow, nullptr);

  RefPtr<nsFilePicker> first = CreatePicker(firstWindow, u"first.txt"_ns);

  RefPtr<nsFilePicker> second = CreatePicker(firstWindow, u"second.txt"_ns);

  RefPtr<nsFilePicker> other = CreatePicker(secondWindow, u"other.txt"_ns);

  RefPtr<PickerCallback> firstCallback = MakeRefPtr<PickerCallback>();

  RefPtr<PickerCallback> secondCallback = MakeRefPtr<PickerCallback>();

  RefPtr<PickerCallback> otherCallback = MakeRefPtr<PickerCallback>();

  ASSERT_EQ(NS_OK, Open(first, firstCallback));

  ASSERT_EQ(NS_OK, Open(second, secondCallback));

  ASSERT_EQ(NS_OK, Open(other, otherCallback));

  ProcessEvents();

  ASSERT_EQ(2u, sPresentedPanels.count);

  EXPECT_TRUE([PresentedName(0) isEqualToString:@"first.txt"]);

  EXPECT_TRUE([PresentedName(1) isEqualToString:@"other.txt"]);

  Complete(1, NSModalResponseCancel);

  EXPECT_EQ(1u, otherCallback->mCalls);

  EXPECT_EQ(0u, firstCallback->mCalls);

  EXPECT_EQ(0u, secondCallback->mCalls);

  Complete(0, NSModalResponseCancel);

  ASSERT_EQ(1u, sPresentedPanels.count);

  EXPECT_TRUE([PresentedName() isEqualToString:@"second.txt"]);

  Complete(0, NSModalResponseCancel);

  EXPECT_EQ(1u, firstCallback->mCalls);

  EXPECT_EQ(1u, secondCallback->mCalls);

  firstWindow->Destroy();

  secondWindow->Destroy();

TEST_F(FilePickerTest, KeepsQueueWhenNativeWindowIsRecreated) {

  RefPtr<nsCocoaWindow> window = CreateWindow();

  ASSERT_NE(window, nullptr);

  RefPtr<nsFilePicker> first = CreatePicker(window, u"first.txt"_ns);

  RefPtr<nsFilePicker> second = CreatePicker(window, u"second.txt"_ns);

  RefPtr<nsFilePicker> third = CreatePicker(window, u"third.txt"_ns);

  RefPtr<PickerCallback> firstCallback = MakeRefPtr<PickerCallback>();

  RefPtr<PickerCallback> secondCallback = MakeRefPtr<PickerCallback>();

  RefPtr<PickerCallback> thirdCallback = MakeRefPtr<PickerCallback>();

  ASSERT_EQ(NS_OK, Open(first, firstCallback));

  ASSERT_EQ(NS_OK, Open(second, secondCallback));

  ProcessEvents();

  ASSERT_EQ(1u, sPresentedPanels.count);

  NSWindow* originalWindow =

      static_cast<NSWindow*>(window->GetNativeData(NS_NATIVE_WINDOW));

  [originalWindow retain];

  auto releaseWindow =

      MakeScopeExit([originalWindow]() { [originalWindow release]; });

  window->HideWindowChrome(true);

  ASSERT_NE(originalWindow, window->GetNativeData(NS_NATIVE_WINDOW));

  ASSERT_FALSE(window->Destroyed());

  ASSERT_EQ(NS_OK, Open(third, thirdCallback));

  Complete(0, NSModalResponseCancel);

  ASSERT_EQ(1u, sPresentedPanels.count);

  EXPECT_TRUE([PresentedName() isEqualToString:@"second.txt"]);

  EXPECT_EQ(1u, firstCallback->mCalls);

  EXPECT_EQ(0u, secondCallback->mCalls);

  EXPECT_EQ(0u, thirdCallback->mCalls);

  Complete(0, NSModalResponseCancel);

  ASSERT_EQ(1u, sPresentedPanels.count);

  EXPECT_TRUE([PresentedName() isEqualToString:@"third.txt"]);

  Complete(0, NSModalResponseCancel);

  EXPECT_EQ(0u, sPresentedPanels.count);

  EXPECT_EQ(1u, firstCallback->mCalls);

  EXPECT_EQ(1u, secondCallback->mCalls);

  EXPECT_EQ(1u, thirdCallback->mCalls);

  window->Destroy();

TEST_F(FilePickerTest, CancelsQueuedRequestsAfterParentIsDestroyed) {

  RefPtr<nsCocoaWindow> window = CreateWindow();

  ASSERT_NE(window, nullptr);

  RefPtr<nsFilePicker> first = CreatePicker(window, u"first.txt"_ns);

  RefPtr<nsFilePicker> second = CreatePicker(window, u"second.txt"_ns);

  RefPtr<PickerCallback> firstCallback = MakeRefPtr<PickerCallback>();

  RefPtr<PickerCallback> secondCallback = MakeRefPtr<PickerCallback>();

  ASSERT_EQ(NS_OK, Open(first, firstCallback));

  ASSERT_EQ(NS_OK, Open(second, secondCallback));

  ProcessEvents();

  ASSERT_EQ(1u, sPresentedPanels.count);

  window->Destroy();

  Complete(0, NSModalResponseCancel);

  EXPECT_EQ(0u, sPresentedPanels.count);

  EXPECT_EQ(1u, firstCallback->mCalls);

  EXPECT_EQ(1u, secondCallback->mCalls);

  EXPECT_EQ(nsIFilePicker::returnCancel, secondCallback->mResult);

TEST_F(FilePickerTest, CancelsQueuedRequestsWhenPickersAreDisabled) {

  RefPtr<nsCocoaWindow> window = CreateWindow();

  ASSERT_NE(window, nullptr);

  RefPtr<nsFilePicker> first = CreatePicker(window, u"first.txt"_ns);

  RefPtr<nsFilePicker> second = CreatePicker(window, u"second.txt"_ns);

  RefPtr<PickerCallback> firstCallback = MakeRefPtr<PickerCallback>();

  RefPtr<PickerCallback> secondCallback = MakeRefPtr<PickerCallback>();

  ASSERT_EQ(NS_OK, Open(first, firstCallback));

  ASSERT_EQ(NS_OK, Open(second, secondCallback));

  ProcessEvents();

  ASSERT_EQ(1u, sPresentedPanels.count);

  const char* prefName = "widget.disable_file_pickers";

  const bool hasUserValue = Preferences::HasUserValue(prefName);

  const bool isDisabled = Preferences::GetBool(prefName);

  auto restorePref = MakeScopeExit([prefName, hasUserValue, isDisabled]() {

    if (hasUserValue) {

      Preferences::SetBool(prefName, isDisabled);

    } else {

      Preferences::ClearUser(prefName);

});

  ASSERT_EQ(NS_OK, Preferences::SetBool(prefName, true));

  Complete(0, NSModalResponseCancel);

  EXPECT_EQ(0u, sPresentedPanels.count);

  EXPECT_EQ(1u, firstCallback->mCalls);

  EXPECT_EQ(1u, secondCallback->mCalls);

  EXPECT_EQ(nsIFilePicker::returnCancel, secondCallback->mResult);

  window->Destroy();

TEST_F(FilePickerTest, SerializesPickersWithoutParentWindows) {

  RefPtr<nsFilePicker> first = CreatePicker(nullptr, u"first.txt"_ns);

  RefPtr<nsFilePicker> second = CreatePicker(nullptr, u"second.txt"_ns);

  RefPtr<PickerCallback> firstCallback = MakeRefPtr<PickerCallback>();

  RefPtr<PickerCallback> secondCallback = MakeRefPtr<PickerCallback>();

  ASSERT_EQ(NS_OK, Open(first, firstCallback));

  ASSERT_EQ(NS_OK, Open(second, secondCallback));

  ProcessEvents();

  ASSERT_EQ(1u, sPresentedPanels.count);

  Complete(0, NSModalResponseCancel);

  ASSERT_EQ(1u, sPresentedPanels.count);

  Complete(0, NSModalResponseCancel);

  EXPECT_EQ(1u, firstCallback->mCalls);

  EXPECT_EQ(1u, secondCallback->mCalls);

  EXPECT_EQ(0u, sPresentedPanels.count);

TEST_F(FilePickerTest, CallbackRequestsStayBehindQueuedRequests) {

  RefPtr<nsCocoaWindow> window = CreateWindow();

  ASSERT_NE(window, nullptr);

  RefPtr<nsFilePicker> first = CreatePicker(window, u"first.txt"_ns);

  RefPtr<nsFilePicker> second = CreatePicker(window, u"second.txt"_ns);

  RefPtr<nsFilePicker> third = CreatePicker(window, u"third.txt"_ns);

  RefPtr<PickerCallback> firstCallback = MakeRefPtr<PickerCallback>();

  RefPtr<PickerCallback> secondCallback = MakeRefPtr<PickerCallback>();

  RefPtr<PickerCallback> thirdCallback = MakeRefPtr<PickerCallback>();

  firstCallback->mOnDone = NS_NewRunnableFunction(

      "OpenPickerFromCallback", [third, thirdCallback]() {

        EXPECT_EQ(NS_OK, Open(third, thirdCallback));

});

  ASSERT_EQ(NS_OK, Open(first, firstCallback));

  ASSERT_EQ(NS_OK, Open(second, secondCallback));

  ProcessEvents();

  ASSERT_EQ(1u, sPresentedPanels.count);

  Complete(0, NSModalResponseCancel);

  ASSERT_EQ(1u, sPresentedPanels.count);

  EXPECT_TRUE([PresentedName() isEqualToString:@"second.txt"]);

  Complete(0, NSModalResponseCancel);

  ASSERT_EQ(1u, sPresentedPanels.count);

  EXPECT_TRUE([PresentedName() isEqualToString:@"third.txt"]);

  Complete(0, NSModalResponseCancel);

  EXPECT_EQ(1u, firstCallback->mCalls);

  EXPECT_EQ(1u, secondCallback->mCalls);

  EXPECT_EQ(1u, thirdCallback->mCalls);

  EXPECT_EQ(0u, sPresentedPanels.count);

  window->Destroy();

TEST_F(FilePickerTest, AdvancesWithoutCallerCallback) {

  RefPtr<nsCocoaWindow> window = CreateWindow();

  ASSERT_NE(window, nullptr);

  RefPtr<nsFilePicker> first = CreatePicker(window, u"first.txt"_ns);

  RefPtr<nsFilePicker> second = CreatePicker(window, u"second.txt"_ns);

  RefPtr<PickerCallback> callback = MakeRefPtr<PickerCallback>();

  ASSERT_EQ(NS_OK, Open(first, nullptr));

  ASSERT_EQ(NS_OK, Open(second, callback));

  ProcessEvents();

  ASSERT_EQ(1u, sPresentedPanels.count);

  Complete(0, NSModalResponseCancel);

  ASSERT_EQ(1u, sPresentedPanels.count);

  EXPECT_TRUE([PresentedName() isEqualToString:@"second.txt"]);

  Complete(0, NSModalResponseCancel);

  EXPECT_EQ(1u, callback->mCalls);

  EXPECT_EQ(0u, sPresentedPanels.count);

  window->Destroy();

TEST_F(FilePickerTest, QueuesRealSavePanels) {

  gfxPlatform::GetPlatform();

  RestorePanelFactory();

  RefPtr<nsCocoaWindow> window = CreateWindow();

  ASSERT_NE(window, nullptr);

  RefPtr<nsFilePicker> pickers[3];

  RefPtr<PickerCallback> callbacks[3];

  nsTArray<uint32_t> completed;

  auto destroyWindow = MakeScopeExit([&]() {

    for (const auto& callback : callbacks) {

      if (callback) {

        callback->mOnDone = nullptr;

    window->Destroy();

    if (NSSavePanel* panel = NativePanel()) {

      [panel cancel:panel];

      ProcessEvents();

    ProcessEvents();

});

  window->Show(/* aState = */ true);

  nsCOMPtr<nsIFile> directory;

  ASSERT_EQ(NS_OK,

            NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(directory)));

  const char* filenames[] = {"native-file-picker-queue-first.txt",

                             "native-file-picker-queue-second.txt",

                             "native-file-picker-queue-third.txt"};

  for (uint32_t i = 0; i < 3; ++i) {

    pickers[i] = CreatePicker(window, NS_ConvertASCIItoUTF16(filenames[i]));

    ASSERT_EQ(NS_OK, pickers[i]->SetDisplayDirectory(directory));

    callbacks[i] = MakeRefPtr<PickerCallback>();

    callbacks[i]->mOnDone =

        NS_NewRunnableFunction("RecordNativePickerCompletion",

                               [&, i]() { completed.AppendElement(i); });

    ASSERT_EQ(NS_OK, Open(pickers[i], callbacks[i]));

  // Bound a missing panel or callback without delaying successful runs.

  bool hasTimedOut = false;

  nsCOMPtr<nsITimer> timer;

  ASSERT_EQ(NS_OK,

            NS_NewTimerWithCallback(

                getter_AddRefs(timer), [&](nsITimer*) { hasTimedOut = true; },

                60000, nsITimer::TYPE_ONE_SHOT, "NativeFilePickerTimeout"_ns));

  auto cancelTimer = MakeScopeExit([&]() { timer->Cancel(); });

  for (uint32_t i = 0; i < 3; ++i) {

    ASSERT_TRUE(SpinEventLoopUntil("WaitForNativeFilePicker"_ns, [&]() {

      NSSavePanel* panel = NativePanel();

      return hasTimedOut ||

             (panel &&

              [panel.nameFieldStringValue

                  isEqualToString:[NSString

                                      stringWithUTF8String:filenames[i]]]);

    }));

    ASSERT_FALSE(hasTimedOut)

    << "Missing native panel " << filenames[i];

    ASSERT_EQ(i, completed.Length());

    NSSavePanel* panel = NativePanel();

    ASSERT_NE(panel, nil);

    [panel cancel:panel];

    ASSERT_TRUE(SpinEventLoopUntil("WaitForNativeFilePickerCallback"_ns, [&]() {

      return hasTimedOut || callbacks[i]->mCalls;

    }));

    ASSERT_FALSE(hasTimedOut)

    << "Missing callback for " << filenames[i];

    ASSERT_EQ(i + 1, completed.Length());

    EXPECT_EQ(i, completed[i]);

    EXPECT_EQ(nsIFilePicker::returnCancel, callbacks[i]->mResult);

  ProcessEvents();

  for (const auto& callback : callbacks) {

    EXPECT_EQ(1u, callback->mCalls);

  ASSERT_TRUE(SpinEventLoopUntil("WaitForNativeFilePickerToClose"_ns, [&]() {

    return hasTimedOut || !NativePanel();

  }));

  EXPECT_FALSE(hasTimedOut);