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 "SandboxExtension.h"
30#include "WebsiteDataFetchOption.h"
31#include "WebsiteDataType.h"
32#include <WebCore/RegistrableDomain.h>
33#include <WebCore/SecurityOriginData.h>
34#include <WebCore/ServiceWorkerClientIdentifier.h>
35#include <WebCore/ServiceWorkerIdentifier.h>
36#include <WebCore/ServiceWorkerTypes.h>
37#include <wtf/Forward.h>
38#include <wtf/OptionSet.h>
39#include <wtf/Optional.h>
40#include <wtf/Seconds.h>
41#include <wtf/ThreadSafeRefCounted.h>
42#include <wtf/Vector.h>
43#include <wtf/WallTime.h>
44#include <wtf/text/WTFString.h>
45
46namespace IPC {
47class DataReference;
48}
49
50namespace PAL {
51class SessionID;
52}
53
54namespace WebCore {
55class AdClickAttribution;
56class CertificateInfo;
57struct ClientOrigin;
58struct MessageWithMessagePorts;
59struct ServiceWorkerClientIdentifier;
60enum class StoredCredentialsPolicy : uint8_t;
61class CurlProxySettings;
62class RegistrableDomain;
63struct SoupNetworkProxySettings;
64class ResourceRequest;
65}
66
67namespace WebKit {
68struct NetworkProcessCreationParameters;
69enum class ShouldGrandfatherStatistics : bool;
70enum class CacheModel : uint8_t;
71class DownloadID;
72struct WebsiteDataStoreParameters;
73}
74
75namespace Messages {
76namespace NetworkProcess {
77
78static inline IPC::StringReference messageReceiverName()
79{
80 return IPC::StringReference("NetworkProcess");
81}
82
83class InitializeNetworkProcess {
84public:
85 typedef std::tuple<const WebKit::NetworkProcessCreationParameters&> Arguments;
86
87 static IPC::StringReference receiverName() { return messageReceiverName(); }
88 static IPC::StringReference name() { return IPC::StringReference("InitializeNetworkProcess"); }
89 static const bool isSync = false;
90
91 explicit InitializeNetworkProcess(const WebKit::NetworkProcessCreationParameters& processCreationParameters)
92 : m_arguments(processCreationParameters)
93 {
94 }
95
96 const Arguments& arguments() const
97 {
98 return m_arguments;
99 }
100
101private:
102 Arguments m_arguments;
103};
104
105class CreateNetworkConnectionToWebProcess {
106public:
107 typedef std::tuple<bool, const WebCore::RegistrableDomain&> Arguments;
108
109 static IPC::StringReference receiverName() { return messageReceiverName(); }
110 static IPC::StringReference name() { return IPC::StringReference("CreateNetworkConnectionToWebProcess"); }
111 static const bool isSync = false;
112
113 CreateNetworkConnectionToWebProcess(bool isServiceWorkerProcess, const WebCore::RegistrableDomain& registrableDomain)
114 : m_arguments(isServiceWorkerProcess, registrableDomain)
115 {
116 }
117
118 const Arguments& arguments() const
119 {
120 return m_arguments;
121 }
122
123private:
124 Arguments m_arguments;
125};
126
127#if USE(SOUP)
128class SetIgnoreTLSErrors {
129public:
130 typedef std::tuple<bool> Arguments;
131
132 static IPC::StringReference receiverName() { return messageReceiverName(); }
133 static IPC::StringReference name() { return IPC::StringReference("SetIgnoreTLSErrors"); }
134 static const bool isSync = false;
135
136 explicit SetIgnoreTLSErrors(bool ignoreTLSErrors)
137 : m_arguments(ignoreTLSErrors)
138 {
139 }
140
141 const Arguments& arguments() const
142 {
143 return m_arguments;
144 }
145
146private:
147 Arguments m_arguments;
148};
149#endif
150
151#if USE(SOUP)
152class UserPreferredLanguagesChanged {
153public:
154 typedef std::tuple<const Vector<String>&> Arguments;
155
156 static IPC::StringReference receiverName() { return messageReceiverName(); }
157 static IPC::StringReference name() { return IPC::StringReference("UserPreferredLanguagesChanged"); }
158 static const bool isSync = false;
159
160 explicit UserPreferredLanguagesChanged(const Vector<String>& languages)
161 : m_arguments(languages)
162 {
163 }
164
165 const Arguments& arguments() const
166 {
167 return m_arguments;
168 }
169
170private:
171 Arguments m_arguments;
172};
173#endif
174
175#if USE(SOUP)
176class SetNetworkProxySettings {
177public:
178 typedef std::tuple<const WebCore::SoupNetworkProxySettings&> Arguments;
179
180 static IPC::StringReference receiverName() { return messageReceiverName(); }
181 static IPC::StringReference name() { return IPC::StringReference("SetNetworkProxySettings"); }
182 static const bool isSync = false;
183
184 explicit SetNetworkProxySettings(const WebCore::SoupNetworkProxySettings& settings)
185 : m_arguments(settings)
186 {
187 }
188
189 const Arguments& arguments() const
190 {
191 return m_arguments;
192 }
193
194private:
195 Arguments m_arguments;
196};
197#endif
198
199#if USE(CURL)
200class SetNetworkProxySettings {
201public:
202 typedef std::tuple<const PAL::SessionID&, const WebCore::CurlProxySettings&> Arguments;
203
204 static IPC::StringReference receiverName() { return messageReceiverName(); }
205 static IPC::StringReference name() { return IPC::StringReference("SetNetworkProxySettings"); }
206 static const bool isSync = false;
207
208 SetNetworkProxySettings(const PAL::SessionID& sessionID, const WebCore::CurlProxySettings& settings)
209 : m_arguments(sessionID, settings)
210 {
211 }
212
213 const Arguments& arguments() const
214 {
215 return m_arguments;
216 }
217
218private:
219 Arguments m_arguments;
220};
221#endif
222
223class ClearCachedCredentials {
224public:
225 typedef std::tuple<> Arguments;
226
227 static IPC::StringReference receiverName() { return messageReceiverName(); }
228 static IPC::StringReference name() { return IPC::StringReference("ClearCachedCredentials"); }
229 static const bool isSync = false;
230
231 const Arguments& arguments() const
232 {
233 return m_arguments;
234 }
235
236private:
237 Arguments m_arguments;
238};
239
240class AddWebsiteDataStore {
241public:
242 typedef std::tuple<const WebKit::WebsiteDataStoreParameters&> Arguments;
243
244 static IPC::StringReference receiverName() { return messageReceiverName(); }
245 static IPC::StringReference name() { return IPC::StringReference("AddWebsiteDataStore"); }
246 static const bool isSync = false;
247
248 explicit AddWebsiteDataStore(const WebKit::WebsiteDataStoreParameters& websiteDataStoreParameters)
249 : m_arguments(websiteDataStoreParameters)
250 {
251 }
252
253 const Arguments& arguments() const
254 {
255 return m_arguments;
256 }
257
258private:
259 Arguments m_arguments;
260};
261
262class DestroySession {
263public:
264 typedef std::tuple<const PAL::SessionID&> Arguments;
265
266 static IPC::StringReference receiverName() { return messageReceiverName(); }
267 static IPC::StringReference name() { return IPC::StringReference("DestroySession"); }
268 static const bool isSync = false;
269
270 explicit DestroySession(const PAL::SessionID& sessionID)
271 : m_arguments(sessionID)
272 {
273 }
274
275 const Arguments& arguments() const
276 {
277 return m_arguments;
278 }
279
280private:
281 Arguments m_arguments;
282};
283
284class FetchWebsiteData {
285public:
286 typedef std::tuple<const PAL::SessionID&, const OptionSet<WebKit::WebsiteDataType>&, const OptionSet<WebKit::WebsiteDataFetchOption>&, uint64_t> Arguments;
287
288 static IPC::StringReference receiverName() { return messageReceiverName(); }
289 static IPC::StringReference name() { return IPC::StringReference("FetchWebsiteData"); }
290 static const bool isSync = false;
291
292 FetchWebsiteData(const PAL::SessionID& sessionID, const OptionSet<WebKit::WebsiteDataType>& websiteDataTypes, const OptionSet<WebKit::WebsiteDataFetchOption>& fetchOptions, uint64_t callbackID)
293 : m_arguments(sessionID, websiteDataTypes, fetchOptions, callbackID)
294 {
295 }
296
297 const Arguments& arguments() const
298 {
299 return m_arguments;
300 }
301
302private:
303 Arguments m_arguments;
304};
305
306class DeleteWebsiteData {
307public:
308 typedef std::tuple<const PAL::SessionID&, const OptionSet<WebKit::WebsiteDataType>&, const WallTime&, uint64_t> Arguments;
309
310 static IPC::StringReference receiverName() { return messageReceiverName(); }
311 static IPC::StringReference name() { return IPC::StringReference("DeleteWebsiteData"); }
312 static const bool isSync = false;
313
314 DeleteWebsiteData(const PAL::SessionID& sessionID, const OptionSet<WebKit::WebsiteDataType>& websiteDataTypes, const WallTime& modifiedSince, uint64_t callbackID)
315 : m_arguments(sessionID, websiteDataTypes, modifiedSince, callbackID)
316 {
317 }
318
319 const Arguments& arguments() const
320 {
321 return m_arguments;
322 }
323
324private:
325 Arguments m_arguments;
326};
327
328class DeleteWebsiteDataForOrigins {
329public:
330 typedef std::tuple<const PAL::SessionID&, const OptionSet<WebKit::WebsiteDataType>&, const Vector<WebCore::SecurityOriginData>&, const Vector<String>&, const Vector<String>&, uint64_t> Arguments;
331
332 static IPC::StringReference receiverName() { return messageReceiverName(); }
333 static IPC::StringReference name() { return IPC::StringReference("DeleteWebsiteDataForOrigins"); }
334 static const bool isSync = false;
335
336 DeleteWebsiteDataForOrigins(const PAL::SessionID& sessionID, const OptionSet<WebKit::WebsiteDataType>& websiteDataTypes, const Vector<WebCore::SecurityOriginData>& origins, const Vector<String>& cookieHostNames, const Vector<String>& HSTSCacheHostNames, uint64_t callbackID)
337 : m_arguments(sessionID, websiteDataTypes, origins, cookieHostNames, HSTSCacheHostNames, callbackID)
338 {
339 }
340
341 const Arguments& arguments() const
342 {
343 return m_arguments;
344 }
345
346private:
347 Arguments m_arguments;
348};
349
350class DownloadRequest {
351public:
352 typedef std::tuple<const PAL::SessionID&, const WebKit::DownloadID&, const WebCore::ResourceRequest&, const String&> Arguments;
353
354 static IPC::StringReference receiverName() { return messageReceiverName(); }
355 static IPC::StringReference name() { return IPC::StringReference("DownloadRequest"); }
356 static const bool isSync = false;
357
358 DownloadRequest(const PAL::SessionID& sessionID, const WebKit::DownloadID& downloadID, const WebCore::ResourceRequest& request, const String& suggestedFilename)
359 : m_arguments(sessionID, downloadID, request, suggestedFilename)
360 {
361 }
362
363 const Arguments& arguments() const
364 {
365 return m_arguments;
366 }
367
368private:
369 Arguments m_arguments;
370};
371
372class ResumeDownload {
373public:
374 typedef std::tuple<const PAL::SessionID&, const WebKit::DownloadID&, const IPC::DataReference&, const String&, const WebKit::SandboxExtension::Handle&> Arguments;
375
376 static IPC::StringReference receiverName() { return messageReceiverName(); }
377 static IPC::StringReference name() { return IPC::StringReference("ResumeDownload"); }
378 static const bool isSync = false;
379
380 ResumeDownload(const PAL::SessionID& sessionID, const WebKit::DownloadID& downloadID, const IPC::DataReference& resumeData, const String& path, const WebKit::SandboxExtension::Handle& sandboxExtensionHandle)
381 : m_arguments(sessionID, downloadID, resumeData, path, sandboxExtensionHandle)
382 {
383 }
384
385 const Arguments& arguments() const
386 {
387 return m_arguments;
388 }
389
390private:
391 Arguments m_arguments;
392};
393
394class CancelDownload {
395public:
396 typedef std::tuple<const WebKit::DownloadID&> Arguments;
397
398 static IPC::StringReference receiverName() { return messageReceiverName(); }
399 static IPC::StringReference name() { return IPC::StringReference("CancelDownload"); }
400 static const bool isSync = false;
401
402 explicit CancelDownload(const WebKit::DownloadID& downloadID)
403 : m_arguments(downloadID)
404 {
405 }
406
407 const Arguments& arguments() const
408 {
409 return m_arguments;
410 }
411
412private:
413 Arguments m_arguments;
414};
415
416#if PLATFORM(COCOA)
417class PublishDownloadProgress {
418public:
419 typedef std::tuple<const WebKit::DownloadID&, const URL&, const WebKit::SandboxExtension::Handle&> Arguments;
420
421 static IPC::StringReference receiverName() { return messageReceiverName(); }
422 static IPC::StringReference name() { return IPC::StringReference("PublishDownloadProgress"); }
423 static const bool isSync = false;
424
425 PublishDownloadProgress(const WebKit::DownloadID& downloadID, const URL& url, const WebKit::SandboxExtension::Handle& sandboxExtensionHandle)
426 : m_arguments(downloadID, url, sandboxExtensionHandle)
427 {
428 }
429
430 const Arguments& arguments() const
431 {
432 return m_arguments;
433 }
434
435private:
436 Arguments m_arguments;
437};
438#endif
439
440class ApplicationDidEnterBackground {
441public:
442 typedef std::tuple<> Arguments;
443
444 static IPC::StringReference receiverName() { return messageReceiverName(); }
445 static IPC::StringReference name() { return IPC::StringReference("ApplicationDidEnterBackground"); }
446 static const bool isSync = false;
447
448 const Arguments& arguments() const
449 {
450 return m_arguments;
451 }
452
453private:
454 Arguments m_arguments;
455};
456
457class ApplicationWillEnterForeground {
458public:
459 typedef std::tuple<> Arguments;
460
461 static IPC::StringReference receiverName() { return messageReceiverName(); }
462 static IPC::StringReference name() { return IPC::StringReference("ApplicationWillEnterForeground"); }
463 static const bool isSync = false;
464
465 const Arguments& arguments() const
466 {
467 return m_arguments;
468 }
469
470private:
471 Arguments m_arguments;
472};
473
474class ContinueWillSendRequest {
475public:
476 typedef std::tuple<const WebKit::DownloadID&, const WebCore::ResourceRequest&> Arguments;
477
478 static IPC::StringReference receiverName() { return messageReceiverName(); }
479 static IPC::StringReference name() { return IPC::StringReference("ContinueWillSendRequest"); }
480 static const bool isSync = false;
481
482 ContinueWillSendRequest(const WebKit::DownloadID& downloadID, const WebCore::ResourceRequest& request)
483 : m_arguments(downloadID, request)
484 {
485 }
486
487 const Arguments& arguments() const
488 {
489 return m_arguments;
490 }
491
492private:
493 Arguments m_arguments;
494};
495
496class ContinueDecidePendingDownloadDestination {
497public:
498 typedef std::tuple<const WebKit::DownloadID&, const String&, const WebKit::SandboxExtension::Handle&, bool> Arguments;
499
500 static IPC::StringReference receiverName() { return messageReceiverName(); }
501 static IPC::StringReference name() { return IPC::StringReference("ContinueDecidePendingDownloadDestination"); }
502 static const bool isSync = false;
503
504 ContinueDecidePendingDownloadDestination(const WebKit::DownloadID& downloadID, const String& destination, const WebKit::SandboxExtension::Handle& sandboxExtensionHandle, bool allowOverwrite)
505 : m_arguments(downloadID, destination, sandboxExtensionHandle, allowOverwrite)
506 {
507 }
508
509 const Arguments& arguments() const
510 {
511 return m_arguments;
512 }
513
514private:
515 Arguments m_arguments;
516};
517
518#if PLATFORM(COCOA)
519class SetQOS {
520public:
521 typedef std::tuple<const int&, const int&> Arguments;
522
523 static IPC::StringReference receiverName() { return messageReceiverName(); }
524 static IPC::StringReference name() { return IPC::StringReference("SetQOS"); }
525 static const bool isSync = false;
526
527 SetQOS(const int& latencyQOS, const int& throughputQOS)
528 : m_arguments(latencyQOS, throughputQOS)
529 {
530 }
531
532 const Arguments& arguments() const
533 {
534 return m_arguments;
535 }
536
537private:
538 Arguments m_arguments;
539};
540#endif
541
542#if PLATFORM(COCOA)
543class SetStorageAccessAPIEnabled {
544public:
545 typedef std::tuple<bool> Arguments;
546
547 static IPC::StringReference receiverName() { return messageReceiverName(); }
548 static IPC::StringReference name() { return IPC::StringReference("SetStorageAccessAPIEnabled"); }
549 static const bool isSync = false;
550
551 explicit SetStorageAccessAPIEnabled(bool enabled)
552 : m_arguments(enabled)
553 {
554 }
555
556 const Arguments& arguments() const
557 {
558 return m_arguments;
559 }
560
561private:
562 Arguments m_arguments;
563};
564#endif
565
566class SetAllowsAnySSLCertificateForWebSocket {
567public:
568 typedef std::tuple<bool> Arguments;
569
570 static IPC::StringReference receiverName() { return messageReceiverName(); }
571 static IPC::StringReference name() { return IPC::StringReference("SetAllowsAnySSLCertificateForWebSocket"); }
572 static const bool isSync = true;
573
574 using DelayedReply = CompletionHandler<void()>;
575 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
576 using Reply = std::tuple<>;
577 using ReplyArguments = std::tuple<>;
578 explicit SetAllowsAnySSLCertificateForWebSocket(bool enabled)
579 : m_arguments(enabled)
580 {
581 }
582
583 const Arguments& arguments() const
584 {
585 return m_arguments;
586 }
587
588private:
589 Arguments m_arguments;
590};
591
592class SyncAllCookies {
593public:
594 typedef std::tuple<> Arguments;
595
596 static IPC::StringReference receiverName() { return messageReceiverName(); }
597 static IPC::StringReference name() { return IPC::StringReference("SyncAllCookies"); }
598 static const bool isSync = false;
599
600 const Arguments& arguments() const
601 {
602 return m_arguments;
603 }
604
605private:
606 Arguments m_arguments;
607};
608
609class AllowSpecificHTTPSCertificateForHost {
610public:
611 typedef std::tuple<const WebCore::CertificateInfo&, const String&> Arguments;
612
613 static IPC::StringReference receiverName() { return messageReceiverName(); }
614 static IPC::StringReference name() { return IPC::StringReference("AllowSpecificHTTPSCertificateForHost"); }
615 static const bool isSync = false;
616
617 AllowSpecificHTTPSCertificateForHost(const WebCore::CertificateInfo& certificate, const String& host)
618 : m_arguments(certificate, host)
619 {
620 }
621
622 const Arguments& arguments() const
623 {
624 return m_arguments;
625 }
626
627private:
628 Arguments m_arguments;
629};
630
631class SetCanHandleHTTPSServerTrustEvaluation {
632public:
633 typedef std::tuple<bool> Arguments;
634
635 static IPC::StringReference receiverName() { return messageReceiverName(); }
636 static IPC::StringReference name() { return IPC::StringReference("SetCanHandleHTTPSServerTrustEvaluation"); }
637 static const bool isSync = false;
638
639 explicit SetCanHandleHTTPSServerTrustEvaluation(bool value)
640 : m_arguments(value)
641 {
642 }
643
644 const Arguments& arguments() const
645 {
646 return m_arguments;
647 }
648
649private:
650 Arguments m_arguments;
651};
652
653class GetNetworkProcessStatistics {
654public:
655 typedef std::tuple<uint64_t> Arguments;
656
657 static IPC::StringReference receiverName() { return messageReceiverName(); }
658 static IPC::StringReference name() { return IPC::StringReference("GetNetworkProcessStatistics"); }
659 static const bool isSync = false;
660
661 explicit GetNetworkProcessStatistics(uint64_t callbackID)
662 : m_arguments(callbackID)
663 {
664 }
665
666 const Arguments& arguments() const
667 {
668 return m_arguments;
669 }
670
671private:
672 Arguments m_arguments;
673};
674
675class ClearCacheForAllOrigins {
676public:
677 typedef std::tuple<uint32_t> Arguments;
678
679 static IPC::StringReference receiverName() { return messageReceiverName(); }
680 static IPC::StringReference name() { return IPC::StringReference("ClearCacheForAllOrigins"); }
681 static const bool isSync = false;
682
683 explicit ClearCacheForAllOrigins(uint32_t cachesToClear)
684 : m_arguments(cachesToClear)
685 {
686 }
687
688 const Arguments& arguments() const
689 {
690 return m_arguments;
691 }
692
693private:
694 Arguments m_arguments;
695};
696
697class SetCacheModel {
698public:
699 typedef std::tuple<WebKit::CacheModel> Arguments;
700
701 static IPC::StringReference receiverName() { return messageReceiverName(); }
702 static IPC::StringReference name() { return IPC::StringReference("SetCacheModel"); }
703 static const bool isSync = false;
704
705 explicit SetCacheModel(WebKit::CacheModel cacheModel)
706 : m_arguments(cacheModel)
707 {
708 }
709
710 const Arguments& arguments() const
711 {
712 return m_arguments;
713 }
714
715private:
716 Arguments m_arguments;
717};
718
719class ProcessDidTransitionToBackground {
720public:
721 typedef std::tuple<> Arguments;
722
723 static IPC::StringReference receiverName() { return messageReceiverName(); }
724 static IPC::StringReference name() { return IPC::StringReference("ProcessDidTransitionToBackground"); }
725 static const bool isSync = false;
726
727 const Arguments& arguments() const
728 {
729 return m_arguments;
730 }
731
732private:
733 Arguments m_arguments;
734};
735
736class ProcessDidTransitionToForeground {
737public:
738 typedef std::tuple<> Arguments;
739
740 static IPC::StringReference receiverName() { return messageReceiverName(); }
741 static IPC::StringReference name() { return IPC::StringReference("ProcessDidTransitionToForeground"); }
742 static const bool isSync = false;
743
744 const Arguments& arguments() const
745 {
746 return m_arguments;
747 }
748
749private:
750 Arguments m_arguments;
751};
752
753class ProcessWillSuspendImminently {
754public:
755 typedef std::tuple<> Arguments;
756
757 static IPC::StringReference receiverName() { return messageReceiverName(); }
758 static IPC::StringReference name() { return IPC::StringReference("ProcessWillSuspendImminently"); }
759 static const bool isSync = false;
760
761 const Arguments& arguments() const
762 {
763 return m_arguments;
764 }
765
766private:
767 Arguments m_arguments;
768};
769
770class PrepareToSuspend {
771public:
772 typedef std::tuple<> Arguments;
773
774 static IPC::StringReference receiverName() { return messageReceiverName(); }
775 static IPC::StringReference name() { return IPC::StringReference("PrepareToSuspend"); }
776 static const bool isSync = false;
777
778 const Arguments& arguments() const
779 {
780 return m_arguments;
781 }
782
783private:
784 Arguments m_arguments;
785};
786
787class CancelPrepareToSuspend {
788public:
789 typedef std::tuple<> Arguments;
790
791 static IPC::StringReference receiverName() { return messageReceiverName(); }
792 static IPC::StringReference name() { return IPC::StringReference("CancelPrepareToSuspend"); }
793 static const bool isSync = false;
794
795 const Arguments& arguments() const
796 {
797 return m_arguments;
798 }
799
800private:
801 Arguments m_arguments;
802};
803
804class ProcessDidResume {
805public:
806 typedef std::tuple<> Arguments;
807
808 static IPC::StringReference receiverName() { return messageReceiverName(); }
809 static IPC::StringReference name() { return IPC::StringReference("ProcessDidResume"); }
810 static const bool isSync = false;
811
812 const Arguments& arguments() const
813 {
814 return m_arguments;
815 }
816
817private:
818 Arguments m_arguments;
819};
820
821class PreconnectTo {
822public:
823 typedef std::tuple<const URL&, WebCore::StoredCredentialsPolicy> Arguments;
824
825 static IPC::StringReference receiverName() { return messageReceiverName(); }
826 static IPC::StringReference name() { return IPC::StringReference("PreconnectTo"); }
827 static const bool isSync = false;
828
829 PreconnectTo(const URL& url, WebCore::StoredCredentialsPolicy storedCredentialsPolicy)
830 : m_arguments(url, storedCredentialsPolicy)
831 {
832 }
833
834 const Arguments& arguments() const
835 {
836 return m_arguments;
837 }
838
839private:
840 Arguments m_arguments;
841};
842
843#if ENABLE(RESOURCE_LOAD_STATISTICS)
844class ClearPrevalentResource {
845public:
846 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&> Arguments;
847
848 static IPC::StringReference receiverName() { return messageReceiverName(); }
849 static IPC::StringReference name() { return IPC::StringReference("ClearPrevalentResource"); }
850 static const bool isSync = false;
851
852 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
853 static void cancelReply(CompletionHandler<void()>&&);
854 static IPC::StringReference asyncMessageReplyName() { return { "ClearPrevalentResourceReply" }; }
855 using AsyncReply = CompletionHandler<void()>;
856 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
857 using Reply = std::tuple<>;
858 using ReplyArguments = std::tuple<>;
859 ClearPrevalentResource(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& resourceDomain)
860 : m_arguments(sessionID, resourceDomain)
861 {
862 }
863
864 const Arguments& arguments() const
865 {
866 return m_arguments;
867 }
868
869private:
870 Arguments m_arguments;
871};
872#endif
873
874#if ENABLE(RESOURCE_LOAD_STATISTICS)
875class ClearUserInteraction {
876public:
877 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&> Arguments;
878
879 static IPC::StringReference receiverName() { return messageReceiverName(); }
880 static IPC::StringReference name() { return IPC::StringReference("ClearUserInteraction"); }
881 static const bool isSync = false;
882
883 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
884 static void cancelReply(CompletionHandler<void()>&&);
885 static IPC::StringReference asyncMessageReplyName() { return { "ClearUserInteractionReply" }; }
886 using AsyncReply = CompletionHandler<void()>;
887 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
888 using Reply = std::tuple<>;
889 using ReplyArguments = std::tuple<>;
890 ClearUserInteraction(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& resourceDomain)
891 : m_arguments(sessionID, resourceDomain)
892 {
893 }
894
895 const Arguments& arguments() const
896 {
897 return m_arguments;
898 }
899
900private:
901 Arguments m_arguments;
902};
903#endif
904
905#if ENABLE(RESOURCE_LOAD_STATISTICS)
906class DumpResourceLoadStatistics {
907public:
908 typedef std::tuple<const PAL::SessionID&> Arguments;
909
910 static IPC::StringReference receiverName() { return messageReceiverName(); }
911 static IPC::StringReference name() { return IPC::StringReference("DumpResourceLoadStatistics"); }
912 static const bool isSync = false;
913
914 static void callReply(IPC::Decoder&, CompletionHandler<void(String&&)>&&);
915 static void cancelReply(CompletionHandler<void(String&&)>&&);
916 static IPC::StringReference asyncMessageReplyName() { return { "DumpResourceLoadStatisticsReply" }; }
917 using AsyncReply = CompletionHandler<void(const String& dumpedStatistics)>;
918 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const String& dumpedStatistics);
919 using Reply = std::tuple<String&>;
920 using ReplyArguments = std::tuple<String>;
921 explicit DumpResourceLoadStatistics(const PAL::SessionID& sessionID)
922 : m_arguments(sessionID)
923 {
924 }
925
926 const Arguments& arguments() const
927 {
928 return m_arguments;
929 }
930
931private:
932 Arguments m_arguments;
933};
934#endif
935
936#if ENABLE(RESOURCE_LOAD_STATISTICS)
937class SetResourceLoadStatisticsEnabled {
938public:
939 typedef std::tuple<bool> Arguments;
940
941 static IPC::StringReference receiverName() { return messageReceiverName(); }
942 static IPC::StringReference name() { return IPC::StringReference("SetResourceLoadStatisticsEnabled"); }
943 static const bool isSync = false;
944
945 explicit SetResourceLoadStatisticsEnabled(bool enabled)
946 : m_arguments(enabled)
947 {
948 }
949
950 const Arguments& arguments() const
951 {
952 return m_arguments;
953 }
954
955private:
956 Arguments m_arguments;
957};
958#endif
959
960#if ENABLE(RESOURCE_LOAD_STATISTICS)
961class UpdatePrevalentDomainsToBlockCookiesFor {
962public:
963 typedef std::tuple<const PAL::SessionID&, const Vector<WebCore::RegistrableDomain>&> Arguments;
964
965 static IPC::StringReference receiverName() { return messageReceiverName(); }
966 static IPC::StringReference name() { return IPC::StringReference("UpdatePrevalentDomainsToBlockCookiesFor"); }
967 static const bool isSync = false;
968
969 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
970 static void cancelReply(CompletionHandler<void()>&&);
971 static IPC::StringReference asyncMessageReplyName() { return { "UpdatePrevalentDomainsToBlockCookiesForReply" }; }
972 using AsyncReply = CompletionHandler<void()>;
973 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
974 using Reply = std::tuple<>;
975 using ReplyArguments = std::tuple<>;
976 UpdatePrevalentDomainsToBlockCookiesFor(const PAL::SessionID& sessionID, const Vector<WebCore::RegistrableDomain>& domainsToBlock)
977 : m_arguments(sessionID, domainsToBlock)
978 {
979 }
980
981 const Arguments& arguments() const
982 {
983 return m_arguments;
984 }
985
986private:
987 Arguments m_arguments;
988};
989#endif
990
991#if ENABLE(RESOURCE_LOAD_STATISTICS)
992class IsGrandfathered {
993public:
994 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&> Arguments;
995
996 static IPC::StringReference receiverName() { return messageReceiverName(); }
997 static IPC::StringReference name() { return IPC::StringReference("IsGrandfathered"); }
998 static const bool isSync = false;
999
1000 static void callReply(IPC::Decoder&, CompletionHandler<void(bool&&)>&&);
1001 static void cancelReply(CompletionHandler<void(bool&&)>&&);
1002 static IPC::StringReference asyncMessageReplyName() { return { "IsGrandfatheredReply" }; }
1003 using AsyncReply = CompletionHandler<void(bool isGrandfathered)>;
1004 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool isGrandfathered);
1005 using Reply = std::tuple<bool&>;
1006 using ReplyArguments = std::tuple<bool>;
1007 IsGrandfathered(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& targetDomain)
1008 : m_arguments(sessionID, targetDomain)
1009 {
1010 }
1011
1012 const Arguments& arguments() const
1013 {
1014 return m_arguments;
1015 }
1016
1017private:
1018 Arguments m_arguments;
1019};
1020#endif
1021
1022#if ENABLE(RESOURCE_LOAD_STATISTICS)
1023class IsPrevalentResource {
1024public:
1025 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&> Arguments;
1026
1027 static IPC::StringReference receiverName() { return messageReceiverName(); }
1028 static IPC::StringReference name() { return IPC::StringReference("IsPrevalentResource"); }
1029 static const bool isSync = false;
1030
1031 static void callReply(IPC::Decoder&, CompletionHandler<void(bool&&)>&&);
1032 static void cancelReply(CompletionHandler<void(bool&&)>&&);
1033 static IPC::StringReference asyncMessageReplyName() { return { "IsPrevalentResourceReply" }; }
1034 using AsyncReply = CompletionHandler<void(bool isPrevalent)>;
1035 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool isPrevalent);
1036 using Reply = std::tuple<bool&>;
1037 using ReplyArguments = std::tuple<bool>;
1038 IsPrevalentResource(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& targetDomain)
1039 : m_arguments(sessionID, targetDomain)
1040 {
1041 }
1042
1043 const Arguments& arguments() const
1044 {
1045 return m_arguments;
1046 }
1047
1048private:
1049 Arguments m_arguments;
1050};
1051#endif
1052
1053#if ENABLE(RESOURCE_LOAD_STATISTICS)
1054class IsVeryPrevalentResource {
1055public:
1056 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&> Arguments;
1057
1058 static IPC::StringReference receiverName() { return messageReceiverName(); }
1059 static IPC::StringReference name() { return IPC::StringReference("IsVeryPrevalentResource"); }
1060 static const bool isSync = false;
1061
1062 static void callReply(IPC::Decoder&, CompletionHandler<void(bool&&)>&&);
1063 static void cancelReply(CompletionHandler<void(bool&&)>&&);
1064 static IPC::StringReference asyncMessageReplyName() { return { "IsVeryPrevalentResourceReply" }; }
1065 using AsyncReply = CompletionHandler<void(bool isVeryPrevalent)>;
1066 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool isVeryPrevalent);
1067 using Reply = std::tuple<bool&>;
1068 using ReplyArguments = std::tuple<bool>;
1069 IsVeryPrevalentResource(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& targetDomain)
1070 : m_arguments(sessionID, targetDomain)
1071 {
1072 }
1073
1074 const Arguments& arguments() const
1075 {
1076 return m_arguments;
1077 }
1078
1079private:
1080 Arguments m_arguments;
1081};
1082#endif
1083
1084#if ENABLE(RESOURCE_LOAD_STATISTICS)
1085class SetAgeCapForClientSideCookies {
1086public:
1087 typedef std::tuple<const PAL::SessionID&, const Optional<Seconds>&> Arguments;
1088
1089 static IPC::StringReference receiverName() { return messageReceiverName(); }
1090 static IPC::StringReference name() { return IPC::StringReference("SetAgeCapForClientSideCookies"); }
1091 static const bool isSync = false;
1092
1093 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1094 static void cancelReply(CompletionHandler<void()>&&);
1095 static IPC::StringReference asyncMessageReplyName() { return { "SetAgeCapForClientSideCookiesReply" }; }
1096 using AsyncReply = CompletionHandler<void()>;
1097 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1098 using Reply = std::tuple<>;
1099 using ReplyArguments = std::tuple<>;
1100 SetAgeCapForClientSideCookies(const PAL::SessionID& sessionID, const Optional<Seconds>& seconds)
1101 : m_arguments(sessionID, seconds)
1102 {
1103 }
1104
1105 const Arguments& arguments() const
1106 {
1107 return m_arguments;
1108 }
1109
1110private:
1111 Arguments m_arguments;
1112};
1113#endif
1114
1115#if ENABLE(RESOURCE_LOAD_STATISTICS)
1116class SetLastSeen {
1117public:
1118 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, const Seconds&> Arguments;
1119
1120 static IPC::StringReference receiverName() { return messageReceiverName(); }
1121 static IPC::StringReference name() { return IPC::StringReference("SetLastSeen"); }
1122 static const bool isSync = false;
1123
1124 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1125 static void cancelReply(CompletionHandler<void()>&&);
1126 static IPC::StringReference asyncMessageReplyName() { return { "SetLastSeenReply" }; }
1127 using AsyncReply = CompletionHandler<void()>;
1128 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1129 using Reply = std::tuple<>;
1130 using ReplyArguments = std::tuple<>;
1131 SetLastSeen(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& resourceDomain, const Seconds& seconds)
1132 : m_arguments(sessionID, resourceDomain, seconds)
1133 {
1134 }
1135
1136 const Arguments& arguments() const
1137 {
1138 return m_arguments;
1139 }
1140
1141private:
1142 Arguments m_arguments;
1143};
1144#endif
1145
1146#if ENABLE(RESOURCE_LOAD_STATISTICS)
1147class SetPrevalentResource {
1148public:
1149 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&> Arguments;
1150
1151 static IPC::StringReference receiverName() { return messageReceiverName(); }
1152 static IPC::StringReference name() { return IPC::StringReference("SetPrevalentResource"); }
1153 static const bool isSync = false;
1154
1155 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1156 static void cancelReply(CompletionHandler<void()>&&);
1157 static IPC::StringReference asyncMessageReplyName() { return { "SetPrevalentResourceReply" }; }
1158 using AsyncReply = CompletionHandler<void()>;
1159 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1160 using Reply = std::tuple<>;
1161 using ReplyArguments = std::tuple<>;
1162 SetPrevalentResource(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& resourceDomain)
1163 : m_arguments(sessionID, resourceDomain)
1164 {
1165 }
1166
1167 const Arguments& arguments() const
1168 {
1169 return m_arguments;
1170 }
1171
1172private:
1173 Arguments m_arguments;
1174};
1175#endif
1176
1177#if ENABLE(RESOURCE_LOAD_STATISTICS)
1178class SetPrevalentResourceForDebugMode {
1179public:
1180 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&> Arguments;
1181
1182 static IPC::StringReference receiverName() { return messageReceiverName(); }
1183 static IPC::StringReference name() { return IPC::StringReference("SetPrevalentResourceForDebugMode"); }
1184 static const bool isSync = false;
1185
1186 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1187 static void cancelReply(CompletionHandler<void()>&&);
1188 static IPC::StringReference asyncMessageReplyName() { return { "SetPrevalentResourceForDebugModeReply" }; }
1189 using AsyncReply = CompletionHandler<void()>;
1190 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1191 using Reply = std::tuple<>;
1192 using ReplyArguments = std::tuple<>;
1193 SetPrevalentResourceForDebugMode(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& resourceDomain)
1194 : m_arguments(sessionID, resourceDomain)
1195 {
1196 }
1197
1198 const Arguments& arguments() const
1199 {
1200 return m_arguments;
1201 }
1202
1203private:
1204 Arguments m_arguments;
1205};
1206#endif
1207
1208#if ENABLE(RESOURCE_LOAD_STATISTICS)
1209class HadUserInteraction {
1210public:
1211 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&> Arguments;
1212
1213 static IPC::StringReference receiverName() { return messageReceiverName(); }
1214 static IPC::StringReference name() { return IPC::StringReference("HadUserInteraction"); }
1215 static const bool isSync = false;
1216
1217 static void callReply(IPC::Decoder&, CompletionHandler<void(bool&&)>&&);
1218 static void cancelReply(CompletionHandler<void(bool&&)>&&);
1219 static IPC::StringReference asyncMessageReplyName() { return { "HadUserInteractionReply" }; }
1220 using AsyncReply = CompletionHandler<void(bool hadUserInteraction)>;
1221 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool hadUserInteraction);
1222 using Reply = std::tuple<bool&>;
1223 using ReplyArguments = std::tuple<bool>;
1224 HadUserInteraction(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& resourceDomain)
1225 : m_arguments(sessionID, resourceDomain)
1226 {
1227 }
1228
1229 const Arguments& arguments() const
1230 {
1231 return m_arguments;
1232 }
1233
1234private:
1235 Arguments m_arguments;
1236};
1237#endif
1238
1239#if ENABLE(RESOURCE_LOAD_STATISTICS)
1240class GetAllStorageAccessEntries {
1241public:
1242 typedef std::tuple<const PAL::SessionID&> Arguments;
1243
1244 static IPC::StringReference receiverName() { return messageReceiverName(); }
1245 static IPC::StringReference name() { return IPC::StringReference("GetAllStorageAccessEntries"); }
1246 static const bool isSync = false;
1247
1248 static void callReply(IPC::Decoder&, CompletionHandler<void(Vector<String>&&)>&&);
1249 static void cancelReply(CompletionHandler<void(Vector<String>&&)>&&);
1250 static IPC::StringReference asyncMessageReplyName() { return { "GetAllStorageAccessEntriesReply" }; }
1251 using AsyncReply = CompletionHandler<void(const Vector<String>& domains)>;
1252 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const Vector<String>& domains);
1253 using Reply = std::tuple<Vector<String>&>;
1254 using ReplyArguments = std::tuple<Vector<String>>;
1255 explicit GetAllStorageAccessEntries(const PAL::SessionID& sessionID)
1256 : m_arguments(sessionID)
1257 {
1258 }
1259
1260 const Arguments& arguments() const
1261 {
1262 return m_arguments;
1263 }
1264
1265private:
1266 Arguments m_arguments;
1267};
1268#endif
1269
1270#if ENABLE(RESOURCE_LOAD_STATISTICS)
1271class IsRegisteredAsRedirectingTo {
1272public:
1273 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, const WebCore::RegistrableDomain&> Arguments;
1274
1275 static IPC::StringReference receiverName() { return messageReceiverName(); }
1276 static IPC::StringReference name() { return IPC::StringReference("IsRegisteredAsRedirectingTo"); }
1277 static const bool isSync = false;
1278
1279 static void callReply(IPC::Decoder&, CompletionHandler<void(bool&&)>&&);
1280 static void cancelReply(CompletionHandler<void(bool&&)>&&);
1281 static IPC::StringReference asyncMessageReplyName() { return { "IsRegisteredAsRedirectingToReply" }; }
1282 using AsyncReply = CompletionHandler<void(bool isRedirectingTo)>;
1283 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool isRedirectingTo);
1284 using Reply = std::tuple<bool&>;
1285 using ReplyArguments = std::tuple<bool>;
1286 IsRegisteredAsRedirectingTo(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& redirectedFromDomain, const WebCore::RegistrableDomain& redirectedToDomain)
1287 : m_arguments(sessionID, redirectedFromDomain, redirectedToDomain)
1288 {
1289 }
1290
1291 const Arguments& arguments() const
1292 {
1293 return m_arguments;
1294 }
1295
1296private:
1297 Arguments m_arguments;
1298};
1299#endif
1300
1301#if ENABLE(RESOURCE_LOAD_STATISTICS)
1302class IsRegisteredAsSubFrameUnder {
1303public:
1304 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, const WebCore::RegistrableDomain&> Arguments;
1305
1306 static IPC::StringReference receiverName() { return messageReceiverName(); }
1307 static IPC::StringReference name() { return IPC::StringReference("IsRegisteredAsSubFrameUnder"); }
1308 static const bool isSync = false;
1309
1310 static void callReply(IPC::Decoder&, CompletionHandler<void(bool&&)>&&);
1311 static void cancelReply(CompletionHandler<void(bool&&)>&&);
1312 static IPC::StringReference asyncMessageReplyName() { return { "IsRegisteredAsSubFrameUnderReply" }; }
1313 using AsyncReply = CompletionHandler<void(bool isSubframeUnder)>;
1314 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool isSubframeUnder);
1315 using Reply = std::tuple<bool&>;
1316 using ReplyArguments = std::tuple<bool>;
1317 IsRegisteredAsSubFrameUnder(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& subFrameDomain, const WebCore::RegistrableDomain& topFrameDomain)
1318 : m_arguments(sessionID, subFrameDomain, topFrameDomain)
1319 {
1320 }
1321
1322 const Arguments& arguments() const
1323 {
1324 return m_arguments;
1325 }
1326
1327private:
1328 Arguments m_arguments;
1329};
1330#endif
1331
1332#if ENABLE(RESOURCE_LOAD_STATISTICS)
1333class IsRegisteredAsSubresourceUnder {
1334public:
1335 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, const WebCore::RegistrableDomain&> Arguments;
1336
1337 static IPC::StringReference receiverName() { return messageReceiverName(); }
1338 static IPC::StringReference name() { return IPC::StringReference("IsRegisteredAsSubresourceUnder"); }
1339 static const bool isSync = false;
1340
1341 static void callReply(IPC::Decoder&, CompletionHandler<void(bool&&)>&&);
1342 static void cancelReply(CompletionHandler<void(bool&&)>&&);
1343 static IPC::StringReference asyncMessageReplyName() { return { "IsRegisteredAsSubresourceUnderReply" }; }
1344 using AsyncReply = CompletionHandler<void(bool isSubresourceUnder)>;
1345 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool isSubresourceUnder);
1346 using Reply = std::tuple<bool&>;
1347 using ReplyArguments = std::tuple<bool>;
1348 IsRegisteredAsSubresourceUnder(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& subresourceDomain, const WebCore::RegistrableDomain& topFrameDomain)
1349 : m_arguments(sessionID, subresourceDomain, topFrameDomain)
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(RESOURCE_LOAD_STATISTICS)
1364class LogFrameNavigation {
1365public:
1366 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, const WebCore::RegistrableDomain&, const WebCore::RegistrableDomain&, bool, bool> Arguments;
1367
1368 static IPC::StringReference receiverName() { return messageReceiverName(); }
1369 static IPC::StringReference name() { return IPC::StringReference("LogFrameNavigation"); }
1370 static const bool isSync = false;
1371
1372 LogFrameNavigation(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& targetDomain, const WebCore::RegistrableDomain& topFrameDomain, const WebCore::RegistrableDomain& sourceDomain, bool isRedirect, bool isMainFrame)
1373 : m_arguments(sessionID, targetDomain, topFrameDomain, sourceDomain, isRedirect, isMainFrame)
1374 {
1375 }
1376
1377 const Arguments& arguments() const
1378 {
1379 return m_arguments;
1380 }
1381
1382private:
1383 Arguments m_arguments;
1384};
1385#endif
1386
1387#if ENABLE(RESOURCE_LOAD_STATISTICS)
1388class LogUserInteraction {
1389public:
1390 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&> Arguments;
1391
1392 static IPC::StringReference receiverName() { return messageReceiverName(); }
1393 static IPC::StringReference name() { return IPC::StringReference("LogUserInteraction"); }
1394 static const bool isSync = false;
1395
1396 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1397 static void cancelReply(CompletionHandler<void()>&&);
1398 static IPC::StringReference asyncMessageReplyName() { return { "LogUserInteractionReply" }; }
1399 using AsyncReply = CompletionHandler<void()>;
1400 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1401 using Reply = std::tuple<>;
1402 using ReplyArguments = std::tuple<>;
1403 LogUserInteraction(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& topFrameDomain)
1404 : m_arguments(sessionID, topFrameDomain)
1405 {
1406 }
1407
1408 const Arguments& arguments() const
1409 {
1410 return m_arguments;
1411 }
1412
1413private:
1414 Arguments m_arguments;
1415};
1416#endif
1417
1418#if ENABLE(RESOURCE_LOAD_STATISTICS)
1419class RemovePrevalentDomains {
1420public:
1421 typedef std::tuple<const PAL::SessionID&, const Vector<WebCore::RegistrableDomain>&> Arguments;
1422
1423 static IPC::StringReference receiverName() { return messageReceiverName(); }
1424 static IPC::StringReference name() { return IPC::StringReference("RemovePrevalentDomains"); }
1425 static const bool isSync = false;
1426
1427 RemovePrevalentDomains(const PAL::SessionID& sessionID, const Vector<WebCore::RegistrableDomain>& domainsWithInteraction)
1428 : m_arguments(sessionID, domainsWithInteraction)
1429 {
1430 }
1431
1432 const Arguments& arguments() const
1433 {
1434 return m_arguments;
1435 }
1436
1437private:
1438 Arguments m_arguments;
1439};
1440#endif
1441
1442#if ENABLE(RESOURCE_LOAD_STATISTICS)
1443class ResetParametersToDefaultValues {
1444public:
1445 typedef std::tuple<const PAL::SessionID&> Arguments;
1446
1447 static IPC::StringReference receiverName() { return messageReceiverName(); }
1448 static IPC::StringReference name() { return IPC::StringReference("ResetParametersToDefaultValues"); }
1449 static const bool isSync = false;
1450
1451 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1452 static void cancelReply(CompletionHandler<void()>&&);
1453 static IPC::StringReference asyncMessageReplyName() { return { "ResetParametersToDefaultValuesReply" }; }
1454 using AsyncReply = CompletionHandler<void()>;
1455 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1456 using Reply = std::tuple<>;
1457 using ReplyArguments = std::tuple<>;
1458 explicit ResetParametersToDefaultValues(const PAL::SessionID& sessionID)
1459 : m_arguments(sessionID)
1460 {
1461 }
1462
1463 const Arguments& arguments() const
1464 {
1465 return m_arguments;
1466 }
1467
1468private:
1469 Arguments m_arguments;
1470};
1471#endif
1472
1473#if ENABLE(RESOURCE_LOAD_STATISTICS)
1474class ScheduleClearInMemoryAndPersistent {
1475public:
1476 typedef std::tuple<const PAL::SessionID&, const Optional<WallTime>&, WebKit::ShouldGrandfatherStatistics> Arguments;
1477
1478 static IPC::StringReference receiverName() { return messageReceiverName(); }
1479 static IPC::StringReference name() { return IPC::StringReference("ScheduleClearInMemoryAndPersistent"); }
1480 static const bool isSync = false;
1481
1482 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1483 static void cancelReply(CompletionHandler<void()>&&);
1484 static IPC::StringReference asyncMessageReplyName() { return { "ScheduleClearInMemoryAndPersistentReply" }; }
1485 using AsyncReply = CompletionHandler<void()>;
1486 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1487 using Reply = std::tuple<>;
1488 using ReplyArguments = std::tuple<>;
1489 ScheduleClearInMemoryAndPersistent(const PAL::SessionID& sessionID, const Optional<WallTime>& modifiedSince, WebKit::ShouldGrandfatherStatistics shouldGrandfather)
1490 : m_arguments(sessionID, modifiedSince, shouldGrandfather)
1491 {
1492 }
1493
1494 const Arguments& arguments() const
1495 {
1496 return m_arguments;
1497 }
1498
1499private:
1500 Arguments m_arguments;
1501};
1502#endif
1503
1504#if ENABLE(RESOURCE_LOAD_STATISTICS)
1505class ScheduleCookieBlockingUpdate {
1506public:
1507 typedef std::tuple<const PAL::SessionID&> Arguments;
1508
1509 static IPC::StringReference receiverName() { return messageReceiverName(); }
1510 static IPC::StringReference name() { return IPC::StringReference("ScheduleCookieBlockingUpdate"); }
1511 static const bool isSync = false;
1512
1513 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1514 static void cancelReply(CompletionHandler<void()>&&);
1515 static IPC::StringReference asyncMessageReplyName() { return { "ScheduleCookieBlockingUpdateReply" }; }
1516 using AsyncReply = CompletionHandler<void()>;
1517 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1518 using Reply = std::tuple<>;
1519 using ReplyArguments = std::tuple<>;
1520 explicit ScheduleCookieBlockingUpdate(const PAL::SessionID& sessionID)
1521 : m_arguments(sessionID)
1522 {
1523 }
1524
1525 const Arguments& arguments() const
1526 {
1527 return m_arguments;
1528 }
1529
1530private:
1531 Arguments m_arguments;
1532};
1533#endif
1534
1535#if ENABLE(RESOURCE_LOAD_STATISTICS)
1536class ScheduleStatisticsAndDataRecordsProcessing {
1537public:
1538 typedef std::tuple<const PAL::SessionID&> Arguments;
1539
1540 static IPC::StringReference receiverName() { return messageReceiverName(); }
1541 static IPC::StringReference name() { return IPC::StringReference("ScheduleStatisticsAndDataRecordsProcessing"); }
1542 static const bool isSync = false;
1543
1544 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1545 static void cancelReply(CompletionHandler<void()>&&);
1546 static IPC::StringReference asyncMessageReplyName() { return { "ScheduleStatisticsAndDataRecordsProcessingReply" }; }
1547 using AsyncReply = CompletionHandler<void()>;
1548 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1549 using Reply = std::tuple<>;
1550 using ReplyArguments = std::tuple<>;
1551 explicit ScheduleStatisticsAndDataRecordsProcessing(const PAL::SessionID& sessionID)
1552 : m_arguments(sessionID)
1553 {
1554 }
1555
1556 const Arguments& arguments() const
1557 {
1558 return m_arguments;
1559 }
1560
1561private:
1562 Arguments m_arguments;
1563};
1564#endif
1565
1566#if ENABLE(RESOURCE_LOAD_STATISTICS)
1567class SubmitTelemetry {
1568public:
1569 typedef std::tuple<const PAL::SessionID&> Arguments;
1570
1571 static IPC::StringReference receiverName() { return messageReceiverName(); }
1572 static IPC::StringReference name() { return IPC::StringReference("SubmitTelemetry"); }
1573 static const bool isSync = false;
1574
1575 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1576 static void cancelReply(CompletionHandler<void()>&&);
1577 static IPC::StringReference asyncMessageReplyName() { return { "SubmitTelemetryReply" }; }
1578 using AsyncReply = CompletionHandler<void()>;
1579 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1580 using Reply = std::tuple<>;
1581 using ReplyArguments = std::tuple<>;
1582 explicit SubmitTelemetry(const PAL::SessionID& sessionID)
1583 : m_arguments(sessionID)
1584 {
1585 }
1586
1587 const Arguments& arguments() const
1588 {
1589 return m_arguments;
1590 }
1591
1592private:
1593 Arguments m_arguments;
1594};
1595#endif
1596
1597#if ENABLE(RESOURCE_LOAD_STATISTICS)
1598class SetCacheMaxAgeCapForPrevalentResources {
1599public:
1600 typedef std::tuple<const PAL::SessionID&, const Seconds&> Arguments;
1601
1602 static IPC::StringReference receiverName() { return messageReceiverName(); }
1603 static IPC::StringReference name() { return IPC::StringReference("SetCacheMaxAgeCapForPrevalentResources"); }
1604 static const bool isSync = false;
1605
1606 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1607 static void cancelReply(CompletionHandler<void()>&&);
1608 static IPC::StringReference asyncMessageReplyName() { return { "SetCacheMaxAgeCapForPrevalentResourcesReply" }; }
1609 using AsyncReply = CompletionHandler<void()>;
1610 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1611 using Reply = std::tuple<>;
1612 using ReplyArguments = std::tuple<>;
1613 SetCacheMaxAgeCapForPrevalentResources(const PAL::SessionID& sessionID, const Seconds& seconds)
1614 : m_arguments(sessionID, seconds)
1615 {
1616 }
1617
1618 const Arguments& arguments() const
1619 {
1620 return m_arguments;
1621 }
1622
1623private:
1624 Arguments m_arguments;
1625};
1626#endif
1627
1628#if ENABLE(RESOURCE_LOAD_STATISTICS)
1629class SetGrandfathered {
1630public:
1631 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, bool> Arguments;
1632
1633 static IPC::StringReference receiverName() { return messageReceiverName(); }
1634 static IPC::StringReference name() { return IPC::StringReference("SetGrandfathered"); }
1635 static const bool isSync = false;
1636
1637 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1638 static void cancelReply(CompletionHandler<void()>&&);
1639 static IPC::StringReference asyncMessageReplyName() { return { "SetGrandfatheredReply" }; }
1640 using AsyncReply = CompletionHandler<void()>;
1641 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1642 using Reply = std::tuple<>;
1643 using ReplyArguments = std::tuple<>;
1644 SetGrandfathered(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& resourceDomain, bool isGrandfathered)
1645 : m_arguments(sessionID, resourceDomain, isGrandfathered)
1646 {
1647 }
1648
1649 const Arguments& arguments() const
1650 {
1651 return m_arguments;
1652 }
1653
1654private:
1655 Arguments m_arguments;
1656};
1657#endif
1658
1659#if ENABLE(RESOURCE_LOAD_STATISTICS)
1660class SetGrandfatheringTime {
1661public:
1662 typedef std::tuple<const PAL::SessionID&, const Seconds&> Arguments;
1663
1664 static IPC::StringReference receiverName() { return messageReceiverName(); }
1665 static IPC::StringReference name() { return IPC::StringReference("SetGrandfatheringTime"); }
1666 static const bool isSync = false;
1667
1668 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1669 static void cancelReply(CompletionHandler<void()>&&);
1670 static IPC::StringReference asyncMessageReplyName() { return { "SetGrandfatheringTimeReply" }; }
1671 using AsyncReply = CompletionHandler<void()>;
1672 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1673 using Reply = std::tuple<>;
1674 using ReplyArguments = std::tuple<>;
1675 SetGrandfatheringTime(const PAL::SessionID& sessionID, const Seconds& seconds)
1676 : m_arguments(sessionID, seconds)
1677 {
1678 }
1679
1680 const Arguments& arguments() const
1681 {
1682 return m_arguments;
1683 }
1684
1685private:
1686 Arguments m_arguments;
1687};
1688#endif
1689
1690#if ENABLE(RESOURCE_LOAD_STATISTICS)
1691class SetMaxStatisticsEntries {
1692public:
1693 typedef std::tuple<const PAL::SessionID&, uint64_t> Arguments;
1694
1695 static IPC::StringReference receiverName() { return messageReceiverName(); }
1696 static IPC::StringReference name() { return IPC::StringReference("SetMaxStatisticsEntries"); }
1697 static const bool isSync = false;
1698
1699 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1700 static void cancelReply(CompletionHandler<void()>&&);
1701 static IPC::StringReference asyncMessageReplyName() { return { "SetMaxStatisticsEntriesReply" }; }
1702 using AsyncReply = CompletionHandler<void()>;
1703 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1704 using Reply = std::tuple<>;
1705 using ReplyArguments = std::tuple<>;
1706 SetMaxStatisticsEntries(const PAL::SessionID& sessionID, uint64_t maximumEntryCount)
1707 : m_arguments(sessionID, maximumEntryCount)
1708 {
1709 }
1710
1711 const Arguments& arguments() const
1712 {
1713 return m_arguments;
1714 }
1715
1716private:
1717 Arguments m_arguments;
1718};
1719#endif
1720
1721#if ENABLE(RESOURCE_LOAD_STATISTICS)
1722class SetMinimumTimeBetweenDataRecordsRemoval {
1723public:
1724 typedef std::tuple<const PAL::SessionID&, const Seconds&> Arguments;
1725
1726 static IPC::StringReference receiverName() { return messageReceiverName(); }
1727 static IPC::StringReference name() { return IPC::StringReference("SetMinimumTimeBetweenDataRecordsRemoval"); }
1728 static const bool isSync = false;
1729
1730 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1731 static void cancelReply(CompletionHandler<void()>&&);
1732 static IPC::StringReference asyncMessageReplyName() { return { "SetMinimumTimeBetweenDataRecordsRemovalReply" }; }
1733 using AsyncReply = CompletionHandler<void()>;
1734 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1735 using Reply = std::tuple<>;
1736 using ReplyArguments = std::tuple<>;
1737 SetMinimumTimeBetweenDataRecordsRemoval(const PAL::SessionID& sessionID, const Seconds& seconds)
1738 : m_arguments(sessionID, seconds)
1739 {
1740 }
1741
1742 const Arguments& arguments() const
1743 {
1744 return m_arguments;
1745 }
1746
1747private:
1748 Arguments m_arguments;
1749};
1750#endif
1751
1752#if ENABLE(RESOURCE_LOAD_STATISTICS)
1753class SetPruneEntriesDownTo {
1754public:
1755 typedef std::tuple<const PAL::SessionID&, uint64_t> Arguments;
1756
1757 static IPC::StringReference receiverName() { return messageReceiverName(); }
1758 static IPC::StringReference name() { return IPC::StringReference("SetPruneEntriesDownTo"); }
1759 static const bool isSync = false;
1760
1761 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1762 static void cancelReply(CompletionHandler<void()>&&);
1763 static IPC::StringReference asyncMessageReplyName() { return { "SetPruneEntriesDownToReply" }; }
1764 using AsyncReply = CompletionHandler<void()>;
1765 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1766 using Reply = std::tuple<>;
1767 using ReplyArguments = std::tuple<>;
1768 SetPruneEntriesDownTo(const PAL::SessionID& sessionID, uint64_t maximumEntryCount)
1769 : m_arguments(sessionID, maximumEntryCount)
1770 {
1771 }
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(RESOURCE_LOAD_STATISTICS)
1784class SetShouldClassifyResourcesBeforeDataRecordsRemoval {
1785public:
1786 typedef std::tuple<const PAL::SessionID&, bool> Arguments;
1787
1788 static IPC::StringReference receiverName() { return messageReceiverName(); }
1789 static IPC::StringReference name() { return IPC::StringReference("SetShouldClassifyResourcesBeforeDataRecordsRemoval"); }
1790 static const bool isSync = false;
1791
1792 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1793 static void cancelReply(CompletionHandler<void()>&&);
1794 static IPC::StringReference asyncMessageReplyName() { return { "SetShouldClassifyResourcesBeforeDataRecordsRemovalReply" }; }
1795 using AsyncReply = CompletionHandler<void()>;
1796 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1797 using Reply = std::tuple<>;
1798 using ReplyArguments = std::tuple<>;
1799 SetShouldClassifyResourcesBeforeDataRecordsRemoval(const PAL::SessionID& sessionID, bool value)
1800 : m_arguments(sessionID, value)
1801 {
1802 }
1803
1804 const Arguments& arguments() const
1805 {
1806 return m_arguments;
1807 }
1808
1809private:
1810 Arguments m_arguments;
1811};
1812#endif
1813
1814#if ENABLE(RESOURCE_LOAD_STATISTICS)
1815class SetNotifyPagesWhenDataRecordsWereScanned {
1816public:
1817 typedef std::tuple<const PAL::SessionID&, bool> Arguments;
1818
1819 static IPC::StringReference receiverName() { return messageReceiverName(); }
1820 static IPC::StringReference name() { return IPC::StringReference("SetNotifyPagesWhenDataRecordsWereScanned"); }
1821 static const bool isSync = false;
1822
1823 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1824 static void cancelReply(CompletionHandler<void()>&&);
1825 static IPC::StringReference asyncMessageReplyName() { return { "SetNotifyPagesWhenDataRecordsWereScannedReply" }; }
1826 using AsyncReply = CompletionHandler<void()>;
1827 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1828 using Reply = std::tuple<>;
1829 using ReplyArguments = std::tuple<>;
1830 SetNotifyPagesWhenDataRecordsWereScanned(const PAL::SessionID& sessionID, bool value)
1831 : m_arguments(sessionID, value)
1832 {
1833 }
1834
1835 const Arguments& arguments() const
1836 {
1837 return m_arguments;
1838 }
1839
1840private:
1841 Arguments m_arguments;
1842};
1843#endif
1844
1845#if ENABLE(RESOURCE_LOAD_STATISTICS)
1846class SetIsRunningResourceLoadStatisticsTest {
1847public:
1848 typedef std::tuple<const PAL::SessionID&, bool> Arguments;
1849
1850 static IPC::StringReference receiverName() { return messageReceiverName(); }
1851 static IPC::StringReference name() { return IPC::StringReference("SetIsRunningResourceLoadStatisticsTest"); }
1852 static const bool isSync = false;
1853
1854 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1855 static void cancelReply(CompletionHandler<void()>&&);
1856 static IPC::StringReference asyncMessageReplyName() { return { "SetIsRunningResourceLoadStatisticsTestReply" }; }
1857 using AsyncReply = CompletionHandler<void()>;
1858 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1859 using Reply = std::tuple<>;
1860 using ReplyArguments = std::tuple<>;
1861 SetIsRunningResourceLoadStatisticsTest(const PAL::SessionID& sessionID, bool value)
1862 : m_arguments(sessionID, value)
1863 {
1864 }
1865
1866 const Arguments& arguments() const
1867 {
1868 return m_arguments;
1869 }
1870
1871private:
1872 Arguments m_arguments;
1873};
1874#endif
1875
1876#if ENABLE(RESOURCE_LOAD_STATISTICS)
1877class SetNotifyPagesWhenTelemetryWasCaptured {
1878public:
1879 typedef std::tuple<const PAL::SessionID&, bool> Arguments;
1880
1881 static IPC::StringReference receiverName() { return messageReceiverName(); }
1882 static IPC::StringReference name() { return IPC::StringReference("SetNotifyPagesWhenTelemetryWasCaptured"); }
1883 static const bool isSync = false;
1884
1885 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1886 static void cancelReply(CompletionHandler<void()>&&);
1887 static IPC::StringReference asyncMessageReplyName() { return { "SetNotifyPagesWhenTelemetryWasCapturedReply" }; }
1888 using AsyncReply = CompletionHandler<void()>;
1889 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1890 using Reply = std::tuple<>;
1891 using ReplyArguments = std::tuple<>;
1892 SetNotifyPagesWhenTelemetryWasCaptured(const PAL::SessionID& sessionID, bool value)
1893 : m_arguments(sessionID, value)
1894 {
1895 }
1896
1897 const Arguments& arguments() const
1898 {
1899 return m_arguments;
1900 }
1901
1902private:
1903 Arguments m_arguments;
1904};
1905#endif
1906
1907#if ENABLE(RESOURCE_LOAD_STATISTICS)
1908class SetResourceLoadStatisticsDebugMode {
1909public:
1910 typedef std::tuple<const PAL::SessionID&, bool> Arguments;
1911
1912 static IPC::StringReference receiverName() { return messageReceiverName(); }
1913 static IPC::StringReference name() { return IPC::StringReference("SetResourceLoadStatisticsDebugMode"); }
1914 static const bool isSync = false;
1915
1916 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1917 static void cancelReply(CompletionHandler<void()>&&);
1918 static IPC::StringReference asyncMessageReplyName() { return { "SetResourceLoadStatisticsDebugModeReply" }; }
1919 using AsyncReply = CompletionHandler<void()>;
1920 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1921 using Reply = std::tuple<>;
1922 using ReplyArguments = std::tuple<>;
1923 SetResourceLoadStatisticsDebugMode(const PAL::SessionID& sessionID, bool debugMode)
1924 : m_arguments(sessionID, debugMode)
1925 {
1926 }
1927
1928 const Arguments& arguments() const
1929 {
1930 return m_arguments;
1931 }
1932
1933private:
1934 Arguments m_arguments;
1935};
1936#endif
1937
1938#if ENABLE(RESOURCE_LOAD_STATISTICS)
1939class SetVeryPrevalentResource {
1940public:
1941 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&> Arguments;
1942
1943 static IPC::StringReference receiverName() { return messageReceiverName(); }
1944 static IPC::StringReference name() { return IPC::StringReference("SetVeryPrevalentResource"); }
1945 static const bool isSync = false;
1946
1947 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1948 static void cancelReply(CompletionHandler<void()>&&);
1949 static IPC::StringReference asyncMessageReplyName() { return { "SetVeryPrevalentResourceReply" }; }
1950 using AsyncReply = CompletionHandler<void()>;
1951 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1952 using Reply = std::tuple<>;
1953 using ReplyArguments = std::tuple<>;
1954 SetVeryPrevalentResource(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& resourceDomain)
1955 : m_arguments(sessionID, resourceDomain)
1956 {
1957 }
1958
1959 const Arguments& arguments() const
1960 {
1961 return m_arguments;
1962 }
1963
1964private:
1965 Arguments m_arguments;
1966};
1967#endif
1968
1969#if ENABLE(RESOURCE_LOAD_STATISTICS)
1970class SetSubframeUnderTopFrameDomain {
1971public:
1972 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, const WebCore::RegistrableDomain&> Arguments;
1973
1974 static IPC::StringReference receiverName() { return messageReceiverName(); }
1975 static IPC::StringReference name() { return IPC::StringReference("SetSubframeUnderTopFrameDomain"); }
1976 static const bool isSync = false;
1977
1978 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
1979 static void cancelReply(CompletionHandler<void()>&&);
1980 static IPC::StringReference asyncMessageReplyName() { return { "SetSubframeUnderTopFrameDomainReply" }; }
1981 using AsyncReply = CompletionHandler<void()>;
1982 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1983 using Reply = std::tuple<>;
1984 using ReplyArguments = std::tuple<>;
1985 SetSubframeUnderTopFrameDomain(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& subFrameDomain, const WebCore::RegistrableDomain& topFrameDomain)
1986 : m_arguments(sessionID, subFrameDomain, topFrameDomain)
1987 {
1988 }
1989
1990 const Arguments& arguments() const
1991 {
1992 return m_arguments;
1993 }
1994
1995private:
1996 Arguments m_arguments;
1997};
1998#endif
1999
2000#if ENABLE(RESOURCE_LOAD_STATISTICS)
2001class SetSubresourceUnderTopFrameDomain {
2002public:
2003 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, const WebCore::RegistrableDomain&> Arguments;
2004
2005 static IPC::StringReference receiverName() { return messageReceiverName(); }
2006 static IPC::StringReference name() { return IPC::StringReference("SetSubresourceUnderTopFrameDomain"); }
2007 static const bool isSync = false;
2008
2009 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2010 static void cancelReply(CompletionHandler<void()>&&);
2011 static IPC::StringReference asyncMessageReplyName() { return { "SetSubresourceUnderTopFrameDomainReply" }; }
2012 using AsyncReply = CompletionHandler<void()>;
2013 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2014 using Reply = std::tuple<>;
2015 using ReplyArguments = std::tuple<>;
2016 SetSubresourceUnderTopFrameDomain(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& subresourceDomain, const WebCore::RegistrableDomain& topFrameDomain)
2017 : m_arguments(sessionID, subresourceDomain, topFrameDomain)
2018 {
2019 }
2020
2021 const Arguments& arguments() const
2022 {
2023 return m_arguments;
2024 }
2025
2026private:
2027 Arguments m_arguments;
2028};
2029#endif
2030
2031#if ENABLE(RESOURCE_LOAD_STATISTICS)
2032class SetSubresourceUniqueRedirectTo {
2033public:
2034 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, const WebCore::RegistrableDomain&> Arguments;
2035
2036 static IPC::StringReference receiverName() { return messageReceiverName(); }
2037 static IPC::StringReference name() { return IPC::StringReference("SetSubresourceUniqueRedirectTo"); }
2038 static const bool isSync = false;
2039
2040 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2041 static void cancelReply(CompletionHandler<void()>&&);
2042 static IPC::StringReference asyncMessageReplyName() { return { "SetSubresourceUniqueRedirectToReply" }; }
2043 using AsyncReply = CompletionHandler<void()>;
2044 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2045 using Reply = std::tuple<>;
2046 using ReplyArguments = std::tuple<>;
2047 SetSubresourceUniqueRedirectTo(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& subresourceDomain, const WebCore::RegistrableDomain& redirectedToDomain)
2048 : m_arguments(sessionID, subresourceDomain, redirectedToDomain)
2049 {
2050 }
2051
2052 const Arguments& arguments() const
2053 {
2054 return m_arguments;
2055 }
2056
2057private:
2058 Arguments m_arguments;
2059};
2060#endif
2061
2062#if ENABLE(RESOURCE_LOAD_STATISTICS)
2063class SetSubresourceUniqueRedirectFrom {
2064public:
2065 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, const WebCore::RegistrableDomain&> Arguments;
2066
2067 static IPC::StringReference receiverName() { return messageReceiverName(); }
2068 static IPC::StringReference name() { return IPC::StringReference("SetSubresourceUniqueRedirectFrom"); }
2069 static const bool isSync = false;
2070
2071 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2072 static void cancelReply(CompletionHandler<void()>&&);
2073 static IPC::StringReference asyncMessageReplyName() { return { "SetSubresourceUniqueRedirectFromReply" }; }
2074 using AsyncReply = CompletionHandler<void()>;
2075 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2076 using Reply = std::tuple<>;
2077 using ReplyArguments = std::tuple<>;
2078 SetSubresourceUniqueRedirectFrom(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& subresourceDomain, const WebCore::RegistrableDomain& redirectedFromDomain)
2079 : m_arguments(sessionID, subresourceDomain, redirectedFromDomain)
2080 {
2081 }
2082
2083 const Arguments& arguments() const
2084 {
2085 return m_arguments;
2086 }
2087
2088private:
2089 Arguments m_arguments;
2090};
2091#endif
2092
2093#if ENABLE(RESOURCE_LOAD_STATISTICS)
2094class SetTimeToLiveUserInteraction {
2095public:
2096 typedef std::tuple<const PAL::SessionID&, const Seconds&> Arguments;
2097
2098 static IPC::StringReference receiverName() { return messageReceiverName(); }
2099 static IPC::StringReference name() { return IPC::StringReference("SetTimeToLiveUserInteraction"); }
2100 static const bool isSync = false;
2101
2102 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2103 static void cancelReply(CompletionHandler<void()>&&);
2104 static IPC::StringReference asyncMessageReplyName() { return { "SetTimeToLiveUserInteractionReply" }; }
2105 using AsyncReply = CompletionHandler<void()>;
2106 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2107 using Reply = std::tuple<>;
2108 using ReplyArguments = std::tuple<>;
2109 SetTimeToLiveUserInteraction(const PAL::SessionID& sessionID, const Seconds& seconds)
2110 : m_arguments(sessionID, seconds)
2111 {
2112 }
2113
2114 const Arguments& arguments() const
2115 {
2116 return m_arguments;
2117 }
2118
2119private:
2120 Arguments m_arguments;
2121};
2122#endif
2123
2124#if ENABLE(RESOURCE_LOAD_STATISTICS)
2125class SetTopFrameUniqueRedirectTo {
2126public:
2127 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, const WebCore::RegistrableDomain&> Arguments;
2128
2129 static IPC::StringReference receiverName() { return messageReceiverName(); }
2130 static IPC::StringReference name() { return IPC::StringReference("SetTopFrameUniqueRedirectTo"); }
2131 static const bool isSync = false;
2132
2133 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2134 static void cancelReply(CompletionHandler<void()>&&);
2135 static IPC::StringReference asyncMessageReplyName() { return { "SetTopFrameUniqueRedirectToReply" }; }
2136 using AsyncReply = CompletionHandler<void()>;
2137 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2138 using Reply = std::tuple<>;
2139 using ReplyArguments = std::tuple<>;
2140 SetTopFrameUniqueRedirectTo(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& topFrameDomain, const WebCore::RegistrableDomain& redirectedToDomain)
2141 : m_arguments(sessionID, topFrameDomain, redirectedToDomain)
2142 {
2143 }
2144
2145 const Arguments& arguments() const
2146 {
2147 return m_arguments;
2148 }
2149
2150private:
2151 Arguments m_arguments;
2152};
2153#endif
2154
2155#if ENABLE(RESOURCE_LOAD_STATISTICS)
2156class SetTopFrameUniqueRedirectFrom {
2157public:
2158 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, const WebCore::RegistrableDomain&> Arguments;
2159
2160 static IPC::StringReference receiverName() { return messageReceiverName(); }
2161 static IPC::StringReference name() { return IPC::StringReference("SetTopFrameUniqueRedirectFrom"); }
2162 static const bool isSync = false;
2163
2164 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2165 static void cancelReply(CompletionHandler<void()>&&);
2166 static IPC::StringReference asyncMessageReplyName() { return { "SetTopFrameUniqueRedirectFromReply" }; }
2167 using AsyncReply = CompletionHandler<void()>;
2168 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2169 using Reply = std::tuple<>;
2170 using ReplyArguments = std::tuple<>;
2171 SetTopFrameUniqueRedirectFrom(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& topFrameDomain, const WebCore::RegistrableDomain& redirectedFromDomain)
2172 : m_arguments(sessionID, topFrameDomain, redirectedFromDomain)
2173 {
2174 }
2175
2176 const Arguments& arguments() const
2177 {
2178 return m_arguments;
2179 }
2180
2181private:
2182 Arguments m_arguments;
2183};
2184#endif
2185
2186#if ENABLE(RESOURCE_LOAD_STATISTICS)
2187class ResetCacheMaxAgeCapForPrevalentResources {
2188public:
2189 typedef std::tuple<const PAL::SessionID&> Arguments;
2190
2191 static IPC::StringReference receiverName() { return messageReceiverName(); }
2192 static IPC::StringReference name() { return IPC::StringReference("ResetCacheMaxAgeCapForPrevalentResources"); }
2193 static const bool isSync = false;
2194
2195 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2196 static void cancelReply(CompletionHandler<void()>&&);
2197 static IPC::StringReference asyncMessageReplyName() { return { "ResetCacheMaxAgeCapForPrevalentResourcesReply" }; }
2198 using AsyncReply = CompletionHandler<void()>;
2199 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2200 using Reply = std::tuple<>;
2201 using ReplyArguments = std::tuple<>;
2202 explicit ResetCacheMaxAgeCapForPrevalentResources(const PAL::SessionID& sessionID)
2203 : m_arguments(sessionID)
2204 {
2205 }
2206
2207 const Arguments& arguments() const
2208 {
2209 return m_arguments;
2210 }
2211
2212private:
2213 Arguments m_arguments;
2214};
2215#endif
2216
2217#if ENABLE(RESOURCE_LOAD_STATISTICS)
2218class CommittedCrossSiteLoadWithLinkDecoration {
2219public:
2220 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, const WebCore::RegistrableDomain&, uint64_t> Arguments;
2221
2222 static IPC::StringReference receiverName() { return messageReceiverName(); }
2223 static IPC::StringReference name() { return IPC::StringReference("CommittedCrossSiteLoadWithLinkDecoration"); }
2224 static const bool isSync = false;
2225
2226 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2227 static void cancelReply(CompletionHandler<void()>&&);
2228 static IPC::StringReference asyncMessageReplyName() { return { "CommittedCrossSiteLoadWithLinkDecorationReply" }; }
2229 using AsyncReply = CompletionHandler<void()>;
2230 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2231 using Reply = std::tuple<>;
2232 using ReplyArguments = std::tuple<>;
2233 CommittedCrossSiteLoadWithLinkDecoration(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& fromDomain, const WebCore::RegistrableDomain& toDomain, uint64_t pageID)
2234 : m_arguments(sessionID, fromDomain, toDomain, pageID)
2235 {
2236 }
2237
2238 const Arguments& arguments() const
2239 {
2240 return m_arguments;
2241 }
2242
2243private:
2244 Arguments m_arguments;
2245};
2246#endif
2247
2248#if ENABLE(RESOURCE_LOAD_STATISTICS)
2249class SetCrossSiteLoadWithLinkDecorationForTesting {
2250public:
2251 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, const WebCore::RegistrableDomain&> Arguments;
2252
2253 static IPC::StringReference receiverName() { return messageReceiverName(); }
2254 static IPC::StringReference name() { return IPC::StringReference("SetCrossSiteLoadWithLinkDecorationForTesting"); }
2255 static const bool isSync = false;
2256
2257 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2258 static void cancelReply(CompletionHandler<void()>&&);
2259 static IPC::StringReference asyncMessageReplyName() { return { "SetCrossSiteLoadWithLinkDecorationForTestingReply" }; }
2260 using AsyncReply = CompletionHandler<void()>;
2261 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2262 using Reply = std::tuple<>;
2263 using ReplyArguments = std::tuple<>;
2264 SetCrossSiteLoadWithLinkDecorationForTesting(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& fromDomain, const WebCore::RegistrableDomain& toDomain)
2265 : m_arguments(sessionID, fromDomain, toDomain)
2266 {
2267 }
2268
2269 const Arguments& arguments() const
2270 {
2271 return m_arguments;
2272 }
2273
2274private:
2275 Arguments m_arguments;
2276};
2277#endif
2278
2279#if ENABLE(RESOURCE_LOAD_STATISTICS)
2280class ResetCrossSiteLoadsWithLinkDecorationForTesting {
2281public:
2282 typedef std::tuple<const PAL::SessionID&> Arguments;
2283
2284 static IPC::StringReference receiverName() { return messageReceiverName(); }
2285 static IPC::StringReference name() { return IPC::StringReference("ResetCrossSiteLoadsWithLinkDecorationForTesting"); }
2286 static const bool isSync = false;
2287
2288 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2289 static void cancelReply(CompletionHandler<void()>&&);
2290 static IPC::StringReference asyncMessageReplyName() { return { "ResetCrossSiteLoadsWithLinkDecorationForTestingReply" }; }
2291 using AsyncReply = CompletionHandler<void()>;
2292 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2293 using Reply = std::tuple<>;
2294 using ReplyArguments = std::tuple<>;
2295 explicit ResetCrossSiteLoadsWithLinkDecorationForTesting(const PAL::SessionID& sessionID)
2296 : m_arguments(sessionID)
2297 {
2298 }
2299
2300 const Arguments& arguments() const
2301 {
2302 return m_arguments;
2303 }
2304
2305private:
2306 Arguments m_arguments;
2307};
2308#endif
2309
2310#if ENABLE(RESOURCE_LOAD_STATISTICS)
2311class DeleteCookiesForTesting {
2312public:
2313 typedef std::tuple<const PAL::SessionID&, const WebCore::RegistrableDomain&, bool> Arguments;
2314
2315 static IPC::StringReference receiverName() { return messageReceiverName(); }
2316 static IPC::StringReference name() { return IPC::StringReference("DeleteCookiesForTesting"); }
2317 static const bool isSync = false;
2318
2319 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2320 static void cancelReply(CompletionHandler<void()>&&);
2321 static IPC::StringReference asyncMessageReplyName() { return { "DeleteCookiesForTestingReply" }; }
2322 using AsyncReply = CompletionHandler<void()>;
2323 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2324 using Reply = std::tuple<>;
2325 using ReplyArguments = std::tuple<>;
2326 DeleteCookiesForTesting(const PAL::SessionID& sessionID, const WebCore::RegistrableDomain& domain, bool includeHttpOnlyCookies)
2327 : m_arguments(sessionID, domain, includeHttpOnlyCookies)
2328 {
2329 }
2330
2331 const Arguments& arguments() const
2332 {
2333 return m_arguments;
2334 }
2335
2336private:
2337 Arguments m_arguments;
2338};
2339#endif
2340
2341class SetSessionIsControlledByAutomation {
2342public:
2343 typedef std::tuple<const PAL::SessionID&, bool> Arguments;
2344
2345 static IPC::StringReference receiverName() { return messageReceiverName(); }
2346 static IPC::StringReference name() { return IPC::StringReference("SetSessionIsControlledByAutomation"); }
2347 static const bool isSync = false;
2348
2349 SetSessionIsControlledByAutomation(const PAL::SessionID& sessionID, bool controlled)
2350 : m_arguments(sessionID, controlled)
2351 {
2352 }
2353
2354 const Arguments& arguments() const
2355 {
2356 return m_arguments;
2357 }
2358
2359private:
2360 Arguments m_arguments;
2361};
2362
2363class RegisterURLSchemeAsSecure {
2364public:
2365 typedef std::tuple<const String&> Arguments;
2366
2367 static IPC::StringReference receiverName() { return messageReceiverName(); }
2368 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsSecure"); }
2369 static const bool isSync = false;
2370
2371 explicit RegisterURLSchemeAsSecure(const String& scheme)
2372 : m_arguments(scheme)
2373 {
2374 }
2375
2376 const Arguments& arguments() const
2377 {
2378 return m_arguments;
2379 }
2380
2381private:
2382 Arguments m_arguments;
2383};
2384
2385class RegisterURLSchemeAsBypassingContentSecurityPolicy {
2386public:
2387 typedef std::tuple<const String&> Arguments;
2388
2389 static IPC::StringReference receiverName() { return messageReceiverName(); }
2390 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsBypassingContentSecurityPolicy"); }
2391 static const bool isSync = false;
2392
2393 explicit RegisterURLSchemeAsBypassingContentSecurityPolicy(const String& scheme)
2394 : m_arguments(scheme)
2395 {
2396 }
2397
2398 const Arguments& arguments() const
2399 {
2400 return m_arguments;
2401 }
2402
2403private:
2404 Arguments m_arguments;
2405};
2406
2407class RegisterURLSchemeAsLocal {
2408public:
2409 typedef std::tuple<const String&> Arguments;
2410
2411 static IPC::StringReference receiverName() { return messageReceiverName(); }
2412 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsLocal"); }
2413 static const bool isSync = false;
2414
2415 explicit RegisterURLSchemeAsLocal(const String& scheme)
2416 : m_arguments(scheme)
2417 {
2418 }
2419
2420 const Arguments& arguments() const
2421 {
2422 return m_arguments;
2423 }
2424
2425private:
2426 Arguments m_arguments;
2427};
2428
2429class RegisterURLSchemeAsNoAccess {
2430public:
2431 typedef std::tuple<const String&> Arguments;
2432
2433 static IPC::StringReference receiverName() { return messageReceiverName(); }
2434 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsNoAccess"); }
2435 static const bool isSync = false;
2436
2437 explicit RegisterURLSchemeAsNoAccess(const String& scheme)
2438 : m_arguments(scheme)
2439 {
2440 }
2441
2442 const Arguments& arguments() const
2443 {
2444 return m_arguments;
2445 }
2446
2447private:
2448 Arguments m_arguments;
2449};
2450
2451class RegisterURLSchemeAsDisplayIsolated {
2452public:
2453 typedef std::tuple<const String&> Arguments;
2454
2455 static IPC::StringReference receiverName() { return messageReceiverName(); }
2456 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsDisplayIsolated"); }
2457 static const bool isSync = false;
2458
2459 explicit RegisterURLSchemeAsDisplayIsolated(const String& scheme)
2460 : m_arguments(scheme)
2461 {
2462 }
2463
2464 const Arguments& arguments() const
2465 {
2466 return m_arguments;
2467 }
2468
2469private:
2470 Arguments m_arguments;
2471};
2472
2473class RegisterURLSchemeAsCORSEnabled {
2474public:
2475 typedef std::tuple<const String&> Arguments;
2476
2477 static IPC::StringReference receiverName() { return messageReceiverName(); }
2478 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsCORSEnabled"); }
2479 static const bool isSync = false;
2480
2481 explicit RegisterURLSchemeAsCORSEnabled(const String& scheme)
2482 : m_arguments(scheme)
2483 {
2484 }
2485
2486 const Arguments& arguments() const
2487 {
2488 return m_arguments;
2489 }
2490
2491private:
2492 Arguments m_arguments;
2493};
2494
2495class RegisterURLSchemeAsCanDisplayOnlyIfCanRequest {
2496public:
2497 typedef std::tuple<const String&> Arguments;
2498
2499 static IPC::StringReference receiverName() { return messageReceiverName(); }
2500 static IPC::StringReference name() { return IPC::StringReference("RegisterURLSchemeAsCanDisplayOnlyIfCanRequest"); }
2501 static const bool isSync = false;
2502
2503 explicit RegisterURLSchemeAsCanDisplayOnlyIfCanRequest(const String& scheme)
2504 : m_arguments(scheme)
2505 {
2506 }
2507
2508 const Arguments& arguments() const
2509 {
2510 return m_arguments;
2511 }
2512
2513private:
2514 Arguments m_arguments;
2515};
2516
2517class SetCacheStorageParameters {
2518public:
2519 typedef std::tuple<const PAL::SessionID&, const String&, const WebKit::SandboxExtension::Handle&> Arguments;
2520
2521 static IPC::StringReference receiverName() { return messageReceiverName(); }
2522 static IPC::StringReference name() { return IPC::StringReference("SetCacheStorageParameters"); }
2523 static const bool isSync = false;
2524
2525 SetCacheStorageParameters(const PAL::SessionID& sessionID, const String& cacheStorageDirectory, const WebKit::SandboxExtension::Handle& handle)
2526 : m_arguments(sessionID, cacheStorageDirectory, handle)
2527 {
2528 }
2529
2530 const Arguments& arguments() const
2531 {
2532 return m_arguments;
2533 }
2534
2535private:
2536 Arguments m_arguments;
2537};
2538
2539#if ENABLE(SERVICE_WORKER)
2540class PostMessageToServiceWorkerClient {
2541public:
2542 typedef std::tuple<const WebCore::ServiceWorkerClientIdentifier&, const WebCore::MessageWithMessagePorts&, const WebCore::ServiceWorkerIdentifier&, const String&> Arguments;
2543
2544 static IPC::StringReference receiverName() { return messageReceiverName(); }
2545 static IPC::StringReference name() { return IPC::StringReference("PostMessageToServiceWorkerClient"); }
2546 static const bool isSync = false;
2547
2548 PostMessageToServiceWorkerClient(const WebCore::ServiceWorkerClientIdentifier& destinationIdentifier, const WebCore::MessageWithMessagePorts& message, const WebCore::ServiceWorkerIdentifier& sourceIdentifier, const String& sourceOrigin)
2549 : m_arguments(destinationIdentifier, message, sourceIdentifier, sourceOrigin)
2550 {
2551 }
2552
2553 const Arguments& arguments() const
2554 {
2555 return m_arguments;
2556 }
2557
2558private:
2559 Arguments m_arguments;
2560};
2561#endif
2562
2563#if ENABLE(SERVICE_WORKER)
2564class PostMessageToServiceWorker {
2565public:
2566 typedef std::tuple<const WebCore::ServiceWorkerIdentifier&, const WebCore::MessageWithMessagePorts&, const WebCore::ServiceWorkerOrClientIdentifier&, const WebCore::SWServerConnectionIdentifier&> Arguments;
2567
2568 static IPC::StringReference receiverName() { return messageReceiverName(); }
2569 static IPC::StringReference name() { return IPC::StringReference("PostMessageToServiceWorker"); }
2570 static const bool isSync = false;
2571
2572 PostMessageToServiceWorker(const WebCore::ServiceWorkerIdentifier& destination, const WebCore::MessageWithMessagePorts& message, const WebCore::ServiceWorkerOrClientIdentifier& source, const WebCore::SWServerConnectionIdentifier& connectionIdentifier)
2573 : m_arguments(destination, message, source, connectionIdentifier)
2574 {
2575 }
2576
2577 const Arguments& arguments() const
2578 {
2579 return m_arguments;
2580 }
2581
2582private:
2583 Arguments m_arguments;
2584};
2585#endif
2586
2587#if ENABLE(SERVICE_WORKER)
2588class DisableServiceWorkerProcessTerminationDelay {
2589public:
2590 typedef std::tuple<> Arguments;
2591
2592 static IPC::StringReference receiverName() { return messageReceiverName(); }
2593 static IPC::StringReference name() { return IPC::StringReference("DisableServiceWorkerProcessTerminationDelay"); }
2594 static const bool isSync = false;
2595
2596 const Arguments& arguments() const
2597 {
2598 return m_arguments;
2599 }
2600
2601private:
2602 Arguments m_arguments;
2603};
2604#endif
2605
2606#if ENABLE(INDEXED_DATABASE)
2607class SetIDBPerOriginQuota {
2608public:
2609 typedef std::tuple<uint64_t> Arguments;
2610
2611 static IPC::StringReference receiverName() { return messageReceiverName(); }
2612 static IPC::StringReference name() { return IPC::StringReference("SetIDBPerOriginQuota"); }
2613 static const bool isSync = false;
2614
2615 explicit SetIDBPerOriginQuota(uint64_t quota)
2616 : m_arguments(quota)
2617 {
2618 }
2619
2620 const Arguments& arguments() const
2621 {
2622 return m_arguments;
2623 }
2624
2625private:
2626 Arguments m_arguments;
2627};
2628#endif
2629
2630class UpdateQuotaBasedOnSpaceUsageForTesting {
2631public:
2632 typedef std::tuple<const PAL::SessionID&, const WebCore::ClientOrigin&> Arguments;
2633
2634 static IPC::StringReference receiverName() { return messageReceiverName(); }
2635 static IPC::StringReference name() { return IPC::StringReference("UpdateQuotaBasedOnSpaceUsageForTesting"); }
2636 static const bool isSync = false;
2637
2638 UpdateQuotaBasedOnSpaceUsageForTesting(const PAL::SessionID& sessionID, const WebCore::ClientOrigin& origin)
2639 : m_arguments(sessionID, origin)
2640 {
2641 }
2642
2643 const Arguments& arguments() const
2644 {
2645 return m_arguments;
2646 }
2647
2648private:
2649 Arguments m_arguments;
2650};
2651
2652class StoreAdClickAttribution {
2653public:
2654 typedef std::tuple<const PAL::SessionID&, const WebCore::AdClickAttribution&> Arguments;
2655
2656 static IPC::StringReference receiverName() { return messageReceiverName(); }
2657 static IPC::StringReference name() { return IPC::StringReference("StoreAdClickAttribution"); }
2658 static const bool isSync = false;
2659
2660 StoreAdClickAttribution(const PAL::SessionID& sessionID, const WebCore::AdClickAttribution& adClickAttribution)
2661 : m_arguments(sessionID, adClickAttribution)
2662 {
2663 }
2664
2665 const Arguments& arguments() const
2666 {
2667 return m_arguments;
2668 }
2669
2670private:
2671 Arguments m_arguments;
2672};
2673
2674class DumpAdClickAttribution {
2675public:
2676 typedef std::tuple<const PAL::SessionID&> Arguments;
2677
2678 static IPC::StringReference receiverName() { return messageReceiverName(); }
2679 static IPC::StringReference name() { return IPC::StringReference("DumpAdClickAttribution"); }
2680 static const bool isSync = false;
2681
2682 static void callReply(IPC::Decoder&, CompletionHandler<void(String&&)>&&);
2683 static void cancelReply(CompletionHandler<void(String&&)>&&);
2684 static IPC::StringReference asyncMessageReplyName() { return { "DumpAdClickAttributionReply" }; }
2685 using AsyncReply = CompletionHandler<void(const String& adClickAttributionState)>;
2686 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const String& adClickAttributionState);
2687 using Reply = std::tuple<String&>;
2688 using ReplyArguments = std::tuple<String>;
2689 explicit DumpAdClickAttribution(const PAL::SessionID& sessionID)
2690 : m_arguments(sessionID)
2691 {
2692 }
2693
2694 const Arguments& arguments() const
2695 {
2696 return m_arguments;
2697 }
2698
2699private:
2700 Arguments m_arguments;
2701};
2702
2703class ClearAdClickAttribution {
2704public:
2705 typedef std::tuple<const PAL::SessionID&> Arguments;
2706
2707 static IPC::StringReference receiverName() { return messageReceiverName(); }
2708 static IPC::StringReference name() { return IPC::StringReference("ClearAdClickAttribution"); }
2709 static const bool isSync = false;
2710
2711 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2712 static void cancelReply(CompletionHandler<void()>&&);
2713 static IPC::StringReference asyncMessageReplyName() { return { "ClearAdClickAttributionReply" }; }
2714 using AsyncReply = CompletionHandler<void()>;
2715 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2716 using Reply = std::tuple<>;
2717 using ReplyArguments = std::tuple<>;
2718 explicit ClearAdClickAttribution(const PAL::SessionID& sessionID)
2719 : m_arguments(sessionID)
2720 {
2721 }
2722
2723 const Arguments& arguments() const
2724 {
2725 return m_arguments;
2726 }
2727
2728private:
2729 Arguments m_arguments;
2730};
2731
2732class SetAdClickAttributionOverrideTimerForTesting {
2733public:
2734 typedef std::tuple<const PAL::SessionID&, bool> Arguments;
2735
2736 static IPC::StringReference receiverName() { return messageReceiverName(); }
2737 static IPC::StringReference name() { return IPC::StringReference("SetAdClickAttributionOverrideTimerForTesting"); }
2738 static const bool isSync = false;
2739
2740 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2741 static void cancelReply(CompletionHandler<void()>&&);
2742 static IPC::StringReference asyncMessageReplyName() { return { "SetAdClickAttributionOverrideTimerForTestingReply" }; }
2743 using AsyncReply = CompletionHandler<void()>;
2744 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2745 using Reply = std::tuple<>;
2746 using ReplyArguments = std::tuple<>;
2747 SetAdClickAttributionOverrideTimerForTesting(const PAL::SessionID& sessionID, bool value)
2748 : m_arguments(sessionID, value)
2749 {
2750 }
2751
2752 const Arguments& arguments() const
2753 {
2754 return m_arguments;
2755 }
2756
2757private:
2758 Arguments m_arguments;
2759};
2760
2761class SetAdClickAttributionConversionURLForTesting {
2762public:
2763 typedef std::tuple<const PAL::SessionID&, const URL&> Arguments;
2764
2765 static IPC::StringReference receiverName() { return messageReceiverName(); }
2766 static IPC::StringReference name() { return IPC::StringReference("SetAdClickAttributionConversionURLForTesting"); }
2767 static const bool isSync = false;
2768
2769 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2770 static void cancelReply(CompletionHandler<void()>&&);
2771 static IPC::StringReference asyncMessageReplyName() { return { "SetAdClickAttributionConversionURLForTestingReply" }; }
2772 using AsyncReply = CompletionHandler<void()>;
2773 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2774 using Reply = std::tuple<>;
2775 using ReplyArguments = std::tuple<>;
2776 SetAdClickAttributionConversionURLForTesting(const PAL::SessionID& sessionID, const URL& url)
2777 : m_arguments(sessionID, url)
2778 {
2779 }
2780
2781 const Arguments& arguments() const
2782 {
2783 return m_arguments;
2784 }
2785
2786private:
2787 Arguments m_arguments;
2788};
2789
2790class MarkAdClickAttributionsAsExpiredForTesting {
2791public:
2792 typedef std::tuple<const PAL::SessionID&> Arguments;
2793
2794 static IPC::StringReference receiverName() { return messageReceiverName(); }
2795 static IPC::StringReference name() { return IPC::StringReference("MarkAdClickAttributionsAsExpiredForTesting"); }
2796 static const bool isSync = false;
2797
2798 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2799 static void cancelReply(CompletionHandler<void()>&&);
2800 static IPC::StringReference asyncMessageReplyName() { return { "MarkAdClickAttributionsAsExpiredForTestingReply" }; }
2801 using AsyncReply = CompletionHandler<void()>;
2802 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2803 using Reply = std::tuple<>;
2804 using ReplyArguments = std::tuple<>;
2805 explicit MarkAdClickAttributionsAsExpiredForTesting(const PAL::SessionID& sessionID)
2806 : m_arguments(sessionID)
2807 {
2808 }
2809
2810 const Arguments& arguments() const
2811 {
2812 return m_arguments;
2813 }
2814
2815private:
2816 Arguments m_arguments;
2817};
2818
2819class OriginsWithPersistentCredentials {
2820public:
2821 typedef std::tuple<> Arguments;
2822
2823 static IPC::StringReference receiverName() { return messageReceiverName(); }
2824 static IPC::StringReference name() { return IPC::StringReference("OriginsWithPersistentCredentials"); }
2825 static const bool isSync = false;
2826
2827 static void callReply(IPC::Decoder&, CompletionHandler<void(Vector<WebCore::SecurityOriginData>&&)>&&);
2828 static void cancelReply(CompletionHandler<void(Vector<WebCore::SecurityOriginData>&&)>&&);
2829 static IPC::StringReference asyncMessageReplyName() { return { "OriginsWithPersistentCredentialsReply" }; }
2830 using AsyncReply = CompletionHandler<void(const Vector<WebCore::SecurityOriginData>& origins)>;
2831 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const Vector<WebCore::SecurityOriginData>& origins);
2832 using Reply = std::tuple<Vector<WebCore::SecurityOriginData>&>;
2833 using ReplyArguments = std::tuple<Vector<WebCore::SecurityOriginData>>;
2834 const Arguments& arguments() const
2835 {
2836 return m_arguments;
2837 }
2838
2839private:
2840 Arguments m_arguments;
2841};
2842
2843class RemoveCredentialsWithOrigins {
2844public:
2845 typedef std::tuple<const Vector<WebCore::SecurityOriginData>&> Arguments;
2846
2847 static IPC::StringReference receiverName() { return messageReceiverName(); }
2848 static IPC::StringReference name() { return IPC::StringReference("RemoveCredentialsWithOrigins"); }
2849 static const bool isSync = false;
2850
2851 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
2852 static void cancelReply(CompletionHandler<void()>&&);
2853 static IPC::StringReference asyncMessageReplyName() { return { "RemoveCredentialsWithOriginsReply" }; }
2854 using AsyncReply = CompletionHandler<void()>;
2855 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
2856 using Reply = std::tuple<>;
2857 using ReplyArguments = std::tuple<>;
2858 explicit RemoveCredentialsWithOrigins(const Vector<WebCore::SecurityOriginData>& origins)
2859 : m_arguments(origins)
2860 {
2861 }
2862
2863 const Arguments& arguments() const
2864 {
2865 return m_arguments;
2866 }
2867
2868private:
2869 Arguments m_arguments;
2870};
2871
2872} // namespace NetworkProcess
2873} // namespace Messages
2874