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 "GamepadData.h"
30#include "SandboxExtension.h"
31#include "WebsiteDataType.h"
32#include <WebCore/MessageWithMessagePorts.h>
33#include <WebCore/PageIdentifier.h>
34#include <WebCore/SecurityOriginData.h>
35#include <pal/SessionID.h>
36#include <wtf/Forward.h>
37#include <wtf/HashMap.h>
38#include <wtf/OptionSet.h>
39#include <wtf/ThreadSafeRefCounted.h>
40#include <wtf/Vector.h>
41#include <wtf/WallTime.h>
42#include <wtf/text/WTFString.h>
43
44namespace IPC {
45class DataReference;
46}
47
48namespace PAL {
49class SessionID;
50}
51
52namespace WebCore {
53struct PrewarmInformation;
54struct MockMediaDevice;
55struct MessagePortIdentifier;
56struct ScreenProperties;
57}
58
59namespace WebKit {
60enum class CacheModel : uint8_t;
61class GamepadData;
62class UserData;
63struct WebPreferencesStore;
64struct WebProcessDataStoreParameters;
65struct TextCheckerState;
66struct WebPageCreationParameters;
67class MediaDeviceSandboxExtensions;
68struct WebProcessCreationParameters;
69struct WebsiteData;
70}
71
72namespace Messages {
73namespace WebProcess {
74
75static inline IPC::StringReference messageReceiverName()
76{
77 return IPC::StringReference("WebProcess");
78}
79
80class InitializeWebProcess {
81public:
82 typedef std::tuple<const WebKit::WebProcessCreationParameters&> Arguments;
83
84 static IPC::StringReference receiverName() { return messageReceiverName(); }
85 static IPC::StringReference name() { return IPC::StringReference("InitializeWebProcess"); }
86 static const bool isSync = false;
87
88 explicit InitializeWebProcess(const WebKit::WebProcessCreationParameters& processCreationParameters)
89 : m_arguments(processCreationParameters)
90 {
91 }
92
93 const Arguments& arguments() const
94 {
95 return m_arguments;
96 }
97
98private:
99 Arguments m_arguments;
100};
101
102class SetWebsiteDataStoreParameters {
103public:
104 typedef std::tuple<const WebKit::WebProcessDataStoreParameters&> Arguments;
105
106 static IPC::StringReference receiverName() { return messageReceiverName(); }
107 static IPC::StringReference name() { return IPC::StringReference("SetWebsiteDataStoreParameters"); }
108 static const bool isSync = false;
109
110 explicit SetWebsiteDataStoreParameters(const WebKit::WebProcessDataStoreParameters& parameters)
111 : m_arguments(parameters)
112 {
113 }
114
115 const Arguments& arguments() const
116 {
117 return m_arguments;
118 }
119
120private:
121 Arguments m_arguments;
122};
123
124class CreateWebPage {
125public:
126 typedef std::tuple<const WebCore::PageIdentifier&, const WebKit::WebPageCreationParameters&> Arguments;
127
128 static IPC::StringReference receiverName() { return messageReceiverName(); }
129 static IPC::StringReference name() { return IPC::StringReference("CreateWebPage"); }
130 static const bool isSync = false;
131
132 CreateWebPage(const WebCore::PageIdentifier& newPageID, const WebKit::WebPageCreationParameters& pageCreationParameters)
133 : m_arguments(newPageID, pageCreationParameters)
134 {
135 }
136
137 const Arguments& arguments() const
138 {
139 return m_arguments;
140 }
141
142private:
143 Arguments m_arguments;
144};
145
146class PrewarmGlobally {
147public:
148 typedef std::tuple<> Arguments;
149
150 static IPC::StringReference receiverName() { return messageReceiverName(); }
151 static IPC::StringReference name() { return IPC::StringReference("PrewarmGlobally"); }
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 PrewarmWithDomainInformation {
164public:
165 typedef std::tuple<const WebCore::PrewarmInformation&> Arguments;
166
167 static IPC::StringReference receiverName() { return messageReceiverName(); }
168 static IPC::StringReference name() { return IPC::StringReference("PrewarmWithDomainInformation"); }
169 static const bool isSync = false;
170
171 explicit PrewarmWithDomainInformation(const WebCore::PrewarmInformation& prewarmInformation)
172 : m_arguments(prewarmInformation)
173 {
174 }
175
176 const Arguments& arguments() const
177 {
178 return m_arguments;
179 }
180
181private:
182 Arguments m_arguments;
183};
184
185class SetCacheModel {
186public:
187 typedef std::tuple<WebKit::CacheModel> Arguments;
188
189 static IPC::StringReference receiverName() { return messageReceiverName(); }
190 static IPC::StringReference name() { return IPC::StringReference("SetCacheModel"); }
191 static const bool isSync = false;
192
193 explicit SetCacheModel(WebKit::CacheModel cacheModel)
194 : m_arguments(cacheModel)
195 {
196 }
197
198 const Arguments& arguments() const
199 {
200 return m_arguments;
201 }
202
203private:
204 Arguments m_arguments;
205};
206
207class RegisterURLSchemeAsEmptyDocument {
208public:
209 typedef std::tuple<const String&> Arguments;
210
211 static IPC::StringReference receiverName() { return messageReceiverName(); }
212 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsEmptyDocument"); }
213 static const bool isSync = false;
214
215 explicit RegisterURLSchemeAsEmptyDocument(const String& scheme)
216 : m_arguments(scheme)
217 {
218 }
219
220 const Arguments& arguments() const
221 {
222 return m_arguments;
223 }
224
225private:
226 Arguments m_arguments;
227};
228
229class RegisterURLSchemeAsSecure {
230public:
231 typedef std::tuple<const String&> Arguments;
232
233 static IPC::StringReference receiverName() { return messageReceiverName(); }
234 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsSecure"); }
235 static const bool isSync = false;
236
237 explicit RegisterURLSchemeAsSecure(const String& scheme)
238 : m_arguments(scheme)
239 {
240 }
241
242 const Arguments& arguments() const
243 {
244 return m_arguments;
245 }
246
247private:
248 Arguments m_arguments;
249};
250
251class RegisterURLSchemeAsBypassingContentSecurityPolicy {
252public:
253 typedef std::tuple<const String&> Arguments;
254
255 static IPC::StringReference receiverName() { return messageReceiverName(); }
256 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsBypassingContentSecurityPolicy"); }
257 static const bool isSync = false;
258
259 explicit RegisterURLSchemeAsBypassingContentSecurityPolicy(const String& scheme)
260 : m_arguments(scheme)
261 {
262 }
263
264 const Arguments& arguments() const
265 {
266 return m_arguments;
267 }
268
269private:
270 Arguments m_arguments;
271};
272
273class SetDomainRelaxationForbiddenForURLScheme {
274public:
275 typedef std::tuple<const String&> Arguments;
276
277 static IPC::StringReference receiverName() { return messageReceiverName(); }
278 static IPC::StringReference name() { return IPC::StringReference("SetDomainRelaxationForbiddenForURLScheme"); }
279 static const bool isSync = false;
280
281 explicit SetDomainRelaxationForbiddenForURLScheme(const String& scheme)
282 : m_arguments(scheme)
283 {
284 }
285
286 const Arguments& arguments() const
287 {
288 return m_arguments;
289 }
290
291private:
292 Arguments m_arguments;
293};
294
295class RegisterURLSchemeAsLocal {
296public:
297 typedef std::tuple<const String&> Arguments;
298
299 static IPC::StringReference receiverName() { return messageReceiverName(); }
300 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsLocal"); }
301 static const bool isSync = false;
302
303 explicit RegisterURLSchemeAsLocal(const String& scheme)
304 : m_arguments(scheme)
305 {
306 }
307
308 const Arguments& arguments() const
309 {
310 return m_arguments;
311 }
312
313private:
314 Arguments m_arguments;
315};
316
317class RegisterURLSchemeAsNoAccess {
318public:
319 typedef std::tuple<const String&> Arguments;
320
321 static IPC::StringReference receiverName() { return messageReceiverName(); }
322 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsNoAccess"); }
323 static const bool isSync = false;
324
325 explicit RegisterURLSchemeAsNoAccess(const String& scheme)
326 : m_arguments(scheme)
327 {
328 }
329
330 const Arguments& arguments() const
331 {
332 return m_arguments;
333 }
334
335private:
336 Arguments m_arguments;
337};
338
339class RegisterURLSchemeAsDisplayIsolated {
340public:
341 typedef std::tuple<const String&> Arguments;
342
343 static IPC::StringReference receiverName() { return messageReceiverName(); }
344 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsDisplayIsolated"); }
345 static const bool isSync = false;
346
347 explicit RegisterURLSchemeAsDisplayIsolated(const String& scheme)
348 : m_arguments(scheme)
349 {
350 }
351
352 const Arguments& arguments() const
353 {
354 return m_arguments;
355 }
356
357private:
358 Arguments m_arguments;
359};
360
361class RegisterURLSchemeAsCORSEnabled {
362public:
363 typedef std::tuple<const String&> Arguments;
364
365 static IPC::StringReference receiverName() { return messageReceiverName(); }
366 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsCORSEnabled"); }
367 static const bool isSync = false;
368
369 explicit RegisterURLSchemeAsCORSEnabled(const String& scheme)
370 : m_arguments(scheme)
371 {
372 }
373
374 const Arguments& arguments() const
375 {
376 return m_arguments;
377 }
378
379private:
380 Arguments m_arguments;
381};
382
383class RegisterURLSchemeAsCachePartitioned {
384public:
385 typedef std::tuple<const String&> Arguments;
386
387 static IPC::StringReference receiverName() { return messageReceiverName(); }
388 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsCachePartitioned"); }
389 static const bool isSync = false;
390
391 explicit RegisterURLSchemeAsCachePartitioned(const String& scheme)
392 : m_arguments(scheme)
393 {
394 }
395
396 const Arguments& arguments() const
397 {
398 return m_arguments;
399 }
400
401private:
402 Arguments m_arguments;
403};
404
405class RegisterURLSchemeAsCanDisplayOnlyIfCanRequest {
406public:
407 typedef std::tuple<const String&> Arguments;
408
409 static IPC::StringReference receiverName() { return messageReceiverName(); }
410 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsCanDisplayOnlyIfCanRequest"); }
411 static const bool isSync = false;
412
413 explicit RegisterURLSchemeAsCanDisplayOnlyIfCanRequest(const String& scheme)
414 : m_arguments(scheme)
415 {
416 }
417
418 const Arguments& arguments() const
419 {
420 return m_arguments;
421 }
422
423private:
424 Arguments m_arguments;
425};
426
427class SetDefaultRequestTimeoutInterval {
428public:
429 typedef std::tuple<double> Arguments;
430
431 static IPC::StringReference receiverName() { return messageReceiverName(); }
432 static IPC::StringReference name() { return IPC::StringReference("SetDefaultRequestTimeoutInterval"); }
433 static const bool isSync = false;
434
435 explicit SetDefaultRequestTimeoutInterval(double timeoutInterval)
436 : m_arguments(timeoutInterval)
437 {
438 }
439
440 const Arguments& arguments() const
441 {
442 return m_arguments;
443 }
444
445private:
446 Arguments m_arguments;
447};
448
449class SetAlwaysUsesComplexTextCodePath {
450public:
451 typedef std::tuple<bool> Arguments;
452
453 static IPC::StringReference receiverName() { return messageReceiverName(); }
454 static IPC::StringReference name() { return IPC::StringReference("SetAlwaysUsesComplexTextCodePath"); }
455 static const bool isSync = false;
456
457 explicit SetAlwaysUsesComplexTextCodePath(bool alwaysUseComplexText)
458 : m_arguments(alwaysUseComplexText)
459 {
460 }
461
462 const Arguments& arguments() const
463 {
464 return m_arguments;
465 }
466
467private:
468 Arguments m_arguments;
469};
470
471class SetShouldUseFontSmoothing {
472public:
473 typedef std::tuple<bool> Arguments;
474
475 static IPC::StringReference receiverName() { return messageReceiverName(); }
476 static IPC::StringReference name() { return IPC::StringReference("SetShouldUseFontSmoothing"); }
477 static const bool isSync = false;
478
479 explicit SetShouldUseFontSmoothing(bool useFontSmoothing)
480 : m_arguments(useFontSmoothing)
481 {
482 }
483
484 const Arguments& arguments() const
485 {
486 return m_arguments;
487 }
488
489private:
490 Arguments m_arguments;
491};
492
493class SetResourceLoadStatisticsEnabled {
494public:
495 typedef std::tuple<bool> Arguments;
496
497 static IPC::StringReference receiverName() { return messageReceiverName(); }
498 static IPC::StringReference name() { return IPC::StringReference("SetResourceLoadStatisticsEnabled"); }
499 static const bool isSync = false;
500
501 explicit SetResourceLoadStatisticsEnabled(bool resourceLoadStatisticsEnabled)
502 : m_arguments(resourceLoadStatisticsEnabled)
503 {
504 }
505
506 const Arguments& arguments() const
507 {
508 return m_arguments;
509 }
510
511private:
512 Arguments m_arguments;
513};
514
515class ClearResourceLoadStatistics {
516public:
517 typedef std::tuple<> Arguments;
518
519 static IPC::StringReference receiverName() { return messageReceiverName(); }
520 static IPC::StringReference name() { return IPC::StringReference("ClearResourceLoadStatistics"); }
521 static const bool isSync = false;
522
523 const Arguments& arguments() const
524 {
525 return m_arguments;
526 }
527
528private:
529 Arguments m_arguments;
530};
531
532class UserPreferredLanguagesChanged {
533public:
534 typedef std::tuple<const Vector<String>&> Arguments;
535
536 static IPC::StringReference receiverName() { return messageReceiverName(); }
537 static IPC::StringReference name() { return IPC::StringReference("UserPreferredLanguagesChanged"); }
538 static const bool isSync = false;
539
540 explicit UserPreferredLanguagesChanged(const Vector<String>& languages)
541 : m_arguments(languages)
542 {
543 }
544
545 const Arguments& arguments() const
546 {
547 return m_arguments;
548 }
549
550private:
551 Arguments m_arguments;
552};
553
554class FullKeyboardAccessModeChanged {
555public:
556 typedef std::tuple<bool> Arguments;
557
558 static IPC::StringReference receiverName() { return messageReceiverName(); }
559 static IPC::StringReference name() { return IPC::StringReference("FullKeyboardAccessModeChanged"); }
560 static const bool isSync = false;
561
562 explicit FullKeyboardAccessModeChanged(bool fullKeyboardAccessEnabled)
563 : m_arguments(fullKeyboardAccessEnabled)
564 {
565 }
566
567 const Arguments& arguments() const
568 {
569 return m_arguments;
570 }
571
572private:
573 Arguments m_arguments;
574};
575
576class DidAddPlugInAutoStartOriginHash {
577public:
578 typedef std::tuple<uint32_t, const WallTime&, const PAL::SessionID&> Arguments;
579
580 static IPC::StringReference receiverName() { return messageReceiverName(); }
581 static IPC::StringReference name() { return IPC::StringReference("DidAddPlugInAutoStartOriginHash"); }
582 static const bool isSync = false;
583
584 DidAddPlugInAutoStartOriginHash(uint32_t hash, const WallTime& expirationTime, const PAL::SessionID& sessionID)
585 : m_arguments(hash, expirationTime, sessionID)
586 {
587 }
588
589 const Arguments& arguments() const
590 {
591 return m_arguments;
592 }
593
594private:
595 Arguments m_arguments;
596};
597
598class ResetPlugInAutoStartOriginDefaultHashes {
599public:
600 typedef std::tuple<const HashMap<uint32_t,WallTime>&> Arguments;
601
602 static IPC::StringReference receiverName() { return messageReceiverName(); }
603 static IPC::StringReference name() { return IPC::StringReference("ResetPlugInAutoStartOriginDefaultHashes"); }
604 static const bool isSync = false;
605
606 explicit ResetPlugInAutoStartOriginDefaultHashes(const HashMap<uint32_t,WallTime>& hashes)
607 : m_arguments(hashes)
608 {
609 }
610
611 const Arguments& arguments() const
612 {
613 return m_arguments;
614 }
615
616private:
617 Arguments m_arguments;
618};
619
620class ResetPlugInAutoStartOriginHashes {
621public:
622 typedef std::tuple<const HashMap<PAL::SessionID, HashMap<uint32_t,WallTime>>&> Arguments;
623
624 static IPC::StringReference receiverName() { return messageReceiverName(); }
625 static IPC::StringReference name() { return IPC::StringReference("ResetPlugInAutoStartOriginHashes"); }
626 static const bool isSync = false;
627
628 explicit ResetPlugInAutoStartOriginHashes(const HashMap<PAL::SessionID, HashMap<uint32_t,WallTime>>& hashes)
629 : m_arguments(hashes)
630 {
631 }
632
633 const Arguments& arguments() const
634 {
635 return m_arguments;
636 }
637
638private:
639 Arguments m_arguments;
640};
641
642class SetPluginLoadClientPolicy {
643public:
644 typedef std::tuple<uint8_t, const String&, const String&, const String&> Arguments;
645
646 static IPC::StringReference receiverName() { return messageReceiverName(); }
647 static IPC::StringReference name() { return IPC::StringReference("SetPluginLoadClientPolicy"); }
648 static const bool isSync = false;
649
650 SetPluginLoadClientPolicy(uint8_t policy, const String& host, const String& bundleIdentifier, const String& versionString)
651 : m_arguments(policy, host, bundleIdentifier, versionString)
652 {
653 }
654
655 const Arguments& arguments() const
656 {
657 return m_arguments;
658 }
659
660private:
661 Arguments m_arguments;
662};
663
664class ResetPluginLoadClientPolicies {
665public:
666 typedef std::tuple<const HashMap<String, HashMap<String, HashMap<String, uint8_t>>>&> Arguments;
667
668 static IPC::StringReference receiverName() { return messageReceiverName(); }
669 static IPC::StringReference name() { return IPC::StringReference("ResetPluginLoadClientPolicies"); }
670 static const bool isSync = false;
671
672 explicit ResetPluginLoadClientPolicies(const HashMap<String, HashMap<String, HashMap<String, uint8_t>>>& pluginLoadClientPolicies)
673 : m_arguments(pluginLoadClientPolicies)
674 {
675 }
676
677 const Arguments& arguments() const
678 {
679 return m_arguments;
680 }
681
682private:
683 Arguments m_arguments;
684};
685
686class ClearPluginClientPolicies {
687public:
688 typedef std::tuple<> Arguments;
689
690 static IPC::StringReference receiverName() { return messageReceiverName(); }
691 static IPC::StringReference name() { return IPC::StringReference("ClearPluginClientPolicies"); }
692 static const bool isSync = false;
693
694 const Arguments& arguments() const
695 {
696 return m_arguments;
697 }
698
699private:
700 Arguments m_arguments;
701};
702
703class RefreshPlugins {
704public:
705 typedef std::tuple<> Arguments;
706
707 static IPC::StringReference receiverName() { return messageReceiverName(); }
708 static IPC::StringReference name() { return IPC::StringReference("RefreshPlugins"); }
709 static const bool isSync = false;
710
711 const Arguments& arguments() const
712 {
713 return m_arguments;
714 }
715
716private:
717 Arguments m_arguments;
718};
719
720class StartMemorySampler {
721public:
722 typedef std::tuple<const WebKit::SandboxExtension::Handle&, const String&, double> Arguments;
723
724 static IPC::StringReference receiverName() { return messageReceiverName(); }
725 static IPC::StringReference name() { return IPC::StringReference("StartMemorySampler"); }
726 static const bool isSync = false;
727
728 StartMemorySampler(const WebKit::SandboxExtension::Handle& sampleLogFileHandle, const String& sampleLogFilePath, double interval)
729 : m_arguments(sampleLogFileHandle, sampleLogFilePath, interval)
730 {
731 }
732
733 const Arguments& arguments() const
734 {
735 return m_arguments;
736 }
737
738private:
739 Arguments m_arguments;
740};
741
742class StopMemorySampler {
743public:
744 typedef std::tuple<> Arguments;
745
746 static IPC::StringReference receiverName() { return messageReceiverName(); }
747 static IPC::StringReference name() { return IPC::StringReference("StopMemorySampler"); }
748 static const bool isSync = false;
749
750 const Arguments& arguments() const
751 {
752 return m_arguments;
753 }
754
755private:
756 Arguments m_arguments;
757};
758
759class SetTextCheckerState {
760public:
761 typedef std::tuple<const WebKit::TextCheckerState&> Arguments;
762
763 static IPC::StringReference receiverName() { return messageReceiverName(); }
764 static IPC::StringReference name() { return IPC::StringReference("SetTextCheckerState"); }
765 static const bool isSync = false;
766
767 explicit SetTextCheckerState(const WebKit::TextCheckerState& textCheckerState)
768 : m_arguments(textCheckerState)
769 {
770 }
771
772 const Arguments& arguments() const
773 {
774 return m_arguments;
775 }
776
777private:
778 Arguments m_arguments;
779};
780
781class SetEnhancedAccessibility {
782public:
783 typedef std::tuple<bool> Arguments;
784
785 static IPC::StringReference receiverName() { return messageReceiverName(); }
786 static IPC::StringReference name() { return IPC::StringReference("SetEnhancedAccessibility"); }
787 static const bool isSync = false;
788
789 explicit SetEnhancedAccessibility(bool flag)
790 : m_arguments(flag)
791 {
792 }
793
794 const Arguments& arguments() const
795 {
796 return m_arguments;
797 }
798
799private:
800 Arguments m_arguments;
801};
802
803class GetWebCoreStatistics {
804public:
805 typedef std::tuple<uint64_t> Arguments;
806
807 static IPC::StringReference receiverName() { return messageReceiverName(); }
808 static IPC::StringReference name() { return IPC::StringReference("GetWebCoreStatistics"); }
809 static const bool isSync = false;
810
811 explicit GetWebCoreStatistics(uint64_t callbackID)
812 : m_arguments(callbackID)
813 {
814 }
815
816 const Arguments& arguments() const
817 {
818 return m_arguments;
819 }
820
821private:
822 Arguments m_arguments;
823};
824
825class GarbageCollectJavaScriptObjects {
826public:
827 typedef std::tuple<> Arguments;
828
829 static IPC::StringReference receiverName() { return messageReceiverName(); }
830 static IPC::StringReference name() { return IPC::StringReference("GarbageCollectJavaScriptObjects"); }
831 static const bool isSync = false;
832
833 const Arguments& arguments() const
834 {
835 return m_arguments;
836 }
837
838private:
839 Arguments m_arguments;
840};
841
842class SetJavaScriptGarbageCollectorTimerEnabled {
843public:
844 typedef std::tuple<bool> Arguments;
845
846 static IPC::StringReference receiverName() { return messageReceiverName(); }
847 static IPC::StringReference name() { return IPC::StringReference("SetJavaScriptGarbageCollectorTimerEnabled"); }
848 static const bool isSync = false;
849
850 explicit SetJavaScriptGarbageCollectorTimerEnabled(bool enable)
851 : m_arguments(enable)
852 {
853 }
854
855 const Arguments& arguments() const
856 {
857 return m_arguments;
858 }
859
860private:
861 Arguments m_arguments;
862};
863
864class SetInjectedBundleParameter {
865public:
866 typedef std::tuple<const String&, const IPC::DataReference&> Arguments;
867
868 static IPC::StringReference receiverName() { return messageReceiverName(); }
869 static IPC::StringReference name() { return IPC::StringReference("SetInjectedBundleParameter"); }
870 static const bool isSync = false;
871
872 SetInjectedBundleParameter(const String& parameter, const IPC::DataReference& value)
873 : m_arguments(parameter, value)
874 {
875 }
876
877 const Arguments& arguments() const
878 {
879 return m_arguments;
880 }
881
882private:
883 Arguments m_arguments;
884};
885
886class SetInjectedBundleParameters {
887public:
888 typedef std::tuple<const IPC::DataReference&> Arguments;
889
890 static IPC::StringReference receiverName() { return messageReceiverName(); }
891 static IPC::StringReference name() { return IPC::StringReference("SetInjectedBundleParameters"); }
892 static const bool isSync = false;
893
894 explicit SetInjectedBundleParameters(const IPC::DataReference& parameters)
895 : m_arguments(parameters)
896 {
897 }
898
899 const Arguments& arguments() const
900 {
901 return m_arguments;
902 }
903
904private:
905 Arguments m_arguments;
906};
907
908class HandleInjectedBundleMessage {
909public:
910 typedef std::tuple<const String&, const WebKit::UserData&> Arguments;
911
912 static IPC::StringReference receiverName() { return messageReceiverName(); }
913 static IPC::StringReference name() { return IPC::StringReference("HandleInjectedBundleMessage"); }
914 static const bool isSync = false;
915
916 HandleInjectedBundleMessage(const String& messageName, const WebKit::UserData& messageBody)
917 : m_arguments(messageName, messageBody)
918 {
919 }
920
921 const Arguments& arguments() const
922 {
923 return m_arguments;
924 }
925
926private:
927 Arguments m_arguments;
928};
929
930class ReleasePageCache {
931public:
932 typedef std::tuple<> Arguments;
933
934 static IPC::StringReference receiverName() { return messageReceiverName(); }
935 static IPC::StringReference name() { return IPC::StringReference("ReleasePageCache"); }
936 static const bool isSync = false;
937
938 const Arguments& arguments() const
939 {
940 return m_arguments;
941 }
942
943private:
944 Arguments m_arguments;
945};
946
947class FetchWebsiteData {
948public:
949 typedef std::tuple<const PAL::SessionID&, const OptionSet<WebKit::WebsiteDataType>&> Arguments;
950
951 static IPC::StringReference receiverName() { return messageReceiverName(); }
952 static IPC::StringReference name() { return IPC::StringReference("FetchWebsiteData"); }
953 static const bool isSync = false;
954
955 static void callReply(IPC::Decoder&, CompletionHandler<void(WebKit::WebsiteData&&)>&&);
956 static void cancelReply(CompletionHandler<void(WebKit::WebsiteData&&)>&&);
957 static IPC::StringReference asyncMessageReplyName() { return { "FetchWebsiteDataReply" }; }
958 using AsyncReply = CompletionHandler<void(const WebKit::WebsiteData& websiteData)>;
959 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const WebKit::WebsiteData& websiteData);
960 using Reply = std::tuple<WebKit::WebsiteData&>;
961 using ReplyArguments = std::tuple<WebKit::WebsiteData>;
962 FetchWebsiteData(const PAL::SessionID& sessionID, const OptionSet<WebKit::WebsiteDataType>& websiteDataTypes)
963 : m_arguments(sessionID, websiteDataTypes)
964 {
965 }
966
967 const Arguments& arguments() const
968 {
969 return m_arguments;
970 }
971
972private:
973 Arguments m_arguments;
974};
975
976class DeleteWebsiteData {
977public:
978 typedef std::tuple<const PAL::SessionID&, const OptionSet<WebKit::WebsiteDataType>&, const WallTime&> Arguments;
979
980 static IPC::StringReference receiverName() { return messageReceiverName(); }
981 static IPC::StringReference name() { return IPC::StringReference("DeleteWebsiteData"); }
982 static const bool isSync = false;
983
984 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
985 static void cancelReply(CompletionHandler<void()>&&);
986 static IPC::StringReference asyncMessageReplyName() { return { "DeleteWebsiteDataReply" }; }
987 using AsyncReply = CompletionHandler<void()>;
988 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
989 using Reply = std::tuple<>;
990 using ReplyArguments = std::tuple<>;
991 DeleteWebsiteData(const PAL::SessionID& sessionID, const OptionSet<WebKit::WebsiteDataType>& websiteDataTypes, const WallTime& modifiedSince)
992 : m_arguments(sessionID, websiteDataTypes, modifiedSince)
993 {
994 }
995
996 const Arguments& arguments() const
997 {
998 return m_arguments;
999 }
1000
1001private:
1002 Arguments m_arguments;
1003};
1004
1005class DeleteWebsiteDataForOrigins {
1006public:
1007 typedef std::tuple<const PAL::SessionID&, const OptionSet<WebKit::WebsiteDataType>&, const Vector<WebCore::SecurityOriginData>&> Arguments;
1008
1009 static IPC::StringReference receiverName() { return messageReceiverName(); }
1010 static IPC::StringReference name() { return IPC::StringReference("DeleteWebsiteDataForOrigins"); }
1011 static const bool isSync = false;
1012
1013 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1014 static void cancelReply(CompletionHandler<void()>&&);
1015 static IPC::StringReference asyncMessageReplyName() { return { "DeleteWebsiteDataForOriginsReply" }; }
1016 using AsyncReply = CompletionHandler<void()>;
1017 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1018 using Reply = std::tuple<>;
1019 using ReplyArguments = std::tuple<>;
1020 DeleteWebsiteDataForOrigins(const PAL::SessionID& sessionID, const OptionSet<WebKit::WebsiteDataType>& websiteDataTypes, const Vector<WebCore::SecurityOriginData>& origins)
1021 : m_arguments(sessionID, websiteDataTypes, origins)
1022 {
1023 }
1024
1025 const Arguments& arguments() const
1026 {
1027 return m_arguments;
1028 }
1029
1030private:
1031 Arguments m_arguments;
1032};
1033
1034class SetHiddenPageDOMTimerThrottlingIncreaseLimit {
1035public:
1036 typedef std::tuple<const int&> Arguments;
1037
1038 static IPC::StringReference receiverName() { return messageReceiverName(); }
1039 static IPC::StringReference name() { return IPC::StringReference("SetHiddenPageDOMTimerThrottlingIncreaseLimit"); }
1040 static const bool isSync = false;
1041
1042 explicit SetHiddenPageDOMTimerThrottlingIncreaseLimit(const int& milliseconds)
1043 : m_arguments(milliseconds)
1044 {
1045 }
1046
1047 const Arguments& arguments() const
1048 {
1049 return m_arguments;
1050 }
1051
1052private:
1053 Arguments m_arguments;
1054};
1055
1056#if PLATFORM(COCOA)
1057class SetQOS {
1058public:
1059 typedef std::tuple<const int&, const int&> Arguments;
1060
1061 static IPC::StringReference receiverName() { return messageReceiverName(); }
1062 static IPC::StringReference name() { return IPC::StringReference("SetQOS"); }
1063 static const bool isSync = false;
1064
1065 SetQOS(const int& latencyQOS, const int& throughputQOS)
1066 : m_arguments(latencyQOS, throughputQOS)
1067 {
1068 }
1069
1070 const Arguments& arguments() const
1071 {
1072 return m_arguments;
1073 }
1074
1075private:
1076 Arguments m_arguments;
1077};
1078#endif
1079
1080class SetMemoryCacheDisabled {
1081public:
1082 typedef std::tuple<bool> Arguments;
1083
1084 static IPC::StringReference receiverName() { return messageReceiverName(); }
1085 static IPC::StringReference name() { return IPC::StringReference("SetMemoryCacheDisabled"); }
1086 static const bool isSync = false;
1087
1088 explicit SetMemoryCacheDisabled(bool disabled)
1089 : m_arguments(disabled)
1090 {
1091 }
1092
1093 const Arguments& arguments() const
1094 {
1095 return m_arguments;
1096 }
1097
1098private:
1099 Arguments m_arguments;
1100};
1101
1102#if ENABLE(SERVICE_CONTROLS)
1103class SetEnabledServices {
1104public:
1105 typedef std::tuple<bool, bool, bool> Arguments;
1106
1107 static IPC::StringReference receiverName() { return messageReceiverName(); }
1108 static IPC::StringReference name() { return IPC::StringReference("SetEnabledServices"); }
1109 static const bool isSync = false;
1110
1111 SetEnabledServices(bool hasImageServices, bool hasSelectionServices, bool hasRichContentServices)
1112 : m_arguments(hasImageServices, hasSelectionServices, hasRichContentServices)
1113 {
1114 }
1115
1116 const Arguments& arguments() const
1117 {
1118 return m_arguments;
1119 }
1120
1121private:
1122 Arguments m_arguments;
1123};
1124#endif
1125
1126class EnsureAutomationSessionProxy {
1127public:
1128 typedef std::tuple<const String&> Arguments;
1129
1130 static IPC::StringReference receiverName() { return messageReceiverName(); }
1131 static IPC::StringReference name() { return IPC::StringReference("EnsureAutomationSessionProxy"); }
1132 static const bool isSync = false;
1133
1134 explicit EnsureAutomationSessionProxy(const String& sessionIdentifier)
1135 : m_arguments(sessionIdentifier)
1136 {
1137 }
1138
1139 const Arguments& arguments() const
1140 {
1141 return m_arguments;
1142 }
1143
1144private:
1145 Arguments m_arguments;
1146};
1147
1148class DestroyAutomationSessionProxy {
1149public:
1150 typedef std::tuple<> Arguments;
1151
1152 static IPC::StringReference receiverName() { return messageReceiverName(); }
1153 static IPC::StringReference name() { return IPC::StringReference("DestroyAutomationSessionProxy"); }
1154 static const bool isSync = false;
1155
1156 const Arguments& arguments() const
1157 {
1158 return m_arguments;
1159 }
1160
1161private:
1162 Arguments m_arguments;
1163};
1164
1165class ProcessWillSuspendImminently {
1166public:
1167 typedef std::tuple<> Arguments;
1168
1169 static IPC::StringReference receiverName() { return messageReceiverName(); }
1170 static IPC::StringReference name() { return IPC::StringReference("ProcessWillSuspendImminently"); }
1171 static const bool isSync = false;
1172
1173 const Arguments& arguments() const
1174 {
1175 return m_arguments;
1176 }
1177
1178private:
1179 Arguments m_arguments;
1180};
1181
1182class PrepareToSuspend {
1183public:
1184 typedef std::tuple<> Arguments;
1185
1186 static IPC::StringReference receiverName() { return messageReceiverName(); }
1187 static IPC::StringReference name() { return IPC::StringReference("PrepareToSuspend"); }
1188 static const bool isSync = false;
1189
1190 const Arguments& arguments() const
1191 {
1192 return m_arguments;
1193 }
1194
1195private:
1196 Arguments m_arguments;
1197};
1198
1199class CancelPrepareToSuspend {
1200public:
1201 typedef std::tuple<> Arguments;
1202
1203 static IPC::StringReference receiverName() { return messageReceiverName(); }
1204 static IPC::StringReference name() { return IPC::StringReference("CancelPrepareToSuspend"); }
1205 static const bool isSync = false;
1206
1207 const Arguments& arguments() const
1208 {
1209 return m_arguments;
1210 }
1211
1212private:
1213 Arguments m_arguments;
1214};
1215
1216class ProcessDidResume {
1217public:
1218 typedef std::tuple<> Arguments;
1219
1220 static IPC::StringReference receiverName() { return messageReceiverName(); }
1221 static IPC::StringReference name() { return IPC::StringReference("ProcessDidResume"); }
1222 static const bool isSync = false;
1223
1224 const Arguments& arguments() const
1225 {
1226 return m_arguments;
1227 }
1228
1229private:
1230 Arguments m_arguments;
1231};
1232
1233class MainThreadPing {
1234public:
1235 typedef std::tuple<> Arguments;
1236
1237 static IPC::StringReference receiverName() { return messageReceiverName(); }
1238 static IPC::StringReference name() { return IPC::StringReference("MainThreadPing"); }
1239 static const bool isSync = false;
1240
1241 const Arguments& arguments() const
1242 {
1243 return m_arguments;
1244 }
1245
1246private:
1247 Arguments m_arguments;
1248};
1249
1250class BackgroundResponsivenessPing {
1251public:
1252 typedef std::tuple<> Arguments;
1253
1254 static IPC::StringReference receiverName() { return messageReceiverName(); }
1255 static IPC::StringReference name() { return IPC::StringReference("BackgroundResponsivenessPing"); }
1256 static const bool isSync = false;
1257
1258 const Arguments& arguments() const
1259 {
1260 return m_arguments;
1261 }
1262
1263private:
1264 Arguments m_arguments;
1265};
1266
1267#if ENABLE(GAMEPAD)
1268class SetInitialGamepads {
1269public:
1270 typedef std::tuple<const Vector<WebKit::GamepadData>&> Arguments;
1271
1272 static IPC::StringReference receiverName() { return messageReceiverName(); }
1273 static IPC::StringReference name() { return IPC::StringReference("SetInitialGamepads"); }
1274 static const bool isSync = false;
1275
1276 explicit SetInitialGamepads(const Vector<WebKit::GamepadData>& gamepadDatas)
1277 : m_arguments(gamepadDatas)
1278 {
1279 }
1280
1281 const Arguments& arguments() const
1282 {
1283 return m_arguments;
1284 }
1285
1286private:
1287 Arguments m_arguments;
1288};
1289#endif
1290
1291#if ENABLE(GAMEPAD)
1292class GamepadConnected {
1293public:
1294 typedef std::tuple<const WebKit::GamepadData&> Arguments;
1295
1296 static IPC::StringReference receiverName() { return messageReceiverName(); }
1297 static IPC::StringReference name() { return IPC::StringReference("GamepadConnected"); }
1298 static const bool isSync = false;
1299
1300 explicit GamepadConnected(const WebKit::GamepadData& gamepadData)
1301 : m_arguments(gamepadData)
1302 {
1303 }
1304
1305 const Arguments& arguments() const
1306 {
1307 return m_arguments;
1308 }
1309
1310private:
1311 Arguments m_arguments;
1312};
1313#endif
1314
1315#if ENABLE(GAMEPAD)
1316class GamepadDisconnected {
1317public:
1318 typedef std::tuple<const unsigned&> Arguments;
1319
1320 static IPC::StringReference receiverName() { return messageReceiverName(); }
1321 static IPC::StringReference name() { return IPC::StringReference("GamepadDisconnected"); }
1322 static const bool isSync = false;
1323
1324 explicit GamepadDisconnected(const unsigned& index)
1325 : m_arguments(index)
1326 {
1327 }
1328
1329 const Arguments& arguments() const
1330 {
1331 return m_arguments;
1332 }
1333
1334private:
1335 Arguments m_arguments;
1336};
1337#endif
1338
1339#if ENABLE(SERVICE_WORKER)
1340class EstablishWorkerContextConnectionToNetworkProcess {
1341public:
1342 typedef std::tuple<uint64_t, const WebCore::PageIdentifier&, const WebKit::WebPreferencesStore&, const PAL::SessionID&> Arguments;
1343
1344 static IPC::StringReference receiverName() { return messageReceiverName(); }
1345 static IPC::StringReference name() { return IPC::StringReference("EstablishWorkerContextConnectionToNetworkProcess"); }
1346 static const bool isSync = false;
1347
1348 EstablishWorkerContextConnectionToNetworkProcess(uint64_t pageGroupID, const WebCore::PageIdentifier& pageID, const WebKit::WebPreferencesStore& store, const PAL::SessionID& initialSessionID)
1349 : m_arguments(pageGroupID, pageID, store, initialSessionID)
1350 {
1351 }
1352
1353 const Arguments& arguments() const
1354 {
1355 return m_arguments;
1356 }
1357
1358private:
1359 Arguments m_arguments;
1360};
1361#endif
1362
1363#if ENABLE(SERVICE_WORKER)
1364class RegisterServiceWorkerClients {
1365public:
1366 typedef std::tuple<> Arguments;
1367
1368 static IPC::StringReference receiverName() { return messageReceiverName(); }
1369 static IPC::StringReference name() { return IPC::StringReference("RegisterServiceWorkerClients"); }
1370 static const bool isSync = false;
1371
1372 const Arguments& arguments() const
1373 {
1374 return m_arguments;
1375 }
1376
1377private:
1378 Arguments m_arguments;
1379};
1380#endif
1381
1382class DidTakeAllMessagesForPort {
1383public:
1384 typedef std::tuple<const Vector<WebCore::MessageWithMessagePorts>&, uint64_t, uint64_t> Arguments;
1385
1386 static IPC::StringReference receiverName() { return messageReceiverName(); }
1387 static IPC::StringReference name() { return IPC::StringReference("DidTakeAllMessagesForPort"); }
1388 static const bool isSync = false;
1389
1390 DidTakeAllMessagesForPort(const Vector<WebCore::MessageWithMessagePorts>& messages, uint64_t messageCallbackIdentifier, uint64_t messageBatchIdentifier)
1391 : m_arguments(messages, messageCallbackIdentifier, messageBatchIdentifier)
1392 {
1393 }
1394
1395 const Arguments& arguments() const
1396 {
1397 return m_arguments;
1398 }
1399
1400private:
1401 Arguments m_arguments;
1402};
1403
1404class DidCheckRemotePortForActivity {
1405public:
1406 typedef std::tuple<uint64_t, bool> Arguments;
1407
1408 static IPC::StringReference receiverName() { return messageReceiverName(); }
1409 static IPC::StringReference name() { return IPC::StringReference("DidCheckRemotePortForActivity"); }
1410 static const bool isSync = false;
1411
1412 DidCheckRemotePortForActivity(uint64_t callbackIdentifier, bool hasActivity)
1413 : m_arguments(callbackIdentifier, hasActivity)
1414 {
1415 }
1416
1417 const Arguments& arguments() const
1418 {
1419 return m_arguments;
1420 }
1421
1422private:
1423 Arguments m_arguments;
1424};
1425
1426class CheckProcessLocalPortForActivity {
1427public:
1428 typedef std::tuple<const WebCore::MessagePortIdentifier&, uint64_t> Arguments;
1429
1430 static IPC::StringReference receiverName() { return messageReceiverName(); }
1431 static IPC::StringReference name() { return IPC::StringReference("CheckProcessLocalPortForActivity"); }
1432 static const bool isSync = false;
1433
1434 CheckProcessLocalPortForActivity(const WebCore::MessagePortIdentifier& port, uint64_t callbackIdentifier)
1435 : m_arguments(port, callbackIdentifier)
1436 {
1437 }
1438
1439 const Arguments& arguments() const
1440 {
1441 return m_arguments;
1442 }
1443
1444private:
1445 Arguments m_arguments;
1446};
1447
1448class MessagesAvailableForPort {
1449public:
1450 typedef std::tuple<const WebCore::MessagePortIdentifier&> Arguments;
1451
1452 static IPC::StringReference receiverName() { return messageReceiverName(); }
1453 static IPC::StringReference name() { return IPC::StringReference("MessagesAvailableForPort"); }
1454 static const bool isSync = false;
1455
1456 explicit MessagesAvailableForPort(const WebCore::MessagePortIdentifier& port)
1457 : m_arguments(port)
1458 {
1459 }
1460
1461 const Arguments& arguments() const
1462 {
1463 return m_arguments;
1464 }
1465
1466private:
1467 Arguments m_arguments;
1468};
1469
1470class SetHasSuspendedPageProxy {
1471public:
1472 typedef std::tuple<bool> Arguments;
1473
1474 static IPC::StringReference receiverName() { return messageReceiverName(); }
1475 static IPC::StringReference name() { return IPC::StringReference("SetHasSuspendedPageProxy"); }
1476 static const bool isSync = false;
1477
1478 explicit SetHasSuspendedPageProxy(bool hasSuspendedPageProxy)
1479 : m_arguments(hasSuspendedPageProxy)
1480 {
1481 }
1482
1483 const Arguments& arguments() const
1484 {
1485 return m_arguments;
1486 }
1487
1488private:
1489 Arguments m_arguments;
1490};
1491
1492class SetIsInProcessCache {
1493public:
1494 typedef std::tuple<bool> Arguments;
1495
1496 static IPC::StringReference receiverName() { return messageReceiverName(); }
1497 static IPC::StringReference name() { return IPC::StringReference("SetIsInProcessCache"); }
1498 static const bool isSync = false;
1499
1500 explicit SetIsInProcessCache(bool isInProcessCache)
1501 : m_arguments(isInProcessCache)
1502 {
1503 }
1504
1505 const Arguments& arguments() const
1506 {
1507 return m_arguments;
1508 }
1509
1510private:
1511 Arguments m_arguments;
1512};
1513
1514class MarkIsNoLongerPrewarmed {
1515public:
1516 typedef std::tuple<> Arguments;
1517
1518 static IPC::StringReference receiverName() { return messageReceiverName(); }
1519 static IPC::StringReference name() { return IPC::StringReference("MarkIsNoLongerPrewarmed"); }
1520 static const bool isSync = false;
1521
1522 const Arguments& arguments() const
1523 {
1524 return m_arguments;
1525 }
1526
1527private:
1528 Arguments m_arguments;
1529};
1530
1531class UpdateActivePages {
1532public:
1533 typedef std::tuple<> Arguments;
1534
1535 static IPC::StringReference receiverName() { return messageReceiverName(); }
1536 static IPC::StringReference name() { return IPC::StringReference("UpdateActivePages"); }
1537 static const bool isSync = false;
1538
1539 const Arguments& arguments() const
1540 {
1541 return m_arguments;
1542 }
1543
1544private:
1545 Arguments m_arguments;
1546};
1547
1548class GetActivePagesOriginsForTesting {
1549public:
1550 typedef std::tuple<> Arguments;
1551
1552 static IPC::StringReference receiverName() { return messageReceiverName(); }
1553 static IPC::StringReference name() { return IPC::StringReference("GetActivePagesOriginsForTesting"); }
1554 static const bool isSync = false;
1555
1556 static void callReply(IPC::Decoder&, CompletionHandler<void(Vector<String>&&)>&&);
1557 static void cancelReply(CompletionHandler<void(Vector<String>&&)>&&);
1558 static IPC::StringReference asyncMessageReplyName() { return { "GetActivePagesOriginsForTestingReply" }; }
1559 using AsyncReply = CompletionHandler<void(const Vector<String>& activeOrigins)>;
1560 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const Vector<String>& activeOrigins);
1561 using Reply = std::tuple<Vector<String>&>;
1562 using ReplyArguments = std::tuple<Vector<String>>;
1563 const Arguments& arguments() const
1564 {
1565 return m_arguments;
1566 }
1567
1568private:
1569 Arguments m_arguments;
1570};
1571
1572#if PLATFORM(MAC)
1573class SetScreenProperties {
1574public:
1575 typedef std::tuple<const WebCore::ScreenProperties&> Arguments;
1576
1577 static IPC::StringReference receiverName() { return messageReceiverName(); }
1578 static IPC::StringReference name() { return IPC::StringReference("SetScreenProperties"); }
1579 static const bool isSync = false;
1580
1581 explicit SetScreenProperties(const WebCore::ScreenProperties& screenProperties)
1582 : m_arguments(screenProperties)
1583 {
1584 }
1585
1586 const Arguments& arguments() const
1587 {
1588 return m_arguments;
1589 }
1590
1591private:
1592 Arguments m_arguments;
1593};
1594#endif
1595
1596#if (PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING))
1597class ScrollerStylePreferenceChanged {
1598public:
1599 typedef std::tuple<bool> Arguments;
1600
1601 static IPC::StringReference receiverName() { return messageReceiverName(); }
1602 static IPC::StringReference name() { return IPC::StringReference("ScrollerStylePreferenceChanged"); }
1603 static const bool isSync = false;
1604
1605 explicit ScrollerStylePreferenceChanged(bool useOvelayScrollbars)
1606 : m_arguments(useOvelayScrollbars)
1607 {
1608 }
1609
1610 const Arguments& arguments() const
1611 {
1612 return m_arguments;
1613 }
1614
1615private:
1616 Arguments m_arguments;
1617};
1618#endif
1619
1620#if (PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING))
1621class DisplayConfigurationChanged {
1622public:
1623 typedef std::tuple<const CGDirectDisplayID&, const CGDisplayChangeSummaryFlags&> Arguments;
1624
1625 static IPC::StringReference receiverName() { return messageReceiverName(); }
1626 static IPC::StringReference name() { return IPC::StringReference("DisplayConfigurationChanged"); }
1627 static const bool isSync = false;
1628
1629 DisplayConfigurationChanged(const CGDirectDisplayID& displayID, const CGDisplayChangeSummaryFlags& flags)
1630 : m_arguments(displayID, flags)
1631 {
1632 }
1633
1634 const Arguments& arguments() const
1635 {
1636 return m_arguments;
1637 }
1638
1639private:
1640 Arguments m_arguments;
1641};
1642#endif
1643
1644#if (PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING))
1645class DisplayWasRefreshed {
1646public:
1647 typedef std::tuple<uint32_t> Arguments;
1648
1649 static IPC::StringReference receiverName() { return messageReceiverName(); }
1650 static IPC::StringReference name() { return IPC::StringReference("DisplayWasRefreshed"); }
1651 static const bool isSync = false;
1652
1653 explicit DisplayWasRefreshed(uint32_t displayID)
1654 : m_arguments(displayID)
1655 {
1656 }
1657
1658 const Arguments& arguments() const
1659 {
1660 return m_arguments;
1661 }
1662
1663private:
1664 Arguments m_arguments;
1665};
1666#endif
1667
1668#if PLATFORM(IOS)
1669class BacklightLevelDidChange {
1670public:
1671 typedef std::tuple<float> Arguments;
1672
1673 static IPC::StringReference receiverName() { return messageReceiverName(); }
1674 static IPC::StringReference name() { return IPC::StringReference("BacklightLevelDidChange"); }
1675 static const bool isSync = false;
1676
1677 explicit BacklightLevelDidChange(float backlightLevel)
1678 : m_arguments(backlightLevel)
1679 {
1680 }
1681
1682 const Arguments& arguments() const
1683 {
1684 return m_arguments;
1685 }
1686
1687private:
1688 Arguments m_arguments;
1689};
1690#endif
1691
1692class IsJITEnabled {
1693public:
1694 typedef std::tuple<> Arguments;
1695
1696 static IPC::StringReference receiverName() { return messageReceiverName(); }
1697 static IPC::StringReference name() { return IPC::StringReference("IsJITEnabled"); }
1698 static const bool isSync = false;
1699
1700 static void callReply(IPC::Decoder&, CompletionHandler<void(bool&&)>&&);
1701 static void cancelReply(CompletionHandler<void(bool&&)>&&);
1702 static IPC::StringReference asyncMessageReplyName() { return { "IsJITEnabledReply" }; }
1703 using AsyncReply = CompletionHandler<void(bool enabled)>;
1704 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool enabled);
1705 using Reply = std::tuple<bool&>;
1706 using ReplyArguments = std::tuple<bool>;
1707 const Arguments& arguments() const
1708 {
1709 return m_arguments;
1710 }
1711
1712private:
1713 Arguments m_arguments;
1714};
1715
1716#if PLATFORM(COCOA)
1717class SetMediaMIMETypes {
1718public:
1719 typedef std::tuple<const Vector<String>&> Arguments;
1720
1721 static IPC::StringReference receiverName() { return messageReceiverName(); }
1722 static IPC::StringReference name() { return IPC::StringReference("SetMediaMIMETypes"); }
1723 static const bool isSync = false;
1724
1725 explicit SetMediaMIMETypes(const Vector<String>& types)
1726 : m_arguments(types)
1727 {
1728 }
1729
1730 const Arguments& arguments() const
1731 {
1732 return m_arguments;
1733 }
1734
1735private:
1736 Arguments m_arguments;
1737};
1738#endif
1739
1740#if ENABLE(MEDIA_STREAM)
1741class AddMockMediaDevice {
1742public:
1743 typedef std::tuple<const WebCore::MockMediaDevice&> Arguments;
1744
1745 static IPC::StringReference receiverName() { return messageReceiverName(); }
1746 static IPC::StringReference name() { return IPC::StringReference("AddMockMediaDevice"); }
1747 static const bool isSync = false;
1748
1749 explicit AddMockMediaDevice(const WebCore::MockMediaDevice& device)
1750 : m_arguments(device)
1751 {
1752 }
1753
1754 const Arguments& arguments() const
1755 {
1756 return m_arguments;
1757 }
1758
1759private:
1760 Arguments m_arguments;
1761};
1762#endif
1763
1764#if ENABLE(MEDIA_STREAM)
1765class ClearMockMediaDevices {
1766public:
1767 typedef std::tuple<> Arguments;
1768
1769 static IPC::StringReference receiverName() { return messageReceiverName(); }
1770 static IPC::StringReference name() { return IPC::StringReference("ClearMockMediaDevices"); }
1771 static const bool isSync = false;
1772
1773 const Arguments& arguments() const
1774 {
1775 return m_arguments;
1776 }
1777
1778private:
1779 Arguments m_arguments;
1780};
1781#endif
1782
1783#if ENABLE(MEDIA_STREAM)
1784class RemoveMockMediaDevice {
1785public:
1786 typedef std::tuple<const String&> Arguments;
1787
1788 static IPC::StringReference receiverName() { return messageReceiverName(); }
1789 static IPC::StringReference name() { return IPC::StringReference("RemoveMockMediaDevice"); }
1790 static const bool isSync = false;
1791
1792 explicit RemoveMockMediaDevice(const String& persistentId)
1793 : m_arguments(persistentId)
1794 {
1795 }
1796
1797 const Arguments& arguments() const
1798 {
1799 return m_arguments;
1800 }
1801
1802private:
1803 Arguments m_arguments;
1804};
1805#endif
1806
1807#if ENABLE(MEDIA_STREAM)
1808class ResetMockMediaDevices {
1809public:
1810 typedef std::tuple<> Arguments;
1811
1812 static IPC::StringReference receiverName() { return messageReceiverName(); }
1813 static IPC::StringReference name() { return IPC::StringReference("ResetMockMediaDevices"); }
1814 static const bool isSync = false;
1815
1816 const Arguments& arguments() const
1817 {
1818 return m_arguments;
1819 }
1820
1821private:
1822 Arguments m_arguments;
1823};
1824#endif
1825
1826#if (ENABLE(MEDIA_STREAM) && ENABLE(SANDBOX_EXTENSIONS))
1827class GrantUserMediaDeviceSandboxExtensions {
1828public:
1829 typedef std::tuple<const WebKit::MediaDeviceSandboxExtensions&> Arguments;
1830
1831 static IPC::StringReference receiverName() { return messageReceiverName(); }
1832 static IPC::StringReference name() { return IPC::StringReference("GrantUserMediaDeviceSandboxExtensions"); }
1833 static const bool isSync = false;
1834
1835 explicit GrantUserMediaDeviceSandboxExtensions(const WebKit::MediaDeviceSandboxExtensions& sandboxExtensions)
1836 : m_arguments(sandboxExtensions)
1837 {
1838 }
1839
1840 const Arguments& arguments() const
1841 {
1842 return m_arguments;
1843 }
1844
1845private:
1846 Arguments m_arguments;
1847};
1848#endif
1849
1850#if (ENABLE(MEDIA_STREAM) && ENABLE(SANDBOX_EXTENSIONS))
1851class RevokeUserMediaDeviceSandboxExtensions {
1852public:
1853 typedef std::tuple<const Vector<String>&> Arguments;
1854
1855 static IPC::StringReference receiverName() { return messageReceiverName(); }
1856 static IPC::StringReference name() { return IPC::StringReference("RevokeUserMediaDeviceSandboxExtensions"); }
1857 static const bool isSync = false;
1858
1859 explicit RevokeUserMediaDeviceSandboxExtensions(const Vector<String>& sandboxExtensionIDs)
1860 : m_arguments(sandboxExtensionIDs)
1861 {
1862 }
1863
1864 const Arguments& arguments() const
1865 {
1866 return m_arguments;
1867 }
1868
1869private:
1870 Arguments m_arguments;
1871};
1872#endif
1873
1874class ClearCurrentModifierStateForTesting {
1875public:
1876 typedef std::tuple<> Arguments;
1877
1878 static IPC::StringReference receiverName() { return messageReceiverName(); }
1879 static IPC::StringReference name() { return IPC::StringReference("ClearCurrentModifierStateForTesting"); }
1880 static const bool isSync = false;
1881
1882 const Arguments& arguments() const
1883 {
1884 return m_arguments;
1885 }
1886
1887private:
1888 Arguments m_arguments;
1889};
1890
1891#if PLATFORM(IOS_FAMILY)
1892class UnblockAccessibilityServer {
1893public:
1894 typedef std::tuple<const WebKit::SandboxExtension::Handle&> Arguments;
1895
1896 static IPC::StringReference receiverName() { return messageReceiverName(); }
1897 static IPC::StringReference name() { return IPC::StringReference("UnblockAccessibilityServer"); }
1898 static const bool isSync = false;
1899
1900 explicit UnblockAccessibilityServer(const WebKit::SandboxExtension::Handle& handle)
1901 : m_arguments(handle)
1902 {
1903 }
1904
1905 const Arguments& arguments() const
1906 {
1907 return m_arguments;
1908 }
1909
1910private:
1911 Arguments m_arguments;
1912};
1913#endif
1914
1915} // namespace WebProcess
1916} // namespace Messages
1917