Changeset 249835 in webkit

Timestamp:

Sep 13, 2019, 9:03:17 AM (6 years ago)

Author:

achristensen@apple.com

Message:

AuxiliaryProcessProxy::sendWithAsyncReply should queue up messages if sent while the process is starting like it does messages without replies
​https://bugs.webkit.org/show_bug.cgi?id=201746

Reviewed by Youenn Fablet.

• UIProcess/AuxiliaryProcessProxy.cpp:

(WebKit::AuxiliaryProcessProxy::sendMessage):
(WebKit::AuxiliaryProcessProxy::didFinishLaunching):

• UIProcess/AuxiliaryProcessProxy.h:

(WebKit::AuxiliaryProcessProxy::sendWithAsyncReply):

Location:

trunk/Source/WebKit

Files:

• ChangeLog (modified) (1 diff)
• UIProcess/AuxiliaryProcessProxy.cpp (modified) (3 diffs)
• UIProcess/AuxiliaryProcessProxy.h (modified) (4 diffs)

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2019-09-13  Alex Christensen  <achristensen@webkit.org>
+
+        AuxiliaryProcessProxy::sendWithAsyncReply should queue up messages if sent while the process is starting like it does messages without replies
+        https://bugs.webkit.org/show_bug.cgi?id=201746
+
+        Reviewed by Youenn Fablet.
+
+        * UIProcess/AuxiliaryProcessProxy.cpp:
+        (WebKit::AuxiliaryProcessProxy::sendMessage):
+        (WebKit::AuxiliaryProcessProxy::didFinishLaunching):
+        * UIProcess/AuxiliaryProcessProxy.h:
+        (WebKit::AuxiliaryProcessProxy::sendWithAsyncReply):
+
 2019-09-13  Youenn Fablet  <youenn@apple.com>
 

trunk/Source/WebKit/UIProcess/AuxiliaryProcessProxy.cpp

@@ -141 +141 @@
 }
 
-bool AuxiliaryProcessProxy::sendMessage(std::unique_ptr<IPC::Encoder> encoder, OptionSet<IPC::SendOption> sendOptions)
+bool AuxiliaryProcessProxy::sendMessage(std::unique_ptr<IPC::Encoder> encoder, OptionSet<IPC::SendOption> sendOptions, Optional<std::pair<CompletionHandler<void(IPC::Decoder*)>, uint64_t>>&& asyncReplyInfo)
 {
     switch (state()) {
     case State::Launching:
         // If we're waiting for the child process to launch, we need to stash away the messages so we can send them once we have a connection.
-        m_pendingMessages.append(std::make_pair(WTFMove(encoder), sendOptions));
+        m_pendingMessages.append({ WTFMove(encoder), sendOptions, WTFMove(asyncReplyInfo) });
         return true;
 
     case State::Running:
-        return connection()->sendMessage(WTFMove(encoder), sendOptions);
+        if (connection()->sendMessage(WTFMove(encoder), sendOptions)) {
+            if (asyncReplyInfo)
+                IPC::addAsyncReplyHandler(*connection(), asyncReplyInfo->second, WTFMove(asyncReplyInfo->first));
+            return true;
+        }
+        break;
 
     case State::Terminated:
-        return false;
-    }
-
+        break;
+    }
+
+    if (asyncReplyInfo)
+        asyncReplyInfo->first(nullptr);
+    
     return false;
 }
@@ -201 +209 @@
     m_connection->open();
 
