Changeset 230293 in webkit


Ignore:
Timestamp:
Apr 4, 2018 8:15:46 PM (6 years ago)
Author:
Ryan Haddad
Message:

Unreviewed, rolling out r230283.

Caused webkitpy test failures.

Reverted changeset:

"Use CompletionHandlers for DelayedReplies"
https://bugs.webkit.org/show_bug.cgi?id=182269
https://trac.webkit.org/changeset/230283

Location:
trunk/Source/WebKit
Files:
30 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebKit/ChangeLog

    r230292 r230293  
     12018-04-04  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        Unreviewed, rolling out r230283.
     4
     5        Caused webkitpy test failures.
     6
     7        Reverted changeset:
     8
     9        "Use CompletionHandlers for DelayedReplies"
     10        https://bugs.webkit.org/show_bug.cgi?id=182269
     11        https://trac.webkit.org/changeset/230283
     12
    1132018-04-04  Youenn Fablet  <youenn@apple.com>
    214
  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp

    r230290 r230293  
    229229}
    230230
    231 void NetworkConnectionToWebProcess::scheduleResourceLoad(NetworkResourceLoadParameters&& loadParameters)
    232 {
    233     auto loader = NetworkResourceLoader::create(WTFMove(loadParameters), *this);
     231void NetworkConnectionToWebProcess::scheduleResourceLoad(const NetworkResourceLoadParameters& loadParameters)
     232{
     233    auto loader = NetworkResourceLoader::create(loadParameters, *this);
    234234    m_networkResourceLoaders.add(loadParameters.identifier, loader.ptr());
    235235    loader->start();
    236236}
    237237
    238 void NetworkConnectionToWebProcess::performSynchronousLoad(NetworkResourceLoadParameters&& loadParameters, Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply&& reply)
    239 {
    240     auto loader = NetworkResourceLoader::create(WTFMove(loadParameters), *this, WTFMove(reply));
     238void NetworkConnectionToWebProcess::performSynchronousLoad(const NetworkResourceLoadParameters& loadParameters, Ref<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>&& reply)
     239{
     240    auto loader = NetworkResourceLoader::create(loadParameters, *this, WTFMove(reply));
    241241    m_networkResourceLoaders.add(loadParameters.identifier, loader.ptr());
    242242    loader->start();
  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h

    r230290 r230293  
    9191    void didReceiveSyncNetworkConnectionToWebProcessMessage(IPC::Connection&, IPC::Decoder&, std::unique_ptr<IPC::Encoder>&);
    9292
    93     void scheduleResourceLoad(NetworkResourceLoadParameters&&);
    94     void performSynchronousLoad(NetworkResourceLoadParameters&&, Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply&&);
     93    void scheduleResourceLoad(const NetworkResourceLoadParameters&);
     94    void performSynchronousLoad(const NetworkResourceLoadParameters&, Ref<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>&&);
    9595    void loadPing(NetworkResourceLoadParameters&&, WebCore::HTTPHeaderMap&& originalRequestHeaders);
    9696    void prefetchDNS(const String&);
  • trunk/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp

    r230283 r230293  
    6363
    6464struct NetworkResourceLoader::SynchronousLoadData {
    65     SynchronousLoadData(Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply&& reply)
     65    SynchronousLoadData(RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>&& reply)
    6666        : delayedReply(WTFMove(reply))
    6767    {
     
    6969    }
    7070    ResourceRequest currentRequest;
    71     Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply delayedReply;
     71    RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> delayedReply;
    7272    ResourceResponse response;
    7373    ResourceError error;
     
    8383        responseBuffer.append(buffer->data(), buffer->size());
    8484
    85     data.delayedReply(data.error, data.response, responseBuffer);
     85    data.delayedReply->send(data.error, data.response, responseBuffer);
    8686    data.delayedReply = nullptr;
    8787}
    8888
    89 NetworkResourceLoader::NetworkResourceLoader(NetworkResourceLoadParameters&& parameters, NetworkConnectionToWebProcess& connection, Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply&& synchronousReply)
    90     : m_parameters { WTFMove(parameters) }
     89NetworkResourceLoader::NetworkResourceLoader(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess& connection, RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>&& synchronousReply)
     90    : m_parameters { parameters }
    9191    , m_connection { connection }
    92     , m_defersLoading { m_parameters.defersLoading }
    93     , m_isAllowedToAskUserForCredentials { m_parameters.clientCredentialPolicy == ClientCredentialPolicy::MayAskClientForCredentials }
     92    , m_defersLoading { parameters.defersLoading }
     93    , m_isAllowedToAskUserForCredentials { parameters.clientCredentialPolicy == ClientCredentialPolicy::MayAskClientForCredentials }
    9494    , m_bufferingTimer { *this, &NetworkResourceLoader::bufferingTimerFired }
    9595    , m_cache { sessionID().isEphemeral() ? nullptr : NetworkProcess::singleton().cache() }
  • trunk/Source/WebKit/NetworkProcess/NetworkResourceLoader.h

    r230283 r230293  
    2424 */
    2525
    26 #pragma once
     26#ifndef NetworkResourceLoader_h
     27#define NetworkResourceLoader_h
    2728
    2829#include "DownloadID.h"
     
    5253class NetworkResourceLoader final : public RefCounted<NetworkResourceLoader>, public NetworkLoadClient, public IPC::MessageSender {
    5354public:
    54     static Ref<NetworkResourceLoader> create(NetworkResourceLoadParameters&& parameters, NetworkConnectionToWebProcess& connection, Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply&& reply = nullptr)
     55    static Ref<NetworkResourceLoader> create(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess& connection, RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>&& reply = nullptr)
    5556    {
    56         return adoptRef(*new NetworkResourceLoader(WTFMove(parameters), connection, WTFMove(reply)));
     57        return adoptRef(*new NetworkResourceLoader(parameters, connection, WTFMove(reply)));
    5758    }
    5859    virtual ~NetworkResourceLoader();
     
    111112
    112113private:
    113     NetworkResourceLoader(NetworkResourceLoadParameters&&, NetworkConnectionToWebProcess&, Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply&&);
     114    NetworkResourceLoader(const NetworkResourceLoadParameters&, NetworkConnectionToWebProcess&, RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>&&);
    114115
    115116    // IPC::MessageSender
     
    181182
    182183} // namespace WebKit
     184
     185#endif // NetworkResourceLoader_h
  • trunk/Source/WebKit/Platform/IPC/Connection.h

    r230283 r230293  
    5555namespace IPC {
    5656
    57 template<typename> struct CodingType;
    58 
    5957enum class SendOption {
    6058    // Whether this message should be dispatched when waiting for a sync reply.
  • trunk/Source/WebKit/Platform/IPC/HandleMessage.h

    r230283 r230293  
    2727
    2828#include "ArgumentCoders.h"
    29 #include <wtf/CompletionHandler.h>
    3029#include <wtf/StdLibExtras.h>
    3130
     
    6463// Dispatch functions with delayed reply arguments.
    6564
    66 template <typename C, typename MF, typename CH, typename ArgsTuple, size_t... ArgsIndex>
    67 void callMemberFunctionImpl(C* object, MF function, CompletionHandler<CH>&& completionHandler, ArgsTuple&& args, std::index_sequence<ArgsIndex...>)
     65template <typename C, typename MF, typename R, typename ArgsTuple, size_t... ArgsIndex>
     66void callMemberFunctionImpl(C* object, MF function, Ref<R>&& delayedReply, ArgsTuple&& args, std::index_sequence<ArgsIndex...>)
    6867{
    69     (object->*function)(std::get<ArgsIndex>(std::forward<ArgsTuple>(args))..., WTFMove(completionHandler));
     68    (object->*function)(std::get<ArgsIndex>(std::forward<ArgsTuple>(args))..., WTFMove(delayedReply));
    7069}
    7170
    72 template<typename C, typename MF, typename CH, typename ArgsTuple, typename ArgsIndicies = std::make_index_sequence<std::tuple_size<ArgsTuple>::value>>
    73 void callMemberFunction(ArgsTuple&& args, CompletionHandler<CH>&& completionHandler, C* object, MF function)
     71template<typename C, typename MF, typename R, typename ArgsTuple, typename ArgsIndicies = std::make_index_sequence<std::tuple_size<ArgsTuple>::value>>
     72void callMemberFunction(ArgsTuple&& args, Ref<R>&& delayedReply, C* object, MF function)
    7473{
    75     callMemberFunctionImpl(object, function, WTFMove(completionHandler), std::forward<ArgsTuple>(args), ArgsIndicies());
     74    callMemberFunctionImpl(object, function, WTFMove(delayedReply), std::forward<ArgsTuple>(args), ArgsIndicies());
    7675}
    7776
     
    176175    }
    177176
    178     typename T::DelayedReply completionHandler = [replyEncoder = WTFMove(replyEncoder), connection = makeRef(connection)] (auto&&... args) mutable {
    179         T::send(WTFMove(replyEncoder), WTFMove(connection), args...);
    180     };
    181    
    182     callMemberFunction(WTFMove(arguments), WTFMove(completionHandler), object, function);
     177    Ref<typename T::DelayedReply> delayedReply = adoptRef(*new typename T::DelayedReply(connection, WTFMove(replyEncoder)));
     178    callMemberFunction(WTFMove(arguments), WTFMove(delayedReply), object, function);
    183179}
    184180
  • trunk/Source/WebKit/PluginProcess/PluginControllerProxy.cpp

    r230283 r230293  
    9292}
    9393
    94 void PluginControllerProxy::setInitializationReply(Messages::WebProcessConnection::CreatePlugin::DelayedReply&& reply)
     94void PluginControllerProxy::setInitializationReply(Ref<Messages::WebProcessConnection::CreatePlugin::DelayedReply>&& reply)
    9595{
    9696    ASSERT(!m_initializationReply);
     
    9898}
    9999
    100 Messages::WebProcessConnection::CreatePlugin::DelayedReply PluginControllerProxy::takeInitializationReply()
    101 {
    102     ASSERT(m_initializationReply);
    103     return WTFMove(m_initializationReply);
     100RefPtr<Messages::WebProcessConnection::CreatePlugin::DelayedReply> PluginControllerProxy::takeInitializationReply()
     101{
     102    return m_initializationReply;
    104103}
    105104
  • trunk/Source/WebKit/PluginProcess/PluginControllerProxy.h

    r230283 r230293  
    7575    bool isInitializing() const { return m_isInitializing; }
    7676   
    77     void setInitializationReply(Messages::WebProcessConnection::CreatePlugin::DelayedReply&&);
    78     Messages::WebProcessConnection::CreatePlugin::DelayedReply takeInitializationReply();
     77    void setInitializationReply(Ref<Messages::WebProcessConnection::CreatePlugin::DelayedReply>&&);
     78    RefPtr<Messages::WebProcessConnection::CreatePlugin::DelayedReply> takeInitializationReply();
    7979
    8080private:
     
    184184    bool m_isWindowVisible;
    185185
    186     Messages::WebProcessConnection::CreatePlugin::DelayedReply m_initializationReply;
     186    RefPtr<Messages::WebProcessConnection::CreatePlugin::DelayedReply> m_initializationReply;
    187187
    188188    RefPtr<Plugin> m_plugin;
  • trunk/Source/WebKit/PluginProcess/WebProcessConnection.cpp

    r230283 r230293  
    180180}
    181181
    182 void WebProcessConnection::destroyPlugin(uint64_t pluginInstanceID, bool asynchronousCreationIncomplete, Messages::WebProcessConnection::DestroyPlugin::DelayedReply&& reply)
     182void WebProcessConnection::destroyPlugin(uint64_t pluginInstanceID, bool asynchronousCreationIncomplete, Ref<Messages::WebProcessConnection::DestroyPlugin::DelayedReply>&& reply)
    183183{
    184184    // We return immediately from this synchronous IPC. We want to make sure the plugin destruction is just about to start so audio playback
    185185    // will finish soon after returning. However we don't want to wait for destruction to complete fully as that may take a while.
    186     reply();
     186    reply->send();
    187187
    188188    // Ensure we don't clamp any timers during destruction
     
    233233}
    234234
    235 void WebProcessConnection::createPlugin(const PluginCreationParameters& creationParameters, Messages::WebProcessConnection::CreatePlugin::DelayedReply&& reply)
     235void WebProcessConnection::createPlugin(const PluginCreationParameters& creationParameters, Ref<Messages::WebProcessConnection::CreatePlugin::DelayedReply>&& reply)
    236236{
    237237    // Ensure we don't clamp any timers during initialization
     
    250250        // If its initialization is complete then we need to respond to this message with the correct information about its creation.
    251251#if PLATFORM(COCOA)
    252         reply(true, pluginControllerProxy->wantsWheelEvents(), pluginControllerProxy->remoteLayerClientID());
     252        reply->send(true, pluginControllerProxy->wantsWheelEvents(), pluginControllerProxy->remoteLayerClientID());
    253253#else
    254         reply(true, pluginControllerProxy->wantsWheelEvents(), 0);
     254        reply->send(true, pluginControllerProxy->wantsWheelEvents(), 0);
    255255#endif
    256256        return;
     
    267267    createPluginInternal(creationParameters, result, wantsWheelEvents, remoteLayerClientID);
    268268   
    269     reply(result, wantsWheelEvents, remoteLayerClientID);
     269    reply->send(result, wantsWheelEvents, remoteLayerClientID);
    270270}
    271271
     
    312312    PluginControllerProxy* pluginControllerProxy = m_pluginControllers.get(creationParameters.pluginInstanceID);
    313313    ASSERT(pluginControllerProxy);
    314     if (auto delayedSyncReply = pluginControllerProxy->takeInitializationReply()) {
    315         delayedSyncReply(result, wantsWheelEvents, remoteLayerClientID);
     314    if (RefPtr<Messages::WebProcessConnection::CreatePlugin::DelayedReply> delayedSyncReply = pluginControllerProxy->takeInitializationReply()) {
     315        delayedSyncReply->send(result, wantsWheelEvents, remoteLayerClientID);
    316316        return;
    317317    }
  • trunk/Source/WebKit/PluginProcess/WebProcessConnection.h

    r230283 r230293  
    7070    void didReceiveWebProcessConnectionMessage(IPC::Connection&, IPC::Decoder&);
    7171    void didReceiveSyncWebProcessConnectionMessage(IPC::Connection&, IPC::Decoder&, std::unique_ptr<IPC::Encoder>&);
    72     void createPlugin(const PluginCreationParameters&, Messages::WebProcessConnection::CreatePlugin::DelayedReply&&);
     72    void createPlugin(const PluginCreationParameters&, Ref<Messages::WebProcessConnection::CreatePlugin::DelayedReply>&&);
    7373    void createPluginAsynchronously(const PluginCreationParameters&);
    74     void destroyPlugin(uint64_t pluginInstanceID, bool asynchronousCreationIncomplete, Messages::WebProcessConnection::DestroyPlugin::DelayedReply&&);
     74    void destroyPlugin(uint64_t pluginInstanceID, bool asynchronousCreationIncomplete, Ref<Messages::WebProcessConnection::DestroyPlugin::DelayedReply>&&);
    7575   
    7676    void createPluginInternal(const PluginCreationParameters&, bool& result, bool& wantsWheelEvents, uint32_t& remoteLayerClientID);
  • trunk/Source/WebKit/Scripts/webkit/messages.py

    r230283 r230293  
    119119        if message.has_attribute(DELAYED_ATTRIBUTE):
    120120            send_parameters = [(function_parameter_type(x.type, x.kind), x.name) for x in message.reply_parameters]
    121             result.append('    using DelayedReply = CompletionHandler<void(')
    122             if len(send_parameters):
    123                 result.append('%s' % ', '.join([' '.join(x) for x in send_parameters]))
    124             result.append(')>;')
    125             result.append('    static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&')
    126             if len(send_parameters):
    127                 result.append(', %s' % ', '.join([' '.join(x) for x in send_parameters]))
    128             result.append(');\n')
     121            result.append('    struct DelayedReply : public ThreadSafeRefCounted<DelayedReply> {\n')
     122            result.append('        DelayedReply(Ref<IPC::Connection>&&, std::unique_ptr<IPC::Encoder>);\n')
     123            result.append('        ~DelayedReply();\n')
     124            result.append('\n')
     125            result.append('        bool send(%s);\n' % ', '.join([' '.join(x) for x in send_parameters]))
     126            result.append('\n')
     127            result.append('    private:\n')
     128            result.append('        RefPtr<IPC::Connection> m_connection;\n')
     129            result.append('        std::unique_ptr<IPC::Encoder> m_encoder;\n')
     130            result.append('    };\n\n')
    129131
    130132        result.append('    typedef %s Reply;\n' % reply_type(message))
     
    529531                result.append('#if %s\n\n' % message.condition)
    530532
    531             result.append('void %s::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection' % (message.name))
    532             if len(send_parameters):
    533                 result.append(', %s' % ', '.join([' '.join(x) for x in send_parameters]))
    534             result.append(')\n{\n')
    535             result += ['    *encoder << %s;\n' % x.name for x in message.reply_parameters]
    536             result.append('    connection.sendSyncReply(WTFMove(encoder));\n')
     533            result.append('%s::DelayedReply::DelayedReply(Ref<IPC::Connection>&& connection, std::unique_ptr<IPC::Encoder> encoder)\n' % message.name)
     534            result.append('    : m_connection(WTFMove(connection))\n')
     535            result.append('    , m_encoder(WTFMove(encoder))\n')
     536            result.append('{\n')
     537            result.append('}\n')
     538            result.append('\n')
     539            result.append('%s::DelayedReply::~DelayedReply()\n' % message.name)
     540            result.append('{\n')
     541            result.append('    ASSERT(!m_connection);\n')
     542            result.append('}\n')
     543            result.append('\n')
     544            result.append('bool %s::DelayedReply::send(%s)\n' % (message.name, ', '.join([' '.join(x) for x in send_parameters])))
     545            result.append('{\n')
     546            result.append('    ASSERT(m_encoder);\n')
     547            result += ['    *m_encoder << %s;\n' % x.name for x in message.reply_parameters]
     548            result.append('    bool _result = m_connection->sendSyncReply(WTFMove(m_encoder));\n')
     549            result.append('    m_connection = nullptr;\n')
     550            result.append('    return _result;\n')
    537551            result.append('}\n')
    538552            result.append('\n')
  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp

    r230283 r230293  
    116116}
    117117
    118 void NetworkProcessProxy::getNetworkProcessConnection(Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply&& reply)
     118void NetworkProcessProxy::getNetworkProcessConnection(Ref<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply>&& reply)
    119119{
    120120    m_pendingConnectionReplies.append(WTFMove(reply));
     
    194194    clearCallbackStates();
    195195
    196     Vector<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply> pendingReplies;
     196    Vector<Ref<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply>> pendingReplies;
    197197    pendingReplies.reserveInitialCapacity(m_pendingConnectionReplies.size());
    198198    for (auto& reply : m_pendingConnectionReplies)
     
    207207    // The network process must have crashed or exited, send any pending sync replies we might have.
    208208    while (!m_pendingConnectionReplies.isEmpty()) {
    209         auto reply = m_pendingConnectionReplies.takeFirst();
     209        Ref<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply> reply = m_pendingConnectionReplies.takeFirst();
    210210
    211211#if USE(UNIX_DOMAIN_SOCKETS)
    212         reply(IPC::Attachment());
     212        reply->send(IPC::Attachment());
    213213#elif OS(DARWIN)
    214         reply(IPC::Attachment(0, MACH_MSG_TYPE_MOVE_SEND));
     214        reply->send(IPC::Attachment(0, MACH_MSG_TYPE_MOVE_SEND));
    215215#else
    216216        notImplemented();
     
    283283
    284284    // Grab the first pending connection reply.
    285     auto reply = m_pendingConnectionReplies.takeFirst();
     285    RefPtr<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply> reply = m_pendingConnectionReplies.takeFirst();
    286286
    287287#if USE(UNIX_DOMAIN_SOCKETS)
    288     reply(connectionIdentifier);
     288    reply->send(connectionIdentifier);
    289289#elif OS(DARWIN)
    290     reply(IPC::Attachment(connectionIdentifier.port(), MACH_MSG_TYPE_MOVE_SEND));
     290    reply->send(IPC::Attachment(connectionIdentifier.port(), MACH_MSG_TYPE_MOVE_SEND));
    291291#else
    292292    notImplemented();
  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h

    r230283 r230293  
    6969    ~NetworkProcessProxy();
    7070
    71     void getNetworkProcessConnection(Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply&&);
     71    void getNetworkProcessConnection(Ref<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply>&&);
    7272
    7373    DownloadProxy* createDownloadProxy(const WebCore::ResourceRequest&);
     
    156156   
    157157    unsigned m_numPendingConnectionRequests;
    158     Deque<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply> m_pendingConnectionReplies;
     158    Deque<Ref<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply>> m_pendingConnectionReplies;
    159159
    160160    HashMap<uint64_t, WTF::Function<void (WebsiteData)>> m_pendingFetchWebsiteDataCallbacks;
  • trunk/Source/WebKit/UIProcess/Plugins/PluginProcessManager.cpp

    r230283 r230293  
    8282}
    8383
    84 void PluginProcessManager::getPluginProcessConnection(uint64_t pluginProcessToken, Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply&& reply)
     84void PluginProcessManager::getPluginProcessConnection(uint64_t pluginProcessToken, Ref<Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply>&& reply)
    8585{
    8686    ASSERT(pluginProcessToken);
  • trunk/Source/WebKit/UIProcess/Plugins/PluginProcessManager.h

    r230283 r230293  
    5858    uint64_t pluginProcessToken(const PluginModuleInfo&, PluginProcessType, PluginProcessSandboxPolicy);
    5959
    60     void getPluginProcessConnection(uint64_t pluginProcessToken, Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply&&);
     60    void getPluginProcessConnection(uint64_t pluginProcessToken, Ref<Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply>&&);
    6161    void removePluginProcessProxy(PluginProcessProxy*);
    6262
  • trunk/Source/WebKit/UIProcess/Plugins/PluginProcessProxy.cpp

    r230283 r230293  
    103103// Asks the plug-in process to create a new connection to a web process. The connection identifier will be
    104104// encoded in the given argument encoder and sent back to the connection of the given web process.
    105 void PluginProcessProxy::getPluginProcessConnection(Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply&& reply)
     105void PluginProcessProxy::getPluginProcessConnection(Ref<Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply>&& reply)
    106106{
    107107    m_pendingConnectionReplies.append(WTFMove(reply));
     
    160160    // The plug-in process must have crashed or exited, send any pending sync replies we might have.
    161161    while (!m_pendingConnectionReplies.isEmpty()) {
    162         auto reply = m_pendingConnectionReplies.takeFirst();
     162        RefPtr<Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply> reply = m_pendingConnectionReplies.takeFirst();
    163163
    164164#if USE(UNIX_DOMAIN_SOCKETS)
    165         reply(IPC::Attachment(), false);
     165        reply->send(IPC::Attachment(), false);
    166166#elif OS(DARWIN)
    167         reply(IPC::Attachment(0, MACH_MSG_TYPE_MOVE_SEND), false);
     167        reply->send(IPC::Attachment(0, MACH_MSG_TYPE_MOVE_SEND), false);
    168168#else
    169169        notImplemented();
     
    277277
    278278    // Grab the first pending connection reply.
    279     auto reply = m_pendingConnectionReplies.takeFirst();
     279    RefPtr<Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply> reply = m_pendingConnectionReplies.takeFirst();
    280280
    281281#if USE(UNIX_DOMAIN_SOCKETS)
    282     reply(connectionIdentifier, supportsAsynchronousPluginInitialization);
     282    reply->send(connectionIdentifier, supportsAsynchronousPluginInitialization);
    283283#elif OS(DARWIN)
    284     reply(IPC::Attachment(connectionIdentifier.port(), MACH_MSG_TYPE_MOVE_SEND), supportsAsynchronousPluginInitialization);
     284    reply->send(IPC::Attachment(connectionIdentifier.port(), MACH_MSG_TYPE_MOVE_SEND), supportsAsynchronousPluginInitialization);
    285285#else
    286286    notImplemented();
  • trunk/Source/WebKit/UIProcess/Plugins/PluginProcessProxy.h

    r230283 r230293  
    7777    // Asks the plug-in process to create a new connection to a web process. The connection identifier will be
    7878    // encoded in the given argument encoder and sent back to the connection of the given web process.
    79     void getPluginProcessConnection(Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply&&);
     79    void getPluginProcessConnection(Ref<Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply>&&);
    8080
    8181    void fetchWebsiteData(WTF::Function<void (Vector<String>)>&& completionHandler);
     
    150150    RefPtr<IPC::Connection> m_connection;
    151151
    152     Deque<Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply> m_pendingConnectionReplies;
     152    Deque<RefPtr<Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply>> m_pendingConnectionReplies;
    153153
    154154    Vector<uint64_t> m_pendingFetchWebsiteDataRequests;
  • trunk/Source/WebKit/UIProcess/Storage/StorageProcessProxy.cpp

    r230283 r230293  
    113113}
    114114
    115 void StorageProcessProxy::getStorageProcessConnection(WebProcessProxy& webProcessProxy, Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply&& reply)
     115void StorageProcessProxy::getStorageProcessConnection(WebProcessProxy& webProcessProxy, Ref<Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply>&& reply)
    116116{
    117117    m_pendingConnectionReplies.append(WTFMove(reply));
     
    141141
    142142#if USE(UNIX_DOMAIN_SOCKETS)
    143         reply(IPC::Attachment());
     143        reply->send(IPC::Attachment());
    144144#elif OS(DARWIN)
    145         reply(IPC::Attachment(0, MACH_MSG_TYPE_MOVE_SEND));
     145        reply->send(IPC::Attachment(0, MACH_MSG_TYPE_MOVE_SEND));
    146146#else
    147147        notImplemented();
     
    173173    ASSERT(!m_pendingConnectionReplies.isEmpty());
    174174
    175     auto reply = m_pendingConnectionReplies.takeFirst();
     175    RefPtr<Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply> reply = m_pendingConnectionReplies.takeFirst();
    176176
    177177#if USE(UNIX_DOMAIN_SOCKETS)
    178     reply(connectionIdentifier);
     178    reply->send(connectionIdentifier);
    179179#elif OS(DARWIN)
    180     reply(IPC::Attachment(connectionIdentifier.port(), MACH_MSG_TYPE_MOVE_SEND));
     180    reply->send(IPC::Attachment(connectionIdentifier.port(), MACH_MSG_TYPE_MOVE_SEND));
    181181#else
    182182    notImplemented();
  • trunk/Source/WebKit/UIProcess/Storage/StorageProcessProxy.h

    r230283 r230293  
    5757    void deleteWebsiteDataForOrigins(PAL::SessionID, OptionSet<WebsiteDataType>, const Vector<WebCore::SecurityOriginData>&, WTF::Function<void()>&& completionHandler);
    5858
    59     void getStorageProcessConnection(WebProcessProxy&, Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply&&);
     59    void getStorageProcessConnection(WebProcessProxy&, Ref<Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply>&&);
    6060
    6161private:
     
    9292
    9393    unsigned m_numPendingConnectionRequests;
    94     Deque<Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply> m_pendingConnectionReplies;
     94    Deque<Ref<Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply>> m_pendingConnectionReplies;
    9595
    9696    HashMap<uint64_t, WTF::Function<void (WebsiteData)>> m_pendingFetchWebsiteDataCallbacks;
  • trunk/Source/WebKit/UIProcess/WebPageProxy.cpp

    r230283 r230293  
    232232        uint64_t currentDatabaseUsage;
    233233        uint64_t expectedUsage;
    234         Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply reply;
     234        RefPtr<Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply> reply;
    235235    };
    236236
     
    240240        String databaseName, String displayName, uint64_t currentQuota,
    241241        uint64_t currentOriginUsage, uint64_t currentDatabaseUsage, uint64_t expectedUsage,
    242         Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply&&);
     242        Ref<Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply>&&);
    243243
    244244    void add(std::unique_ptr<Record>);
     
    263263    uint64_t frameID, String originIdentifier, String databaseName, String displayName,
    264264    uint64_t currentQuota, uint64_t currentOriginUsage, uint64_t currentDatabaseUsage,
    265     uint64_t expectedUsage, Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply&& reply)
     265    uint64_t expectedUsage, Ref<Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply>&& reply)
    266266{
    267267    auto record = std::make_unique<Record>();
     
    40434043// UIClient
    40444044
    4045 void WebPageProxy::createNewPage(const FrameInfoData& originatingFrameInfoData, uint64_t originatingPageID, ResourceRequest&& request, WindowFeatures&& windowFeatures, NavigationActionData&& navigationActionData, Messages::WebPageProxy::CreateNewPage::DelayedReply&& reply)
     4045void WebPageProxy::createNewPage(const FrameInfoData& originatingFrameInfoData, uint64_t originatingPageID, ResourceRequest&& request, WindowFeatures&& windowFeatures, NavigationActionData&& navigationActionData, Ref<Messages::WebPageProxy::CreateNewPage::DelayedReply>&& reply)
    40464046{
    40474047    MESSAGE_CHECK(m_process->webFrame(originatingFrameInfoData.frameID));
     
    40504050    auto mainFrameURL = m_mainFrame->url();
    40514051
    4052     m_uiClient->createNewPage(*this, WTFMove(originatingFrameInfo), WTFMove(request), WTFMove(windowFeatures), WTFMove(navigationActionData), [this, protectedThis = makeRef(*this), mainFrameURL, request, reply = WTFMove(reply)](RefPtr<WebPageProxy> newPage) {
     4052    m_uiClient->createNewPage(*this, WTFMove(originatingFrameInfo), WTFMove(request), WTFMove(windowFeatures), WTFMove(navigationActionData), [this, protectedThis = RefPtr<WebPageProxy>(this), mainFrameURL, request, reply = WTFMove(reply)](RefPtr<WebPageProxy> newPage) {
    40534053        if (!newPage) {
    4054             reply(0, { });
     4054            reply->send(0, { });
    40554055            return;
    40564056        }
    40574057
    4058         reply(newPage->pageID(), newPage->creationParameters());
     4058        reply->send(newPage->pageID(), newPage->creationParameters());
    40594059
    40604060        WebsiteDataStore::cloneSessionData(*this, *newPage);
     
    40924092}
    40934093
    4094 void WebPageProxy::runJavaScriptAlert(uint64_t frameID, const SecurityOriginData& securityOrigin, const String& message, Messages::WebPageProxy::RunJavaScriptAlert::DelayedReply&& reply)
     4094void WebPageProxy::runJavaScriptAlert(uint64_t frameID, const SecurityOriginData& securityOrigin, const String& message, Ref<Messages::WebPageProxy::RunJavaScriptAlert::DelayedReply>&& reply)
    40954095{
    40964096    WebFrameProxy* frame = m_process->webFrame(frameID);
     
    41054105    }
    41064106    m_uiClient->runJavaScriptAlert(this, message, frame, securityOrigin, [reply = WTFMove(reply)] {
    4107         reply();
     4107        reply->send();
    41084108    });
    41094109}
    41104110
    4111 void WebPageProxy::runJavaScriptConfirm(uint64_t frameID, const SecurityOriginData& securityOrigin, const String& message, Messages::WebPageProxy::RunJavaScriptConfirm::DelayedReply&& reply)
     4111void WebPageProxy::runJavaScriptConfirm(uint64_t frameID, const SecurityOriginData& securityOrigin, const String& message, Ref<Messages::WebPageProxy::RunJavaScriptConfirm::DelayedReply>&& reply)
    41124112{
    41134113    WebFrameProxy* frame = m_process->webFrame(frameID);
     
    41234123
    41244124    m_uiClient->runJavaScriptConfirm(this, message, frame, securityOrigin, [reply = WTFMove(reply)](bool result) {
    4125         reply(result);
     4125        reply->send(result);
    41264126    });
    41274127}
    41284128
    4129 void WebPageProxy::runJavaScriptPrompt(uint64_t frameID, const SecurityOriginData& securityOrigin, const String& message, const String& defaultValue, Messages::WebPageProxy::RunJavaScriptPrompt::DelayedReply&& reply)
     4129void WebPageProxy::runJavaScriptPrompt(uint64_t frameID, const SecurityOriginData& securityOrigin, const String& message, const String& defaultValue, Ref<Messages::WebPageProxy::RunJavaScriptPrompt::DelayedReply>&& reply)
    41304130{
    41314131    WebFrameProxy* frame = m_process->webFrame(frameID);
     
    41414141
    41424142    m_uiClient->runJavaScriptPrompt(this, message, defaultValue, frame, securityOrigin, [reply = WTFMove(reply)](const String& result) {
    4143         reply(result);
     4143        reply->send(result);
    41444144    });
    41454145}
     
    42104210
    42114211#if ENABLE(WEBGL)
    4212 void WebPageProxy::webGLPolicyForURL(URL&& url, Messages::WebPageProxy::WebGLPolicyForURL::DelayedReply&& reply)
     4212void WebPageProxy::webGLPolicyForURL(URL&& url, Ref<Messages::WebPageProxy::WebGLPolicyForURL::DelayedReply>&& reply)
    42134213{
    42144214    if (m_navigationClient) {
    42154215        m_navigationClient->webGLLoadPolicy(*this, url, [reply = WTFMove(reply)](WebGLLoadPolicy policy) {
    4216             reply(static_cast<uint32_t>(policy));
     4216            reply->send(static_cast<uint32_t>(policy));
    42174217        });
    42184218    } else
    4219         reply(static_cast<uint32_t>(m_loaderClient->webGLLoadPolicy(*this, url)));
    4220 }
    4221 
    4222 void WebPageProxy::resolveWebGLPolicyForURL(URL&& url, Messages::WebPageProxy::ResolveWebGLPolicyForURL::DelayedReply&& reply)
     4219        reply->send(static_cast<uint32_t>(m_loaderClient->webGLLoadPolicy(*this, url)));
     4220}
     4221
     4222void WebPageProxy::resolveWebGLPolicyForURL(URL&& url, Ref<Messages::WebPageProxy::ResolveWebGLPolicyForURL::DelayedReply>&& reply)
    42234223{
    42244224    if (m_navigationClient) {
    42254225        m_navigationClient->resolveWebGLLoadPolicy(*this, url, [reply = WTFMove(reply)](WebGLLoadPolicy policy) {
    4226             reply(static_cast<uint32_t>(policy));
     4226            reply->send(static_cast<uint32_t>(policy));
    42274227        });
    42284228    } else
    4229         reply(static_cast<uint32_t>(m_loaderClient->resolveWebGLLoadPolicy(*this, url)));
     4229        reply->send(static_cast<uint32_t>(m_loaderClient->resolveWebGLLoadPolicy(*this, url)));
    42304230}
    42314231#endif // ENABLE(WEBGL)
     
    42364236}
    42374237
    4238 void WebPageProxy::getToolbarsAreVisible(Messages::WebPageProxy::GetToolbarsAreVisible::DelayedReply&& reply)
     4238void WebPageProxy::getToolbarsAreVisible(Ref<Messages::WebPageProxy::GetToolbarsAreVisible::DelayedReply>&& reply)
    42394239{
    42404240    m_uiClient->toolbarsAreVisible(*this, [reply = WTFMove(reply)](bool visible) {
    4241         reply(visible);
     4241        reply->send(visible);
    42424242    });
    42434243}
     
    42484248}
    42494249
    4250 void WebPageProxy::getMenuBarIsVisible(Messages::WebPageProxy::GetMenuBarIsVisible::DelayedReply&& reply)
     4250void WebPageProxy::getMenuBarIsVisible(Ref<Messages::WebPageProxy::GetMenuBarIsVisible::DelayedReply>&& reply)
    42514251{
    42524252    m_uiClient->menuBarIsVisible(*this, [reply = WTFMove(reply)] (bool visible) {
    4253         reply(visible);
     4253        reply->send(visible);
    42544254    });
    42554255}
     
    42604260}
    42614261
    4262 void WebPageProxy::getStatusBarIsVisible(Messages::WebPageProxy::GetStatusBarIsVisible::DelayedReply&& reply)
     4262void WebPageProxy::getStatusBarIsVisible(Ref<Messages::WebPageProxy::GetStatusBarIsVisible::DelayedReply>&& reply)
    42634263{
    42644264    m_uiClient->statusBarIsVisible(*this, [reply = WTFMove(reply)] (bool visible) {
    4265         reply(visible);
     4265        reply->send(visible);
    42664266    });
    42674267}
     
    42774277}
    42784278
    4279 void WebPageProxy::getWindowFrame(Messages::WebPageProxy::GetWindowFrame::DelayedReply&& reply)
     4279void WebPageProxy::getWindowFrame(Ref<Messages::WebPageProxy::GetWindowFrame::DelayedReply>&& reply)
    42804280{
    42814281    m_uiClient->windowFrame(*this, [this, protectedThis = makeRef(*this), reply = WTFMove(reply)] (FloatRect frame) {
    4282         reply(m_pageClient.convertToUserSpace(frame));
     4282        reply->send(m_pageClient.convertToUserSpace(frame));
    42834283    });
    42844284}
     
    42894289}
    42904290
    4291 void WebPageProxy::screenToRootView(const IntPoint& screenPoint, Messages::WebPageProxy::ScreenToRootView::DelayedReply&& reply)
    4292 {
    4293     reply(m_pageClient.screenToRootView(screenPoint));
     4291void WebPageProxy::screenToRootView(const IntPoint& screenPoint, Ref<Messages::WebPageProxy::ScreenToRootView::DelayedReply>&& reply)
     4292{
     4293    reply->send(m_pageClient.screenToRootView(screenPoint));
    42944294}
    42954295   
    4296 void WebPageProxy::rootViewToScreen(const IntRect& viewRect, Messages::WebPageProxy::RootViewToScreen::DelayedReply&& reply)
    4297 {
    4298     reply(m_pageClient.rootViewToScreen(viewRect));
     4296void WebPageProxy::rootViewToScreen(const IntRect& viewRect, Ref<Messages::WebPageProxy::RootViewToScreen::DelayedReply>&& reply)
     4297{
     4298    reply->send(m_pageClient.rootViewToScreen(viewRect));
    42994299}
    43004300   
     
    43114311#endif
    43124312
    4313 void WebPageProxy::runBeforeUnloadConfirmPanel(uint64_t frameID, const SecurityOriginData& securityOrigin, const String& message, Messages::WebPageProxy::RunBeforeUnloadConfirmPanel::DelayedReply reply)
     4313void WebPageProxy::runBeforeUnloadConfirmPanel(uint64_t frameID, const SecurityOriginData& securityOrigin, const String& message, RefPtr<Messages::WebPageProxy::RunBeforeUnloadConfirmPanel::DelayedReply> reply)
    43144314{
    43154315    WebFrameProxy* frame = m_process->webFrame(frameID);
     
    43244324    }
    43254325
    4326     m_uiClient->runBeforeUnloadConfirmPanel(this, message, frame, securityOrigin, [reply = WTFMove(reply)](bool result) { reply(result); });
     4326    m_uiClient->runBeforeUnloadConfirmPanel(this, message, frame, securityOrigin, [reply](bool result) { reply->send(result); });
    43274327}
    43284328
     
    60196019}
    60206020
    6021 void WebPageProxy::exceededDatabaseQuota(uint64_t frameID, const String& originIdentifier, const String& databaseName, const String& displayName, uint64_t currentQuota, uint64_t currentOriginUsage, uint64_t currentDatabaseUsage, uint64_t expectedUsage, Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply&& reply)
     6021void WebPageProxy::exceededDatabaseQuota(uint64_t frameID, const String& originIdentifier, const String& databaseName, const String& displayName, uint64_t currentQuota, uint64_t currentOriginUsage, uint64_t currentDatabaseUsage, uint64_t expectedUsage, Ref<Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply>&& reply)
    60226022{
    60236023    ExceededDatabaseQuotaRecords& records = ExceededDatabaseQuotaRecords::singleton();
     
    60306030        return;
    60316031
    6032     while (auto* record = records.next()) {
     6032    ExceededDatabaseQuotaRecords::Record* record = records.next();
     6033    while (record) {
    60336034        WebFrameProxy* frame = m_process->webFrame(record->frameID);
    60346035        MESSAGE_CHECK(frame);
    60356036
    6036         auto origin = API::SecurityOrigin::create(SecurityOriginData::fromDatabaseIdentifier(record->originIdentifier)->securityOrigin());
    6037         m_uiClient->exceededDatabaseQuota(this, frame, origin.ptr(), record->databaseName, record->displayName, record->currentQuota, record->currentOriginUsage, record->currentDatabaseUsage, record->expectedUsage, [currentReply = WTFMove(record->reply)](unsigned long long newQuota) {
    6038             currentReply(newQuota);
    6039         });
    6040     }
    6041 }
    6042 
    6043 void WebPageProxy::reachedApplicationCacheOriginQuota(const String& originIdentifier, uint64_t currentQuota, uint64_t totalBytesNeeded, Messages::WebPageProxy::ReachedApplicationCacheOriginQuota::DelayedReply&& reply)
     6037        RefPtr<API::SecurityOrigin> origin = API::SecurityOrigin::create(SecurityOriginData::fromDatabaseIdentifier(record->originIdentifier)->securityOrigin());
     6038        auto currentReply = record->reply;
     6039        m_uiClient->exceededDatabaseQuota(this, frame, origin.get(),
     6040            record->databaseName, record->displayName, record->currentQuota,
     6041            record->currentOriginUsage, record->currentDatabaseUsage, record->expectedUsage,
     6042            [currentReply](unsigned long long newQuota) { currentReply->send(newQuota); });
     6043
     6044        record = records.next();
     6045    }
     6046}
     6047
     6048void WebPageProxy::reachedApplicationCacheOriginQuota(const String& originIdentifier, uint64_t currentQuota, uint64_t totalBytesNeeded, Ref<Messages::WebPageProxy::ReachedApplicationCacheOriginQuota::DelayedReply>&& reply)
    60446049{
    60456050    Ref<SecurityOrigin> securityOrigin = SecurityOriginData::fromDatabaseIdentifier(originIdentifier)->securityOrigin();
    6046     m_uiClient->reachedApplicationCacheOriginQuota(this, securityOrigin.get(), currentQuota, totalBytesNeeded, [reply = WTFMove(reply)](unsigned long long newQuota) {
    6047         reply(newQuota);
    6048     });
     6051    m_uiClient->reachedApplicationCacheOriginQuota(this, securityOrigin.get(), currentQuota, totalBytesNeeded, [reply = WTFMove(reply)](unsigned long long newQuota) { reply->send(newQuota); });
    60496052}
    60506053
  • trunk/Source/WebKit/UIProcess/WebPageProxy.h

    r230283 r230293  
    12281228    void setFocus(bool focused);
    12291229    void setWindowFrame(const WebCore::FloatRect&);
    1230     void getWindowFrame(Messages::WebPageProxy::GetWindowFrame::DelayedReply&&);
     1230    void getWindowFrame(Ref<Messages::WebPageProxy::GetWindowFrame::DelayedReply>&&);
    12311231    void getWindowFrameWithCallback(Function<void(WebCore::FloatRect)>&&);
    12321232
     
    13851385
    13861386    // UI client
    1387     void createNewPage(const FrameInfoData&, uint64_t originatingPageID, WebCore::ResourceRequest&&, WebCore::WindowFeatures&&, NavigationActionData&&, Messages::WebPageProxy::CreateNewPage::DelayedReply&&);
     1387    void createNewPage(const FrameInfoData&, uint64_t originatingPageID, WebCore::ResourceRequest&&, WebCore::WindowFeatures&&, NavigationActionData&&, Ref<Messages::WebPageProxy::CreateNewPage::DelayedReply>&&);
    13881388    void showPage();
    1389     void runJavaScriptAlert(uint64_t frameID, const WebCore::SecurityOriginData&, const String&, Messages::WebPageProxy::RunJavaScriptAlert::DelayedReply&&);
    1390     void runJavaScriptConfirm(uint64_t frameID, const WebCore::SecurityOriginData&, const String&, Messages::WebPageProxy::RunJavaScriptConfirm::DelayedReply&&);
    1391     void runJavaScriptPrompt(uint64_t frameID, const WebCore::SecurityOriginData&, const String&, const String&, Messages::WebPageProxy::RunJavaScriptPrompt::DelayedReply&&);
     1389    void runJavaScriptAlert(uint64_t frameID, const WebCore::SecurityOriginData&, const String&, Ref<Messages::WebPageProxy::RunJavaScriptAlert::DelayedReply>&&);
     1390    void runJavaScriptConfirm(uint64_t frameID, const WebCore::SecurityOriginData&, const String&, Ref<Messages::WebPageProxy::RunJavaScriptConfirm::DelayedReply>&&);
     1391    void runJavaScriptPrompt(uint64_t frameID, const WebCore::SecurityOriginData&, const String&, const String&, Ref<Messages::WebPageProxy::RunJavaScriptPrompt::DelayedReply>&&);
    13921392    void setStatusText(const String&);
    13931393    void mouseDidMoveOverElement(WebHitTestResultData&&, uint32_t modifiers, UserData&&);
     
    13971397#endif // ENABLE(NETSCAPE_PLUGIN_API)
    13981398#if ENABLE(WEBGL)
    1399     void webGLPolicyForURL(WebCore::URL&&, Messages::WebPageProxy::WebGLPolicyForURL::DelayedReply&&);
    1400     void resolveWebGLPolicyForURL(WebCore::URL&&, Messages::WebPageProxy::ResolveWebGLPolicyForURL::DelayedReply&&);
     1399    void webGLPolicyForURL(WebCore::URL&&, Ref<Messages::WebPageProxy::WebGLPolicyForURL::DelayedReply>&&);
     1400    void resolveWebGLPolicyForURL(WebCore::URL&&, Ref<Messages::WebPageProxy::ResolveWebGLPolicyForURL::DelayedReply>&&);
    14011401#endif // ENABLE(WEBGL)
    14021402    void setToolbarsAreVisible(bool toolbarsAreVisible);
    1403     void getToolbarsAreVisible(Messages::WebPageProxy::GetToolbarsAreVisible::DelayedReply&&);
     1403    void getToolbarsAreVisible(Ref<Messages::WebPageProxy::GetToolbarsAreVisible::DelayedReply>&&);
    14041404    void setMenuBarIsVisible(bool menuBarIsVisible);
    1405     void getMenuBarIsVisible(Messages::WebPageProxy::GetMenuBarIsVisible::DelayedReply&&);
     1405    void getMenuBarIsVisible(Ref<Messages::WebPageProxy::GetMenuBarIsVisible::DelayedReply>&&);
    14061406    void setStatusBarIsVisible(bool statusBarIsVisible);
    1407     void getStatusBarIsVisible(Messages::WebPageProxy::GetStatusBarIsVisible::DelayedReply&&);
     1407    void getStatusBarIsVisible(Ref<Messages::WebPageProxy::GetStatusBarIsVisible::DelayedReply>&&);
    14081408    void setIsResizable(bool isResizable);
    1409     void screenToRootView(const WebCore::IntPoint& screenPoint, Messages::WebPageProxy::ScreenToRootView::DelayedReply&&);
    1410     void rootViewToScreen(const WebCore::IntRect& viewRect, Messages::WebPageProxy::RootViewToScreen::DelayedReply&&);
     1409    void screenToRootView(const WebCore::IntPoint& screenPoint, Ref<Messages::WebPageProxy::ScreenToRootView::DelayedReply>&&);
     1410    void rootViewToScreen(const WebCore::IntRect& viewRect, Ref<Messages::WebPageProxy::RootViewToScreen::DelayedReply>&&);
    14111411#if PLATFORM(IOS)
    14121412    void accessibilityScreenToRootView(const WebCore::IntPoint& screenPoint, WebCore::IntPoint& windowPoint);
    14131413    void rootViewToAccessibilityScreen(const WebCore::IntRect& viewRect, WebCore::IntRect& result);
    14141414#endif
    1415     void runBeforeUnloadConfirmPanel(uint64_t frameID, const WebCore::SecurityOriginData&, const String& message, Messages::WebPageProxy::RunBeforeUnloadConfirmPanel::DelayedReply);
     1415    void runBeforeUnloadConfirmPanel(uint64_t frameID, const WebCore::SecurityOriginData&, const String& message, RefPtr<Messages::WebPageProxy::RunBeforeUnloadConfirmPanel::DelayedReply>);
    14161416    void didChangeViewportProperties(const WebCore::ViewportAttributes&);
    14171417    void pageDidScroll();
    14181418    void runOpenPanel(uint64_t frameID, const WebCore::SecurityOriginData&, const WebCore::FileChooserSettings&);
    14191419    void printFrame(uint64_t frameID);
    1420     void exceededDatabaseQuota(uint64_t frameID, const String& originIdentifier, const String& databaseName, const String& displayName, uint64_t currentQuota, uint64_t currentOriginUsage, uint64_t currentDatabaseUsage, uint64_t expectedUsage, Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply&&);
    1421     void reachedApplicationCacheOriginQuota(const String& originIdentifier, uint64_t currentQuota, uint64_t totalBytesNeeded, Messages::WebPageProxy::ReachedApplicationCacheOriginQuota::DelayedReply&&);
     1420    void exceededDatabaseQuota(uint64_t frameID, const String& originIdentifier, const String& databaseName, const String& displayName, uint64_t currentQuota, uint64_t currentOriginUsage, uint64_t currentDatabaseUsage, uint64_t expectedUsage, Ref<Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply>&&);
     1421    void reachedApplicationCacheOriginQuota(const String& originIdentifier, uint64_t currentQuota, uint64_t totalBytesNeeded, Ref<Messages::WebPageProxy::ReachedApplicationCacheOriginQuota::DelayedReply>&&);
    14221422    void requestGeolocationPermissionForFrame(uint64_t geolocationID, uint64_t frameID, String originIdentifier);
    14231423
  • trunk/Source/WebKit/UIProcess/WebProcessPool.cpp

    r230283 r230293  
    515515}
    516516
    517 void WebProcessPool::networkProcessCrashed(NetworkProcessProxy& networkProcessProxy, Vector<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply>&& pendingReplies)
     517void WebProcessPool::networkProcessCrashed(NetworkProcessProxy& networkProcessProxy, Vector<Ref<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply>>&& pendingReplies)
    518518{
    519519    networkProcessFailedToLaunch(networkProcessProxy);
     
    541541}
    542542
    543 void WebProcessPool::getNetworkProcessConnection(Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply&& reply)
     543void WebProcessPool::getNetworkProcessConnection(Ref<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply>&& reply)
    544544{
    545545    ensureNetworkProcess();
     
    588588}
    589589
    590 void WebProcessPool::getStorageProcessConnection(WebProcessProxy& webProcessProxy, PAL::SessionID initialSessionID, Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply&& reply)
     590void WebProcessPool::getStorageProcessConnection(WebProcessProxy& webProcessProxy, PAL::SessionID initialSessionID, Ref<Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply>&& reply)
    591591{
    592592    ensureStorageProcessAndWebsiteDataStore(WebsiteDataStore::existingNonDefaultDataStoreForSessionID(initialSessionID));
  • trunk/Source/WebKit/UIProcess/WebProcessPool.h

    r230283 r230293  
    325325    NetworkProcessProxy& ensureNetworkProcess(WebsiteDataStore* withWebsiteDataStore = nullptr);
    326326    NetworkProcessProxy* networkProcess() { return m_networkProcess.get(); }
    327     void networkProcessCrashed(NetworkProcessProxy&, Vector<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply>&&);
     327    void networkProcessCrashed(NetworkProcessProxy&, Vector<Ref<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply>>&&);
    328328    void networkProcessFailedToLaunch(NetworkProcessProxy&);
    329329
    330     void getNetworkProcessConnection(Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply&&);
     330    void getNetworkProcessConnection(Ref<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply>&&);
    331331
    332332    void ensureStorageProcessAndWebsiteDataStore(WebsiteDataStore* relevantDataStore);
    333333    StorageProcessProxy* storageProcess() { return m_storageProcess.get(); }
    334     void getStorageProcessConnection(WebProcessProxy&, PAL::SessionID initialSessionID, Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply&&);
     334    void getStorageProcessConnection(WebProcessProxy&, PAL::SessionID initialSessionID, Ref<Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply>&&);
    335335    void storageProcessCrashed(StorageProcessProxy*);
    336336#if ENABLE(SERVICE_WORKER)
  • trunk/Source/WebKit/UIProcess/WebProcessProxy.cpp

    r230283 r230293  
    595595
    596596#if ENABLE(NETSCAPE_PLUGIN_API)
    597 void WebProcessProxy::getPluginProcessConnection(uint64_t pluginProcessToken, Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply&& reply)
     597void WebProcessProxy::getPluginProcessConnection(uint64_t pluginProcessToken, Ref<Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply>&& reply)
    598598{
    599599    PluginProcessManager::singleton().getPluginProcessConnection(pluginProcessToken, WTFMove(reply));
     
    601601#endif
    602602
    603 void WebProcessProxy::getNetworkProcessConnection(Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply&& reply)
     603void WebProcessProxy::getNetworkProcessConnection(Ref<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply>&& reply)
    604604{
    605605    m_processPool->getNetworkProcessConnection(WTFMove(reply));
    606606}
    607607
    608 void WebProcessProxy::getStorageProcessConnection(PAL::SessionID initialSessionID, Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply&& reply)
     608void WebProcessProxy::getStorageProcessConnection(PAL::SessionID initialSessionID, Ref<Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply>&& reply)
    609609{
    610610    m_processPool->getStorageProcessConnection(*this, initialSessionID, WTFMove(reply));
  • trunk/Source/WebKit/UIProcess/WebProcessProxy.h

    r230283 r230293  
    245245#endif // ENABLE(NETSCAPE_PLUGIN_API)
    246246#if ENABLE(NETSCAPE_PLUGIN_API)
    247     void getPluginProcessConnection(uint64_t pluginProcessToken, Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply&&);
    248 #endif
    249     void getNetworkProcessConnection(Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply&&);
    250     void getStorageProcessConnection(PAL::SessionID initialSessionID, Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply&&);
     247    void getPluginProcessConnection(uint64_t pluginProcessToken, Ref<Messages::WebProcessProxy::GetPluginProcessConnection::DelayedReply>&&);
     248#endif
     249    void getNetworkProcessConnection(Ref<Messages::WebProcessProxy::GetNetworkProcessConnection::DelayedReply>&&);
     250    void getStorageProcessConnection(PAL::SessionID initialSessionID, Ref<Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply>&&);
    251251
    252252    bool platformIsBeingDebugged() const;
  • trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.cpp

    r230283 r230293  
    237237}
    238238
    239 void WebSWContextManagerConnection::syncTerminateWorker(ServiceWorkerIdentifier identifier, Messages::WebSWContextManagerConnection::SyncTerminateWorker::DelayedReply&& reply)
     239void WebSWContextManagerConnection::syncTerminateWorker(ServiceWorkerIdentifier identifier, Ref<Messages::WebSWContextManagerConnection::SyncTerminateWorker::DelayedReply>&& reply)
    240240{
    241241    SWContextManager::singleton().terminateWorker(identifier, syncWorkerTerminationTimeout, [reply = WTFMove(reply)] {
    242         reply();
     242        reply->send();
    243243    });
    244244}
  • trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.h

    r230283 r230293  
    8282    void fireActivateEvent(WebCore::ServiceWorkerIdentifier);
    8383    void terminateWorker(WebCore::ServiceWorkerIdentifier);
    84     void syncTerminateWorker(WebCore::ServiceWorkerIdentifier, Messages::WebSWContextManagerConnection::SyncTerminateWorker::DelayedReply&&);
     84    void syncTerminateWorker(WebCore::ServiceWorkerIdentifier, Ref<Messages::WebSWContextManagerConnection::SyncTerminateWorker::DelayedReply>&&);
    8585    void findClientByIdentifierCompleted(uint64_t requestIdentifier, std::optional<WebCore::ServiceWorkerClientData>&&, bool hasSecurityError);
    8686    void matchAllCompleted(uint64_t matchAllRequestIdentifier, Vector<WebCore::ServiceWorkerClientData>&&);
  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.h

    r230283 r230293  
    808808
    809809#if PLATFORM(IOS)
    810     void computePagesForPrintingAndDrawToPDF(uint64_t frameID, const PrintInfo&, CallbackID, Messages::WebPage::ComputePagesForPrintingAndDrawToPDF::DelayedReply&&);
     810    void computePagesForPrintingAndDrawToPDF(uint64_t frameID, const PrintInfo&, CallbackID, Ref<Messages::WebPage::ComputePagesForPrintingAndDrawToPDF::DelayedReply>&&);
    811811#endif
    812812
  • trunk/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm

    r230283 r230293  
    34273427#endif
    34283428
    3429 void WebPage::computePagesForPrintingAndDrawToPDF(uint64_t frameID, const PrintInfo& printInfo, CallbackID callbackID, Messages::WebPage::ComputePagesForPrintingAndDrawToPDF::DelayedReply&& reply)
     3429void WebPage::computePagesForPrintingAndDrawToPDF(uint64_t frameID, const PrintInfo& printInfo, CallbackID callbackID, Ref<Messages::WebPage::ComputePagesForPrintingAndDrawToPDF::DelayedReply>&& reply)
    34303430{
    34313431    if (printInfo.snapshotFirstPage) {
    3432         reply(1);
     3432        reply->send(1);
    34333433        IntSize snapshotSize { FloatSize { printInfo.availablePaperWidth, printInfo.availablePaperHeight } };
    34343434        IntRect snapshotRect { {0, 0}, snapshotSize };
     
    34453445    std::size_t pageCount = pageRects.size();
    34463446    ASSERT(pageCount <= std::numeric_limits<uint32_t>::max());
    3447     reply(pageCount);
     3447    reply->send(pageCount);
    34483448
    34493449    RetainPtr<CFMutableDataRef> pdfPageData;
Note: See TracChangeset for help on using the changeset viewer.