Changeset 262075 in webkit

Timestamp:

May 22, 2020 2:45:47 PM (4 years ago)

Author:

Wenson Hsieh

Message:

[IPC] Add support for specifying Async WantsConnection in message files
​https://bugs.webkit.org/show_bug.cgi?id=212276

Reviewed by Alex Christensen.

Augments the IPC message receiver generation script to allow for "Async WantsConnection" in .message.in files.
Currently, specifying this in a message causes the connection argument to be passed twice when handling the
IPC message. This is because normal async IPC messages without replies normally don't have the IPC::Connection
argument, and use the overloaded handleMessage(Connection& connection, ...) version of handleMessage when
WantsConnection is specified.

However, in the Async reply case, we already pass in the IPC::Connection. Instead of overloading the method
signature, we introduce a different method instead, named handleMessageAsyncWantsConnection, which forwards
the given IPC::Connection along to the member function.

Test: TestAsyncMessageWithConnection

• Platform/IPC/HandleMessage.h:

(IPC::handleMessageAsyncWantsConnection):

Add another variant of the message receiver template, for the case where the message receiver wants a connection.
This is similar to handleMessageSynchronousWantsConnection, above.

• Scripts/test-superclassMessageReceiver.cpp:

(Messages::WebPage::TestAsyncMessageWithConnection::callReply):
(Messages::WebPage::TestAsyncMessageWithConnection::cancelReply):
(Messages::WebPage::TestAsyncMessageWithConnection::send):
(WebKit::WebPage::didReceiveMessage):

• Scripts/test-superclassMessages.h:

(Messages::WebPage::TestAsyncMessageWithConnection::name):
(Messages::WebPage::TestAsyncMessageWithConnection::asyncMessageReplyName):
(Messages::WebPage::TestAsyncMessageWithConnection::TestAsyncMessageWithConnection):
(Messages::WebPage::TestAsyncMessageWithConnection::arguments const):

• Scripts/webkit/messages.py:
• Scripts/webkit/messages_unittest.py:
• Scripts/webkit/test-superclass.messages.in:

Location:

trunk/Source/WebKit

Files:

• ChangeLog (modified) (1 diff)
• Platform/IPC/HandleMessage.h (modified) (1 diff)
• Scripts/test-superclassMessageReceiver.cpp (modified) (2 diffs)
• Scripts/test-superclassMessages.h (modified) (1 diff)
• Scripts/webkit/messages.py (modified) (1 diff)
• Scripts/webkit/messages_unittest.py (modified) (1 diff)
• Scripts/webkit/test-superclass.messages.in (modified) (1 diff)

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2020-05-22  Wenson Hsieh  <wenson_hsieh@apple.com>
+
+        [IPC] Add support for specifying `Async WantsConnection` in message files
+        https://bugs.webkit.org/show_bug.cgi?id=212276
+
+        Reviewed by Alex Christensen.
+
+        Augments the IPC message receiver generation script to allow for "Async WantsConnection" in `.message.in` files.
+        Currently, specifying this in a message causes the `connection` argument to be passed twice when handling the
+        IPC message. This is because normal async IPC messages without replies normally don't have the `IPC::Connection`
+        argument, and use the overloaded `handleMessage(Connection& connection, ...)` version of `handleMessage` when
+        `WantsConnection` is specified.
+
+        However, in the `Async` reply case, we already pass in the `IPC::Connection`. Instead of overloading the method
+        signature, we introduce a different method instead, named `handleMessageAsyncWantsConnection`, which forwards
+        the given `IPC::Connection` along to the member function.
+
+        Test: TestAsyncMessageWithConnection
+
+        * Platform/IPC/HandleMessage.h:
+        (IPC::handleMessageAsyncWantsConnection):
+
+        Add another variant of the message receiver template, for the case where the message receiver wants a connection.
+        This is similar to handleMessageSynchronousWantsConnection, above.
+
+        * Scripts/test-superclassMessageReceiver.cpp:
+        (Messages::WebPage::TestAsyncMessageWithConnection::callReply):
+        (Messages::WebPage::TestAsyncMessageWithConnection::cancelReply):
+        (Messages::WebPage::TestAsyncMessageWithConnection::send):
+        (WebKit::WebPage::didReceiveMessage):
+        * Scripts/test-superclassMessages.h:
+        (Messages::WebPage::TestAsyncMessageWithConnection::name):
+        (Messages::WebPage::TestAsyncMessageWithConnection::asyncMessageReplyName):
+        (Messages::WebPage::TestAsyncMessageWithConnection::TestAsyncMessageWithConnection):
+        (Messages::WebPage::TestAsyncMessageWithConnection::arguments const):
+        * Scripts/webkit/messages.py:
+        * Scripts/webkit/messages_unittest.py:
+        * Scripts/webkit/test-superclass.messages.in:
+
 2020-05-22  Tim Horton  <timothy_horton@apple.com>
 

trunk/Source/WebKit/Platform/IPC/HandleMessage.h

@@ -184 +184 @@
 }
 
