From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- toolkit/xre/MacApplicationDelegate.mm | 399 ++++++++++++++++++++++++++++++++++ 1 file changed, 399 insertions(+) create mode 100644 toolkit/xre/MacApplicationDelegate.mm (limited to 'toolkit/xre/MacApplicationDelegate.mm') diff --git a/toolkit/xre/MacApplicationDelegate.mm b/toolkit/xre/MacApplicationDelegate.mm new file mode 100644 index 0000000000..ca99497624 --- /dev/null +++ b/toolkit/xre/MacApplicationDelegate.mm @@ -0,0 +1,399 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +// NSApplication delegate for Mac OS X Cocoa API. + +// As of 10.4 Tiger, the system can send six kinds of Apple Events to an +// application; a well-behaved XUL app should have some kind of handling for all +// of them. +// +// See +// http://developer.apple.com/documentation/Cocoa/Conceptual/ScriptableCocoaApplications/SApps_handle_AEs/chapter_11_section_3.html +// for details. + +#include +#import +#include "NativeMenuMac.h" +#import + +#include "CustomCocoaEvents.h" +#include "gfxPlatform.h" +#include "nsCOMPtr.h" +#include "nsINativeAppSupport.h" +#include "nsAppRunner.h" +#include "nsAppShell.h" +#include "nsComponentManagerUtils.h" +#include "nsServiceManagerUtils.h" +#include "nsIAppStartup.h" +#include "nsIObserverService.h" +#include "nsISupportsPrimitives.h" +#include "nsObjCExceptions.h" +#include "nsIFile.h" +#include "nsDirectoryServiceDefs.h" +#include "nsCommandLine.h" +#include "nsIMacDockSupport.h" +#include "nsIStandaloneNativeMenu.h" +#include "nsILocalFileMac.h" +#include "nsString.h" +#include "nsCommandLineServiceMac.h" +#include "nsCommandLine.h" +#include "nsStandaloneNativeMenu.h" +#include "nsCocoaUtils.h" +#include "nsMenuBarX.h" +#include "mozilla/NeverDestroyed.h" + +class AutoAutoreleasePool { + public: + AutoAutoreleasePool() { mLocalPool = [[NSAutoreleasePool alloc] init]; } + ~AutoAutoreleasePool() { [mLocalPool release]; } + + private: + NSAutoreleasePool* mLocalPool; +}; + +@interface MacApplicationDelegate : NSObject { +} + +// This is used as a workaround for bug 1478347 in order to make OS-provided +// menu items such as the emoji picker available in the Edit menu, especially +// in multi-language environments. +- (IBAction)copy:(id)aSender; + +@end + +enum class LaunchStatus { + Initial, + DelegateIsSetup, + CollectingURLs, + CollectedURLs +}; + +static LaunchStatus sLaunchStatus = LaunchStatus::Initial; + +static nsTArray& StartupURLs() { + static mozilla::NeverDestroyed> sStartupURLs; + return *sStartupURLs; +} + +// Methods that can be called from non-Objective-C code. + +// This is needed, on relaunch, to force the OS to use the "Cocoa Dock API" +// instead of the "Carbon Dock API". For more info see bmo bug 377166. +void EnsureUseCocoaDockAPI() { + NS_OBJC_BEGIN_TRY_IGNORE_BLOCK; + + [GeckoNSApplication sharedApplication]; + + NS_OBJC_END_TRY_IGNORE_BLOCK; +} + +void DisableAppNap() { + // Prevent the parent process from entering App Nap. macOS does not put our + // child processes into App Nap and, as a result, when the parent is in + // App Nap, child processes continue to run normally generating IPC messages + // for the parent which can end up being queued. This can cause the browser + // to be unresponsive for a period of time after the App Nap until the parent + // process "catches up." NSAppSleepDisabled has to be set early during + // startup before the OS reads the value for the process. + [[NSUserDefaults standardUserDefaults] registerDefaults:@{ + @"NSAppSleepDisabled" : @YES, + }]; +} + +void SetupMacApplicationDelegate(bool* gRestartedByOS) { + NS_OBJC_BEGIN_TRY_IGNORE_BLOCK; + + // this is called during startup, outside an event loop, and therefore + // needs an autorelease pool to avoid cocoa object leakage (bug 559075) + AutoAutoreleasePool pool; + + // Ensure that InitializeMacApp() doesn't regress bug 377166. + [GeckoNSApplication sharedApplication]; + + // This call makes it so that application:openFile: doesn't get bogus calls + // from Cocoa doing its own parsing of the argument string. And yes, we need + // to use a string with a boolean value in it. That's just how it works. + [[NSUserDefaults standardUserDefaults] + setObject:@"NO" + forKey:@"NSTreatUnknownArgumentsAsOpen"]; + + // Create the delegate. This should be around for the lifetime of the app. + id delegate = [[MacApplicationDelegate alloc] init]; + [[GeckoNSApplication sharedApplication] setDelegate:delegate]; + + *gRestartedByOS = !!nsCocoaUtils::ShouldRestoreStateDueToLaunchAtLogin(); + + MOZ_ASSERT( + sLaunchStatus == LaunchStatus::Initial, + "Launch status should be in intial state when setting up delegate"); + sLaunchStatus = LaunchStatus::DelegateIsSetup; + + NS_OBJC_END_TRY_IGNORE_BLOCK; +} + +// Run the mac app and stop it immediately after launch. This allows us to +// (a) Initialize accessibility early enough for modals that appear before +// the main app and nest their own event loop to be accessible. +// (b) Collect URLs that were provided to the app at open time. +void InitializeMacApp() { + if (sLaunchStatus != LaunchStatus::DelegateIsSetup) { + // Delegate has not been set up or NSApp has been launched already. + return; + } + + sLaunchStatus = LaunchStatus::CollectingURLs; + if (!gfxPlatform::IsHeadless()) { + [NSApp run]; + } + sLaunchStatus = LaunchStatus::CollectedURLs; +} + +nsTArray TakeStartupURLs() { return std::move(StartupURLs()); } + +@implementation MacApplicationDelegate + +- (IBAction)copy:(id)aSender { + [nsMenuBarX::sNativeEventTarget menuItemHit:aSender]; +} + +- (id)init { + NS_OBJC_BEGIN_TRY_BLOCK_RETURN; + + if ((self = [super init])) { + if (![NSApp windowsMenu]) { + // If the application has a windows menu, it will keep it up to date and + // prepend the window list to the Dock menu automatically. + NSMenu* windowsMenu = [[NSMenu alloc] initWithTitle:@"Window"]; + [NSApp setWindowsMenu:windowsMenu]; + [windowsMenu release]; + } + } + return self; + + NS_OBJC_END_TRY_BLOCK_RETURN(nil); +} + +// The method that NSApplication calls upon a request to reopen, such as when +// the Dock icon is clicked and no windows are open. A "visible" window may be +// miniaturized, so we can't skip nsCocoaNativeReOpen() if 'flag' is 'true'. +- (BOOL)applicationShouldHandleReopen:(NSApplication*)theApp + hasVisibleWindows:(BOOL)flag { + nsCOMPtr nas = NS_GetNativeAppSupport(); + NS_ENSURE_TRUE(nas, NO); + + // Go to the common Carbon/Cocoa reopen method. + nsresult rv = nas->ReOpen(); + NS_ENSURE_SUCCESS(rv, NO); + + // NO says we don't want NSApplication to do anything else for us. + return NO; +} + +// The method that NSApplication calls when documents are requested to be +// printed from the Finder (under the "File" menu). It will be called once for +// each selected document. +- (BOOL)application:(NSApplication*)theApplication + printFile:(NSString*)filename { + return NO; +} + +// The method that NSApplication calls for using secure state restoration. +- (BOOL)applicationSupportsSecureRestorableState:(NSApplication*)app { + return YES; +} + +// Create the menu that shows up in the Dock. +- (NSMenu*)applicationDockMenu:(NSApplication*)sender { + NS_OBJC_BEGIN_TRY_BLOCK_RETURN; + + // Create the NSMenu that will contain the dock menu items. + NSMenu* menu = [[[NSMenu alloc] initWithTitle:@""] autorelease]; + [menu setAutoenablesItems:NO]; + + // Add application-specific dock menu items. On error, do not insert the + // dock menu items. + nsresult rv; + nsCOMPtr dockSupport = + do_GetService("@mozilla.org/widget/macdocksupport;1", &rv); + if (NS_FAILED(rv) || !dockSupport) return menu; + + nsCOMPtr dockMenuInterface; + rv = dockSupport->GetDockMenu(getter_AddRefs(dockMenuInterface)); + if (NS_FAILED(rv) || !dockMenuInterface) return menu; + + RefPtr dockMenu = + static_cast(dockMenuInterface.get()) + ->GetNativeMenu(); + + // Give the menu the opportunity to update itself before display. + dockMenu->MenuWillOpen(); + + // Obtain a copy of the native menu. + NSMenu* nativeDockMenu = dockMenu->NativeNSMenu(); + if (!nativeDockMenu) { + return menu; + } + + // Loop through the application-specific dock menu and insert its + // contents into the dock menu that we are building for Cocoa. + int numDockMenuItems = [nativeDockMenu numberOfItems]; + if (numDockMenuItems > 0) { + if ([menu numberOfItems] > 0) [menu addItem:[NSMenuItem separatorItem]]; + + for (int i = 0; i < numDockMenuItems; i++) { + NSMenuItem* itemCopy = [[nativeDockMenu itemAtIndex:i] copy]; + [menu addItem:itemCopy]; + [itemCopy release]; + } + } + + return menu; + + NS_OBJC_END_TRY_BLOCK_RETURN(nil); +} + +- (void)applicationWillFinishLaunching:(NSNotification*)notification { + // We provide our own full screen menu item, so we don't want the OS providing + // one as well. + [[NSUserDefaults standardUserDefaults] + setBool:NO + forKey:@"NSFullScreenMenuItemEverywhere"]; +} + +- (void)applicationDidFinishLaunching:(NSNotification*)notification { + if (sLaunchStatus == LaunchStatus::CollectingURLs) { + // We are in an inner `run` loop that we are spinning in order to get + // URLs that were requested while launching. `application:openURLs:` will + // have been called by this point and we will have finished reconstructing + // the command line. We now stop the app loop for the rest of startup to be + // processed and will call `run` again when the main event loop should + // start. + [NSApp stop:self]; + + // Send a bogus event so that the internal "app stopped" flag is processed. + // Since we aren't calling this from a responder, we need to post an event + // to have the loop iterate and respond to the stopped flag. + [NSApp postEvent:[NSEvent otherEventWithType:NSEventTypeApplicationDefined + location:NSMakePoint(0, 0) + modifierFlags:0 + timestamp:0 + windowNumber:0 + context:NULL + subtype:kEventSubtypeNone + data1:0 + data2:0] + atStart:NO]; + } +} + +// If we don't handle applicationShouldTerminate:, a call to [NSApp terminate:] +// (from the browser or from the OS) can result in an unclean shutdown. +- (NSApplicationTerminateReply)applicationShouldTerminate: + (NSApplication*)sender { + nsCOMPtr obsServ = + do_GetService("@mozilla.org/observer-service;1"); + if (!obsServ) return NSTerminateNow; + + nsCOMPtr cancelQuit = + do_CreateInstance(NS_SUPPORTS_PRBOOL_CONTRACTID); + if (!cancelQuit) return NSTerminateNow; + + cancelQuit->SetData(false); + obsServ->NotifyObservers(cancelQuit, "quit-application-requested", nullptr); + + bool abortQuit; + cancelQuit->GetData(&abortQuit); + if (abortQuit) return NSTerminateCancel; + + nsCOMPtr appService = + do_GetService("@mozilla.org/toolkit/app-startup;1"); + if (appService) { + bool userAllowedQuit = true; + appService->Quit(nsIAppStartup::eForceQuit, 0, &userAllowedQuit); + if (!userAllowedQuit) { + return NSTerminateCancel; + } + } + + return NSTerminateNow; +} + +- (void)application:(NSApplication*)application + openURLs:(NSArray*)urls { + [self openURLs:urls]; +} + +- (BOOL)application:(NSApplication*)application + willContinueUserActivityWithType:(NSString*)userActivityType { + return [userActivityType isEqualToString:NSUserActivityTypeBrowsingWeb]; +} + +- (BOOL)application:(NSApplication*)application + continueUserActivity:(NSUserActivity*)userActivity + restorationHandler: + (void (^)(NSArray>*))restorationHandler { + if (![userActivity.activityType + isEqualToString:NSUserActivityTypeBrowsingWeb]) { + return NO; + } + + return [self openURLs:@[ userActivity.webpageURL ]]; +} + +- (void)application:(NSApplication*)application + didFailToContinueUserActivityWithType:(NSString*)userActivityType + error:(NSError*)error { + NSLog(@"Failed to continue user activity %@: %@", userActivityType, error); +} + +- (BOOL)openURLs:(NSArray*)urls { + nsTArray args([urls count] * 2 + 2); + // Placeholder for unused program name. + args.AppendElement(nullptr); + + for (NSURL* url in urls) { + if (!url || !url.scheme || + [url.scheme caseInsensitiveCompare:@"chrome"] == NSOrderedSame) { + continue; + } + + const char* const urlString = [[url absoluteString] UTF8String]; + if (sLaunchStatus == LaunchStatus::CollectingURLs) { + StartupURLs().AppendElement(urlString); + continue; + } + + args.AppendElement("-url"); + args.AppendElement(urlString); + } + + if (args.Length() <= 1) { + // No URLs were added to the command line. + return NO; + } + + nsCOMPtr cmdLine(new nsCommandLine()); + nsCOMPtr workingDir; + nsresult rv = NS_GetSpecialDirectory(NS_OS_CURRENT_WORKING_DIR, + getter_AddRefs(workingDir)); + if (NS_FAILED(rv)) { + // Couldn't find a working dir. Uh oh. Good job cmdline::Init can cope. + workingDir = nullptr; + } + + rv = cmdLine->Init(args.Length(), args.Elements(), workingDir, + nsICommandLine::STATE_REMOTE_EXPLICIT); + if (NS_FAILED(rv)) { + return NO; + } + rv = cmdLine->Run(); + if (NS_FAILED(rv)) { + return NO; + } + + return YES; +} + +@end -- cgit v1.2.3