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