1/*
2 * Copyright (C) 2010-2018 Apple Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16 * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
17 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
19 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
20 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
21 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
22 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23 */
24
25#pragma once
26
27#include "ArgumentCoders.h"
28#include "Connection.h"
29#include <WebCore/PluginData.h>
30#include <wtf/Forward.h>
31#include <wtf/Optional.h>
32#include <wtf/ThreadSafeRefCounted.h>
33#include <wtf/Vector.h>
34#include <wtf/text/WTFString.h>
35
36namespace IPC {
37class Attachment;
38}
39
40namespace WebCore {
41class RegistrableDomain;
42struct MessagePortIdentifier;
43struct MessageWithMessagePorts;
44struct PrewarmInformation;
45}
46
47namespace WebKit {
48struct BackForwardListItemState;
49}
50
51namespace Messages {
52namespace WebProcessProxy {
53
54static inline IPC::StringReference messageReceiverName()
55{
56 return IPC::StringReference("WebProcessProxy");
57}
58
59class UpdateBackForwardItem {
60public:
61 typedef std::tuple<const WebKit::BackForwardListItemState&> Arguments;
62
63 static IPC::StringReference receiverName() { return messageReceiverName(); }
64 static IPC::StringReference name() { return IPC::StringReference("UpdateBackForwardItem"); }
65 static const bool isSync = false;
66
67 explicit UpdateBackForwardItem(const WebKit::BackForwardListItemState& backForwardListItemState)
68 : m_arguments(backForwardListItemState)
69 {
70 }
71
72 const Arguments& arguments() const
73 {
74 return m_arguments;
75 }
76
77private:
78 Arguments m_arguments;
79};
80
81class DidDestroyFrame {
82public:
83 typedef std::tuple<uint64_t> Arguments;
84
85 static IPC::StringReference receiverName() { return messageReceiverName(); }
86 static IPC::StringReference name() { return IPC::StringReference("DidDestroyFrame"); }
87 static const bool isSync = false;
88
89 explicit DidDestroyFrame(uint64_t frameID)
90 : m_arguments(frameID)
91 {
92 }
93
94 const Arguments& arguments() const
95 {
96 return m_arguments;
97 }
98
99private:
100 Arguments m_arguments;
101};
102
103class DidDestroyUserGestureToken {
104public:
105 typedef std::tuple<uint64_t> Arguments;
106
107 static IPC::StringReference receiverName() { return messageReceiverName(); }
108 static IPC::StringReference name() { return IPC::StringReference("DidDestroyUserGestureToken"); }
109 static const bool isSync = false;
110
111 explicit DidDestroyUserGestureToken(uint64_t userGestureTokenID)
112 : m_arguments(userGestureTokenID)
113 {
114 }
115
116 const Arguments& arguments() const
117 {
118 return m_arguments;
119 }
120
121private:
122 Arguments m_arguments;
123};
124
125class ShouldTerminate {
126public:
127 typedef std::tuple<> Arguments;
128
129 static IPC::StringReference receiverName() { return messageReceiverName(); }
130 static IPC::StringReference name() { return IPC::StringReference("ShouldTerminate"); }
131 static const bool isSync = true;
132
133 using DelayedReply = CompletionHandler<void(bool shouldTerminate)>;
134 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool shouldTerminate);
135 using Reply = std::tuple<bool&>;
136 using ReplyArguments = std::tuple<bool>;
137 const Arguments& arguments() const
138 {
139 return m_arguments;
140 }
141
142private:
143 Arguments m_arguments;
144};
145
146class EnableSuddenTermination {
147public:
148 typedef std::tuple<> Arguments;
149
150 static IPC::StringReference receiverName() { return messageReceiverName(); }
151 static IPC::StringReference name() { return IPC::StringReference("EnableSuddenTermination"); }
152 static const bool isSync = false;
153
154 const Arguments& arguments() const
155 {
156 return m_arguments;
157 }
158
159private:
160 Arguments m_arguments;
161};
162
163class DisableSuddenTermination {
164public:
165 typedef std::tuple<> Arguments;
166
167 static IPC::StringReference receiverName() { return messageReceiverName(); }
168 static IPC::StringReference name() { return IPC::StringReference("DisableSuddenTermination"); }
169 static const bool isSync = false;
170
171 const Arguments& arguments() const
172 {
173 return m_arguments;
174 }
175
176private:
177 Arguments m_arguments;
178};
179
180#if ENABLE(NETSCAPE_PLUGIN_API)
181class GetPlugins {
182public:
183 typedef std::tuple<bool> Arguments;
184
185 static IPC::StringReference receiverName() { return messageReceiverName(); }
186 static IPC::StringReference name() { return IPC::StringReference("GetPlugins"); }
187 static const bool isSync = true;
188
189 using DelayedReply = CompletionHandler<void(const Vector<WebCore::PluginInfo>& plugins, const Vector<WebCore::PluginInfo>& applicationPlugins, const Optional<Vector<WebCore::SupportedPluginIdentifier>>& supportedPluginIdentifiers)>;
190 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const Vector<WebCore::PluginInfo>& plugins, const Vector<WebCore::PluginInfo>& applicationPlugins, const Optional<Vector<WebCore::SupportedPluginIdentifier>>& supportedPluginIdentifiers);
191 using Reply = std::tuple<Vector<WebCore::PluginInfo>&, Vector<WebCore::PluginInfo>&, Optional<Vector<WebCore::SupportedPluginIdentifier>>&>;
192 using ReplyArguments = std::tuple<Vector<WebCore::PluginInfo>, Vector<WebCore::PluginInfo>, Optional<Vector<WebCore::SupportedPluginIdentifier>>>;
193 explicit GetPlugins(bool refresh)
194 : m_arguments(refresh)
195 {
196 }
197
198 const Arguments& arguments() const
199 {
200 return m_arguments;
201 }
202
203private:
204 Arguments m_arguments;
205};
206#endif
207
208#if ENABLE(NETSCAPE_PLUGIN_API)
209class GetPluginProcessConnection {
210public:
211 typedef std::tuple<uint64_t> Arguments;
212
213 static IPC::StringReference receiverName() { return messageReceiverName(); }
214 static IPC::StringReference name() { return IPC::StringReference("GetPluginProcessConnection"); }
215 static const bool isSync = true;
216
217 using DelayedReply = CompletionHandler<void(const IPC::Attachment& connectionHandle, bool supportsAsynchronousInitialization)>;
218 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const IPC::Attachment& connectionHandle, bool supportsAsynchronousInitialization);
219 using Reply = std::tuple<IPC::Attachment&, bool&>;
220 using ReplyArguments = std::tuple<IPC::Attachment, bool>;
221 explicit GetPluginProcessConnection(uint64_t pluginProcessToken)
222 : m_arguments(pluginProcessToken)
223 {
224 }
225
226 const Arguments& arguments() const
227 {
228 return m_arguments;
229 }
230
231private:
232 Arguments m_arguments;
233};
234#endif
235
236class GetNetworkProcessConnection {
237public:
238 typedef std::tuple<> Arguments;
239
240 static IPC::StringReference receiverName() { return messageReceiverName(); }
241 static IPC::StringReference name() { return IPC::StringReference("GetNetworkProcessConnection"); }
242 static const bool isSync = true;
243
244 using DelayedReply = CompletionHandler<void(const IPC::Attachment& connectionHandle)>;
245 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const IPC::Attachment& connectionHandle);
246 using Reply = std::tuple<IPC::Attachment&>;
247 using ReplyArguments = std::tuple<IPC::Attachment>;
248 const Arguments& arguments() const
249 {
250 return m_arguments;
251 }
252
253private:
254 Arguments m_arguments;
255};
256
257class ProcessReadyToSuspend {
258public:
259 typedef std::tuple<> Arguments;
260
261 static IPC::StringReference receiverName() { return messageReceiverName(); }
262 static IPC::StringReference name() { return IPC::StringReference("ProcessReadyToSuspend"); }
263 static const bool isSync = false;
264
265 const Arguments& arguments() const
266 {
267 return m_arguments;
268 }
269
270private:
271 Arguments m_arguments;
272};
273
274class DidCancelProcessSuspension {
275public:
276 typedef std::tuple<> Arguments;
277
278 static IPC::StringReference receiverName() { return messageReceiverName(); }
279 static IPC::StringReference name() { return IPC::StringReference("DidCancelProcessSuspension"); }
280 static const bool isSync = false;
281
282 const Arguments& arguments() const
283 {
284 return m_arguments;
285 }
286
287private:
288 Arguments m_arguments;
289};
290
291class SetIsHoldingLockedFiles {
292public:
293 typedef std::tuple<bool> Arguments;
294
295 static IPC::StringReference receiverName() { return messageReceiverName(); }
296 static IPC::StringReference name() { return IPC::StringReference("SetIsHoldingLockedFiles"); }
297 static const bool isSync = false;
298
299 explicit SetIsHoldingLockedFiles(bool isHoldingLockedFiles)
300 : m_arguments(isHoldingLockedFiles)
301 {
302 }
303
304 const Arguments& arguments() const
305 {
306 return m_arguments;
307 }
308
309private:
310 Arguments m_arguments;
311};
312
313class DidExceedActiveMemoryLimit {
314public:
315 typedef std::tuple<> Arguments;
316
317 static IPC::StringReference receiverName() { return messageReceiverName(); }
318 static IPC::StringReference name() { return IPC::StringReference("DidExceedActiveMemoryLimit"); }
319 static const bool isSync = false;
320
321 const Arguments& arguments() const
322 {
323 return m_arguments;
324 }
325
326private:
327 Arguments m_arguments;
328};
329
330class DidExceedInactiveMemoryLimit {
331public:
332 typedef std::tuple<> Arguments;
333
334 static IPC::StringReference receiverName() { return messageReceiverName(); }
335 static IPC::StringReference name() { return IPC::StringReference("DidExceedInactiveMemoryLimit"); }
336 static const bool isSync = false;
337
338 const Arguments& arguments() const
339 {
340 return m_arguments;
341 }
342
343private:
344 Arguments m_arguments;
345};
346
347class DidExceedCPULimit {
348public:
349 typedef std::tuple<> Arguments;
350
351 static IPC::StringReference receiverName() { return messageReceiverName(); }
352 static IPC::StringReference name() { return IPC::StringReference("DidExceedCPULimit"); }
353 static const bool isSync = false;
354
355 const Arguments& arguments() const
356 {
357 return m_arguments;
358 }
359
360private:
361 Arguments m_arguments;
362};
363
364class StopResponsivenessTimer {
365public:
366 typedef std::tuple<> Arguments;
367
368 static IPC::StringReference receiverName() { return messageReceiverName(); }
369 static IPC::StringReference name() { return IPC::StringReference("StopResponsivenessTimer"); }
370 static const bool isSync = false;
371
372 const Arguments& arguments() const
373 {
374 return m_arguments;
375 }
376
377private:
378 Arguments m_arguments;
379};
380
381class DidReceiveMainThreadPing {
382public:
383 typedef std::tuple<> Arguments;
384
385 static IPC::StringReference receiverName() { return messageReceiverName(); }
386 static IPC::StringReference name() { return IPC::StringReference("DidReceiveMainThreadPing"); }
387 static const bool isSync = false;
388
389 const Arguments& arguments() const
390 {
391 return m_arguments;
392 }
393
394private:
395 Arguments m_arguments;
396};
397
398class DidReceiveBackgroundResponsivenessPing {
399public:
400 typedef std::tuple<> Arguments;
401
402 static IPC::StringReference receiverName() { return messageReceiverName(); }
403 static IPC::StringReference name() { return IPC::StringReference("DidReceiveBackgroundResponsivenessPing"); }
404 static const bool isSync = false;
405
406 const Arguments& arguments() const
407 {
408 return m_arguments;
409 }
410
411private:
412 Arguments m_arguments;
413};
414
415class MemoryPressureStatusChanged {
416public:
417 typedef std::tuple<bool> Arguments;
418
419 static IPC::StringReference receiverName() { return messageReceiverName(); }
420 static IPC::StringReference name() { return IPC::StringReference("MemoryPressureStatusChanged"); }
421 static const bool isSync = false;
422
423 explicit MemoryPressureStatusChanged(bool isUnderMemoryPressure)
424 : m_arguments(isUnderMemoryPressure)
425 {
426 }
427
428 const Arguments& arguments() const
429 {
430 return m_arguments;
431 }
432
433private:
434 Arguments m_arguments;
435};
436
437class DidExceedInactiveMemoryLimitWhileActive {
438public:
439 typedef std::tuple<> Arguments;
440
441 static IPC::StringReference receiverName() { return messageReceiverName(); }
442 static IPC::StringReference name() { return IPC::StringReference("DidExceedInactiveMemoryLimitWhileActive"); }
443 static const bool isSync = false;
444
445 const Arguments& arguments() const
446 {
447 return m_arguments;
448 }
449
450private:
451 Arguments m_arguments;
452};
453
454class CreateNewMessagePortChannel {
455public:
456 typedef std::tuple<const WebCore::MessagePortIdentifier&, const WebCore::MessagePortIdentifier&> Arguments;
457
458 static IPC::StringReference receiverName() { return messageReceiverName(); }
459 static IPC::StringReference name() { return IPC::StringReference("CreateNewMessagePortChannel"); }
460 static const bool isSync = false;
461
462 CreateNewMessagePortChannel(const WebCore::MessagePortIdentifier& port1, const WebCore::MessagePortIdentifier& port2)
463 : m_arguments(port1, port2)
464 {
465 }
466
467 const Arguments& arguments() const
468 {
469 return m_arguments;
470 }
471
472private:
473 Arguments m_arguments;
474};
475
476class EntangleLocalPortInThisProcessToRemote {
477public:
478 typedef std::tuple<const WebCore::MessagePortIdentifier&, const WebCore::MessagePortIdentifier&> Arguments;
479
480 static IPC::StringReference receiverName() { return messageReceiverName(); }
481 static IPC::StringReference name() { return IPC::StringReference("EntangleLocalPortInThisProcessToRemote"); }
482 static const bool isSync = false;
483
484 EntangleLocalPortInThisProcessToRemote(const WebCore::MessagePortIdentifier& local, const WebCore::MessagePortIdentifier& remote)
485 : m_arguments(local, remote)
486 {
487 }
488
489 const Arguments& arguments() const
490 {
491 return m_arguments;
492 }
493
494private:
495 Arguments m_arguments;
496};
497
498class MessagePortDisentangled {
499public:
500 typedef std::tuple<const WebCore::MessagePortIdentifier&> Arguments;
501
502 static IPC::StringReference receiverName() { return messageReceiverName(); }
503 static IPC::StringReference name() { return IPC::StringReference("MessagePortDisentangled"); }
504 static const bool isSync = false;
505
506 explicit MessagePortDisentangled(const WebCore::MessagePortIdentifier& local)
507 : m_arguments(local)
508 {
509 }
510
511 const Arguments& arguments() const
512 {
513 return m_arguments;
514 }
515
516private:
517 Arguments m_arguments;
518};
519
520class MessagePortClosed {
521public:
522 typedef std::tuple<const WebCore::MessagePortIdentifier&> Arguments;
523
524 static IPC::StringReference receiverName() { return messageReceiverName(); }
525 static IPC::StringReference name() { return IPC::StringReference("MessagePortClosed"); }
526 static const bool isSync = false;
527
528 explicit MessagePortClosed(const WebCore::MessagePortIdentifier& local)
529 : m_arguments(local)
530 {
531 }
532
533 const Arguments& arguments() const
534 {
535 return m_arguments;
536 }
537
538private:
539 Arguments m_arguments;
540};
541
542class TakeAllMessagesForPort {
543public:
544 typedef std::tuple<const WebCore::MessagePortIdentifier&, uint64_t> Arguments;
545
546 static IPC::StringReference receiverName() { return messageReceiverName(); }
547 static IPC::StringReference name() { return IPC::StringReference("TakeAllMessagesForPort"); }
548 static const bool isSync = false;
549
550 TakeAllMessagesForPort(const WebCore::MessagePortIdentifier& port, uint64_t messagesCallbackIdentifier)
551 : m_arguments(port, messagesCallbackIdentifier)
552 {
553 }
554
555 const Arguments& arguments() const
556 {
557 return m_arguments;
558 }
559
560private:
561 Arguments m_arguments;
562};
563
564class PostMessageToRemote {
565public:
566 typedef std::tuple<const WebCore::MessageWithMessagePorts&, const WebCore::MessagePortIdentifier&> Arguments;
567
568 static IPC::StringReference receiverName() { return messageReceiverName(); }
569 static IPC::StringReference name() { return IPC::StringReference("PostMessageToRemote"); }
570 static const bool isSync = false;
571
572 PostMessageToRemote(const WebCore::MessageWithMessagePorts& message, const WebCore::MessagePortIdentifier& remote)
573 : m_arguments(message, remote)
574 {
575 }
576
577 const Arguments& arguments() const
578 {
579 return m_arguments;
580 }
581
582private:
583 Arguments m_arguments;
584};
585
586class CheckRemotePortForActivity {
587public:
588 typedef std::tuple<const WebCore::MessagePortIdentifier&, uint64_t> Arguments;
589
590 static IPC::StringReference receiverName() { return messageReceiverName(); }
591 static IPC::StringReference name() { return IPC::StringReference("CheckRemotePortForActivity"); }
592 static const bool isSync = false;
593
594 CheckRemotePortForActivity(const WebCore::MessagePortIdentifier& port, uint64_t callbackIdentifier)
595 : m_arguments(port, callbackIdentifier)
596 {
597 }
598
599 const Arguments& arguments() const
600 {
601 return m_arguments;
602 }
603
604private:
605 Arguments m_arguments;
606};
607
608class DidDeliverMessagePortMessages {
609public:
610 typedef std::tuple<uint64_t> Arguments;
611
612 static IPC::StringReference receiverName() { return messageReceiverName(); }
613 static IPC::StringReference name() { return IPC::StringReference("DidDeliverMessagePortMessages"); }
614 static const bool isSync = false;
615
616 explicit DidDeliverMessagePortMessages(uint64_t messageBatchIdentifier)
617 : m_arguments(messageBatchIdentifier)
618 {
619 }
620
621 const Arguments& arguments() const
622 {
623 return m_arguments;
624 }
625
626private:
627 Arguments m_arguments;
628};
629
630class DidCheckProcessLocalPortForActivity {
631public:
632 typedef std::tuple<uint64_t, bool> Arguments;
633
634 static IPC::StringReference receiverName() { return messageReceiverName(); }
635 static IPC::StringReference name() { return IPC::StringReference("DidCheckProcessLocalPortForActivity"); }
636 static const bool isSync = false;
637
638 DidCheckProcessLocalPortForActivity(uint64_t callbackIdentifier, bool isLocallyReachable)
639 : m_arguments(callbackIdentifier, isLocallyReachable)
640 {
641 }
642
643 const Arguments& arguments() const
644 {
645 return m_arguments;
646 }
647
648private:
649 Arguments m_arguments;
650};
651
652class DidCollectPrewarmInformation {
653public:
654 typedef std::tuple<const WebCore::RegistrableDomain&, const WebCore::PrewarmInformation&> Arguments;
655
656 static IPC::StringReference receiverName() { return messageReceiverName(); }
657 static IPC::StringReference name() { return IPC::StringReference("DidCollectPrewarmInformation"); }
658 static const bool isSync = false;
659
660 DidCollectPrewarmInformation(const WebCore::RegistrableDomain& domain, const WebCore::PrewarmInformation& prewarmInformation)
661 : m_arguments(domain, prewarmInformation)
662 {
663 }
664
665 const Arguments& arguments() const
666 {
667 return m_arguments;
668 }
669
670private:
671 Arguments m_arguments;
672};
673
674#if PLATFORM(COCOA)
675class CacheMediaMIMETypes {
676public:
677 typedef std::tuple<const Vector<String>&> Arguments;
678
679 static IPC::StringReference receiverName() { return messageReceiverName(); }
680 static IPC::StringReference name() { return IPC::StringReference("CacheMediaMIMETypes"); }
681 static const bool isSync = false;
682
683 explicit CacheMediaMIMETypes(const Vector<String>& types)
684 : m_arguments(types)
685 {
686 }
687
688 const Arguments& arguments() const
689 {
690 return m_arguments;
691 }
692
693private:
694 Arguments m_arguments;
695};
696#endif
697
698#if PLATFORM(MAC)
699class RequestHighPerformanceGPU {
700public:
701 typedef std::tuple<> Arguments;
702
703 static IPC::StringReference receiverName() { return messageReceiverName(); }
704 static IPC::StringReference name() { return IPC::StringReference("RequestHighPerformanceGPU"); }
705 static const bool isSync = false;
706
707 const Arguments& arguments() const
708 {
709 return m_arguments;
710 }
711
712private:
713 Arguments m_arguments;
714};
715#endif
716
717#if PLATFORM(MAC)
718class ReleaseHighPerformanceGPU {
719public:
720 typedef std::tuple<> Arguments;
721
722 static IPC::StringReference receiverName() { return messageReceiverName(); }
723 static IPC::StringReference name() { return IPC::StringReference("ReleaseHighPerformanceGPU"); }
724 static const bool isSync = false;
725
726 const Arguments& arguments() const
727 {
728 return m_arguments;
729 }
730
731private:
732 Arguments m_arguments;
733};
734#endif
735
736#if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
737class StartDisplayLink {
738public:
739 typedef std::tuple<const unsigned&, uint32_t> Arguments;
740
741 static IPC::StringReference receiverName() { return messageReceiverName(); }
742 static IPC::StringReference name() { return IPC::StringReference("StartDisplayLink"); }
743 static const bool isSync = false;
744
745 StartDisplayLink(const unsigned& observerID, uint32_t displayID)
746 : m_arguments(observerID, displayID)
747 {
748 }
749
750 const Arguments& arguments() const
751 {
752 return m_arguments;
753 }
754
755private:
756 Arguments m_arguments;
757};
758#endif
759
760#if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
761class StopDisplayLink {
762public:
763 typedef std::tuple<const unsigned&, uint32_t> Arguments;
764
765 static IPC::StringReference receiverName() { return messageReceiverName(); }
766 static IPC::StringReference name() { return IPC::StringReference("StopDisplayLink"); }
767 static const bool isSync = false;
768
769 StopDisplayLink(const unsigned& observerID, uint32_t displayID)
770 : m_arguments(observerID, displayID)
771 {
772 }
773
774 const Arguments& arguments() const
775 {
776 return m_arguments;
777 }
778
779private:
780 Arguments m_arguments;
781};
782#endif
783
784#if PLATFORM(IOS_FAMILY)
785class ProcessWasUnexpectedlyUnsuspended {
786public:
787 typedef std::tuple<> Arguments;
788
789 static IPC::StringReference receiverName() { return messageReceiverName(); }
790 static IPC::StringReference name() { return IPC::StringReference("ProcessWasUnexpectedlyUnsuspended"); }
791 static const bool isSync = false;
792
793 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
794 static void cancelReply(CompletionHandler<void()>&&);
795 static IPC::StringReference asyncMessageReplyName() { return { "ProcessWasUnexpectedlyUnsuspendedReply" }; }
796 using AsyncReply = CompletionHandler<void()>;
797 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
798 using Reply = std::tuple<>;
799 using ReplyArguments = std::tuple<>;
800 const Arguments& arguments() const
801 {
802 return m_arguments;
803 }
804
805private:
806 Arguments m_arguments;
807};
808#endif
809
810} // namespace WebProcessProxy
811} // namespace Messages
812