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#include "config.h"
26
27#include "NetworkProcess.h"
28
29#include "ArgumentCoders.h"
30#include "CacheModel.h"
31#include "DataReference.h"
32#include "Decoder.h"
33#include "DownloadID.h"
34#include "HandleMessage.h"
35#include "NetworkProcessCreationParameters.h"
36#include "NetworkProcessMessages.h"
37#include "SandboxExtension.h"
38#if ENABLE(RESOURCE_LOAD_STATISTICS)
39#include "ShouldGrandfatherStatistics.h"
40#endif
41#include "WebCoreArgumentCoders.h"
42#include "WebsiteDataFetchOption.h"
43#include "WebsiteDataStoreParameters.h"
44#include "WebsiteDataType.h"
45#include <WebCore/AdClickAttribution.h>
46#include <WebCore/CertificateInfo.h>
47#include <WebCore/ClientOrigin.h>
48#if USE(CURL)
49#include <WebCore/CurlProxySettings.h>
50#endif
51#if ENABLE(SERVICE_WORKER)
52#include <WebCore/MessageWithMessagePorts.h>
53#endif
54#include <WebCore/RegistrableDomain.h>
55#include <WebCore/ResourceRequest.h>
56#include <WebCore/SecurityOriginData.h>
57#if ENABLE(SERVICE_WORKER)
58#include <WebCore/ServiceWorkerClientIdentifier.h>
59#endif
60#if ENABLE(SERVICE_WORKER)
61#include <WebCore/ServiceWorkerIdentifier.h>
62#endif
63#if ENABLE(SERVICE_WORKER)
64#include <WebCore/ServiceWorkerTypes.h>
65#endif
66#if USE(SOUP)
67#include <WebCore/SoupNetworkProxySettings.h>
68#endif
69#include <WebCore/StoredCredentialsPolicy.h>
70#include <pal/SessionID.h>
71#include <wtf/OptionSet.h>
72#if ENABLE(RESOURCE_LOAD_STATISTICS)
73#include <wtf/Optional.h>
74#endif
75#if ENABLE(RESOURCE_LOAD_STATISTICS)
76#include <wtf/Seconds.h>
77#endif
78#include <wtf/Vector.h>
79#include <wtf/WallTime.h>
80#include <wtf/text/WTFString.h>
81
82namespace Messages {
83
84namespace NetworkProcess {
85
86void SetAllowsAnySSLCertificateForWebSocket::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
87{
88 connection.sendSyncReply(WTFMove(encoder));
89}
90
91#if ENABLE(RESOURCE_LOAD_STATISTICS)
92
93void ClearPrevalentResource::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
94{
95 completionHandler();
96}
97
98void ClearPrevalentResource::cancelReply(CompletionHandler<void()>&& completionHandler)
99{
100 completionHandler();
101}
102
103void ClearPrevalentResource::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
104{
105 connection.sendSyncReply(WTFMove(encoder));
106}
107
108#endif
109
110#if ENABLE(RESOURCE_LOAD_STATISTICS)
111
112void ClearUserInteraction::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
113{
114 completionHandler();
115}
116
117void ClearUserInteraction::cancelReply(CompletionHandler<void()>&& completionHandler)
118{
119 completionHandler();
120}
121
122void ClearUserInteraction::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
123{
124 connection.sendSyncReply(WTFMove(encoder));
125}
126
127#endif
128
129#if ENABLE(RESOURCE_LOAD_STATISTICS)
130
131void DumpResourceLoadStatistics::callReply(IPC::Decoder& decoder, CompletionHandler<void(String&&)>&& completionHandler)
132{
133 Optional<String> dumpedStatistics;
134 decoder >> dumpedStatistics;
135 if (!dumpedStatistics) {
136 ASSERT_NOT_REACHED();
137 return;
138 }
139 completionHandler(WTFMove(*dumpedStatistics));
140}
141
142void DumpResourceLoadStatistics::cancelReply(CompletionHandler<void(String&&)>&& completionHandler)
143{
144 completionHandler({ });
145}
146
147void DumpResourceLoadStatistics::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection, const String& dumpedStatistics)
148{
149 *encoder << dumpedStatistics;
150 connection.sendSyncReply(WTFMove(encoder));
151}
152
153#endif
154
155#if ENABLE(RESOURCE_LOAD_STATISTICS)
156
157void UpdatePrevalentDomainsToBlockCookiesFor::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
158{
159 completionHandler();
160}
161
162void UpdatePrevalentDomainsToBlockCookiesFor::cancelReply(CompletionHandler<void()>&& completionHandler)
163{
164 completionHandler();
165}
166
167void UpdatePrevalentDomainsToBlockCookiesFor::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
168{
169 connection.sendSyncReply(WTFMove(encoder));
170}
171
172#endif
173
174#if ENABLE(RESOURCE_LOAD_STATISTICS)
175
176void IsGrandfathered::callReply(IPC::Decoder& decoder, CompletionHandler<void(bool&&)>&& completionHandler)
177{
178 Optional<bool> isGrandfathered;
179 decoder >> isGrandfathered;
180 if (!isGrandfathered) {
181 ASSERT_NOT_REACHED();
182 return;
183 }
184 completionHandler(WTFMove(*isGrandfathered));
185}
186
187void IsGrandfathered::cancelReply(CompletionHandler<void(bool&&)>&& completionHandler)
188{
189 completionHandler({ });
190}
191
192void IsGrandfathered::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection, bool isGrandfathered)
193{
194 *encoder << isGrandfathered;
195 connection.sendSyncReply(WTFMove(encoder));
196}
197
198#endif
199
200#if ENABLE(RESOURCE_LOAD_STATISTICS)
201
202void IsPrevalentResource::callReply(IPC::Decoder& decoder, CompletionHandler<void(bool&&)>&& completionHandler)
203{
204 Optional<bool> isPrevalent;
205 decoder >> isPrevalent;
206 if (!isPrevalent) {
207 ASSERT_NOT_REACHED();
208 return;
209 }
210 completionHandler(WTFMove(*isPrevalent));
211}
212
213void IsPrevalentResource::cancelReply(CompletionHandler<void(bool&&)>&& completionHandler)
214{
215 completionHandler({ });
216}
217
218void IsPrevalentResource::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection, bool isPrevalent)
219{
220 *encoder << isPrevalent;
221 connection.sendSyncReply(WTFMove(encoder));
222}
223
224#endif
225
226#if ENABLE(RESOURCE_LOAD_STATISTICS)
227
228void IsVeryPrevalentResource::callReply(IPC::Decoder& decoder, CompletionHandler<void(bool&&)>&& completionHandler)
229{
230 Optional<bool> isVeryPrevalent;
231 decoder >> isVeryPrevalent;
232 if (!isVeryPrevalent) {
233 ASSERT_NOT_REACHED();
234 return;
235 }
236 completionHandler(WTFMove(*isVeryPrevalent));
237}
238
239void IsVeryPrevalentResource::cancelReply(CompletionHandler<void(bool&&)>&& completionHandler)
240{
241 completionHandler({ });
242}
243
244void IsVeryPrevalentResource::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection, bool isVeryPrevalent)
245{
246 *encoder << isVeryPrevalent;
247 connection.sendSyncReply(WTFMove(encoder));
248}
249
250#endif
251
252#if ENABLE(RESOURCE_LOAD_STATISTICS)
253
254void SetAgeCapForClientSideCookies::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
255{
256 completionHandler();
257}
258
259void SetAgeCapForClientSideCookies::cancelReply(CompletionHandler<void()>&& completionHandler)
260{
261 completionHandler();
262}
263
264void SetAgeCapForClientSideCookies::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
265{
266 connection.sendSyncReply(WTFMove(encoder));
267}
268
269#endif
270
271#if ENABLE(RESOURCE_LOAD_STATISTICS)
272
273void SetLastSeen::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
274{
275 completionHandler();
276}
277
278void SetLastSeen::cancelReply(CompletionHandler<void()>&& completionHandler)
279{
280 completionHandler();
281}
282
283void SetLastSeen::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
284{
285 connection.sendSyncReply(WTFMove(encoder));
286}
287
288#endif
289
290#if ENABLE(RESOURCE_LOAD_STATISTICS)
291
292void SetPrevalentResource::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
293{
294 completionHandler();
295}
296
297void SetPrevalentResource::cancelReply(CompletionHandler<void()>&& completionHandler)
298{
299 completionHandler();
300}
301
302void SetPrevalentResource::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
303{
304 connection.sendSyncReply(WTFMove(encoder));
305}
306
307#endif
308
309#if ENABLE(RESOURCE_LOAD_STATISTICS)
310
311void SetPrevalentResourceForDebugMode::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
312{
313 completionHandler();
314}
315
316void SetPrevalentResourceForDebugMode::cancelReply(CompletionHandler<void()>&& completionHandler)
317{
318 completionHandler();
319}
320
321void SetPrevalentResourceForDebugMode::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
322{
323 connection.sendSyncReply(WTFMove(encoder));
324}
325
326#endif
327
328#if ENABLE(RESOURCE_LOAD_STATISTICS)
329
330void HadUserInteraction::callReply(IPC::Decoder& decoder, CompletionHandler<void(bool&&)>&& completionHandler)
331{
332 Optional<bool> hadUserInteraction;
333 decoder >> hadUserInteraction;
334 if (!hadUserInteraction) {
335 ASSERT_NOT_REACHED();
336 return;
337 }
338 completionHandler(WTFMove(*hadUserInteraction));
339}
340
341void HadUserInteraction::cancelReply(CompletionHandler<void(bool&&)>&& completionHandler)
342{
343 completionHandler({ });
344}
345
346void HadUserInteraction::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection, bool hadUserInteraction)
347{
348 *encoder << hadUserInteraction;
349 connection.sendSyncReply(WTFMove(encoder));
350}
351
352#endif
353
354#if ENABLE(RESOURCE_LOAD_STATISTICS)
355
356void GetAllStorageAccessEntries::callReply(IPC::Decoder& decoder, CompletionHandler<void(Vector<String>&&)>&& completionHandler)
357{
358 Optional<Vector<String>> domains;
359 decoder >> domains;
360 if (!domains) {
361 ASSERT_NOT_REACHED();
362 return;
363 }
364 completionHandler(WTFMove(*domains));
365}
366
367void GetAllStorageAccessEntries::cancelReply(CompletionHandler<void(Vector<String>&&)>&& completionHandler)
368{
369 completionHandler({ });
370}
371
372void GetAllStorageAccessEntries::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection, const Vector<String>& domains)
373{
374 *encoder << domains;
375 connection.sendSyncReply(WTFMove(encoder));
376}
377
378#endif
379
380#if ENABLE(RESOURCE_LOAD_STATISTICS)
381
382void IsRegisteredAsRedirectingTo::callReply(IPC::Decoder& decoder, CompletionHandler<void(bool&&)>&& completionHandler)
383{
384 Optional<bool> isRedirectingTo;
385 decoder >> isRedirectingTo;
386 if (!isRedirectingTo) {
387 ASSERT_NOT_REACHED();
388 return;
389 }
390 completionHandler(WTFMove(*isRedirectingTo));
391}
392
393void IsRegisteredAsRedirectingTo::cancelReply(CompletionHandler<void(bool&&)>&& completionHandler)
394{
395 completionHandler({ });
396}
397
398void IsRegisteredAsRedirectingTo::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection, bool isRedirectingTo)
399{
400 *encoder << isRedirectingTo;
401 connection.sendSyncReply(WTFMove(encoder));
402}
403
404#endif
405
406#if ENABLE(RESOURCE_LOAD_STATISTICS)
407
408void IsRegisteredAsSubFrameUnder::callReply(IPC::Decoder& decoder, CompletionHandler<void(bool&&)>&& completionHandler)
409{
410 Optional<bool> isSubframeUnder;
411 decoder >> isSubframeUnder;
412 if (!isSubframeUnder) {
413 ASSERT_NOT_REACHED();
414 return;
415 }
416 completionHandler(WTFMove(*isSubframeUnder));
417}
418
419void IsRegisteredAsSubFrameUnder::cancelReply(CompletionHandler<void(bool&&)>&& completionHandler)
420{
421 completionHandler({ });
422}
423
424void IsRegisteredAsSubFrameUnder::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection, bool isSubframeUnder)
425{
426 *encoder << isSubframeUnder;
427 connection.sendSyncReply(WTFMove(encoder));
428}
429
430#endif
431
432#if ENABLE(RESOURCE_LOAD_STATISTICS)
433
434void IsRegisteredAsSubresourceUnder::callReply(IPC::Decoder& decoder, CompletionHandler<void(bool&&)>&& completionHandler)
435{
436 Optional<bool> isSubresourceUnder;
437 decoder >> isSubresourceUnder;
438 if (!isSubresourceUnder) {
439 ASSERT_NOT_REACHED();
440 return;
441 }
442 completionHandler(WTFMove(*isSubresourceUnder));
443}
444
445void IsRegisteredAsSubresourceUnder::cancelReply(CompletionHandler<void(bool&&)>&& completionHandler)
446{
447 completionHandler({ });
448}
449
450void IsRegisteredAsSubresourceUnder::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection, bool isSubresourceUnder)
451{
452 *encoder << isSubresourceUnder;
453 connection.sendSyncReply(WTFMove(encoder));
454}
455
456#endif
457
458#if ENABLE(RESOURCE_LOAD_STATISTICS)
459
460void LogUserInteraction::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
461{
462 completionHandler();
463}
464
465void LogUserInteraction::cancelReply(CompletionHandler<void()>&& completionHandler)
466{
467 completionHandler();
468}
469
470void LogUserInteraction::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
471{
472 connection.sendSyncReply(WTFMove(encoder));
473}
474
475#endif
476
477#if ENABLE(RESOURCE_LOAD_STATISTICS)
478
479void ResetParametersToDefaultValues::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
480{
481 completionHandler();
482}
483
484void ResetParametersToDefaultValues::cancelReply(CompletionHandler<void()>&& completionHandler)
485{
486 completionHandler();
487}
488
489void ResetParametersToDefaultValues::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
490{
491 connection.sendSyncReply(WTFMove(encoder));
492}
493
494#endif
495
496#if ENABLE(RESOURCE_LOAD_STATISTICS)
497
498void ScheduleClearInMemoryAndPersistent::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
499{
500 completionHandler();
501}
502
503void ScheduleClearInMemoryAndPersistent::cancelReply(CompletionHandler<void()>&& completionHandler)
504{
505 completionHandler();
506}
507
508void ScheduleClearInMemoryAndPersistent::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
509{
510 connection.sendSyncReply(WTFMove(encoder));
511}
512
513#endif
514
515#if ENABLE(RESOURCE_LOAD_STATISTICS)
516
517void ScheduleCookieBlockingUpdate::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
518{
519 completionHandler();
520}
521
522void ScheduleCookieBlockingUpdate::cancelReply(CompletionHandler<void()>&& completionHandler)
523{
524 completionHandler();
525}
526
527void ScheduleCookieBlockingUpdate::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
528{
529 connection.sendSyncReply(WTFMove(encoder));
530}
531
532#endif
533
534#if ENABLE(RESOURCE_LOAD_STATISTICS)
535
536void ScheduleStatisticsAndDataRecordsProcessing::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
537{
538 completionHandler();
539}
540
541void ScheduleStatisticsAndDataRecordsProcessing::cancelReply(CompletionHandler<void()>&& completionHandler)
542{
543 completionHandler();
544}
545
546void ScheduleStatisticsAndDataRecordsProcessing::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
547{
548 connection.sendSyncReply(WTFMove(encoder));
549}
550
551#endif
552
553#if ENABLE(RESOURCE_LOAD_STATISTICS)
554
555void SubmitTelemetry::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
556{
557 completionHandler();
558}
559
560void SubmitTelemetry::cancelReply(CompletionHandler<void()>&& completionHandler)
561{
562 completionHandler();
563}
564
565void SubmitTelemetry::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
566{
567 connection.sendSyncReply(WTFMove(encoder));
568}
569
570#endif
571
572#if ENABLE(RESOURCE_LOAD_STATISTICS)
573
574void SetCacheMaxAgeCapForPrevalentResources::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
575{
576 completionHandler();
577}
578
579void SetCacheMaxAgeCapForPrevalentResources::cancelReply(CompletionHandler<void()>&& completionHandler)
580{
581 completionHandler();
582}
583
584void SetCacheMaxAgeCapForPrevalentResources::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
585{
586 connection.sendSyncReply(WTFMove(encoder));
587}
588
589#endif
590
591#if ENABLE(RESOURCE_LOAD_STATISTICS)
592
593void SetGrandfathered::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
594{
595 completionHandler();
596}
597
598void SetGrandfathered::cancelReply(CompletionHandler<void()>&& completionHandler)
599{
600 completionHandler();
601}
602
603void SetGrandfathered::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
604{
605 connection.sendSyncReply(WTFMove(encoder));
606}
607
608#endif
609
610#if ENABLE(RESOURCE_LOAD_STATISTICS)
611
612void SetGrandfatheringTime::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
613{
614 completionHandler();
615}
616
617void SetGrandfatheringTime::cancelReply(CompletionHandler<void()>&& completionHandler)
618{
619 completionHandler();
620}
621
622void SetGrandfatheringTime::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
623{
624 connection.sendSyncReply(WTFMove(encoder));
625}
626
627#endif
628
629#if ENABLE(RESOURCE_LOAD_STATISTICS)
630
631void SetMaxStatisticsEntries::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
632{
633 completionHandler();
634}
635
636void SetMaxStatisticsEntries::cancelReply(CompletionHandler<void()>&& completionHandler)
637{
638 completionHandler();
639}
640
641void SetMaxStatisticsEntries::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
642{
643 connection.sendSyncReply(WTFMove(encoder));
644}
645
646#endif
647
648#if ENABLE(RESOURCE_LOAD_STATISTICS)
649
650void SetMinimumTimeBetweenDataRecordsRemoval::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
651{
652 completionHandler();
653}
654
655void SetMinimumTimeBetweenDataRecordsRemoval::cancelReply(CompletionHandler<void()>&& completionHandler)
656{
657 completionHandler();
658}
659
660void SetMinimumTimeBetweenDataRecordsRemoval::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
661{
662 connection.sendSyncReply(WTFMove(encoder));
663}
664
665#endif
666
667#if ENABLE(RESOURCE_LOAD_STATISTICS)
668
669void SetPruneEntriesDownTo::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
670{
671 completionHandler();
672}
673
674void SetPruneEntriesDownTo::cancelReply(CompletionHandler<void()>&& completionHandler)
675{
676 completionHandler();
677}
678
679void SetPruneEntriesDownTo::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
680{
681 connection.sendSyncReply(WTFMove(encoder));
682}
683
684#endif
685
686#if ENABLE(RESOURCE_LOAD_STATISTICS)
687
688void SetShouldClassifyResourcesBeforeDataRecordsRemoval::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
689{
690 completionHandler();
691}
692
693void SetShouldClassifyResourcesBeforeDataRecordsRemoval::cancelReply(CompletionHandler<void()>&& completionHandler)
694{
695 completionHandler();
696}
697
698void SetShouldClassifyResourcesBeforeDataRecordsRemoval::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
699{
700 connection.sendSyncReply(WTFMove(encoder));
701}
702
703#endif
704
705#if ENABLE(RESOURCE_LOAD_STATISTICS)
706
707void SetNotifyPagesWhenDataRecordsWereScanned::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
708{
709 completionHandler();
710}
711
712void SetNotifyPagesWhenDataRecordsWereScanned::cancelReply(CompletionHandler<void()>&& completionHandler)
713{
714 completionHandler();
715}
716
717void SetNotifyPagesWhenDataRecordsWereScanned::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
718{
719 connection.sendSyncReply(WTFMove(encoder));
720}
721
722#endif
723
724#if ENABLE(RESOURCE_LOAD_STATISTICS)
725
726void SetIsRunningResourceLoadStatisticsTest::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
727{
728 completionHandler();
729}
730
731void SetIsRunningResourceLoadStatisticsTest::cancelReply(CompletionHandler<void()>&& completionHandler)
732{
733 completionHandler();
734}
735
736void SetIsRunningResourceLoadStatisticsTest::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
737{
738 connection.sendSyncReply(WTFMove(encoder));
739}
740
741#endif
742
743#if ENABLE(RESOURCE_LOAD_STATISTICS)
744
745void SetNotifyPagesWhenTelemetryWasCaptured::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
746{
747 completionHandler();
748}
749
750void SetNotifyPagesWhenTelemetryWasCaptured::cancelReply(CompletionHandler<void()>&& completionHandler)
751{
752 completionHandler();
753}
754
755void SetNotifyPagesWhenTelemetryWasCaptured::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
756{
757 connection.sendSyncReply(WTFMove(encoder));
758}
759
760#endif
761
762#if ENABLE(RESOURCE_LOAD_STATISTICS)
763
764void SetResourceLoadStatisticsDebugMode::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
765{
766 completionHandler();
767}
768
769void SetResourceLoadStatisticsDebugMode::cancelReply(CompletionHandler<void()>&& completionHandler)
770{
771 completionHandler();
772}
773
774void SetResourceLoadStatisticsDebugMode::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
775{
776 connection.sendSyncReply(WTFMove(encoder));
777}
778
779#endif
780
781#if ENABLE(RESOURCE_LOAD_STATISTICS)
782
783void SetVeryPrevalentResource::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
784{
785 completionHandler();
786}
787
788void SetVeryPrevalentResource::cancelReply(CompletionHandler<void()>&& completionHandler)
789{
790 completionHandler();
791}
792
793void SetVeryPrevalentResource::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
794{
795 connection.sendSyncReply(WTFMove(encoder));
796}
797
798#endif
799
800#if ENABLE(RESOURCE_LOAD_STATISTICS)
801
802void SetSubframeUnderTopFrameDomain::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
803{
804 completionHandler();
805}
806
807void SetSubframeUnderTopFrameDomain::cancelReply(CompletionHandler<void()>&& completionHandler)
808{
809 completionHandler();
810}
811
812void SetSubframeUnderTopFrameDomain::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
813{
814 connection.sendSyncReply(WTFMove(encoder));
815}
816
817#endif
818
819#if ENABLE(RESOURCE_LOAD_STATISTICS)
820
821void SetSubresourceUnderTopFrameDomain::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
822{
823 completionHandler();
824}
825
826void SetSubresourceUnderTopFrameDomain::cancelReply(CompletionHandler<void()>&& completionHandler)
827{
828 completionHandler();
829}
830
831void SetSubresourceUnderTopFrameDomain::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
832{
833 connection.sendSyncReply(WTFMove(encoder));
834}
835
836#endif
837
838#if ENABLE(RESOURCE_LOAD_STATISTICS)
839
840void SetSubresourceUniqueRedirectTo::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
841{
842 completionHandler();
843}
844
845void SetSubresourceUniqueRedirectTo::cancelReply(CompletionHandler<void()>&& completionHandler)
846{
847 completionHandler();
848}
849
850void SetSubresourceUniqueRedirectTo::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
851{
852 connection.sendSyncReply(WTFMove(encoder));
853}
854
855#endif
856
857#if ENABLE(RESOURCE_LOAD_STATISTICS)
858
859void SetSubresourceUniqueRedirectFrom::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
860{
861 completionHandler();
862}
863
864void SetSubresourceUniqueRedirectFrom::cancelReply(CompletionHandler<void()>&& completionHandler)
865{
866 completionHandler();
867}
868
869void SetSubresourceUniqueRedirectFrom::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
870{
871 connection.sendSyncReply(WTFMove(encoder));
872}
873
874#endif
875
876#if ENABLE(RESOURCE_LOAD_STATISTICS)
877
878void SetTimeToLiveUserInteraction::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
879{
880 completionHandler();
881}
882
883void SetTimeToLiveUserInteraction::cancelReply(CompletionHandler<void()>&& completionHandler)
884{
885 completionHandler();
886}
887
888void SetTimeToLiveUserInteraction::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
889{
890 connection.sendSyncReply(WTFMove(encoder));
891}
892
893#endif
894
895#if ENABLE(RESOURCE_LOAD_STATISTICS)
896
897void SetTopFrameUniqueRedirectTo::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
898{
899 completionHandler();
900}
901
902void SetTopFrameUniqueRedirectTo::cancelReply(CompletionHandler<void()>&& completionHandler)
903{
904 completionHandler();
905}
906
907void SetTopFrameUniqueRedirectTo::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
908{
909 connection.sendSyncReply(WTFMove(encoder));
910}
911
912#endif
913
914#if ENABLE(RESOURCE_LOAD_STATISTICS)
915
916void SetTopFrameUniqueRedirectFrom::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
917{
918 completionHandler();
919}
920
921void SetTopFrameUniqueRedirectFrom::cancelReply(CompletionHandler<void()>&& completionHandler)
922{
923 completionHandler();
924}
925
926void SetTopFrameUniqueRedirectFrom::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
927{
928 connection.sendSyncReply(WTFMove(encoder));
929}
930
931#endif
932
933#if ENABLE(RESOURCE_LOAD_STATISTICS)
934
935void ResetCacheMaxAgeCapForPrevalentResources::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
936{
937 completionHandler();
938}
939
940void ResetCacheMaxAgeCapForPrevalentResources::cancelReply(CompletionHandler<void()>&& completionHandler)
941{
942 completionHandler();
943}
944
945void ResetCacheMaxAgeCapForPrevalentResources::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
946{
947 connection.sendSyncReply(WTFMove(encoder));
948}
949
950#endif
951
952#if ENABLE(RESOURCE_LOAD_STATISTICS)
953
954void CommittedCrossSiteLoadWithLinkDecoration::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
955{
956 completionHandler();
957}
958
959void CommittedCrossSiteLoadWithLinkDecoration::cancelReply(CompletionHandler<void()>&& completionHandler)
960{
961 completionHandler();
962}
963
964void CommittedCrossSiteLoadWithLinkDecoration::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
965{
966 connection.sendSyncReply(WTFMove(encoder));
967}
968
969#endif
970
971#if ENABLE(RESOURCE_LOAD_STATISTICS)
972
973void SetCrossSiteLoadWithLinkDecorationForTesting::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
974{
975 completionHandler();
976}
977
978void SetCrossSiteLoadWithLinkDecorationForTesting::cancelReply(CompletionHandler<void()>&& completionHandler)
979{
980 completionHandler();
981}
982
983void SetCrossSiteLoadWithLinkDecorationForTesting::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
984{
985 connection.sendSyncReply(WTFMove(encoder));
986}
987
988#endif
989
990#if ENABLE(RESOURCE_LOAD_STATISTICS)
991
992void ResetCrossSiteLoadsWithLinkDecorationForTesting::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
993{
994 completionHandler();
995}
996
997void ResetCrossSiteLoadsWithLinkDecorationForTesting::cancelReply(CompletionHandler<void()>&& completionHandler)
998{
999 completionHandler();
1000}
1001
1002void ResetCrossSiteLoadsWithLinkDecorationForTesting::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
1003{
1004 connection.sendSyncReply(WTFMove(encoder));
1005}
1006
1007#endif
1008
1009#if ENABLE(RESOURCE_LOAD_STATISTICS)
1010
1011void DeleteCookiesForTesting::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
1012{
1013 completionHandler();
1014}
1015
1016void DeleteCookiesForTesting::cancelReply(CompletionHandler<void()>&& completionHandler)
1017{
1018 completionHandler();
1019}
1020
1021void DeleteCookiesForTesting::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
1022{
1023 connection.sendSyncReply(WTFMove(encoder));
1024}
1025
1026#endif
1027
1028void DumpAdClickAttribution::callReply(IPC::Decoder& decoder, CompletionHandler<void(String&&)>&& completionHandler)
1029{
1030 Optional<String> adClickAttributionState;
1031 decoder >> adClickAttributionState;
1032 if (!adClickAttributionState) {
1033 ASSERT_NOT_REACHED();
1034 return;
1035 }
1036 completionHandler(WTFMove(*adClickAttributionState));
1037}
1038
1039void DumpAdClickAttribution::cancelReply(CompletionHandler<void(String&&)>&& completionHandler)
1040{
1041 completionHandler({ });
1042}
1043
1044void DumpAdClickAttribution::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection, const String& adClickAttributionState)
1045{
1046 *encoder << adClickAttributionState;
1047 connection.sendSyncReply(WTFMove(encoder));
1048}
1049
1050void ClearAdClickAttribution::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
1051{
1052 completionHandler();
1053}
1054
1055void ClearAdClickAttribution::cancelReply(CompletionHandler<void()>&& completionHandler)
1056{
1057 completionHandler();
1058}
1059
1060void ClearAdClickAttribution::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
1061{
1062 connection.sendSyncReply(WTFMove(encoder));
1063}
1064
1065void SetAdClickAttributionOverrideTimerForTesting::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
1066{
1067 completionHandler();
1068}
1069
1070void SetAdClickAttributionOverrideTimerForTesting::cancelReply(CompletionHandler<void()>&& completionHandler)
1071{
1072 completionHandler();
1073}
1074
1075void SetAdClickAttributionOverrideTimerForTesting::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
1076{
1077 connection.sendSyncReply(WTFMove(encoder));
1078}
1079
1080void SetAdClickAttributionConversionURLForTesting::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
1081{
1082 completionHandler();
1083}
1084
1085void SetAdClickAttributionConversionURLForTesting::cancelReply(CompletionHandler<void()>&& completionHandler)
1086{
1087 completionHandler();
1088}
1089
1090void SetAdClickAttributionConversionURLForTesting::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
1091{
1092 connection.sendSyncReply(WTFMove(encoder));
1093}
1094
1095void MarkAdClickAttributionsAsExpiredForTesting::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
1096{
1097 completionHandler();
1098}
1099
1100void MarkAdClickAttributionsAsExpiredForTesting::cancelReply(CompletionHandler<void()>&& completionHandler)
1101{
1102 completionHandler();
1103}
1104
1105void MarkAdClickAttributionsAsExpiredForTesting::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
1106{
1107 connection.sendSyncReply(WTFMove(encoder));
1108}
1109
1110void OriginsWithPersistentCredentials::callReply(IPC::Decoder& decoder, CompletionHandler<void(Vector<WebCore::SecurityOriginData>&&)>&& completionHandler)
1111{
1112 Optional<Vector<WebCore::SecurityOriginData>> origins;
1113 decoder >> origins;
1114 if (!origins) {
1115 ASSERT_NOT_REACHED();
1116 return;
1117 }
1118 completionHandler(WTFMove(*origins));
1119}
1120
1121void OriginsWithPersistentCredentials::cancelReply(CompletionHandler<void(Vector<WebCore::SecurityOriginData>&&)>&& completionHandler)
1122{
1123 completionHandler({ });
1124}
1125
1126void OriginsWithPersistentCredentials::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection, const Vector<WebCore::SecurityOriginData>& origins)
1127{
1128 *encoder << origins;
1129 connection.sendSyncReply(WTFMove(encoder));
1130}
1131
1132void RemoveCredentialsWithOrigins::callReply(IPC::Decoder& decoder, CompletionHandler<void()>&& completionHandler)
1133{
1134 completionHandler();
1135}
1136
1137void RemoveCredentialsWithOrigins::cancelReply(CompletionHandler<void()>&& completionHandler)
1138{
1139 completionHandler();
1140}
1141
1142void RemoveCredentialsWithOrigins::send(std::unique_ptr<IPC::Encoder>&& encoder, IPC::Connection& connection)
1143{
1144 connection.sendSyncReply(WTFMove(encoder));
1145}
1146
1147} // namespace NetworkProcess
1148
1149} // namespace Messages
1150
1151namespace WebKit {
1152
1153void NetworkProcess::didReceiveNetworkProcessMessage(IPC::Connection& connection, IPC::Decoder& decoder)
1154{
1155 if (decoder.messageName() == Messages::NetworkProcess::InitializeNetworkProcess::name()) {
1156 IPC::handleMessage<Messages::NetworkProcess::InitializeNetworkProcess>(decoder, this, &NetworkProcess::initializeNetworkProcess);
1157 return;
1158 }
1159 if (decoder.messageName() == Messages::NetworkProcess::CreateNetworkConnectionToWebProcess::name()) {
1160 IPC::handleMessage<Messages::NetworkProcess::CreateNetworkConnectionToWebProcess>(decoder, this, &NetworkProcess::createNetworkConnectionToWebProcess);
1161 return;
1162 }
1163#if USE(SOUP)
1164 if (decoder.messageName() == Messages::NetworkProcess::SetIgnoreTLSErrors::name()) {
1165 IPC::handleMessage<Messages::NetworkProcess::SetIgnoreTLSErrors>(decoder, this, &NetworkProcess::setIgnoreTLSErrors);
1166 return;
1167 }
1168#endif
1169#if USE(SOUP)
1170 if (decoder.messageName() == Messages::NetworkProcess::UserPreferredLanguagesChanged::name()) {
1171 IPC::handleMessage<Messages::NetworkProcess::UserPreferredLanguagesChanged>(decoder, this, &NetworkProcess::userPreferredLanguagesChanged);
1172 return;
1173 }
1174#endif
1175#if USE(SOUP)
1176 if (decoder.messageName() == Messages::NetworkProcess::SetNetworkProxySettings::name()) {
1177 IPC::handleMessage<Messages::NetworkProcess::SetNetworkProxySettings>(decoder, this, &NetworkProcess::setNetworkProxySettings);
1178 return;
1179 }
1180#endif
1181#if USE(CURL)
1182 if (decoder.messageName() == Messages::NetworkProcess::SetNetworkProxySettings::name()) {
1183 IPC::handleMessage<Messages::NetworkProcess::SetNetworkProxySettings>(decoder, this, &NetworkProcess::setNetworkProxySettings);
1184 return;
1185 }
1186#endif
1187 if (decoder.messageName() == Messages::NetworkProcess::ClearCachedCredentials::name()) {
1188 IPC::handleMessage<Messages::NetworkProcess::ClearCachedCredentials>(decoder, this, &NetworkProcess::clearCachedCredentials);
1189 return;
1190 }
1191 if (decoder.messageName() == Messages::NetworkProcess::AddWebsiteDataStore::name()) {
1192 IPC::handleMessage<Messages::NetworkProcess::AddWebsiteDataStore>(decoder, this, &NetworkProcess::addWebsiteDataStore);
1193 return;
1194 }
1195 if (decoder.messageName() == Messages::NetworkProcess::DestroySession::name()) {
1196 IPC::handleMessage<Messages::NetworkProcess::DestroySession>(decoder, this, &NetworkProcess::destroySession);
1197 return;
1198 }
1199 if (decoder.messageName() == Messages::NetworkProcess::FetchWebsiteData::name()) {
1200 IPC::handleMessage<Messages::NetworkProcess::FetchWebsiteData>(decoder, this, &NetworkProcess::fetchWebsiteData);
1201 return;
1202 }
1203 if (decoder.messageName() == Messages::NetworkProcess::DeleteWebsiteData::name()) {
1204 IPC::handleMessage<Messages::NetworkProcess::DeleteWebsiteData>(decoder, this, &NetworkProcess::deleteWebsiteData);
1205 return;
1206 }
1207 if (decoder.messageName() == Messages::NetworkProcess::DeleteWebsiteDataForOrigins::name()) {
1208 IPC::handleMessage<Messages::NetworkProcess::DeleteWebsiteDataForOrigins>(decoder, this, &NetworkProcess::deleteWebsiteDataForOrigins);
1209 return;
1210 }
1211 if (decoder.messageName() == Messages::NetworkProcess::DownloadRequest::name()) {
1212 IPC::handleMessage<Messages::NetworkProcess::DownloadRequest>(decoder, this, &NetworkProcess::downloadRequest);
1213 return;
1214 }
1215 if (decoder.messageName() == Messages::NetworkProcess::ResumeDownload::name()) {
1216 IPC::handleMessage<Messages::NetworkProcess::ResumeDownload>(decoder, this, &NetworkProcess::resumeDownload);
1217 return;
1218 }
1219 if (decoder.messageName() == Messages::NetworkProcess::CancelDownload::name()) {
1220 IPC::handleMessage<Messages::NetworkProcess::CancelDownload>(decoder, this, &NetworkProcess::cancelDownload);
1221 return;
1222 }
1223#if PLATFORM(COCOA)
1224 if (decoder.messageName() == Messages::NetworkProcess::PublishDownloadProgress::name()) {
1225 IPC::handleMessage<Messages::NetworkProcess::PublishDownloadProgress>(decoder, this, &NetworkProcess::publishDownloadProgress);
1226 return;
1227 }
1228#endif
1229 if (decoder.messageName() == Messages::NetworkProcess::ApplicationDidEnterBackground::name()) {
1230 IPC::handleMessage<Messages::NetworkProcess::ApplicationDidEnterBackground>(decoder, this, &NetworkProcess::applicationDidEnterBackground);
1231 return;
1232 }
1233 if (decoder.messageName() == Messages::NetworkProcess::ApplicationWillEnterForeground::name()) {
1234 IPC::handleMessage<Messages::NetworkProcess::ApplicationWillEnterForeground>(decoder, this, &NetworkProcess::applicationWillEnterForeground);
1235 return;
1236 }
1237 if (decoder.messageName() == Messages::NetworkProcess::ContinueWillSendRequest::name()) {
1238 IPC::handleMessage<Messages::NetworkProcess::ContinueWillSendRequest>(decoder, this, &NetworkProcess::continueWillSendRequest);
1239 return;
1240 }
1241 if (decoder.messageName() == Messages::NetworkProcess::ContinueDecidePendingDownloadDestination::name()) {
1242 IPC::handleMessage<Messages::NetworkProcess::ContinueDecidePendingDownloadDestination>(decoder, this, &NetworkProcess::continueDecidePendingDownloadDestination);
1243 return;
1244 }
1245#if PLATFORM(COCOA)
1246 if (decoder.messageName() == Messages::NetworkProcess::SetQOS::name()) {
1247 IPC::handleMessage<Messages::NetworkProcess::SetQOS>(decoder, this, &NetworkProcess::setQOS);
1248 return;
1249 }
1250#endif
1251#if PLATFORM(COCOA)
1252 if (decoder.messageName() == Messages::NetworkProcess::SetStorageAccessAPIEnabled::name()) {
1253 IPC::handleMessage<Messages::NetworkProcess::SetStorageAccessAPIEnabled>(decoder, this, &NetworkProcess::setStorageAccessAPIEnabled);
1254 return;
1255 }
1256#endif
1257 if (decoder.messageName() == Messages::NetworkProcess::SyncAllCookies::name()) {
1258 IPC::handleMessage<Messages::NetworkProcess::SyncAllCookies>(decoder, this, &NetworkProcess::syncAllCookies);
1259 return;
1260 }
1261 if (decoder.messageName() == Messages::NetworkProcess::AllowSpecificHTTPSCertificateForHost::name()) {
1262 IPC::handleMessage<Messages::NetworkProcess::AllowSpecificHTTPSCertificateForHost>(decoder, this, &NetworkProcess::allowSpecificHTTPSCertificateForHost);
1263 return;
1264 }
1265 if (decoder.messageName() == Messages::NetworkProcess::SetCanHandleHTTPSServerTrustEvaluation::name()) {
1266 IPC::handleMessage<Messages::NetworkProcess::SetCanHandleHTTPSServerTrustEvaluation>(decoder, this, &NetworkProcess::setCanHandleHTTPSServerTrustEvaluation);
1267 return;
1268 }
1269 if (decoder.messageName() == Messages::NetworkProcess::GetNetworkProcessStatistics::name()) {
1270 IPC::handleMessage<Messages::NetworkProcess::GetNetworkProcessStatistics>(decoder, this, &NetworkProcess::getNetworkProcessStatistics);
1271 return;
1272 }
1273 if (decoder.messageName() == Messages::NetworkProcess::ClearCacheForAllOrigins::name()) {
1274 IPC::handleMessage<Messages::NetworkProcess::ClearCacheForAllOrigins>(decoder, this, &NetworkProcess::clearCacheForAllOrigins);
1275 return;
1276 }
1277 if (decoder.messageName() == Messages::NetworkProcess::SetCacheModel::name()) {
1278 IPC::handleMessage<Messages::NetworkProcess::SetCacheModel>(decoder, this, &NetworkProcess::setCacheModel);
1279 return;
1280 }
1281 if (decoder.messageName() == Messages::NetworkProcess::ProcessDidTransitionToBackground::name()) {
1282 IPC::handleMessage<Messages::NetworkProcess::ProcessDidTransitionToBackground>(decoder, this, &NetworkProcess::processDidTransitionToBackground);
1283 return;
1284 }
1285 if (decoder.messageName() == Messages::NetworkProcess::ProcessDidTransitionToForeground::name()) {
1286 IPC::handleMessage<Messages::NetworkProcess::ProcessDidTransitionToForeground>(decoder, this, &NetworkProcess::processDidTransitionToForeground);
1287 return;
1288 }
1289 if (decoder.messageName() == Messages::NetworkProcess::ProcessWillSuspendImminently::name()) {
1290 IPC::handleMessage<Messages::NetworkProcess::ProcessWillSuspendImminently>(decoder, this, &NetworkProcess::processWillSuspendImminently);
1291 return;
1292 }
1293 if (decoder.messageName() == Messages::NetworkProcess::PrepareToSuspend::name()) {
1294 IPC::handleMessage<Messages::NetworkProcess::PrepareToSuspend>(decoder, this, &NetworkProcess::prepareToSuspend);
1295 return;
1296 }
1297 if (decoder.messageName() == Messages::NetworkProcess::CancelPrepareToSuspend::name()) {
1298 IPC::handleMessage<Messages::NetworkProcess::CancelPrepareToSuspend>(decoder, this, &NetworkProcess::cancelPrepareToSuspend);
1299 return;
1300 }
1301 if (decoder.messageName() == Messages::NetworkProcess::ProcessDidResume::name()) {
1302 IPC::handleMessage<Messages::NetworkProcess::ProcessDidResume>(decoder, this, &NetworkProcess::processDidResume);
1303 return;
1304 }
1305 if (decoder.messageName() == Messages::NetworkProcess::PreconnectTo::name()) {
1306 IPC::handleMessage<Messages::NetworkProcess::PreconnectTo>(decoder, this, &NetworkProcess::preconnectTo);
1307 return;
1308 }
1309#if ENABLE(RESOURCE_LOAD_STATISTICS)
1310 if (decoder.messageName() == Messages::NetworkProcess::ClearPrevalentResource::name()) {
1311 IPC::handleMessageAsync<Messages::NetworkProcess::ClearPrevalentResource>(connection, decoder, this, &NetworkProcess::clearPrevalentResource);
1312 return;
1313 }
1314#endif
1315#if ENABLE(RESOURCE_LOAD_STATISTICS)
1316 if (decoder.messageName() == Messages::NetworkProcess::ClearUserInteraction::name()) {
1317 IPC::handleMessageAsync<Messages::NetworkProcess::ClearUserInteraction>(connection, decoder, this, &NetworkProcess::clearUserInteraction);
1318 return;
1319 }
1320#endif
1321#if ENABLE(RESOURCE_LOAD_STATISTICS)
1322 if (decoder.messageName() == Messages::NetworkProcess::DumpResourceLoadStatistics::name()) {
1323 IPC::handleMessageAsync<Messages::NetworkProcess::DumpResourceLoadStatistics>(connection, decoder, this, &NetworkProcess::dumpResourceLoadStatistics);
1324 return;
1325 }
1326#endif
1327#if ENABLE(RESOURCE_LOAD_STATISTICS)
1328 if (decoder.messageName() == Messages::NetworkProcess::SetResourceLoadStatisticsEnabled::name()) {
1329 IPC::handleMessage<Messages::NetworkProcess::SetResourceLoadStatisticsEnabled>(decoder, this, &NetworkProcess::setResourceLoadStatisticsEnabled);
1330 return;
1331 }
1332#endif
1333#if ENABLE(RESOURCE_LOAD_STATISTICS)
1334 if (decoder.messageName() == Messages::NetworkProcess::UpdatePrevalentDomainsToBlockCookiesFor::name()) {
1335 IPC::handleMessageAsync<Messages::NetworkProcess::UpdatePrevalentDomainsToBlockCookiesFor>(connection, decoder, this, &NetworkProcess::updatePrevalentDomainsToBlockCookiesFor);
1336 return;
1337 }
1338#endif
1339#if ENABLE(RESOURCE_LOAD_STATISTICS)
1340 if (decoder.messageName() == Messages::NetworkProcess::IsGrandfathered::name()) {
1341 IPC::handleMessageAsync<Messages::NetworkProcess::IsGrandfathered>(connection, decoder, this, &NetworkProcess::isGrandfathered);
1342 return;
1343 }
1344#endif
1345#if ENABLE(RESOURCE_LOAD_STATISTICS)
1346 if (decoder.messageName() == Messages::NetworkProcess::IsPrevalentResource::name()) {
1347 IPC::handleMessageAsync<Messages::NetworkProcess::IsPrevalentResource>(connection, decoder, this, &NetworkProcess::isPrevalentResource);
1348 return;
1349 }
1350#endif
1351#if ENABLE(RESOURCE_LOAD_STATISTICS)
1352 if (decoder.messageName() == Messages::NetworkProcess::IsVeryPrevalentResource::name()) {
1353 IPC::handleMessageAsync<Messages::NetworkProcess::IsVeryPrevalentResource>(connection, decoder, this, &NetworkProcess::isVeryPrevalentResource);
1354 return;
1355 }
1356#endif
1357#if ENABLE(RESOURCE_LOAD_STATISTICS)
1358 if (decoder.messageName() == Messages::NetworkProcess::SetAgeCapForClientSideCookies::name()) {
1359 IPC::handleMessageAsync<Messages::NetworkProcess::SetAgeCapForClientSideCookies>(connection, decoder, this, &NetworkProcess::setAgeCapForClientSideCookies);
1360 return;
1361 }
1362#endif
1363#if ENABLE(RESOURCE_LOAD_STATISTICS)
1364 if (decoder.messageName() == Messages::NetworkProcess::SetLastSeen::name()) {
1365 IPC::handleMessageAsync<Messages::NetworkProcess::SetLastSeen>(connection, decoder, this, &NetworkProcess::setLastSeen);
1366 return;
1367 }
1368#endif
1369#if ENABLE(RESOURCE_LOAD_STATISTICS)
1370 if (decoder.messageName() == Messages::NetworkProcess::SetPrevalentResource::name()) {
1371 IPC::handleMessageAsync<Messages::NetworkProcess::SetPrevalentResource>(connection, decoder, this, &NetworkProcess::setPrevalentResource);
1372 return;
1373 }
1374#endif
1375#if ENABLE(RESOURCE_LOAD_STATISTICS)
1376 if (decoder.messageName() == Messages::NetworkProcess::SetPrevalentResourceForDebugMode::name()) {
1377 IPC::handleMessageAsync<Messages::NetworkProcess::SetPrevalentResourceForDebugMode>(connection, decoder, this, &NetworkProcess::setPrevalentResourceForDebugMode);
1378 return;
1379 }
1380#endif
1381#if ENABLE(RESOURCE_LOAD_STATISTICS)
1382 if (decoder.messageName() == Messages::NetworkProcess::HadUserInteraction::name()) {
1383 IPC::handleMessageAsync<Messages::NetworkProcess::HadUserInteraction>(connection, decoder, this, &NetworkProcess::hadUserInteraction);
1384 return;
1385 }
1386#endif
1387#if ENABLE(RESOURCE_LOAD_STATISTICS)
1388 if (decoder.messageName() == Messages::NetworkProcess::GetAllStorageAccessEntries::name()) {
1389 IPC::handleMessageAsync<Messages::NetworkProcess::GetAllStorageAccessEntries>(connection, decoder, this, &NetworkProcess::getAllStorageAccessEntries);
1390 return;
1391 }
1392#endif
1393#if ENABLE(RESOURCE_LOAD_STATISTICS)
1394 if (decoder.messageName() == Messages::NetworkProcess::IsRegisteredAsRedirectingTo::name()) {
1395 IPC::handleMessageAsync<Messages::NetworkProcess::IsRegisteredAsRedirectingTo>(connection, decoder, this, &NetworkProcess::isRegisteredAsRedirectingTo);
1396 return;
1397 }
1398#endif
1399#if ENABLE(RESOURCE_LOAD_STATISTICS)
1400 if (decoder.messageName() == Messages::NetworkProcess::IsRegisteredAsSubFrameUnder::name()) {
1401 IPC::handleMessageAsync<Messages::NetworkProcess::IsRegisteredAsSubFrameUnder>(connection, decoder, this, &NetworkProcess::isRegisteredAsSubFrameUnder);
1402 return;
1403 }
1404#endif
1405#if ENABLE(RESOURCE_LOAD_STATISTICS)
1406 if (decoder.messageName() == Messages::NetworkProcess::IsRegisteredAsSubresourceUnder::name()) {
1407 IPC::handleMessageAsync<Messages::NetworkProcess::IsRegisteredAsSubresourceUnder>(connection, decoder, this, &NetworkProcess::isRegisteredAsSubresourceUnder);
1408 return;
1409 }
1410#endif
1411#if ENABLE(RESOURCE_LOAD_STATISTICS)
1412 if (decoder.messageName() == Messages::NetworkProcess::LogFrameNavigation::name()) {
1413 IPC::handleMessage<Messages::NetworkProcess::LogFrameNavigation>(decoder, this, &NetworkProcess::logFrameNavigation);
1414 return;
1415 }
1416#endif
1417#if ENABLE(RESOURCE_LOAD_STATISTICS)
1418 if (decoder.messageName() == Messages::NetworkProcess::LogUserInteraction::name()) {
1419 IPC::handleMessageAsync<Messages::NetworkProcess::LogUserInteraction>(connection, decoder, this, &NetworkProcess::logUserInteraction);
1420 return;
1421 }
1422#endif
1423#if ENABLE(RESOURCE_LOAD_STATISTICS)
1424 if (decoder.messageName() == Messages::NetworkProcess::RemovePrevalentDomains::name()) {
1425 IPC::handleMessage<Messages::NetworkProcess::RemovePrevalentDomains>(decoder, this, &NetworkProcess::removePrevalentDomains);
1426 return;
1427 }
1428#endif
1429#if ENABLE(RESOURCE_LOAD_STATISTICS)
1430 if (decoder.messageName() == Messages::NetworkProcess::ResetParametersToDefaultValues::name()) {
1431 IPC::handleMessageAsync<Messages::NetworkProcess::ResetParametersToDefaultValues>(connection, decoder, this, &NetworkProcess::resetParametersToDefaultValues);
1432 return;
1433 }
1434#endif
1435#if ENABLE(RESOURCE_LOAD_STATISTICS)
1436 if (decoder.messageName() == Messages::NetworkProcess::ScheduleClearInMemoryAndPersistent::name()) {
1437 IPC::handleMessageAsync<Messages::NetworkProcess::ScheduleClearInMemoryAndPersistent>(connection, decoder, this, &NetworkProcess::scheduleClearInMemoryAndPersistent);
1438 return;
1439 }
1440#endif
1441#if ENABLE(RESOURCE_LOAD_STATISTICS)
1442 if (decoder.messageName() == Messages::NetworkProcess::ScheduleCookieBlockingUpdate::name()) {
1443 IPC::handleMessageAsync<Messages::NetworkProcess::ScheduleCookieBlockingUpdate>(connection, decoder, this, &NetworkProcess::scheduleCookieBlockingUpdate);
1444 return;
1445 }
1446#endif
1447#if ENABLE(RESOURCE_LOAD_STATISTICS)
1448 if (decoder.messageName() == Messages::NetworkProcess::ScheduleStatisticsAndDataRecordsProcessing::name()) {
1449 IPC::handleMessageAsync<Messages::NetworkProcess::ScheduleStatisticsAndDataRecordsProcessing>(connection, decoder, this, &NetworkProcess::scheduleStatisticsAndDataRecordsProcessing);
1450 return;
1451 }
1452#endif
1453#if ENABLE(RESOURCE_LOAD_STATISTICS)
1454 if (decoder.messageName() == Messages::NetworkProcess::SubmitTelemetry::name()) {
1455 IPC::handleMessageAsync<Messages::NetworkProcess::SubmitTelemetry>(connection, decoder, this, &NetworkProcess::submitTelemetry);
1456 return;
1457 }
1458#endif
1459#if ENABLE(RESOURCE_LOAD_STATISTICS)
1460 if (decoder.messageName() == Messages::NetworkProcess::SetCacheMaxAgeCapForPrevalentResources::name()) {
1461 IPC::handleMessageAsync<Messages::NetworkProcess::SetCacheMaxAgeCapForPrevalentResources>(connection, decoder, this, &NetworkProcess::setCacheMaxAgeCapForPrevalentResources);
1462 return;
1463 }
1464#endif
1465#if ENABLE(RESOURCE_LOAD_STATISTICS)
1466 if (decoder.messageName() == Messages::NetworkProcess::SetGrandfathered::name()) {
1467 IPC::handleMessageAsync<Messages::NetworkProcess::SetGrandfathered>(connection, decoder, this, &NetworkProcess::setGrandfathered);
1468 return;
1469 }
1470#endif
1471#if ENABLE(RESOURCE_LOAD_STATISTICS)
1472 if (decoder.messageName() == Messages::NetworkProcess::SetGrandfatheringTime::name()) {
1473 IPC::handleMessageAsync<Messages::NetworkProcess::SetGrandfatheringTime>(connection, decoder, this, &NetworkProcess::setGrandfatheringTime);
1474 return;
1475 }
1476#endif
1477#if ENABLE(RESOURCE_LOAD_STATISTICS)
1478 if (decoder.messageName() == Messages::NetworkProcess::SetMaxStatisticsEntries::name()) {
1479 IPC::handleMessageAsync<Messages::NetworkProcess::SetMaxStatisticsEntries>(connection, decoder, this, &NetworkProcess::setMaxStatisticsEntries);
1480 return;
1481 }
1482#endif
1483#if ENABLE(RESOURCE_LOAD_STATISTICS)
1484 if (decoder.messageName() == Messages::NetworkProcess::SetMinimumTimeBetweenDataRecordsRemoval::name()) {
1485 IPC::handleMessageAsync<Messages::NetworkProcess::SetMinimumTimeBetweenDataRecordsRemoval>(connection, decoder, this, &NetworkProcess::setMinimumTimeBetweenDataRecordsRemoval);
1486 return;
1487 }
1488#endif
1489#if ENABLE(RESOURCE_LOAD_STATISTICS)
1490 if (decoder.messageName() == Messages::NetworkProcess::SetPruneEntriesDownTo::name()) {
1491 IPC::handleMessageAsync<Messages::NetworkProcess::SetPruneEntriesDownTo>(connection, decoder, this, &NetworkProcess::setPruneEntriesDownTo);
1492 return;
1493 }
1494#endif
1495#if ENABLE(RESOURCE_LOAD_STATISTICS)
1496 if (decoder.messageName() == Messages::NetworkProcess::SetShouldClassifyResourcesBeforeDataRecordsRemoval::name()) {
1497 IPC::handleMessageAsync<Messages::NetworkProcess::SetShouldClassifyResourcesBeforeDataRecordsRemoval>(connection, decoder, this, &NetworkProcess::setShouldClassifyResourcesBeforeDataRecordsRemoval);
1498 return;
1499 }
1500#endif
1501#if ENABLE(RESOURCE_LOAD_STATISTICS)
1502 if (decoder.messageName() == Messages::NetworkProcess::SetNotifyPagesWhenDataRecordsWereScanned::name()) {
1503 IPC::handleMessageAsync<Messages::NetworkProcess::SetNotifyPagesWhenDataRecordsWereScanned>(connection, decoder, this, &NetworkProcess::setNotifyPagesWhenDataRecordsWereScanned);
1504 return;
1505 }
1506#endif
1507#if ENABLE(RESOURCE_LOAD_STATISTICS)
1508 if (decoder.messageName() == Messages::NetworkProcess::SetIsRunningResourceLoadStatisticsTest::name()) {
1509 IPC::handleMessageAsync<Messages::NetworkProcess::SetIsRunningResourceLoadStatisticsTest>(connection, decoder, this, &NetworkProcess::setIsRunningResourceLoadStatisticsTest);
1510 return;
1511 }
1512#endif
1513#if ENABLE(RESOURCE_LOAD_STATISTICS)
1514 if (decoder.messageName() == Messages::NetworkProcess::SetNotifyPagesWhenTelemetryWasCaptured::name()) {
1515 IPC::handleMessageAsync<Messages::NetworkProcess::SetNotifyPagesWhenTelemetryWasCaptured>(connection, decoder, this, &NetworkProcess::setNotifyPagesWhenTelemetryWasCaptured);
1516 return;
1517 }
1518#endif
1519#if ENABLE(RESOURCE_LOAD_STATISTICS)
1520 if (decoder.messageName() == Messages::NetworkProcess::SetResourceLoadStatisticsDebugMode::name()) {
1521 IPC::handleMessageAsync<Messages::NetworkProcess::SetResourceLoadStatisticsDebugMode>(connection, decoder, this, &NetworkProcess::setResourceLoadStatisticsDebugMode);
1522 return;
1523 }
1524#endif
1525#if ENABLE(RESOURCE_LOAD_STATISTICS)
1526 if (decoder.messageName() == Messages::NetworkProcess::SetVeryPrevalentResource::name()) {
1527 IPC::handleMessageAsync<Messages::NetworkProcess::SetVeryPrevalentResource>(connection, decoder, this, &NetworkProcess::setVeryPrevalentResource);
1528 return;
1529 }
1530#endif
1531#if ENABLE(RESOURCE_LOAD_STATISTICS)
1532 if (decoder.messageName() == Messages::NetworkProcess::SetSubframeUnderTopFrameDomain::name()) {
1533 IPC::handleMessageAsync<Messages::NetworkProcess::SetSubframeUnderTopFrameDomain>(connection, decoder, this, &NetworkProcess::setSubframeUnderTopFrameDomain);
1534 return;
1535 }
1536#endif
1537#if ENABLE(RESOURCE_LOAD_STATISTICS)
1538 if (decoder.messageName() == Messages::NetworkProcess::SetSubresourceUnderTopFrameDomain::name()) {
1539 IPC::handleMessageAsync<Messages::NetworkProcess::SetSubresourceUnderTopFrameDomain>(connection, decoder, this, &NetworkProcess::setSubresourceUnderTopFrameDomain);
1540 return;
1541 }
1542#endif
1543#if ENABLE(RESOURCE_LOAD_STATISTICS)
1544 if (decoder.messageName() == Messages::NetworkProcess::SetSubresourceUniqueRedirectTo::name()) {
1545 IPC::handleMessageAsync<Messages::NetworkProcess::SetSubresourceUniqueRedirectTo>(connection, decoder, this, &NetworkProcess::setSubresourceUniqueRedirectTo);
1546 return;
1547 }
1548#endif
1549#if ENABLE(RESOURCE_LOAD_STATISTICS)
1550 if (decoder.messageName() == Messages::NetworkProcess::SetSubresourceUniqueRedirectFrom::name()) {
1551 IPC::handleMessageAsync<Messages::NetworkProcess::SetSubresourceUniqueRedirectFrom>(connection, decoder, this, &NetworkProcess::setSubresourceUniqueRedirectFrom);
1552 return;
1553 }
1554#endif
1555#if ENABLE(RESOURCE_LOAD_STATISTICS)
1556 if (decoder.messageName() == Messages::NetworkProcess::SetTimeToLiveUserInteraction::name()) {
1557 IPC::handleMessageAsync<Messages::NetworkProcess::SetTimeToLiveUserInteraction>(connection, decoder, this, &NetworkProcess::setTimeToLiveUserInteraction);
1558 return;
1559 }
1560#endif
1561#if ENABLE(RESOURCE_LOAD_STATISTICS)
1562 if (decoder.messageName() == Messages::NetworkProcess::SetTopFrameUniqueRedirectTo::name()) {
1563 IPC::handleMessageAsync<Messages::NetworkProcess::SetTopFrameUniqueRedirectTo>(connection, decoder, this, &NetworkProcess::setTopFrameUniqueRedirectTo);
1564 return;
1565 }
1566#endif
1567#if ENABLE(RESOURCE_LOAD_STATISTICS)
1568 if (decoder.messageName() == Messages::NetworkProcess::SetTopFrameUniqueRedirectFrom::name()) {
1569 IPC::handleMessageAsync<Messages::NetworkProcess::SetTopFrameUniqueRedirectFrom>(connection, decoder, this, &NetworkProcess::setTopFrameUniqueRedirectFrom);
1570 return;
1571 }
1572#endif
1573#if ENABLE(RESOURCE_LOAD_STATISTICS)
1574 if (decoder.messageName() == Messages::NetworkProcess::ResetCacheMaxAgeCapForPrevalentResources::name()) {
1575 IPC::handleMessageAsync<Messages::NetworkProcess::ResetCacheMaxAgeCapForPrevalentResources>(connection, decoder, this, &NetworkProcess::resetCacheMaxAgeCapForPrevalentResources);
1576 return;
1577 }
1578#endif
1579#if ENABLE(RESOURCE_LOAD_STATISTICS)
1580 if (decoder.messageName() == Messages::NetworkProcess::CommittedCrossSiteLoadWithLinkDecoration::name()) {
1581 IPC::handleMessageAsync<Messages::NetworkProcess::CommittedCrossSiteLoadWithLinkDecoration>(connection, decoder, this, &NetworkProcess::committedCrossSiteLoadWithLinkDecoration);
1582 return;
1583 }
1584#endif
1585#if ENABLE(RESOURCE_LOAD_STATISTICS)
1586 if (decoder.messageName() == Messages::NetworkProcess::SetCrossSiteLoadWithLinkDecorationForTesting::name()) {
1587 IPC::handleMessageAsync<Messages::NetworkProcess::SetCrossSiteLoadWithLinkDecorationForTesting>(connection, decoder, this, &NetworkProcess::setCrossSiteLoadWithLinkDecorationForTesting);
1588 return;
1589 }
1590#endif
1591#if ENABLE(RESOURCE_LOAD_STATISTICS)
1592 if (decoder.messageName() == Messages::NetworkProcess::ResetCrossSiteLoadsWithLinkDecorationForTesting::name()) {
1593 IPC::handleMessageAsync<Messages::NetworkProcess::ResetCrossSiteLoadsWithLinkDecorationForTesting>(connection, decoder, this, &NetworkProcess::resetCrossSiteLoadsWithLinkDecorationForTesting);
1594 return;
1595 }
1596#endif
1597#if ENABLE(RESOURCE_LOAD_STATISTICS)
1598 if (decoder.messageName() == Messages::NetworkProcess::DeleteCookiesForTesting::name()) {
1599 IPC::handleMessageAsync<Messages::NetworkProcess::DeleteCookiesForTesting>(connection, decoder, this, &NetworkProcess::deleteCookiesForTesting);
1600 return;
1601 }
1602#endif
1603 if (decoder.messageName() == Messages::NetworkProcess::SetSessionIsControlledByAutomation::name()) {
1604 IPC::handleMessage<Messages::NetworkProcess::SetSessionIsControlledByAutomation>(decoder, this, &NetworkProcess::setSessionIsControlledByAutomation);
1605 return;
1606 }
1607 if (decoder.messageName() == Messages::NetworkProcess::RegisterURLSchemeAsSecure::name()) {
1608 IPC::handleMessage<Messages::NetworkProcess::RegisterURLSchemeAsSecure>(decoder, this, &NetworkProcess::registerURLSchemeAsSecure);
1609 return;
1610 }
1611 if (decoder.messageName() == Messages::NetworkProcess::RegisterURLSchemeAsBypassingContentSecurityPolicy::name()) {
1612 IPC::handleMessage<Messages::NetworkProcess::RegisterURLSchemeAsBypassingContentSecurityPolicy>(decoder, this, &NetworkProcess::registerURLSchemeAsBypassingContentSecurityPolicy);
1613 return;
1614 }
1615 if (decoder.messageName() == Messages::NetworkProcess::RegisterURLSchemeAsLocal::name()) {
1616 IPC::handleMessage<Messages::NetworkProcess::RegisterURLSchemeAsLocal>(decoder, this, &NetworkProcess::registerURLSchemeAsLocal);
1617 return;
1618 }
1619 if (decoder.messageName() == Messages::NetworkProcess::RegisterURLSchemeAsNoAccess::name()) {
1620 IPC::handleMessage<Messages::NetworkProcess::RegisterURLSchemeAsNoAccess>(decoder, this, &NetworkProcess::registerURLSchemeAsNoAccess);
1621 return;
1622 }
1623 if (decoder.messageName() == Messages::NetworkProcess::RegisterURLSchemeAsDisplayIsolated::name()) {
1624 IPC::handleMessage<Messages::NetworkProcess::RegisterURLSchemeAsDisplayIsolated>(decoder, this, &NetworkProcess::registerURLSchemeAsDisplayIsolated);
1625 return;
1626 }
1627 if (decoder.messageName() == Messages::NetworkProcess::RegisterURLSchemeAsCORSEnabled::name()) {
1628 IPC::handleMessage<Messages::NetworkProcess::RegisterURLSchemeAsCORSEnabled>(decoder, this, &NetworkProcess::registerURLSchemeAsCORSEnabled);
1629 return;
1630 }
1631 if (decoder.messageName() == Messages::NetworkProcess::RegisterURLSchemeAsCanDisplayOnlyIfCanRequest::name()) {
1632 IPC::handleMessage<Messages::NetworkProcess::RegisterURLSchemeAsCanDisplayOnlyIfCanRequest>(decoder, this, &NetworkProcess::registerURLSchemeAsCanDisplayOnlyIfCanRequest);
1633 return;
1634 }
1635 if (decoder.messageName() == Messages::NetworkProcess::SetCacheStorageParameters::name()) {
1636 IPC::handleMessage<Messages::NetworkProcess::SetCacheStorageParameters>(decoder, this, &NetworkProcess::setCacheStorageParameters);
1637 return;
1638 }
1639#if ENABLE(SERVICE_WORKER)
1640 if (decoder.messageName() == Messages::NetworkProcess::PostMessageToServiceWorkerClient::name()) {
1641 IPC::handleMessage<Messages::NetworkProcess::PostMessageToServiceWorkerClient>(decoder, this, &NetworkProcess::postMessageToServiceWorkerClient);
1642 return;
1643 }
1644#endif
1645#if ENABLE(SERVICE_WORKER)
1646 if (decoder.messageName() == Messages::NetworkProcess::PostMessageToServiceWorker::name()) {
1647 IPC::handleMessage<Messages::NetworkProcess::PostMessageToServiceWorker>(decoder, this, &NetworkProcess::postMessageToServiceWorker);
1648 return;
1649 }
1650#endif
1651#if ENABLE(SERVICE_WORKER)
1652 if (decoder.messageName() == Messages::NetworkProcess::DisableServiceWorkerProcessTerminationDelay::name()) {
1653 IPC::handleMessage<Messages::NetworkProcess::DisableServiceWorkerProcessTerminationDelay>(decoder, this, &NetworkProcess::disableServiceWorkerProcessTerminationDelay);
1654 return;
1655 }
1656#endif
1657#if ENABLE(INDEXED_DATABASE)
1658 if (decoder.messageName() == Messages::NetworkProcess::SetIDBPerOriginQuota::name()) {
1659 IPC::handleMessage<Messages::NetworkProcess::SetIDBPerOriginQuota>(decoder, this, &NetworkProcess::setIDBPerOriginQuota);
1660 return;
1661 }
1662#endif
1663 if (decoder.messageName() == Messages::NetworkProcess::UpdateQuotaBasedOnSpaceUsageForTesting::name()) {
1664 IPC::handleMessage<Messages::NetworkProcess::UpdateQuotaBasedOnSpaceUsageForTesting>(decoder, this, &NetworkProcess::updateQuotaBasedOnSpaceUsageForTesting);
1665 return;
1666 }
1667 if (decoder.messageName() == Messages::NetworkProcess::StoreAdClickAttribution::name()) {
1668 IPC::handleMessage<Messages::NetworkProcess::StoreAdClickAttribution>(decoder, this, &NetworkProcess::storeAdClickAttribution);
1669 return;
1670 }
1671 if (decoder.messageName() == Messages::NetworkProcess::DumpAdClickAttribution::name()) {
1672 IPC::handleMessageAsync<Messages::NetworkProcess::DumpAdClickAttribution>(connection, decoder, this, &NetworkProcess::dumpAdClickAttribution);
1673 return;
1674 }
1675 if (decoder.messageName() == Messages::NetworkProcess::ClearAdClickAttribution::name()) {
1676 IPC::handleMessageAsync<Messages::NetworkProcess::ClearAdClickAttribution>(connection, decoder, this, &NetworkProcess::clearAdClickAttribution);
1677 return;
1678 }
1679 if (decoder.messageName() == Messages::NetworkProcess::SetAdClickAttributionOverrideTimerForTesting::name()) {
1680 IPC::handleMessageAsync<Messages::NetworkProcess::SetAdClickAttributionOverrideTimerForTesting>(connection, decoder, this, &NetworkProcess::setAdClickAttributionOverrideTimerForTesting);
1681 return;
1682 }
1683 if (decoder.messageName() == Messages::NetworkProcess::SetAdClickAttributionConversionURLForTesting::name()) {
1684 IPC::handleMessageAsync<Messages::NetworkProcess::SetAdClickAttributionConversionURLForTesting>(connection, decoder, this, &NetworkProcess::setAdClickAttributionConversionURLForTesting);
1685 return;
1686 }
1687 if (decoder.messageName() == Messages::NetworkProcess::MarkAdClickAttributionsAsExpiredForTesting::name()) {
1688 IPC::handleMessageAsync<Messages::NetworkProcess::MarkAdClickAttributionsAsExpiredForTesting>(connection, decoder, this, &NetworkProcess::markAdClickAttributionsAsExpiredForTesting);
1689 return;
1690 }
1691 if (decoder.messageName() == Messages::NetworkProcess::OriginsWithPersistentCredentials::name()) {
1692 IPC::handleMessageAsync<Messages::NetworkProcess::OriginsWithPersistentCredentials>(connection, decoder, this, &NetworkProcess::originsWithPersistentCredentials);
1693 return;
1694 }
1695 if (decoder.messageName() == Messages::NetworkProcess::RemoveCredentialsWithOrigins::name()) {
1696 IPC::handleMessageAsync<Messages::NetworkProcess::RemoveCredentialsWithOrigins>(connection, decoder, this, &NetworkProcess::removeCredentialsWithOrigins);
1697 return;
1698 }
1699 UNUSED_PARAM(connection);
1700 UNUSED_PARAM(decoder);
1701 ASSERT_NOT_REACHED();
1702}
1703
1704void NetworkProcess::didReceiveSyncNetworkProcessMessage(IPC::Connection& connection, IPC::Decoder& decoder, std::unique_ptr<IPC::Encoder>& replyEncoder)
1705{
1706 if (decoder.messageName() == Messages::NetworkProcess::SetAllowsAnySSLCertificateForWebSocket::name()) {
1707 IPC::handleMessageSynchronous<Messages::NetworkProcess::SetAllowsAnySSLCertificateForWebSocket>(connection, decoder, replyEncoder, this, &NetworkProcess::setAllowsAnySSLCertificateForWebSocket);
1708 return;
1709 }
1710 UNUSED_PARAM(connection);
1711 UNUSED_PARAM(decoder);
1712 UNUSED_PARAM(replyEncoder);
1713 ASSERT_NOT_REACHED();
1714}
1715
1716} // namespace WebKit
1717
1718