-    for (size_t i = 0; i < m_pendingMessages.size(); ++i) {
-        std::unique_ptr<IPC::Encoder> message = WTFMove(m_pendingMessages[i].first);
-        OptionSet<IPC::SendOption> sendOptions = m_pendingMessages[i].second;
+    for (auto&& pendingMessage : std::exchange(m_pendingMessages, { })) {
+        auto encoder = WTFMove(pendingMessage.encoder);
+        auto sendOptions = pendingMessage.sendOptions;
 #if HAVE(SANDBOX_ISSUE_MACH_EXTENSION_TO_PROCESS_BY_PID)
-        if (message->messageName() == "LoadRequestWaitingForPID") {
-            auto buffer = message->buffer();
-            auto bufferSize = message->bufferSize();
+        if (encoder->messageName() == "LoadRequestWaitingForPID") {
+            auto buffer = encoder->buffer();
+            auto bufferSize = encoder->bufferSize();
             std::unique_ptr<IPC::Decoder> decoder = makeUnique<IPC::Decoder>(buffer, bufferSize, nullptr, Vector<IPC::Attachment> { });
             LoadParameters loadParameters;
@@ -218 +226 @@
         }
 #endif
-        m_connection->sendMessage(WTFMove(message), sendOptions);
-    }
-
-    m_pendingMessages.clear();
+        if (pendingMessage.asyncReplyInfo)
+            IPC::addAsyncReplyHandler(*connection(), pendingMessage.asyncReplyInfo->second, WTFMove(pendingMessage.asyncReplyInfo->first));
+        m_connection->sendMessage(WTFMove(encoder), sendOptions);
+    }
 }
 

trunk/Source/WebKit/UIProcess/AuxiliaryProcessProxy.h

@@ -51 +51 @@
     template<typename T> bool send(T&& message, uint64_t destinationID, OptionSet<IPC::SendOption> sendOptions = { });
     template<typename T> bool sendSync(T&& message, typename T::Reply&&, uint64_t destinationID, Seconds timeout = 1_s, OptionSet<IPC::SendSyncOption> sendSyncOptions = { });
-    template<typename T, typename... Args> void sendWithAsyncReply(T&&, CompletionHandler<void(Args...)>&&);
+    template<typename T, typename... Args> void sendWithAsyncReply(T&&, CompletionHandler<void(Args...)>&&, uint64_t destinationID = 0, OptionSet<IPC::SendOption> = { });
     
     template<typename T, typename U>
@@ -103 +103 @@
 
     bool canSendMessage() const { return state() != State::Terminated;}
-    bool sendMessage(std::unique_ptr<IPC::Encoder>, OptionSet<IPC::SendOption>);
+    bool sendMessage(std::unique_ptr<IPC::Encoder>, OptionSet<IPC::SendOption>, Optional<std::pair<CompletionHandler<void(IPC::Decoder*)>, uint64_t>>&& asyncReplyInfo = WTF::nullopt);
 
     void shutDownProcess();
@@ -126 +126 @@
     static bool isRunningProcessPID(ProcessID);
 
-    Vector<std::pair<std::unique_ptr<IPC::Encoder>, OptionSet<IPC::SendOption>>> m_pendingMessages;
+    struct PendingMessage {
+        std::unique_ptr<IPC::Encoder> encoder;
+        OptionSet<IPC::SendOption> sendOptions;
+        Optional<std::pair<CompletionHandler<void(IPC::Decoder*)>, uint64_t>> asyncReplyInfo;
+    };
+    
+    Vector<PendingMessage> m_pendingMessages;
     RefPtr<ProcessLauncher> m_processLauncher;
     RefPtr<IPC::Connection> m_connection;
@@ -159 +165 @@
 
 template<typename T, typename... Args>
-void AuxiliaryProcessProxy::sendWithAsyncReply(T&& message, CompletionHandler<void(Args...)>&& completionHandler)
+void AuxiliaryProcessProxy::sendWithAsyncReply(T&& message, CompletionHandler<void(Args...)>&& completionHandler, uint64_t destinationID, OptionSet<IPC::SendOption> sendOptions)
 {
-    if (!m_connection) {
-        T::cancelReply(WTFMove(completionHandler));
-        return;
-    }
+    COMPILE_ASSERT(!T::isSync, AsyncMessageExpected);
 
-    connection()->sendWithAsyncReply(std::forward<T>(message), WTFMove(completionHandler));
+    auto encoder = makeUnique<IPC::Encoder>(T::receiverName(), T::name(), destinationID);
+    uint64_t listenerID = IPC::nextAsyncReplyHandlerID();
+    encoder->encode(listenerID);
+    encoder->encode(message.arguments());
+    sendMessage(WTFMove(encoder), sendOptions, {{ [completionHandler = WTFMove(completionHandler)] (IPC::Decoder* decoder) mutable {
+        if (decoder && !decoder->isInvalid())
+            T::callReply(*decoder, WTFMove(completionHandler));
+        else
+            T::cancelReply(WTFMove(completionHandler));
+    }, listenerID }});
 }