Changeset 286777 in webkit

Timestamp:
Dec 9, 2021, 6:46:27 AM (3 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, reverting r286764.
​https://bugs.webkit.org/show_bug.cgi?id=234081

broke the build

Reverted changeset:

"Add ability to inject messages into webpushd"
​https://bugs.webkit.org/show_bug.cgi?id=233988
​https://commits.webkit.org/r286764

Location:
trunk
Files:
3 deleted
28 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r286774 r286777  
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12
     13
    1142021-12-09  Youenn Fablet  <youenn@apple.com>
    215

  • trunk/Source/WebKit/Configurations/webpushtool.xcconfig

    r286764 r286777  
    3030EXCLUDED_SOURCE_FILE_NAMES[sdk=watch*] = *;
    3131
    32 OTHER_LDFLAGS = -framework WebKit -framework JavaScriptCore
     32OTHER_LDFLAGS = -
    3333LIBRARY_SEARCH_PATHS = $(BUILT_PRODUCTS_DIR);
    3434

  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.cpp

    r286764 r286777  
    5959#include "WebPageProxyMessages.h"
    6060#include "WebProcessPoolMessages.h"
    61 #include "WebPushMessage.h"
    6261#include "WebResourceLoadStatisticsStore.h"
    6362#include "WebSWOriginStore.h"
    … …  
    25572556}
    25582557
    2559 void NetworkProcess::getPendingPushMessages(PAL::SessionID sessionID, CompletionHandler<void(const Vector<WebPushMessage>&)>&& callback)
    2560 {
    2561 #if ENABLE(BUILT_IN_NOTIFICATIONS)
    2562     if (auto* session = networkSession(sessionID)) {
    2563         session->notificationManager().getPendingPushMessages(WTFMove(callback));
    2564         return;
    2565     }
    2566 #endif
    2567     callback({ });
    2568 }
    2569 
    2570 void NetworkProcess::processPushMessage(PAL::SessionID sessionID, WebPushMessage&& pushMessage, CompletionHandler<void(bool)>&& callback)
    2571 {
    2572     swServerForSession(sessionID).processPushMessage(WTFMove(pushMessage.pushData), WTFMove(pushMessage.registrationURL), WTFMove(callback));
     2558void NetworkProcess::processPushMessage(PAL::SessionID sessionID, const std::optional<IPC::DataReference>& ipcData, URL&& registrationURL, CompletionHandler<void(bool)>&& callback)
     2559{
     2560    std::optional<Vector<uint8_t>> data;
     2561    if (ipcData)
     2562        data = Vector<uint8_t> { ipcData->data(), ipcData->size() };
     2563    swServerForSession(sessionID).processPushMessage(WTFMove(data), WTFMove(registrationURL), WTFMove(callback));
    25732564}
    25742565#endif // ENABLE(SERVICE_WORKER)

  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.h

    r286764 r286777  
    118118enum class WebsiteDataType : uint32_t;
    119119struct NetworkProcessCreationParameters;
    120 struct WebPushMessage;
    121120struct WebsiteDataStoreParameters;
    122121
    … …  
    398397
    399398#if ENABLE(SERVICE_WORKER)
    400     void getPendingPushMessages(PAL::SessionID, CompletionHandler<void(const Vector<WebPushMessage>&)>&&);
    401     void processPushMessage(PAL::SessionID, WebPushMessage&&, CompletionHandler<void(bool)>&&);
     399    void processPushMessage(PAL::SessionID, const std::optional<IPC::DataReference>&, URL&&, CompletionHandler<void(bool)>&&);
    402400#endif
    403401

  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.messages.in

    r286764 r286777  
    208208
    209209#if ENABLE(SERVICE_WORKER)
    210     GetPendingPushMessages(PAL::SessionID sessionID) -> (Vector<WebKit::WebPushMessage> messages) Async
    211     ProcessPushMessage(PAL::SessionID sessionID, struct WebKit::WebPushMessage pushMessage) -> (bool didSucceed) Async
     210    ProcessPushMessage(PAL::SessionID sessionID, std::optional<IPC::DataReference> data, URL registrationURL) -> (bool didSucceed) Async
    212211#endif
    213212    DeletePushAndNotificationRegistration(PAL::SessionID sessionID, struct WebCore::SecurityOriginData origin) -> (String errorMessage) Async

  • trunk/Source/WebKit/NetworkProcess/Notifications/NetworkNotificationManager.cpp

    r286764 r286777  
    3333#include "NetworkSession.h"
    3434#include "WebPushDaemonConnectionConfiguration.h"
    35 #include "WebPushMessage.h"
    3635#include <WebCore/SecurityOriginData.h>
    3736
    … …  
    8887
    8988    sendMessageWithReply<WebPushD::MessageType::GetOriginsWithPushAndNotificationPermissions>(WTFMove(replyHandler));
    90 }
    91 
    92 void NetworkNotificationManager::getPendingPushMessages(CompletionHandler<void(const Vector<WebPushMessage>&)>&& completionHandler)
    93 {
    94     CompletionHandler<void(Vector<WebPushMessage>&&)> replyHandler = [completionHandler = WTFMove(completionHandler)] (Vector<WebPushMessage>&& messages) mutable {
    95         completionHandler(WTFMove(messages));
    96     };
    97 
    98     sendMessageWithReply<WebPushD::MessageType::GetPendingPushMessages>(WTFMove(replyHandler));
    9989}
    10090
    … …  
    197187};
    198188
    199 template<> struct ReplyCaller<Vector<WebPushMessage>&&> {
    200     static void callReply(Daemon::Decoder&& decoder, CompletionHandler<void(Vector<WebPushMessage>&&)>&& completionHandler)
    201     {
    202         std::optional<Vector<WebPushMessage>> messages;
    203         decoder >> messages;
    204         if (!messages)
    205             return completionHandler({ });
    206         completionHandler(WTFMove(*messages));
    207     }
    208 };
    209 
    210189template<WebPushD::MessageType messageType, typename... Args, typename... ReplyArgs>
    211190void NetworkNotificationManager::sendMessageWithReply(CompletionHandler<void(ReplyArgs...)>&& completionHandler, Args&&... args) const

  • trunk/Source/WebKit/NetworkProcess/Notifications/NetworkNotificationManager.h

    r286764 r286777  
    3030#include "NotificationManagerMessageHandler.h"
    3131#include "WebPushDaemonConnection.h"
    32 #include "WebPushMessage.h"
    3332#include <WebCore/NotificationDirection.h>
    3433#include <wtf/text/WTFString.h>
    … …  
    5453    void deletePushAndNotificationRegistration(const WebCore::SecurityOriginData&, CompletionHandler<void(const String&)>&&);
    5554    void getOriginsWithPushAndNotificationPermissions(CompletionHandler<void(const Vector<WebCore::SecurityOriginData>&)>&&);
    56     void getPendingPushMessages(CompletionHandler<void(const Vector<WebPushMessage>&)>&&);
    5755
    5856private:

  • trunk/Source/WebKit/Resources/webpushtool.entitlements

    r286764 r286777  
    55        <key>com.apple.private.webkit.webpush</key>
    66        <true/>
    7         <key>com.apple.private.webkit.webpush.inject</key>
    8         <true/>
    97</dict>
    108</plist>

  • trunk/Source/WebKit/Shared/WebPushDaemonConstants.h

    r286764 r286777  
    4343    SetDebugModeIsEnabled,
    4444    UpdateConnectionConfiguration,
    45     InjectPushMessageForTesting,
    46     GetPendingPushMessages,
    4745};
    4846
    … …  
    5452    case MessageType::DeletePushAndNotificationRegistration:
    5553    case MessageType::RequestSystemNotificationPermission:
    56     case MessageType::GetPendingPushMessages:
    57     case MessageType::InjectPushMessageForTesting:
    5854        return true;
    5955    case MessageType::SetDebugModeIsEnabled:

  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataStore.mm

    r286764 r286777  
    4040#import "WKWebsiteDataRecordInternal.h"
    4141#import "WebPageProxy.h"
    42 #import "WebPushMessage.h"
    4342#import "WebResourceLoadStatisticsStore.h"
    4443#import "WebsiteDataFetchOption.h"
    … …  
    763762}
    764763
    765 -(void)_getPendingPushMessages:(void(^)(NSArray<NSDictionary *> *))completionHandler
     764-(void)_))completionHandler
    766765{
    767766#if ENABLE(SERVICE_WORKER)
    768     _websiteDataStore->networkProcess().getPendingPushMessages(_websiteDataStore->sessionID(), [completionHandler = makeBlockPtr(completionHandler)] (const Vector<WebKit::WebPushMessage>& messages) {
    769         auto result = adoptNS([[NSMutableArray alloc] initWithCapacity:messages.size()]);
    770         for (auto& message : messages)
    771             [result addObject:message.toDictionary()];
    772 
    773         completionHandler(result.get());
    774     });
    775 #endif
    776 }
    777 
    778 -(void)_processPushMessage:(NSDictionary *)pushMessageDictionary completionHandler:(void(^)(bool wasProcessed))completionHandler
    779 {
    780 #if ENABLE(SERVICE_WORKER)
    781     auto pushMessage = WebKit::WebPushMessage::fromDictionary(pushMessageDictionary);
    782     if (!pushMessage) {
    783         completionHandler(false);
    784         return;
    785     }
    786 
    787     _websiteDataStore->networkProcess().processPushMessage(_websiteDataStore->sessionID(), *pushMessage, [completionHandler = makeBlockPtr(completionHandler)] (bool wasProcessed) {
     767    std::optional<Span<const uint8_t>> data;
     768    if (message)
     769        data = Span<const uint8_t> { reinterpret_cast<const uint8_t*>(message.bytes), message.length };
     770    _websiteDataStore->networkProcess().processPushMessage(_websiteDataStore->sessionID(), data, registration, [completionHandler = makeBlockPtr(completionHandler)] (bool wasProcessed) {
    788771        completionHandler(wasProcessed);
    789772    });

  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataStorePrivate.h

    r286764 r286777  
    109109
    110110-(bool)_hasServiceWorkerBackgroundActivityForTesting WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA));
    111 -(void)_getPendingPushMessages:(void(^)(NSArray<NSDictionary *> *))completionHandler WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA));
    112 -(void)_processPushMessage:(NSDictionary *)pushMessage completionHandler:(void(^)(bool))completionHandler WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA));
     111-(void)_processPushMessage:(NSData*)data registration:(NSURL *)registration completionHandler:(void(^)(bool))completionHandler WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA));
    113112-(void)_deletePushAndNotificationRegistration:(WKSecurityOrigin *)securityOrigin completionHandler:(void(^)(NSError *))completionHandler WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA));
    114113-(void)_getOriginsWithPushAndNotificationPermissions:(void(^)(NSSet<WKSecurityOrigin *> *))completionHandler WK_API_AVAILABLE(macos(WK_MAC_TBA), ios(WK_IOS_TBA));

  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp

    r286764 r286777  
    16931693
    16941694#if ENABLE(SERVICE_WORKER)
    1695 void NetworkProcessProxy::getPendingPushMessages(PAL::SessionID sessionID, CompletionHandler<void(const Vector<WebPushMessage>&)>&& completionHandler)
    1696 {
    1697     sendWithAsyncReply(Messages::NetworkProcess::GetPendingPushMessages { sessionID }, WTFMove(completionHandler));
    1698 }
    1699 
    1700 void NetworkProcessProxy::processPushMessage(PAL::SessionID sessionID, const WebPushMessage& pushMessage, CompletionHandler<void(bool wasProcessed)>&& callback)
    1701 {
    1702     sendWithAsyncReply(Messages::NetworkProcess::ProcessPushMessage { sessionID, pushMessage }, WTFMove(callback));
     1695void NetworkProcessProxy::processPushMessage(PAL::SessionID sessionID, std::optional<Span<const uint8_t>> data, const URL& registrationURL, CompletionHandler<void(bool wasProcessed)>&& callback)
     1696{
     1697    std::optional<IPC::DataReference> ipcData;
     1698    if (data)
     1699        ipcData = IPC::DataReference { data->data(), data->size() };
     1700    sendWithAsyncReply(Messages::NetworkProcess::ProcessPushMessage { sessionID, ipcData, registrationURL }, WTFMove(callback));
    17031701}
    17041702#endif // ENABLE(SERVICE_WORKER)

  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h

    r286764 r286777  
    9393struct NetworkProcessCreationParameters;
    9494struct ResourceLoadInfo;
    95 struct WebPushMessage;
    9695struct WebsiteData;
    9796struct WebsiteDataStoreParameters;
    … …  
    275274
    276275#if ENABLE(SERVICE_WORKER)
    277     void getPendingPushMessages(PAL::SessionID, CompletionHandler<void(const Vector<WebPushMessage>&)>&&);
    278     void processPushMessage(PAL::SessionID, const WebPushMessage&, CompletionHandler<void(bool wasProcessed)>&&);
     276    void processPushMessage(PAL::SessionID, std::optional<Span<const uint8_t>>, const URL&, CompletionHandler<void(bool wasProcessed)>&&);
    279277#endif
    280278

  • trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj

    r286764 r286777  
    10351035                517B5F85275E97B6002DC22D /* AppBundleRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 5160E954274B887100567388 /* AppBundleRequest.h */; };
    10361036                517B5F86275E97B6002DC22D /* MockAppBundleRegistry.mm in Sources */ = {isa = PBXBuildFile; fileRef = 5160E95F274C2A3F00567388 /* MockAppBundleRegistry.mm */; };
    1037                 517B5F95275EBA63002DC22D /* PushMessageForTesting.h in Headers */ = {isa = PBXBuildFile; fileRef = 517B5F94275EBA62002DC22D /* PushMessageForTesting.h */; };
    1038                 517B5F97275EC5E5002DC22D /* WebPushMessage.h in Headers */ = {isa = PBXBuildFile; fileRef = 517B5F96275EC5E5002DC22D /* WebPushMessage.h */; };
    1039                 517B5F99275EC601002DC22D /* WebPushMessageCocoa.mm in Sources */ = {isa = PBXBuildFile; fileRef = 517B5F98275EC600002DC22D /* WebPushMessageCocoa.mm */; };
    1040                 517B5F9A275F3A86002DC22D /* ArgumentCoders.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1A3D610413A7F03A00F95D4E /* ArgumentCoders.cpp */; };
    1041                 517B5F9B275F3A98002DC22D /* DaemonUtilities.mm in Sources */ = {isa = PBXBuildFile; fileRef = 5C1579F92717AF5000ED5280 /* DaemonUtilities.mm */; };
    1042                 517B5F9C275F3C37002DC22D /* DaemonEncoder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5C1579E827172A8A00ED5280 /* DaemonEncoder.cpp */; };
    10431037                517CF0E3163A486C00C2950E /* NetworkProcessConnectionMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 517CF0E1163A486C00C2950E /* NetworkProcessConnectionMessageReceiver.cpp */; };
    10441038                517CF0E3163A486C00C2950F /* CacheStorageEngineConnectionMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 517CF0E1163A486C00C2950F /* CacheStorageEngineConnectionMessageReceiver.cpp */; };
    … …  
    44164410                517B5F72275E9609002DC22D /* WebPushDaemonMain.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebPushDaemonMain.h; sourceTree = "<group>"; };
    44174411                517B5F77275E9795002DC22D /* webpushd.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = webpushd.cpp; sourceTree = "<group>"; };
    4418                 517B5F94275EBA62002DC22D /* PushMessageForTesting.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PushMessageForTesting.h; sourceTree = "<group>"; };
    4419                 517B5F96275EC5E5002DC22D /* WebPushMessage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebPushMessage.h; sourceTree = "<group>"; };
    4420                 517B5F98275EC600002DC22D /* WebPushMessageCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebPushMessageCocoa.mm; sourceTree = "<group>"; };
    44214412                517CF0E1163A486C00C2950E /* NetworkProcessConnectionMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = NetworkProcessConnectionMessageReceiver.cpp; path = DerivedSources/WebKit/NetworkProcessConnectionMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
    44224413                517CF0E1163A486C00C2950F /* CacheStorageEngineConnectionMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = CacheStorageEngineConnectionMessageReceiver.cpp; path = DerivedSources/WebKit/CacheStorageEngineConnectionMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
    … …  
    64856476                        buildActionMask = 2147483647;
    64866477                        files = (
    6487                                 517B5F9E275F3F54002DC22D /* libicucore.tbd in Frameworks */,
    64886478                        );
    64896479                        runOnlyForDeploymentPostprocessing = 0;
    … …  
    71477137                                E1CC1B8E12D7EADF00625838 /* PrintInfo.h */,
    71487138                                463FD4811EB94EAD00A2982C /* ProcessTerminationReason.h */,
    7149                                 517B5F94275EBA62002DC22D /* PushMessageForTesting.h */,
    71507139                                9B1229D023FF2A5E008CA751 /* RemoteAudioDestinationIdentifier.h */,
    71517140                                7203449B26A6C476000A5F54 /* RenderingUpdateID.h */,
    … …  
    72547243                                517B5F2D2757382A002DC22D /* WebPushDaemonConnectionConfiguration.h */,
    72557244                                512CD6992721F04900F7F8EC /* WebPushDaemonConstants.h */,
    7256                                 517B5F96275EC5E5002DC22D /* WebPushMessage.h */,
    72577245                                5C8DD37F1FE4519200F2A556 /* WebsiteAutoplayPolicy.h */,
    72587246                                5C8DD3811FE455CA00F2A556 /* WebsiteAutoplayQuirk.h */,
    … …  
    89518939                                465250E51ECF52CD002025CB /* WebKit2InitializeCocoa.mm */,
    89528940                                1DE076D92460CCBD00B211E8 /* WebPreferencesDefaultValuesCocoa.mm */,
    8953                                 517B5F98275EC600002DC22D /* WebPushMessageCocoa.mm */,
    89548941                                37C4C0921814B3AF003688B9 /* WKNSArray.h */,
    89558942                                37C4C0911814B3AF003688B9 /* WKNSArray.mm */,
    … …  
    97149701                        isa = PBXGroup;
    97159702                        children = (
    9716                                 517B5F9D275F3F54002DC22D /* libicucore.tbd */,
    97179703                                57A9FF15252C6AEF006A2040 /* libWTF.a */,
    97189704                                5750F32A2032D4E500389347 /* LocalAuthentication.framework */,
    … …  
    1302813014                                839902031BE9A02B000F3653 /* NetworkLoad.h in Headers */,
    1302913015                                83D454D71BE9D3C4006C93BD /* NetworkLoadClient.h in Headers */,
    13030                                 517B5F97275EC5E5002DC22D /* WebPushMessage.h in Headers */,
    1303113016                                839149651BEA838500D2D953 /* NetworkLoadParameters.h in Headers */,
    1303213017                                E47FC8A025B8331C005495FC /* NetworkLoadScheduler.h in Headers */,
    … …  
    1353613521                                517A53101F47A86200DCDC0A /* WebSWClientConnectionMessages.h in Headers */,
    1353713522                                466BC03C1FA266DA002FA9C1 /* WebSWContextManagerConnection.h in Headers */,
    13538                                 517B5F95275EBA63002DC22D /* PushMessageForTesting.h in Headers */,
    1353913523                                460F48901F996F7100CF4B87 /* WebSWContextManagerConnectionMessages.h in Headers */,
    1354013524                                C11A9ECC214035F800CFB20A /* WebSwitchingGPUClient.h in Headers */,
    … …  
    1510215086                        buildActionMask = 2147483647;
    1510315087                        files = (
    15104                                 517B5F9A275F3A86002DC22D /* ArgumentCoders.cpp in Sources */,
    1510515088                                517B5F68275A9A78002DC22D /* WebPushToolConnection.mm in Sources */,
    15106                                 517B5F9B275F3A98002DC22D /* DaemonUtilities.mm in Sources */,
    15107                                 517B5F9C275F3C37002DC22D /* DaemonEncoder.cpp in Sources */,
    1510815089                                517B5F65275A8D7F002DC22D /* WebPushToolMain.mm in Sources */,
    1510915090                        );
    … …  
    1520115182                                C1A152D724E5A29A00978C8B /* HandleXPCEndpointMessages.mm in Sources */,
    1520215183                                2749F6442146561B008380BF /* InjectedBundleNodeHandle.cpp in Sources */,
    15203                                 517B5F99275EC601002DC22D /* WebPushMessageCocoa.mm in Sources */,
    1520415184                                2749F6452146561E008380BF /* InjectedBundleRangeHandle.cpp in Sources */,
    1520515185                                9BF5EC642541145600984E77 /* JSIPCBinding.cpp in Sources */,

  • trunk/Source/WebKit/webpushd/PushClientConnection.h

    r286764 r286777  
    5757    const String& hostAppCodeSigningIdentifier();
    5858    bool hostAppHasPushEntitlement();
    59     bool hostAppHasPushInjectEntitlement();
    6059
    6160    bool debugModeIsEnabled() const { return m_debugModeEnabled; }
    … …  
    7776    void setHostAppAuditTokenData(const Vector<uint8_t>&);
    7877
    79     bool hostHasEntitlement(const char*);
    80 
    8178    OSObjectPtr<xpc_connection_t> m_xpcConnection;
    8279

  • trunk/Source/WebKit/webpushd/PushClientConnection.mm

    r286764 r286777  
    9090bool ClientConnection::hostAppHasPushEntitlement()
    9191{
    92     if (!m_hostAppHasPushEntitlement)
    93         m_hostAppHasPushEntitlement = hostHasEntitlement("com.apple.private.webkit.webpush"_s);
     92    if (!m_hostAppHasPushEntitlement) {
     93        if (!m_hostAppAuditToken)
     94            return false;
     95        m_hostAppHasPushEntitlement = WTF::hasEntitlement(*m_hostAppAuditToken, "com.apple.private.webkit.webpush");
     96    }
    9497
    9598    return *m_hostAppHasPushEntitlement;
    96 }
    97 
    98 bool ClientConnection::hostAppHasPushInjectEntitlement()
    99 {
    100     return hostHasEntitlement("com.apple.private.webkit.webpush.inject"_s);
    101 }
    102 
    103 bool ClientConnection::hostHasEntitlement(const char* entitlement)
    104 {
    105     if (!m_hostAppAuditToken)
    106         return false;
    107     return WTF::hasEntitlement(*m_hostAppAuditToken, entitlement);
    10899}
    109100
    … …  
    122113    auto signingIdentifer = hostAppCodeSigningIdentifier();
    123114    if (signingIdentifer.isEmpty())
    124         messageIdentifier = makeString("[(0x", hex(reinterpret_cast<uint64_t>(m_xpcConnection.get()), WTF::HexConversionMode::Lowercase), ")] ");
     115        messageIdentifier = makeString("[(0x", hex(reinterpret_cast<uint64_t>(m_xpcConnection.get()), WTF::HexConversionMode::Lowercase), ")] ");
    125116    else
    126         messageIdentifier = makeString("[", signingIdentifer, " (0x", hex(reinterpret_cast<uint64_t>(m_xpcConnection.get()), WTF::HexConversionMode::Lowercase), ")] ");
     117        messageIdentifier = makeString("[", signingIdentifer, " (0x", hex(reinterpret_cast<uint64_t>(m_xpcConnection.get()), WTF::HexConversionMode::Lowercase), ")] ");
    127118
    128119    Daemon::singleton().broadcastDebugMessage(JSC::MessageLevel::Info, makeString(messageIdentifier, message));

  • trunk/Source/WebKit/webpushd/WebPushDaemon.h

    r286764 r286777  
    2727
    2828#include "PushClientConnection.h"
    29 #include "PushMessageForTesting.h"
    3029#include "WebPushDaemonConnectionConfiguration.h"
    3130#include "WebPushDaemonConstants.h"
    32 #include "WebPushMessage.h"
    33 #include <wtf/Deque.h>
    3431#include <wtf/Forward.h>
    3532#include <wtf/HashMap.h>
    … …  
    4441}
    4542
    46 using WebKit::WebPushD::PushMessageForTesting;
    4743using WebKit::WebPushD::WebPushDaemonConnectionConfiguration;
    4844
    … …  
    6763    void setDebugModeIsEnabled(ClientConnection*, bool);
    6864    void updateConnectionConfiguration(ClientConnection*, const WebPushDaemonConnectionConfiguration&);
    69     void injectPushMessageForTesting(ClientConnection*, const PushMessageForTesting&, CompletionHandler<void(bool)>&&);
    70     void getPendingPushMessages(ClientConnection*, CompletionHandler<void(const Vector<WebKit::WebPushMessage>&)>&& replySender);
    7165
    7266    void broadcastDebugMessage(JSC::MessageLevel, const String&);
    … …  
    8276    ClientConnection* toClientConnection(xpc_connection_t);
    8377    HashMap<xpc_connection_t, Ref<ClientConnection>> m_connectionMap;
    84 
    85     HashMap<String, Deque<PushMessageForTesting>> m_testingPushMessages;
    8678};
    8779

  • trunk/Source/WebKit/webpushd/WebPushDaemon.mm

    r286764 r286777  
    7171END
    7272
    73 FUNCTION(getPendingPushMessages)
    74 ARGUMENTS()
    75 REPLY(const Vector<WebKit::WebPushMessage>&)
    76 END
    77 
    7873FUNCTION(setDebugModeIsEnabled)
    7974ARGUMENTS(bool)
    … …  
    8277FUNCTION(updateConnectionConfiguration)
    8378ARGUMENTS(WebPushDaemonConnectionConfiguration)
    84 END
    85 
    86 FUNCTION(injectPushMessageForTesting)
    87 ARGUMENTS(PushMessageForTesting)
    88 REPLY(bool)
    8979END
    9080
    … …  
    116106
    117107WebPushD::EncodedMessage requestSystemNotificationPermission::encodeReply(bool reply)
    118 {
    119     WebKit::Daemon::Encoder encoder;
    120     encoder << reply;
    121     return encoder.takeBuffer();
    122 }
    123 
    124 WebPushD::EncodedMessage injectPushMessageForTesting::encodeReply(bool reply)
    125 {
    126     WebKit::Daemon::Encoder encoder;
    127     encoder << reply;
    128     return encoder.takeBuffer();
    129 }
    130 
    131 WebPushD::EncodedMessage getPendingPushMessages::encodeReply(const Vector<WebKit::WebPushMessage>& reply)
    132108{
    133109    WebKit::Daemon::Encoder encoder;
    … …  
    258234        handleWebPushDMessage<MessageInfo::updateConnectionConfiguration>(clientConnection, encodedMessage);
    259235        break;
    260     case MessageType::InjectPushMessageForTesting:
    261         handleWebPushDMessageWithReply<MessageInfo::injectPushMessageForTesting>(clientConnection, encodedMessage, WTFMove(replySender));
    262         break;
    263     case MessageType::GetPendingPushMessages:
    264         handleWebPushDMessageWithReply<MessageInfo::getPendingPushMessages>(clientConnection, encodedMessage, WTFMove(replySender));
    265         break;
    266236    }
    267237}
    … …  
    328298}
    329299
    330 void Daemon::injectPushMessageForTesting(ClientConnection* connection, const PushMessageForTesting& message, CompletionHandler<void(bool)>&& replySender)
    331 {
    332     if (!connection->hostAppHasPushInjectEntitlement()) {
    333         connection->broadcastDebugMessage("Attempting to inject a push message from an unentitled process");
    334         replySender(false);
    335         return;
    336     }
    337 
    338     if (message.targetAppCodeSigningIdentifier.isEmpty() || !message.registrationURL.isValid()) {
    339         connection->broadcastDebugMessage("Attempting to inject an invalid push message");
    340         replySender(false);
    341         return;
    342     }
    343 
    344     connection->broadcastDebugMessage(makeString("Injected a test push messasge for ", message.targetAppCodeSigningIdentifier, " at ", message.registrationURL.string()));
    345     connection->broadcastDebugMessage(message.message);
    346 
    347     auto addResult = m_testingPushMessages.ensure(message.targetAppCodeSigningIdentifier, [] {
    348         return Deque<PushMessageForTesting> { };
    349     });
    350     addResult.iterator->value.append(message);
    351 
    352     replySender(true);
    353 }
    354 
    355 void Daemon::getPendingPushMessages(ClientConnection* connection, CompletionHandler<void(const Vector<WebKit::WebPushMessage>&)>&& replySender)
    356 {
    357     auto hostAppCodeSigningIdentifier = connection->hostAppCodeSigningIdentifier();
    358     if (hostAppCodeSigningIdentifier.isEmpty()) {
    359         replySender({ });
    360         return;
    361     }
    362 
    363     Vector<WebKit::WebPushMessage> resultMessages;
    364 
    365     auto iterator = m_testingPushMessages.find(hostAppCodeSigningIdentifier);
    366     if (iterator != m_testingPushMessages.end()) {
    367         for (auto& message : iterator->value) {
    368             auto data = message.message.utf8();
    369             resultMessages.append(WebKit::WebPushMessage { Vector<uint8_t> { reinterpret_cast<const uint8_t*>(data.data()), data.length() }, message.registrationURL });
    370         }
    371         m_testingPushMessages.remove(iterator);
    372     }
    373 
    374     connection->broadcastDebugMessage(makeString("Fetching ", String::number(resultMessages.size()), " pending push messages"));
    375 
    376     replySender(WTFMove(resultMessages));
    377 }
    378 
    379300ClientConnection* Daemon::toClientConnection(xpc_connection_t connection)
    380301{

  • trunk/Source/WebKit/webpushd/webpushtool/WebPushToolConnection.h

    r286764 r286777  
    2626#pragma once
    2727
    28 #include "PushMessageForTesting.h"
    2928#include <memory>
    3029#include <wtf/RetainPtr.h>
    31 #include <wtf/URL.h>
    3230#include <wtf/WeakPtr.h>
    3331#include <wtf/spi/darwin/XPCSPI.h>
    34 
    35 using WebKit::WebPushD::PushMessageForTesting;
    3632
    3733namespace WebPushTool {
    … …  
    5955    void connectToService();
    6056
    61     void setPushMessage(std::unique_ptr<PushMessageForTesting>&& message) { m_pushMessage = WTFMove(message); }
    62 
    6357private:
    6458    void messageReceived(xpc_object_t);
    … …  
    6761    void startAction();
    6862    void startDebugStreamAction();
    69     void sendPushMessage();
    7063
    7164    void sendAuditToken();
    72 
     65   
    7366    Action m_action;
    7467    bool m_reconnect { false };
    7568    RetainPtr<xpc_connection_t> m_connection;
    7669    const char* m_serviceName;
    77 
    78     std::unique_ptr<PushMessageForTesting> m_pushMessage;
    7970};
    8071

  • trunk/Source/WebKit/webpushd/webpushtool/WebPushToolConnection.mm

    r286764 r286777  
    2727#import "WebPushToolConnection.h"
    2828
    29 #import "DaemonEncoder.h"
    30 #import "DaemonUtilities.h"
    31 #import "WebPushDaemonConstants.h"
    3229#import <mach/mach_init.h>
    3330#import <mach/task.h>
    … …  
    122119        break;
    123120    };
    124 
    125     if (m_pushMessage)
    126         sendPushMessage();
    127 }
    128 
    129 void Connection::sendPushMessage()
    130 {
    131     ASSERT(m_pushMessage);
    132 
    133     WebKit::Daemon::Encoder encoder;
    134     encoder << *m_pushMessage;
    135 
    136     auto dictionary = adoptNS(xpc_dictionary_create(nullptr, nullptr, 0));
    137     xpc_dictionary_set_uint64(dictionary.get(), WebKit::WebPushD::protocolVersionKey, WebKit::WebPushD::protocolVersionValue);
    138     xpc_dictionary_set_value(dictionary.get(), WebKit::WebPushD::protocolEncodedMessageKey, WebKit::vectorToXPCData(encoder.takeBuffer()).get());
    139     xpc_dictionary_set_uint64(dictionary.get(), WebKit::WebPushD::protocolMessageTypeKey, static_cast<uint64_t>(WebKit::WebPushD::MessageType::InjectPushMessageForTesting));
    140 
    141     xpc_connection_send_message_with_reply(m_connection.get(), dictionary.get(), dispatch_get_main_queue(), ^(xpc_object_t resultMessage) {
    142         // This reply handler intentionally left blank
    143     });
    144121}
    145122

  • trunk/Source/WebKit/webpushd/webpushtool/WebPushToolMain.mm

    r286764 r286777  
    2525
    2626#import "config.h"
    27 #import "PushMessageForTesting.h"
    2827#import "WebPushToolConnection.h"
    2928#import <Foundation/Foundation.h>
    3029#import <optional>
    3130#import <wtf/MainThread.h>
    32 
    33 using WebKit::WebPushD::PushMessageForTesting;
    3431
    3532__attribute__((__noreturn__))
    … …  
    4037    fprintf(stderr, "Usage: webpushtool [options]\n");
    4138    fprintf(stderr, "\n");
    42     fprintf(stderr, "  --development\n");
    43     fprintf(stderr, "    Connects to mach service \"org.webkit.webpushtestdaemon.service\" (Default)\n");
    44     fprintf(stderr, "  --production\n");
    45     fprintf(stderr, "    Connects to mach service \"com.apple.webkit.webpushd.service\"\n");
    46     fprintf(stderr, "  --streamDebugMessages\n");
    47     fprintf(stderr, "    Stream debug messages from webpushd\n");
    48     fprintf(stderr, "  --reconnect\n");
    49     fprintf(stderr, "    Reconnect after connection is lost\n");
    50     fprintf(stderr, "  --push <target app identifier> <registration URL> <message>\n");
    51     fprintf(stderr, "    Inject a test push messasge to the target app and registration URL\n");
     39    fprintf(stderr, "  --development              Connects to mach service \"org.webkit.webpushtestdaemon.service\" (Default)\n");
     40    fprintf(stderr, "  --production               Connects to mach service \"com.apple.webkit.webpushd.service\"\n");
     41    fprintf(stderr, "  --streamDebugMessages      Stream debug messages from webpushd\n");
     42    fprintf(stderr, "  --reconnect                Reconnect after connection is lost\n");
    5243    fprintf(stderr, "\n");
    5344
    5445    exit(-1);
    55 }
    56 
    57 static std::unique_ptr<PushMessageForTesting> pushMessageFromArguments(NSEnumerator<NSString *> *enumerator)
    58 {
    59     NSString *appIdentifier = [enumerator nextObject];
    60     if (!appIdentifier)
    61         return nullptr;
    62 
    63     NSString *registrationString = [enumerator nextObject];
    64     if (!registrationString)
    65         return nullptr;
    66 
    67     NSURL *registrationURL = [NSURL URLWithString:registrationString];
    68     if (!registrationURL)
    69         return nullptr;
    70 
    71     NSString *message = [enumerator nextObject];
    72     if (!message)
    73         return nullptr;
    74 
    75     PushMessageForTesting pushMessage = { appIdentifier, registrationURL, message };
    76     return makeUniqueWithoutFastMallocCheck<PushMessageForTesting>(WTFMove(pushMessage));
    7746}
    7847
    … …  
    8453    auto reconnect = WebPushTool::Reconnect::No;
    8554    std::optional<WebPushTool::Action> action;
    86     std::unique_ptr<PushMessageForTesting> pushMessage;
    8755
    8856    @autoreleasepool {
    … …  
    9159            printUsageAndTerminate(@"No arguments provided");
    9260
    93         NSEnumerator<NSString *> *enumerator = [[arguments subarrayWithRange:NSMakeRange(1, arguments.count - 1)] objectEnumerator];
    94         NSString *argument = [enumerator nextObject];
    95         while (argument) {
     61        for (NSString *argument in [arguments subarrayWithRange:NSMakeRange(1, arguments.count - 1)]) {
    9662            if ([argument isEqualToString:@"--production"])
    9763                preferTestService = WebPushTool::PreferTestService::No;
    … …  
    10268            else if ([argument isEqualToString:@"--reconnect"])
    10369                reconnect = WebPushTool::Reconnect::Yes;
    104             else if ([argument isEqualToString:@"--push"]) {
    105                 pushMessage = pushMessageFromArguments(enumerator);
    106                 if (!pushMessage)
    107                     printUsageAndTerminate([NSString stringWithFormat:@"Invalid push arguments specified"]);
    108             } else
     70            else
    10971                printUsageAndTerminate([NSString stringWithFormat:@"Invalid option provided: %@", argument]);
    110 
    111             argument = [enumerator nextObject];
    11272        }
    11373    }
    11474
    115     if (!action && !pushMessage)
     75    if (!action)
    11676        printUsageAndTerminate(@"No action provided");
    11777
    11878    auto connection = WebPushTool::Connection::create(*action, preferTestService, reconnect);
    119     if (pushMessage)
    120         connection->setPushMessage(WTFMove(pushMessage));
    121 
    12279    connection->connectToService();
    12380

  • trunk/Tools/ChangeLog

    r286772 r286777  
     1
     2
     3
     4
     5
     6
     7
     8
     9
     10
     11
     12
     13
    1142021-12-09  Myles C. Maxfield  <mmaxfield@apple.com> and Don Olmstead  <don.olmstead@sony.com>
    215

  • trunk/Tools/TestWebKitAPI/Configurations/TestWebKitAPI-iOS.entitlements

    r286764 r286777  
    1313        <key>com.apple.private.webkit.webpush</key>
    1414        <true/>
    15         <key>com.apple.private.webkit.webpush.inject</key>
    16         <true/>
    1715        <key>com.apple.private.xpc.launchd.job-manager</key>
    1816        <string>TestWebKitAPI</string>

  • trunk/Tools/TestWebKitAPI/Configurations/TestWebKitAPI-macOS-internal.entitlements

    r286764 r286777  
    66        <string>TestWebKitAPI</string>
    77        <key>com.apple.private.webkit.webpush</key>
    8         <true/>
    9         <key>com.apple.private.webkit.webpush.inject</key>
    108        <true/>
    119        <key>com.apple.hid.manager.user-access-device</key>

  • trunk/Tools/TestWebKitAPI/Configurations/TestWebKitAPI-macOS.entitlements

    r286764 r286777  
    1111        <key>com.apple.private.webkit.webpush</key>
    1212        <true/>
    13         <key>com.apple.private.webkit.webpush.inject</key>
    14         <true/>
    1513        <key>com.apple.security.temporary-exception.sbpl</key>
    1614        <array>

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/PushAPI.mm

    r286764 r286777  
    3535#import <WebKit/_WKWebsiteDataStoreConfiguration.h>
    3636
    37 static NSDictionary *messageDictionary(NSData *data, NSURL *registration)
    38 {
    39     return @{
    40         @"WebKitPushData" : data,
    41         @"WebKitPushRegistrationURL" : registration
    42     };
    43 }
    44 
    4537static String expectedMessage;
    4638
    … …  
    155147    NSString *message = @"Sweet Potatoes";
    156148    expectedMessage = "Received: Sweet Potatoes";
    157 
    158     [[configuration websiteDataStore] _processPushMessage:messageDictionary([message dataUsingEncoding:NSUTF8StringEncoding], [server.request() URL]) completionHandler:^(bool result) {
     149    [[configuration websiteDataStore] _processPushMessage:[message dataUsingEncoding:NSUTF8StringEncoding] registration:[server.request() URL] completionHandler:^(bool result) {
    159150        pushMessageSuccessful = result;
    160151        pushMessageProcessed = true;
    … …  
    170161    message = @"Rotten Potatoes";
    171162    expectedMessage = "Received: Rotten Potatoes";
    172     [[configuration websiteDataStore] _processPushMessage:messageDictionary([message dataUsingEncoding:NSUTF8StringEncoding], [server.request() URL]) completionHandler:^(bool result) {
     163    [[configuration websiteDataStore] _processPushMessage: completionHandler:^(bool result) {
    173164        pushMessageSuccessful = result;
    174165        pushMessageProcessed = true;
    … …  
    244235    pushMessageSuccessful = false;
    245236    NSString *message = @"Sweet Potatoes";
    246     [[configuration websiteDataStore] _processPushMessage:messageDictionary([message dataUsingEncoding:NSUTF8StringEncoding], [server.request() URL]) completionHandler:^(bool result) {
     237    [[configuration websiteDataStore] _processPushMessage: completionHandler:^(bool result) {
    247238        pushMessageSuccessful = result;
    248239        pushMessageProcessed = true;
    … …  
    289280    pushMessageSuccessful = false;
    290281    NSString *message = @"Rotten Potatoes";
    291     [[configuration websiteDataStore] _processPushMessage:messageDictionary([message dataUsingEncoding:NSUTF8StringEncoding], [server.request() URL]) completionHandler:^(bool result) {
     282    [[configuration websiteDataStore] _processPushMessage: completionHandler:^(bool result) {
    292283        pushMessageSuccessful = result;
    293284        pushMessageProcessed = true;
    … …  
    342333    pushMessageSuccessful = false;
    343334    NSString *message = @"Timeless Potatoes";
    344     [[configuration websiteDataStore] _processPushMessage:messageDictionary([message dataUsingEncoding:NSUTF8StringEncoding], [server.request() URL]) completionHandler:^(bool result) {
     335    [[configuration websiteDataStore] _processPushMessage: completionHandler:^(bool result) {
    345336        pushMessageSuccessful = result;
    346337        pushMessageProcessed = true;

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/WebPushDaemon.mm

    r286764 r286777  
    2727
    2828#import "DaemonTestUtilities.h"
    29 #import "HTTPServer.h"
    3029#import "Test.h"
    3130#import "TestURLSchemeHandler.h"
    … …  
    3736#import <WebKit/_WKExperimentalFeature.h>
    3837#import <WebKit/_WKWebsiteDataStoreConfiguration.h>
     38
    3939#import <mach/mach_init.h>
    4040#import <mach/task.h>
    … …  
    163163}
    164164
    165 static RetainPtr<xpc_object_t> createMessageDictionary(uint8_t messageType, const Vector<uint8_t>& message)
    166 {
    167     auto dictionary = adoptNS(xpc_dictionary_create(nullptr, nullptr, 0));
    168     xpc_dictionary_set_uint64(dictionary.get(), "protocol version", 1);
    169     xpc_dictionary_set_uint64(dictionary.get(), "message type", messageType);
    170     xpc_dictionary_set_data(dictionary.get(), "encoded message", message.data(), message.size());
    171     return WTFMove(dictionary);
    172 }
    173 
    174 // Uses an existing connection to the daemon for a one-off message
    175 void sendMessageToDaemon(xpc_connection_t connection, uint8_t messageType, const Vector<uint8_t>& message)
    176 {
    177     auto dictionary = createMessageDictionary(messageType, message);
    178     xpc_connection_send_message(connection, dictionary.get());
    179 }
    180 
    181 // Uses an existing connection to the daemon for a one-off message, waiting for the reply
    182 void sendMessageToDaemonWaitingForReply(xpc_connection_t connection, uint8_t messageType, const Vector<uint8_t>& message)
    183 {
    184     auto dictionary = createMessageDictionary(messageType, message);
    185 
    186     __block bool done = false;
    187     xpc_connection_send_message_with_reply(connection, dictionary.get(), dispatch_get_main_queue(), ^(xpc_object_t request) {
    188         done = true;
    189     });
    190 
    191     TestWebKitAPI::Util::run(&done);
    192 }
    193 
    194 static void sendConfigurationWithAuditToken(xpc_connection_t connection)
    195 {
    196     audit_token_t token = { 0, 0, 0, 0, 0, 0, 0, 0 };
    197     mach_msg_type_number_t auditTokenCount = TASK_AUDIT_TOKEN_COUNT;
    198     kern_return_t result = task_info(mach_task_self(), TASK_AUDIT_TOKEN, (task_info_t)(&token), &auditTokenCount);
    199     if (result != KERN_SUCCESS) {
    200         EXPECT_TRUE(false);
    201         return;
    202     }
    203 
    204     // Send configuration with audit token
    205     {
    206         Vector<uint8_t> encodedMessage(42);
    207         encodedMessage.fill(0);
    208         encodedMessage[1] = 1;
    209         encodedMessage[2] = 32;
    210         memcpy(&encodedMessage[10], &token, sizeof(token));
    211         sendMessageToDaemon(connection, 6, encodedMessage);
    212     }
    213 }
    214 
    215 RetainPtr<xpc_connection_t> createAndConfigureConnectionToService(const char* serviceName)
    216 {
    217     auto connection = adoptNS(xpc_connection_create_mach_service(serviceName, dispatch_get_main_queue(), 0));
    218     xpc_connection_set_event_handler(connection.get(), ^(xpc_object_t) { });
    219     xpc_connection_activate(connection.get());
    220     sendConfigurationWithAuditToken(connection.get());
    221 
    222     return WTFMove(connection);
    223 }
    224 
    225 static Vector<uint8_t> encodeString(const String& message)
    226 {
    227     ASSERT(message.is8Bit());
    228     auto utf8 = message.utf8();
    229 
    230     Vector<uint8_t> result(utf8.length() + 5);
    231     result[0] = static_cast<uint8_t>(utf8.length());
    232     result[1] = static_cast<uint8_t>(utf8.length() >> 8);
    233     result[2] = static_cast<uint8_t>(utf8.length() >> 16);
    234     result[3] = static_cast<uint8_t>(utf8.length() >> 24);
    235     result[4] = 0x01;
    236 
    237     auto data = utf8.data();
    238     for (size_t i = 0; i < utf8.length(); ++i)
    239         result[5 + i] = data[i];
    240 
    241     return result;
    242 }
    243 
    244165// FIXME: Re-enable this test on Mac once webkit.org/232857 is resolved.
    245166#if PLATFORM(MAC)
    … …  
    276197
    277198    xpc_connection_activate(connection.get());
    278     sendConfigurationWithAuditToken(connection.get());
     199
     200    audit_token_t token = { 0, 0, 0, 0, 0, 0, 0, 0 };
     201    mach_msg_type_number_t auditTokenCount = TASK_AUDIT_TOKEN_COUNT;
     202    kern_return_t result = task_info(mach_task_self(), TASK_AUDIT_TOKEN, (task_info_t)(&token), &auditTokenCount);
     203    if (result != KERN_SUCCESS) {
     204        EXPECT_TRUE(false);
     205        return;
     206    }
     207
     208    // Send configuration with audit token
     209    {
     210        std::array<uint8_t, 42> encodedMessage;
     211        encodedMessage.fill(0);
     212        encodedMessage[1] = 1;
     213        encodedMessage[2] = 32;
     214        memcpy(&encodedMessage[10], &token, sizeof(token));
     215        auto dictionary = adoptNS(xpc_dictionary_create(nullptr, nullptr, 0));
     216        xpc_dictionary_set_uint64(dictionary.get(), "protocol version", 1);
     217        xpc_dictionary_set_uint64(dictionary.get(), "message type", 6);
     218        xpc_dictionary_set_data(dictionary.get(), "encoded message", encodedMessage.data(), encodedMessage.size());
     219        xpc_connection_send_message(connection.get(), dictionary.get());
     220    }
    279221
    280222    // Enable debug messages, and wait for the resulting debug message
    281223    {
    282224        auto dictionary = adoptNS(xpc_dictionary_create(nullptr, nullptr, 0));
    283         Vector<uint8_t> encodedMessage(1);
    284         encodedMessage[0] = 1;
    285         sendMessageToDaemon(connection.get(), 5, encodedMessage);
     225        std::array<uint8_t, 1> encodedMessage { 1 };
     226        xpc_dictionary_set_uint64(dictionary.get(), "protocol version", 1);
     227        xpc_dictionary_set_uint64(dictionary.get(), "message type", 5);
     228        xpc_dictionary_set_data(dictionary.get(), "encoded message", encodedMessage.data(), encodedMessage.size());
     229
     230        xpc_connection_send_message(connection.get(), dictionary.get());
    286231        TestWebKitAPI::Util::run(&done);
    287232    }
    … …  
    289234    // Echo and wait for a reply
    290235    auto dictionary = adoptNS(xpc_dictionary_create(nullptr, nullptr, 0));
    291     auto encodedString = encodeString("hello");
     236    ;
    292237    xpc_dictionary_set_uint64(dictionary.get(), "protocol version", 1);
    293238    xpc_dictionary_set_uint64(dictionary.get(), "message type", 1);
    … …  
    397342}
    398343
    399 static const char* mainSWBytes = R"SWRESOURCE(
    400 <script>
    401 function log(msg)
    402 {
    403     window.webkit.messageHandlers.sw.postMessage(msg);
    404 }
    405 
    406 const channel = new MessageChannel();
    407 channel.port1.onmessage = (event) => log(event.data);
    408 
    409 navigator.serviceWorker.register('/sw.js').then((registration) => {
    410     if (registration.active) {
    411         registration.active.postMessage({port: channel.port2}, [channel.port2]);
    412         return;
    413     }
    414     worker = registration.installing;
    415     worker.addEventListener('statechange', function() {
    416         if (worker.state == 'activated')
    417             worker.postMessage({port: channel.port2}, [channel.port2]);
    418     });
    419 }).catch(function(error) {
    420     log("Registration failed with: " + error);
    421 });
    422 </script>
    423 )SWRESOURCE";
    424 
    425 static const char* scriptBytes = R"SWRESOURCE(
    426 let port;
    427 self.addEventListener("message", (event) => {
    428     port = event.data.port;
    429     port.postMessage("Ready");
    430 });
    431 self.addEventListener("push", (event) => {
    432     try {
    433         if (!event.data) {
    434             port.postMessage("Received: null data");
    435             return;
    436         }
    437         const value = event.data.text();
    438         port.postMessage("Received: " + value);
    439         if (value != 'Sweet Potatoes')
    440             event.waitUntil(Promise.reject('I want sweet potatoes'));
    441     } catch (e) {
    442         port.postMessage("Got exception " + e);
    443     }
    444 });
    445 )SWRESOURCE";
    446 
    447 static void clearWebsiteDataStore(WKWebsiteDataStore *store)
    448 {
    449     __block bool clearedStore = false;
    450     [[WKWebsiteDataStore defaultDataStore] removeDataOfTypes:[WKWebsiteDataStore allWebsiteDataTypes] modifiedSince:[NSDate distantPast] completionHandler:^() {
    451         clearedStore = true;
    452     }];
    453     TestWebKitAPI::Util::run(&clearedStore);
    454 }
    455 
    456 // FIXME: Re-enable this test on Mac once webkit.org/232857 is resolved.
    457 #if PLATFORM(MAC)
    458 TEST(WebPushD, DISABLED_HandleInjectedPush)
    459 #else
    460 TEST(WebPushD, HandleInjectedPush)
    461 #endif
    462 {
    463     [WKWebsiteDataStore _allowWebsiteDataRecordsForAllOrigins];
    464 
    465     NSURL *tempDirectory = setUpTestWebPushD();
    466 
    467     auto dataStoreConfiguration = adoptNS([_WKWebsiteDataStoreConfiguration new]);
    468     dataStoreConfiguration.get().webPushMachServiceName = @"org.webkit.webpushtestdaemon.service";
    469     dataStoreConfiguration.get().webPushDaemonUsesMockBundlesForTesting = YES;
    470     auto dataStore = adoptNS([[WKWebsiteDataStore alloc] _initWithConfiguration:dataStoreConfiguration.get()]);
    471 
    472     auto configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
    473     configuration.get().websiteDataStore = dataStore.get();
    474     clearWebsiteDataStore([configuration websiteDataStore]);
    475 
    476     [configuration.get().preferences _setNotificationsEnabled:YES];
    477     for (_WKExperimentalFeature *feature in [WKPreferences _experimentalFeatures]) {
    478         if ([feature.key isEqualToString:@"BuiltInNotificationsEnabled"])
    479             [[configuration preferences] _setEnabled:YES forFeature:feature];
    480     }
    481 
    482     auto messageHandler = adoptNS([[TestMessageHandler alloc] init]);
    483     [[configuration userContentController] addScriptMessageHandler:messageHandler.get() name:@"sw"];
    484     __block bool done = false;
    485     [messageHandler addMessage:@"Ready" withHandler:^{
    486         done = true;
    487     }];
    488     [messageHandler addMessage:@"Received: Hello World" withHandler:^{
    489         done = true;
    490     }];
    491 
    492     TestWebKitAPI::HTTPServer server({
    493         { "/", { mainSWBytes } },
    494         { "/sw.js", { { { "Content-Type", "application/javascript" } }, scriptBytes } }
    495     }, TestWebKitAPI::HTTPServer::Protocol::Http);
    496 
    497     auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:configuration.get()]);
    498     [webView loadRequest:server.request()];
    499 
    500     TestWebKitAPI::Util::run(&done);
    501     done = false;
    502 
    503     // Inject push message
    504     auto encodedMessage = encodeString("com.apple.WebKit.TestWebKitAPI");
    505     encodedMessage.appendVector(encodeString(server.request().URL.absoluteString));
    506     encodedMessage.appendVector(encodeString("Hello World"));
    507 
    508     auto utilityConnection = createAndConfigureConnectionToService("org.webkit.webpushtestdaemon.service");
    509     sendMessageToDaemonWaitingForReply(utilityConnection.get(), 7, encodedMessage);
    510 
    511     // Fetch push messages
    512     __block RetainPtr<NSArray<NSDictionary *>> messages;
    513     [dataStore _getPendingPushMessages:^(NSArray<NSDictionary *> *rawMessages) {
    514         messages = rawMessages;
    515         done = true;
    516     }];
    517     TestWebKitAPI::Util::run(&done);
    518     done = false;
    519 
    520     EXPECT_EQ([messages count], 1u);
    521 
    522     // Handle push message
    523     __block bool pushMessageProcessed = false;
    524     [dataStore _processPushMessage:[messages firstObject] completionHandler:^(bool result) {
    525         pushMessageProcessed = true;
    526     }];
    527     TestWebKitAPI::Util::run(&done);
    528     TestWebKitAPI::Util::run(&pushMessageProcessed);
    529 
    530     cleanUpTestWebPushD(tempDirectory);
    531 }
    532 
    533344} // namespace TestWebKitAPI
    534345

  • trunk/Tools/TestWebKitAPI/cocoa/TestWKWebView.h

    r286764 r286777  
    7979@interface TestMessageHandler : NSObject <WKScriptMessageHandler>
    8080- (void)addMessage:(NSString *)message withHandler:(dispatch_block_t)handler;
    81 - (void)setWildcardMessageHandler:(void (^)(NSString *))handler;
    8281@end
    8382
Note: See TracChangeset for help on using the changeset viewer.