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