+template<typename T, typename C, typename MF>
+void handleMessageAsyncWantsConnection(Connection& connection, Decoder& decoder, C* object, MF function)
+{
+    Optional<uint64_t> listenerID;
+    decoder >> listenerID;
+    if (!listenerID) {
+        decoder.markInvalid();
+        return;
+    }
+
+    Optional<typename CodingType<typename T::Arguments>::Type> arguments;
+    decoder >> arguments;
+    if (!arguments) {
+        decoder.markInvalid();
+        return;
+    }
+
+    typename T::AsyncReply completionHandler = [listenerID = *listenerID, connection = makeRef(connection)] (auto&&... args) mutable {
+        auto encoder = makeUnique<Encoder>(T::asyncMessageReplyName(), 0);
+        *encoder << listenerID;
+        T::send(WTFMove(encoder), WTFMove(connection), args...);
+    };
+    callMemberFunction(connection, WTFMove(*arguments), WTFMove(completionHandler), object, function);
+}
+
 } // namespace IPC

trunk/Source/WebKit/Scripts/test-superclassMessageReceiver.cpp

@@ -123 +123 @@
 #endif
 
+#if ENABLE(TEST_FEATURE)
+
+void TestAsyncMessageWithConnection::callReply(IPC::Decoder& decoder, CompletionHandler<void(bool&&)>&& completionHandler)
+{
+    Optional<bool> flag;
+    decoder >> flag;
+    if (!flag) {
+        ASSERT_NOT_REACHED();
+        cancelReply(WTFMove(completionHandler));
+        return;
+    }
+    completionHandler(WTFMove(*flag));
+}
+
+void TestAsyncMessageWithConnection::cancelReply(CompletionHandler<void(bool&&)>&& completionHandler)
+{
+    completionHandler(IPC::AsyncReplyError<bool>::create());
+}
+
+void TestAsyncMessageWithConnection::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection, bool flag)
+{
+    *encoder << flag;
+    connection.sendSyncReply(WTFMove(encoder));
+}
+
+#endif
+
 void TestSyncMessage::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection, uint8_t reply)
 {
@@ -163 +190 @@
     if (decoder.messageName() == Messages::WebPage::TestAsyncMessageWithMultipleArguments::name()) {
         IPC::handleMessageAsync<Messages::WebPage::TestAsyncMessageWithMultipleArguments>(connection, decoder, this, &WebPage::testAsyncMessageWithMultipleArguments);
+        return;
+    }
+#endif
+#if ENABLE(TEST_FEATURE)
+    if (decoder.messageName() == Messages::WebPage::TestAsyncMessageWithConnection::name()) {
+        IPC::handleMessageAsyncWantsConnection<Messages::WebPage::TestAsyncMessageWithConnection>(connection, decoder, this, &WebPage::testAsyncMessageWithConnection);
         return;
     }

trunk/Source/WebKit/Scripts/test-superclassMessages.h

@@ -148 +148 @@
 #endif
 
+#if ENABLE(TEST_FEATURE)
+class TestAsyncMessageWithConnection {
+public:
+    typedef std::tuple<const int&> Arguments;
+
+    static IPC::MessageName name() { return IPC::MessageName::WebPage_TestAsyncMessageWithConnection; }
+    static const bool isSync = false;
+
+    static void callReply(IPC::Decoder&, CompletionHandler<void(bool&&)>&&);
+    static void cancelReply(CompletionHandler<void(bool&&)>&&);
+    static IPC::MessageName asyncMessageReplyName() { return IPC::MessageName::WebPage_TestAsyncMessageWithConnectionReply; }
+    using AsyncReply = TestAsyncMessageWithConnectionAsyncReply;
+    static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool flag);
+    using Reply = std::tuple<bool&>;
+    using ReplyArguments = std::tuple<bool>;
+    explicit TestAsyncMessageWithConnection(const int& value)
+        : m_arguments(value)
+    {
+    }
+
+    const Arguments& arguments() const
+    {
+        return m_arguments;
+    }
+
+private:
+    Arguments m_arguments;
+};
+#endif
+
 class TestSyncMessage {
 public:

trunk/Source/WebKit/Scripts/webkit/messages.py

@@ -475 +475 @@
 
     if message.has_attribute(WANTS_CONNECTION_ATTRIBUTE):
-        dispatch_function_args.insert(0, 'connection')
+        if message.has_attribute(ASYNC_ATTRIBUTE):
+            dispatch_function += 'WantsConnection'
+        else:
+            dispatch_function_args.insert(0, 'connection')
 
     result = []

trunk/Source/WebKit/Scripts/webkit/messages_unittest.py

@@ -276 +276 @@
         },
         {
+            'name': 'TestAsyncMessageWithConnection',
+            'parameters': (
+                ('int', 'value'),
+            ),
+            'reply_parameters': (
+                ('bool', 'flag'),
+            ),
+            'conditions': ('ENABLE(TEST_FEATURE)'),
+        },
+        {
             'name': 'TestSyncMessage',
             'parameters': (

trunk/Source/WebKit/Scripts/webkit/test-superclass.messages.in

@@ -27 +27 @@
     TestAsyncMessageWithNoArguments() -> () Async
     TestAsyncMessageWithMultipleArguments() -> (bool flag, uint64_t value) Async
+    TestAsyncMessageWithConnection(int value) -> (bool flag) Async WantsConnection
 #endif
     TestSyncMessage(uint32_t param) -> (uint8_t reply) Synchronous