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