Tools/TestWebKitAPI/Tests/WebKitCocoa/MediaSession.mm - external/github.com/WebKit/webkit - Git at Google

 /*
  * Copyright (C) 2020 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */

 #import "config.h"

 #if PLATFORM(MAC) && ENABLE(MEDIA_SESSION)

 #import "PlatformUtilities.h"
 #import "Test.h"
 #import "TestWKWebView.h"
 #import <WebKit/WKPreferencesPrivate.h>
 #import <WebKit/WKWebViewConfigurationPrivate.h>
 #import <WebKit/WKWebViewPrivate.h>
 #import <WebKit/WebViewPrivate.h>
 #import <pal/spi/mac/MediaRemoteSPI.h>
 #import <ranges>
 #import <wtf/Function.h>
 #import <wtf/HashSet.h>
 #import <wtf/NeverDestroyed.h>
 #import <wtf/SoftLinking.h>
 #import <wtf/cocoa/VectorCocoa.h>
 #import <wtf/darwin/DispatchExtras.h>
 #import <wtf/text/MakeString.h>
 #import <wtf/text/StringHash.h>
 #import <wtf/text/WTFString.h>

 SOFT_LINK_PRIVATE_FRAMEWORK(MediaRemote)

 SOFT_LINK(MediaRemote, MRMediaRemoteSendCommandToApp, Boolean, (MRMediaRemoteCommand command, CFDictionaryRef options, MROriginRef origin, CFStringRef appDisplayID, MRSendCommandAppOptions appOptions, dispatch_queue_t replyQ, void(^completion)(MRSendCommandError err, CFArrayRef handlerReturnStatuses)), (command, options, origin, appDisplayID, appOptions, replyQ, completion));
 #define MRMediaRemoteSendCommandToApp softLinkMRMediaRemoteSendCommandToApp

 SOFT_LINK(MediaRemote, MRMediaRemoteGetLocalOrigin, MROriginRef, (), ());
 #define MRMediaRemoteGetLocalOrigin softLinkMRMediaRemoteGetLocalOrigin

 SOFT_LINK(MediaRemote, MRMediaRemoteGetSupportedCommandsForOrigin, void, (MROriginRef origin, dispatch_queue_t queue, void(^completion)(CFArrayRef commands)), (origin, queue, completion));
 #define MRMediaRemoteGetSupportedCommandsForOrigin softLinkMRMediaRemoteGetSupportedCommandsForOrigin

 SOFT_LINK(MediaRemote, MRMediaRemoteGetNowPlayingClient, void, (dispatch_queue_t queue, void(^completion)(MRNowPlayingClientRef, CFErrorRef)), (queue, completion))
 #define MRMediaRemoteGetNowPlayingClient softLinkMRMediaRemoteGetNowPlayingClient

 SOFT_LINK(MediaRemote, MRNowPlayingClientGetProcessIdentifier, pid_t, (MRNowPlayingClientRef client), (client))
 #define MRNowPlayingClientGetProcessIdentifier softLinkMRNowPlayingClientGetProcessIdentifier

 SOFT_LINK_CONSTANT(MediaRemote, kMRMediaRemoteOptionSkipInterval, CFStringRef)
 #define kMRMediaRemoteOptionSkipInterval getkMRMediaRemoteOptionSkipIntervalSingleton()

 SOFT_LINK_CONSTANT(MediaRemote, kMRMediaRemoteOptionPlaybackPosition, CFStringRef)
 #define kMRMediaRemoteOptionPlaybackPosition getkMRMediaRemoteOptionPlaybackPositionSingleton()

 #if !USE(APPLE_INTERNAL_SDK)
 @interface MRCommandInfo : NSObject
 @property (nonatomic, readonly) MRMediaRemoteCommand command;
 @property (nonatomic, readonly, getter=isEnabled) BOOL enabled;
 @property (nonatomic, readonly, copy) NSDictionary *options;
 @end
 #endif

 namespace TestWebKitAPI {

 class MediaSessionTest : public testing::Test {
 public:
     void SetUp() final
     {
         _configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
         [_configuration setMediaTypesRequiringUserActionForPlayback:WKAudiovisualMediaTypeAudio];

         _webView = adoptNS([[TestWKWebView alloc] initWithFrame:NSMakeRect(0, 0, 300, 300) configuration:_configuration.get() addToWindow:YES]);

         WKPreferences *preferences = [_webView configuration].preferences;
         preferences._mediaSessionEnabled = YES;

         _messageHandlers = adoptNS([[NSMutableArray alloc] init]);
     }

     void TearDown() override
     {
         [_webView clearMessageHandlers:_messageHandlers.get()];
     }

     TestWKWebView* webView() { return _webView.get(); }

     pid_t gpuProcessPID() { return [_webView _gpuProcessIdentifier]; }

     RetainPtr<MRNowPlayingClientRef> getNowPlayingClient()
     {
         bool gotNowPlaying = false;
         RetainPtr<MRNowPlayingClientRef> nowPlayingClient;
         MRMediaRemoteGetNowPlayingClient(mainDispatchQueueSingleton(), [&] (MRNowPlayingClientRef player, CFErrorRef error) {
             if (!error && player)
                 nowPlayingClient = player;
             gotNowPlaying = true;
         });
         TestWebKitAPI::Util::run(&gotNowPlaying);
         return nowPlayingClient;
     }

     pid_t getNowPlayingClientPid()
     {
         return MRNowPlayingClientGetProcessIdentifier(getNowPlayingClient().get());
     }

     void loadPageAndBecomeNowPlaying(NSString *pageName)
     {
         [_webView synchronouslyLoadTestPageNamed:pageName];

         bool canplaythrough = false;
         [webView() performAfterReceivingMessage:@"canplaythrough event" action:[&] {
             canplaythrough = true;
         }];
         runScriptWithUserGesture(@"load()");
         Util::run(&canplaythrough);

         play();
         pause();
         ASSERT_EQ(gpuProcessPID(), getNowPlayingClientPid());
     }

     void runScriptWithUserGesture(NSString *script)
     {
         bool complete = false;
         [_webView evaluateJavaScript:script completionHandler:[&] (id, NSError *) { complete = true; }];
         TestWebKitAPI::Util::run(&complete);
     }

     void play()
     {
         bool playing = false;
         [_webView performAfterReceivingMessage:@"play event" action:[&] { playing = true; }];
         runScriptWithUserGesture(@"audio.play()");
         Util::run(&playing);
     }

     void pause()
     {
         bool paused = false;
         [_webView performAfterReceivingMessage:@"pause event" action:[&] { paused = true; }];
         runScriptWithUserGesture(@"audio.pause()");
         Util::run(&paused);
     }

     bool sendMediaRemoteCommand(MRMediaRemoteCommand command, CFDictionaryRef options = nullptr)
     {
         bool completed = false;
         bool success;

         MRMediaRemoteSendCommandToApp(command, options, NULL, NULL, static_cast<MRSendCommandAppOptions>(0), NULL, [&] (MRSendCommandError error, CFArrayRef) {
             success = !error;
             completed = true;
         });
         TestWebKitAPI::Util::run(&completed);

         return success;
     }

     bool sendMediaRemoteSeekCommand(MRMediaRemoteCommand command, double interval)
     {
         CFStringRef seekInterval = (command == MRMediaRemoteCommandSeekToPlaybackPosition) ? kMRMediaRemoteOptionPlaybackPosition : kMRMediaRemoteOptionSkipInterval;
         NSDictionary *options = @{(__bridge NSString *)seekInterval : @(interval)};
         return sendMediaRemoteCommand(command, (__bridge CFDictionaryRef)options);
     }

     void listenForEventMessages(std::initializer_list<ASCIILiteral> events)
     {
         for (auto event : events) {
             auto eventMessage = makeString(event, " event"_s);
             RetainPtr nsEventMessage = eventMessage.createNSString();
             [_messageHandlers addObject:nsEventMessage.get()];
             [webView() performAfterReceivingMessage:nsEventMessage.get() action:[this, eventMessage = WTF::move(eventMessage)] {
                 _eventListenersCalled.add(eventMessage);
             }];
         }
     }

     bool eventListenerWasCalled(StringView event)
     {
         return _eventListenersCalled.contains(makeString(event, " event"_s));
     }

     void clearEventListenerState()
     {
         _eventListenersCalled.clear();
     }

     void waitForEventListenerToBeCalled(StringView event)
     {
         int tries = 0;
         do {
             if (eventListenerWasCalled(event))
                 return;
             Util::runFor(0.1_s);
         } while (++tries <= 50);

         return;
     }

     void listenForSessionHandlerMessages(std::initializer_list<ASCIILiteral> handlers)
     {
         for (auto handler : handlers) {
             auto handlerMessage = makeString(handler, " handler"_s);
             RetainPtr nsHandleMessage = handlerMessage.createNSString();
             [_messageHandlers addObject:nsHandleMessage.get()];
             [webView() performAfterReceivingMessage:nsHandleMessage.get() action:[this, handlerMessage = WTF::move(handlerMessage)] {
                 _mediaSessionHandlersCalled.add(handlerMessage);
             }];
         }
     }

     bool sessionHandlerWasCalled(StringView handler)
     {
         return _mediaSessionHandlersCalled.contains(makeString(handler, " handler"_s));
     }

     void waitForSessionHandlerToBeCalled(StringView handler)
     {
         int tries = 0;
         do {
             if (sessionHandlerWasCalled(handler))
                 return;
             Util::runFor(0.1_s);
         } while (++tries <= 50);

         return;
     }

     RetainPtr<NSArray> getSupportedCommands()
     {
         bool completed = false;
         RetainPtr<NSArray> result;

         MRMediaRemoteGetSupportedCommandsForOrigin(MRMediaRemoteGetLocalOrigin(), mainDispatchQueueSingleton(), [&] (CFArrayRef commands) {
             result = (__bridge NSArray *)commands;
             completed = true;
         });

         TestWebKitAPI::Util::run(&completed);

         return result;
     }

 private:
     RetainPtr<WKWebViewConfiguration> _configuration;
     RetainPtr<TestWKWebView> _webView;

     HashSet<String> _mediaSessionHandlersCalled;
     HashSet<String> _eventListenersCalled;
     RetainPtr<NSMutableArray> _messageHandlers;
 };

 TEST_F(MediaSessionTest, DISABLED_OnlyOneHandler)
 {
     loadPageAndBecomeNowPlaying(@"media-remote");

     [webView() objectByEvaluatingJavaScript:@"setEmptyActionHandlers([ 'play' ])"];

     listenForSessionHandlerMessages({ "play"_s, "pause"_s, "seekto"_s, "seekforward"_s, "seekbackward"_s, "previoustrack"_s, "nexttrack"_s });
     listenForEventMessages({ "play"_s, "pause"_s, "seeked"_s });

 #if __MAC_OS_X_VERSION_MIN_REQUIRED > 101500
     static Vector<MRMediaRemoteCommand> registeredCommands = { MRMediaRemoteCommandPlay };
     auto currentCommands = getSupportedCommands();
     for (MRCommandInfo *command in currentCommands.get()) {
         if (!command.enabled)
             continue;

         ASSERT_TRUE(registeredCommands.contains(command.command));
     }
 #endif

     ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPlay));
     waitForSessionHandlerToBeCalled("play"_s);
     ASSERT_TRUE(sessionHandlerWasCalled("play"_s));
     ASSERT_FALSE(eventListenerWasCalled("play"_s));

     // The media session only registered for Play, but no other commands should reach HTMLMediaElement.
     ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSkipForward, 1));
     ASSERT_FALSE(sessionHandlerWasCalled("seekforward"_s));
     ASSERT_FALSE(eventListenerWasCalled("seeked"_s));

     ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSkipBackward, 10));
     ASSERT_FALSE(sessionHandlerWasCalled("seekbackward"_s));
     ASSERT_FALSE(eventListenerWasCalled("seeked"_s));

     ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSeekToPlaybackPosition, 6));
     ASSERT_FALSE(sessionHandlerWasCalled("seekto"_s));
     ASSERT_FALSE(eventListenerWasCalled("seeked"_s));

     ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandNextTrack));
     ASSERT_FALSE(sessionHandlerWasCalled("nexttrack"_s));

     ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPreviousTrack));
     ASSERT_FALSE(sessionHandlerWasCalled("previoustrack"_s));
 }

 TEST_F(MediaSessionTest, DISABLED_RemoteCommands)
 {
     loadPageAndBecomeNowPlaying(@"media-remote");

     [webView() objectByEvaluatingJavaScript:@"setEmptyActionHandlers([ 'play', 'pause', 'seekto', 'seekforward', 'seekbackward', 'previoustrack', 'nexttrack' ])"];

     listenForSessionHandlerMessages({ "play"_s, "pause"_s, "seekto"_s, "seekforward"_s, "seekbackward"_s, "previoustrack"_s, "nexttrack"_s });
     listenForEventMessages({ "play"_s, "pause"_s, "seeked"_s });

 #if __MAC_OS_X_VERSION_MIN_REQUIRED > 101500
     static Vector<MRMediaRemoteCommand> registeredCommands = { MRMediaRemoteCommandPlay, MRMediaRemoteCommandPause, MRMediaRemoteCommandSeekToPlaybackPosition, MRMediaRemoteCommandSkipForward, MRMediaRemoteCommandSkipBackward, MRMediaRemoteCommandPreviousTrack, MRMediaRemoteCommandNextTrack };
     auto currentCommands = getSupportedCommands();
     for (MRCommandInfo *command in currentCommands.get()) {
         if (!command.enabled)
             continue;

         ASSERT_TRUE(registeredCommands.contains(command.command));
     }
 #endif

     ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPlay));
     waitForSessionHandlerToBeCalled("play"_s);
     ASSERT_TRUE(sessionHandlerWasCalled("play"_s));
     ASSERT_FALSE(eventListenerWasCalled("play"_s));

     ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPause));
     waitForSessionHandlerToBeCalled("pause"_s);
     ASSERT_TRUE(sessionHandlerWasCalled("pause"_s));
     ASSERT_FALSE(eventListenerWasCalled("pause"_s));

     ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSkipForward, 1));
     waitForSessionHandlerToBeCalled("seekforward"_s);
     ASSERT_TRUE(sessionHandlerWasCalled("seekforward"_s));
     ASSERT_FALSE(eventListenerWasCalled("seeked"_s));

     ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSkipBackward, 10));
     waitForSessionHandlerToBeCalled("seekbackward"_s);
     ASSERT_TRUE(sessionHandlerWasCalled("seekbackward"_s));
     ASSERT_FALSE(eventListenerWasCalled("seeked"_s));

     ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSeekToPlaybackPosition, 6));
     waitForSessionHandlerToBeCalled("seekto"_s);
     ASSERT_TRUE(sessionHandlerWasCalled("seekto"_s));
     ASSERT_FALSE(eventListenerWasCalled("seeked"_s));

     ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandNextTrack));
     waitForSessionHandlerToBeCalled("nexttrack"_s);
     ASSERT_TRUE(sessionHandlerWasCalled("nexttrack"_s));

     ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPreviousTrack));
     waitForSessionHandlerToBeCalled("previoustrack"_s);
     ASSERT_TRUE(sessionHandlerWasCalled("previoustrack"_s));

     // Unregister action handlers, supported commands should go to HTMLMediaElement.
     [webView() objectByEvaluatingJavaScript:@"clearActionHandlers()"];
     clearEventListenerState();

     ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPlay));
     waitForEventListenerToBeCalled("play"_s);
     ASSERT_TRUE(eventListenerWasCalled("play"_s));

     ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPause));
     waitForEventListenerToBeCalled("pause"_s);
     ASSERT_TRUE(eventListenerWasCalled("pause"_s));

     ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSkipForward, 1));
     waitForEventListenerToBeCalled("seeked"_s);
     ASSERT_TRUE(eventListenerWasCalled("seeked"_s));
     clearEventListenerState();

     ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSkipBackward, 10));
     waitForEventListenerToBeCalled("seeked"_s);
     ASSERT_TRUE(eventListenerWasCalled("seeked"_s));
     clearEventListenerState();

     ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSeekToPlaybackPosition, 6));
     waitForEventListenerToBeCalled("seeked"_s);
     ASSERT_TRUE(eventListenerWasCalled("seeked"_s));
 }

 TEST_F(MediaSessionTest, MinimalCommands)
 {
     loadPageAndBecomeNowPlaying(@"media-remote");

     [webView() objectByEvaluatingJavaScript:@"setEmptyActionHandlers([ 'seekforward' ])"];

     listenForSessionHandlerMessages({ "seekforward"_s });
     listenForEventMessages({ "play"_s, "pause"_s, "seeked"_s });

     ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSkipForward, 1));
     waitForSessionHandlerToBeCalled("seekforward"_s);
     ASSERT_TRUE(sessionHandlerWasCalled("seekforward"_s));
     ASSERT_FALSE(eventListenerWasCalled("seeked"_s));

     ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPlay));
     waitForEventListenerToBeCalled("play"_s);
     ASSERT_TRUE(eventListenerWasCalled("play"_s));
     ASSERT_FALSE(sessionHandlerWasCalled("play"_s));

     ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPause));
     waitForEventListenerToBeCalled("pause"_s);
     ASSERT_TRUE(eventListenerWasCalled("pause"_s));
     ASSERT_FALSE(sessionHandlerWasCalled("pause"_s));

     Vector<MRMediaRemoteCommand> expectedCommands {
         MRMediaRemoteCommandPlay,
         MRMediaRemoteCommandPause,
         MRMediaRemoteCommandSkipForward,
     };
     std::ranges::sort(expectedCommands);

     Vector actualCommands = makeVector(getSupportedCommands().get(), [] (MRCommandInfo *command) -> std::optional<MRMediaRemoteCommand> {
         if (!command.enabled)
             return std::nullopt;
         return command.command;
     });
     std::ranges::sort(actualCommands);

     EXPECT_EQ(expectedCommands, actualCommands);
 }

 } // namespace TestWebKitAPI

 #endif // PLATFORM(MAC) && ENABLE(MEDIA_SESSION)
	/*
	* Copyright (C) 2020 Apple Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	* THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#import "config.h"

	#if PLATFORM(MAC) && ENABLE(MEDIA_SESSION)

	#import "PlatformUtilities.h"
	#import "Test.h"
	#import "TestWKWebView.h"
	#import <WebKit/WKPreferencesPrivate.h>
	#import <WebKit/WKWebViewConfigurationPrivate.h>
	#import <WebKit/WKWebViewPrivate.h>
	#import <WebKit/WebViewPrivate.h>
	#import <pal/spi/mac/MediaRemoteSPI.h>
	#import <ranges>
	#import <wtf/Function.h>
	#import <wtf/HashSet.h>
	#import <wtf/NeverDestroyed.h>
	#import <wtf/SoftLinking.h>
	#import <wtf/cocoa/VectorCocoa.h>
	#import <wtf/darwin/DispatchExtras.h>
	#import <wtf/text/MakeString.h>
	#import <wtf/text/StringHash.h>
	#import <wtf/text/WTFString.h>

	SOFT_LINK_PRIVATE_FRAMEWORK(MediaRemote)

	SOFT_LINK(MediaRemote, MRMediaRemoteSendCommandToApp, Boolean, (MRMediaRemoteCommand command, CFDictionaryRef options, MROriginRef origin, CFStringRef appDisplayID, MRSendCommandAppOptions appOptions, dispatch_queue_t replyQ, void(^completion)(MRSendCommandError err, CFArrayRef handlerReturnStatuses)), (command, options, origin, appDisplayID, appOptions, replyQ, completion));
	#define MRMediaRemoteSendCommandToApp softLinkMRMediaRemoteSendCommandToApp

	SOFT_LINK(MediaRemote, MRMediaRemoteGetLocalOrigin, MROriginRef, (), ());
	#define MRMediaRemoteGetLocalOrigin softLinkMRMediaRemoteGetLocalOrigin

	SOFT_LINK(MediaRemote, MRMediaRemoteGetSupportedCommandsForOrigin, void, (MROriginRef origin, dispatch_queue_t queue, void(^completion)(CFArrayRef commands)), (origin, queue, completion));
	#define MRMediaRemoteGetSupportedCommandsForOrigin softLinkMRMediaRemoteGetSupportedCommandsForOrigin

	SOFT_LINK(MediaRemote, MRMediaRemoteGetNowPlayingClient, void, (dispatch_queue_t queue, void(^completion)(MRNowPlayingClientRef, CFErrorRef)), (queue, completion))
	#define MRMediaRemoteGetNowPlayingClient softLinkMRMediaRemoteGetNowPlayingClient

	SOFT_LINK(MediaRemote, MRNowPlayingClientGetProcessIdentifier, pid_t, (MRNowPlayingClientRef client), (client))
	#define MRNowPlayingClientGetProcessIdentifier softLinkMRNowPlayingClientGetProcessIdentifier

	SOFT_LINK_CONSTANT(MediaRemote, kMRMediaRemoteOptionSkipInterval, CFStringRef)
	#define kMRMediaRemoteOptionSkipInterval getkMRMediaRemoteOptionSkipIntervalSingleton()

	SOFT_LINK_CONSTANT(MediaRemote, kMRMediaRemoteOptionPlaybackPosition, CFStringRef)
	#define kMRMediaRemoteOptionPlaybackPosition getkMRMediaRemoteOptionPlaybackPositionSingleton()

	#if !USE(APPLE_INTERNAL_SDK)
	@interface MRCommandInfo : NSObject
	@property (nonatomic, readonly) MRMediaRemoteCommand command;
	@property (nonatomic, readonly, getter=isEnabled) BOOL enabled;
	@property (nonatomic, readonly, copy) NSDictionary *options;
	@end
	#endif

	namespace TestWebKitAPI {

	class MediaSessionTest : public testing::Test {
	public:
	void SetUp() final
	{
	_configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
	[_configuration setMediaTypesRequiringUserActionForPlayback:WKAudiovisualMediaTypeAudio];

	_webView = adoptNS([[TestWKWebView alloc] initWithFrame:NSMakeRect(0, 0, 300, 300) configuration:_configuration.get() addToWindow:YES]);

	WKPreferences *preferences = [_webView configuration].preferences;
	preferences._mediaSessionEnabled = YES;

	_messageHandlers = adoptNS([[NSMutableArray alloc] init]);
	}

	void TearDown() override
	{
	[_webView clearMessageHandlers:_messageHandlers.get()];
	}

	TestWKWebView* webView() { return _webView.get(); }

	pid_t gpuProcessPID() { return [_webView _gpuProcessIdentifier]; }

	RetainPtr<MRNowPlayingClientRef> getNowPlayingClient()
	{
	bool gotNowPlaying = false;
	RetainPtr<MRNowPlayingClientRef> nowPlayingClient;
	MRMediaRemoteGetNowPlayingClient(mainDispatchQueueSingleton(), [&] (MRNowPlayingClientRef player, CFErrorRef error) {
	if (!error && player)
	nowPlayingClient = player;
	gotNowPlaying = true;
	});
	TestWebKitAPI::Util::run(&gotNowPlaying);
	return nowPlayingClient;
	}

	pid_t getNowPlayingClientPid()
	{
	return MRNowPlayingClientGetProcessIdentifier(getNowPlayingClient().get());
	}

	void loadPageAndBecomeNowPlaying(NSString *pageName)
	{
	[_webView synchronouslyLoadTestPageNamed:pageName];

	bool canplaythrough = false;
	[webView() performAfterReceivingMessage:@"canplaythrough event" action:[&] {
	canplaythrough = true;
	}];
	runScriptWithUserGesture(@"load()");
	Util::run(&canplaythrough);

	play();
	pause();
	ASSERT_EQ(gpuProcessPID(), getNowPlayingClientPid());
	}

	void runScriptWithUserGesture(NSString *script)
	{
	bool complete = false;
	[_webView evaluateJavaScript:script completionHandler:[&] (id, NSError *) { complete = true; }];
	TestWebKitAPI::Util::run(&complete);
	}

	void play()
	{
	bool playing = false;
	[_webView performAfterReceivingMessage:@"play event" action:[&] { playing = true; }];
	runScriptWithUserGesture(@"audio.play()");
	Util::run(&playing);
	}

	void pause()
	{
	bool paused = false;
	[_webView performAfterReceivingMessage:@"pause event" action:[&] { paused = true; }];
	runScriptWithUserGesture(@"audio.pause()");
	Util::run(&paused);
	}

	bool sendMediaRemoteCommand(MRMediaRemoteCommand command, CFDictionaryRef options = nullptr)
	{
	bool completed = false;
	bool success;

	MRMediaRemoteSendCommandToApp(command, options, NULL, NULL, static_cast<MRSendCommandAppOptions>(0), NULL, [&] (MRSendCommandError error, CFArrayRef) {
	success = !error;
	completed = true;
	});
	TestWebKitAPI::Util::run(&completed);

	return success;
	}

	bool sendMediaRemoteSeekCommand(MRMediaRemoteCommand command, double interval)
	{
	CFStringRef seekInterval = (command == MRMediaRemoteCommandSeekToPlaybackPosition) ? kMRMediaRemoteOptionPlaybackPosition : kMRMediaRemoteOptionSkipInterval;
	NSDictionary options = @{(__bridge NSString )seekInterval : @(interval)};
	return sendMediaRemoteCommand(command, (__bridge CFDictionaryRef)options);
	}

	void listenForEventMessages(std::initializer_list<ASCIILiteral> events)
	{
	for (auto event : events) {
	auto eventMessage = makeString(event, " event"_s);
	RetainPtr nsEventMessage = eventMessage.createNSString();
	[_messageHandlers addObject:nsEventMessage.get()];
	[webView() performAfterReceivingMessage:nsEventMessage.get() action:[this, eventMessage = WTF::move(eventMessage)] {
	_eventListenersCalled.add(eventMessage);
	}];
	}
	}

	bool eventListenerWasCalled(StringView event)
	{
	return _eventListenersCalled.contains(makeString(event, " event"_s));
	}

	void clearEventListenerState()
	{
	_eventListenersCalled.clear();
	}

	void waitForEventListenerToBeCalled(StringView event)
	{
	int tries = 0;
	do {
	if (eventListenerWasCalled(event))
	return;
	Util::runFor(0.1_s);
	} while (++tries <= 50);

	return;
	}

	void listenForSessionHandlerMessages(std::initializer_list<ASCIILiteral> handlers)
	{
	for (auto handler : handlers) {
	auto handlerMessage = makeString(handler, " handler"_s);
	RetainPtr nsHandleMessage = handlerMessage.createNSString();
	[_messageHandlers addObject:nsHandleMessage.get()];
	[webView() performAfterReceivingMessage:nsHandleMessage.get() action:[this, handlerMessage = WTF::move(handlerMessage)] {
	_mediaSessionHandlersCalled.add(handlerMessage);
	}];
	}
	}

	bool sessionHandlerWasCalled(StringView handler)
	{
	return _mediaSessionHandlersCalled.contains(makeString(handler, " handler"_s));
	}

	void waitForSessionHandlerToBeCalled(StringView handler)
	{
	int tries = 0;
	do {
	if (sessionHandlerWasCalled(handler))
	return;
	Util::runFor(0.1_s);
	} while (++tries <= 50);

	return;
	}

	RetainPtr<NSArray> getSupportedCommands()
	{
	bool completed = false;
	RetainPtr<NSArray> result;

	MRMediaRemoteGetSupportedCommandsForOrigin(MRMediaRemoteGetLocalOrigin(), mainDispatchQueueSingleton(), [&] (CFArrayRef commands) {
	result = (__bridge NSArray *)commands;
	completed = true;
	});

	TestWebKitAPI::Util::run(&completed);

	return result;
	}

	private:
	RetainPtr<WKWebViewConfiguration> _configuration;
	RetainPtr<TestWKWebView> _webView;

	HashSet<String> _mediaSessionHandlersCalled;
	HashSet<String> _eventListenersCalled;
	RetainPtr<NSMutableArray> _messageHandlers;
	};

	TEST_F(MediaSessionTest, DISABLED_OnlyOneHandler)
	{
	loadPageAndBecomeNowPlaying(@"media-remote");

	[webView() objectByEvaluatingJavaScript:@"setEmptyActionHandlers([ 'play' ])"];

	listenForSessionHandlerMessages({ "play"_s, "pause"_s, "seekto"_s, "seekforward"_s, "seekbackward"_s, "previoustrack"_s, "nexttrack"_s });
	listenForEventMessages({ "play"_s, "pause"_s, "seeked"_s });

	#if __MAC_OS_X_VERSION_MIN_REQUIRED > 101500
	static Vector<MRMediaRemoteCommand> registeredCommands = { MRMediaRemoteCommandPlay };
	auto currentCommands = getSupportedCommands();
	for (MRCommandInfo *command in currentCommands.get()) {
	if (!command.enabled)
	continue;

	ASSERT_TRUE(registeredCommands.contains(command.command));
	}
	#endif

	ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPlay));
	waitForSessionHandlerToBeCalled("play"_s);
	ASSERT_TRUE(sessionHandlerWasCalled("play"_s));
	ASSERT_FALSE(eventListenerWasCalled("play"_s));

	// The media session only registered for Play, but no other commands should reach HTMLMediaElement.
	ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSkipForward, 1));
	ASSERT_FALSE(sessionHandlerWasCalled("seekforward"_s));
	ASSERT_FALSE(eventListenerWasCalled("seeked"_s));

	ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSkipBackward, 10));
	ASSERT_FALSE(sessionHandlerWasCalled("seekbackward"_s));
	ASSERT_FALSE(eventListenerWasCalled("seeked"_s));

	ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSeekToPlaybackPosition, 6));
	ASSERT_FALSE(sessionHandlerWasCalled("seekto"_s));
	ASSERT_FALSE(eventListenerWasCalled("seeked"_s));

	ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandNextTrack));
	ASSERT_FALSE(sessionHandlerWasCalled("nexttrack"_s));

	ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPreviousTrack));
	ASSERT_FALSE(sessionHandlerWasCalled("previoustrack"_s));
	}

	TEST_F(MediaSessionTest, DISABLED_RemoteCommands)
	{
	loadPageAndBecomeNowPlaying(@"media-remote");

	[webView() objectByEvaluatingJavaScript:@"setEmptyActionHandlers([ 'play', 'pause', 'seekto', 'seekforward', 'seekbackward', 'previoustrack', 'nexttrack' ])"];

	listenForSessionHandlerMessages({ "play"_s, "pause"_s, "seekto"_s, "seekforward"_s, "seekbackward"_s, "previoustrack"_s, "nexttrack"_s });
	listenForEventMessages({ "play"_s, "pause"_s, "seeked"_s });

	#if __MAC_OS_X_VERSION_MIN_REQUIRED > 101500
	static Vector<MRMediaRemoteCommand> registeredCommands = { MRMediaRemoteCommandPlay, MRMediaRemoteCommandPause, MRMediaRemoteCommandSeekToPlaybackPosition, MRMediaRemoteCommandSkipForward, MRMediaRemoteCommandSkipBackward, MRMediaRemoteCommandPreviousTrack, MRMediaRemoteCommandNextTrack };
	auto currentCommands = getSupportedCommands();
	for (MRCommandInfo *command in currentCommands.get()) {
	if (!command.enabled)
	continue;

	ASSERT_TRUE(registeredCommands.contains(command.command));
	}
	#endif

	ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPlay));
	waitForSessionHandlerToBeCalled("play"_s);
	ASSERT_TRUE(sessionHandlerWasCalled("play"_s));
	ASSERT_FALSE(eventListenerWasCalled("play"_s));

	ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPause));
	waitForSessionHandlerToBeCalled("pause"_s);
	ASSERT_TRUE(sessionHandlerWasCalled("pause"_s));
	ASSERT_FALSE(eventListenerWasCalled("pause"_s));

	ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSkipForward, 1));
	waitForSessionHandlerToBeCalled("seekforward"_s);
	ASSERT_TRUE(sessionHandlerWasCalled("seekforward"_s));
	ASSERT_FALSE(eventListenerWasCalled("seeked"_s));

	ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSkipBackward, 10));
	waitForSessionHandlerToBeCalled("seekbackward"_s);
	ASSERT_TRUE(sessionHandlerWasCalled("seekbackward"_s));
	ASSERT_FALSE(eventListenerWasCalled("seeked"_s));

	ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSeekToPlaybackPosition, 6));
	waitForSessionHandlerToBeCalled("seekto"_s);
	ASSERT_TRUE(sessionHandlerWasCalled("seekto"_s));
	ASSERT_FALSE(eventListenerWasCalled("seeked"_s));

	ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandNextTrack));
	waitForSessionHandlerToBeCalled("nexttrack"_s);
	ASSERT_TRUE(sessionHandlerWasCalled("nexttrack"_s));

	ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPreviousTrack));
	waitForSessionHandlerToBeCalled("previoustrack"_s);
	ASSERT_TRUE(sessionHandlerWasCalled("previoustrack"_s));

	// Unregister action handlers, supported commands should go to HTMLMediaElement.
	[webView() objectByEvaluatingJavaScript:@"clearActionHandlers()"];
	clearEventListenerState();

	ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPlay));
	waitForEventListenerToBeCalled("play"_s);
	ASSERT_TRUE(eventListenerWasCalled("play"_s));

	ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPause));
	waitForEventListenerToBeCalled("pause"_s);
	ASSERT_TRUE(eventListenerWasCalled("pause"_s));

	ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSkipForward, 1));
	waitForEventListenerToBeCalled("seeked"_s);
	ASSERT_TRUE(eventListenerWasCalled("seeked"_s));
	clearEventListenerState();

	ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSkipBackward, 10));
	waitForEventListenerToBeCalled("seeked"_s);
	ASSERT_TRUE(eventListenerWasCalled("seeked"_s));
	clearEventListenerState();

	ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSeekToPlaybackPosition, 6));
	waitForEventListenerToBeCalled("seeked"_s);
	ASSERT_TRUE(eventListenerWasCalled("seeked"_s));
	}

	TEST_F(MediaSessionTest, MinimalCommands)
	{
	loadPageAndBecomeNowPlaying(@"media-remote");

	[webView() objectByEvaluatingJavaScript:@"setEmptyActionHandlers([ 'seekforward' ])"];

	listenForSessionHandlerMessages({ "seekforward"_s });
	listenForEventMessages({ "play"_s, "pause"_s, "seeked"_s });

	ASSERT_TRUE(sendMediaRemoteSeekCommand(MRMediaRemoteCommandSkipForward, 1));
	waitForSessionHandlerToBeCalled("seekforward"_s);
	ASSERT_TRUE(sessionHandlerWasCalled("seekforward"_s));
	ASSERT_FALSE(eventListenerWasCalled("seeked"_s));

	ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPlay));
	waitForEventListenerToBeCalled("play"_s);
	ASSERT_TRUE(eventListenerWasCalled("play"_s));
	ASSERT_FALSE(sessionHandlerWasCalled("play"_s));

	ASSERT_TRUE(sendMediaRemoteCommand(MRMediaRemoteCommandPause));
	waitForEventListenerToBeCalled("pause"_s);
	ASSERT_TRUE(eventListenerWasCalled("pause"_s));
	ASSERT_FALSE(sessionHandlerWasCalled("pause"_s));

	Vector<MRMediaRemoteCommand> expectedCommands {
	MRMediaRemoteCommandPlay,
	MRMediaRemoteCommandPause,
	MRMediaRemoteCommandSkipForward,
	};
	std::ranges::sort(expectedCommands);

	Vector actualCommands = makeVector(getSupportedCommands().get(), [] (MRCommandInfo *command) -> std::optional<MRMediaRemoteCommand> {
	if (!command.enabled)
	return std::nullopt;
	return command.command;
	});
	std::ranges::sort(actualCommands);

	EXPECT_EQ(expectedCommands, actualCommands);
	}

	} // namespace TestWebKitAPI

	#endif // PLATFORM(MAC) && ENABLE(MEDIA_SESSION)