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 "EditorState.h"
30#if PLATFORM(COCOA)
31#include "LayerHostingContext.h"
32#endif
33#include "SandboxExtension.h"
34#include "ShareableBitmap.h"
35#include "SharedMemory.h"
36#include "WebPageCreationParameters.h"
37#include "WebPopupItem.h"
38#include "WebSpeechSynthesisVoice.h"
39#include "WebsitePoliciesData.h"
40#include <WebCore/ActivityState.h>
41#include <WebCore/ApplicationManifest.h>
42#include <WebCore/AutoplayEvent.h>
43#include <WebCore/BackForwardItemIdentifier.h>
44#include <WebCore/Color.h>
45#include <WebCore/DiagnosticLoggingClient.h>
46#include <WebCore/FloatPoint.h>
47#include <WebCore/FloatQuad.h>
48#include <WebCore/FrameLoaderTypes.h>
49#include <WebCore/IntRect.h>
50#include <WebCore/LayoutMilestone.h>
51#include <WebCore/PageIdentifier.h>
52#include <WebCore/RectEdges.h>
53#include <WebCore/SearchPopupMenu.h>
54#include <WebCore/SerializedAttachmentData.h>
55#include <WebCore/TextCheckerClient.h>
56#include <WebCore/TextChecking.h>
57#include <WebCore/TextIndicator.h>
58#include <utility>
59#include <wtf/Forward.h>
60#include <wtf/MachSendRight.h>
61#include <wtf/OptionSet.h>
62#include <wtf/Optional.h>
63#include <wtf/ThreadSafeRefCounted.h>
64#include <wtf/Vector.h>
65#include <wtf/text/WTFString.h>
66
67namespace IPC {
68class SharedBufferDataReference;
69class DataReference;
70class FormDataReference;
71}
72
73namespace Inspector {
74enum class InspectorTargetType : uint8_t;
75}
76
77namespace WebCore {
78class FloatRect;
79class TextCheckingRequestData;
80struct FontAttributes;
81class Color;
82class ResourceResponse;
83struct WindowFeatures;
84struct ShareDataWithParsedURL;
85enum class NotificationDirection : uint8_t;
86struct Highlight;
87struct SecurityOriginData;
88struct DataListSuggestionInformation;
89struct GlobalWindowIdentifier;
90class PolicyCheckIdentifier;
91class ContentFilterUnblockHandler;
92class IntRect;
93class IntPoint;
94enum class ShouldSample : bool;
95class Cursor;
96enum class AutoplayEvent : uint8_t;
97struct LinkIcon;
98class ResourceError;
99enum class RouteSharingPolicy : uint8_t;
100enum class InputMode : uint8_t;
101struct GrammarDetail;
102enum class LockBackForwardList : bool;
103struct ExceptionDetails;
104struct DictionaryPopupInfo;
105class IntSize;
106enum class DeviceOrientationOrMotionPermissionState : uint8_t;
107class FloatPoint;
108struct FileChooserSettings;
109class ResourceRequest;
110struct MediaStreamRequest;
111enum class PolicyAction : uint8_t;
112struct TextIndicatorData;
113enum class WillContinueLoading : bool;
114class CertificateInfo;
115struct DragItem;
116class MediaSessionMetadata;
117struct ViewportAttributes;
118enum class DOMPasteAccessResponse : uint8_t;
119struct BackForwardItemIdentifier;
120enum class HasInsecureContent : bool;
121enum class DragHandlingMethod : uint8_t;
122struct ContentRuleListResults;
123}
124
125namespace WebKit {
126struct InteractionInformationAtPosition;
127struct WebNavigationDataStore;
128struct FocusedElementInformation;
129class QuickLookDocumentData;
130struct WebHitTestResultData;
131struct AttributedString;
132class CallbackID;
133class ContextMenuContextData;
134struct PlatformPopupMenuData;
135struct DataDetectionResult;
136struct WebSelectionData;
137enum class UndoOrRedo : bool;
138struct NavigationActionData;
139struct FrameInfoData;
140class TouchBarMenuData;
141struct BackForwardListItemState;
142struct URLSchemeTaskParameters;
143class UserData;
144struct WebAutocorrectionContext;
145struct EditorState;
146struct TouchBarMenuItemData;
147struct PDFContextMenu;
148struct EditingRange;
149class DownloadID;
150}
151
152namespace Messages {
153namespace WebPageProxy {
154
155static inline IPC::StringReference messageReceiverName()
156{
157 return IPC::StringReference("WebPageProxy");
158}
159
160class CreateNewPage {
161public:
162 typedef std::tuple<const WebKit::FrameInfoData&, const Optional<WebCore::PageIdentifier>&, const WebCore::ResourceRequest&, const WebCore::WindowFeatures&, const WebKit::NavigationActionData&> Arguments;
163
164 static IPC::StringReference receiverName() { return messageReceiverName(); }
165 static IPC::StringReference name() { return IPC::StringReference("CreateNewPage"); }
166 static const bool isSync = true;
167
168 using DelayedReply = CompletionHandler<void(const Optional<WebCore::PageIdentifier>& newPageID, const Optional<WebKit::WebPageCreationParameters>& newPageParameters)>;
169 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const Optional<WebCore::PageIdentifier>& newPageID, const Optional<WebKit::WebPageCreationParameters>& newPageParameters);
170 using Reply = std::tuple<Optional<WebCore::PageIdentifier>&, Optional<WebKit::WebPageCreationParameters>&>;
171 using ReplyArguments = std::tuple<Optional<WebCore::PageIdentifier>, Optional<WebKit::WebPageCreationParameters>>;
172 CreateNewPage(const WebKit::FrameInfoData& originatingFrameInfoData, const Optional<WebCore::PageIdentifier>& originatingPageID, const WebCore::ResourceRequest& request, const WebCore::WindowFeatures& windowFeatures, const WebKit::NavigationActionData& navigationActionData)
173 : m_arguments(originatingFrameInfoData, originatingPageID, request, windowFeatures, navigationActionData)
174 {
175 }
176
177 const Arguments& arguments() const
178 {
179 return m_arguments;
180 }
181
182private:
183 Arguments m_arguments;
184};
185
186class ShowPage {
187public:
188 typedef std::tuple<> Arguments;
189
190 static IPC::StringReference receiverName() { return messageReceiverName(); }
191 static IPC::StringReference name() { return IPC::StringReference("ShowPage"); }
192 static const bool isSync = false;
193
194 const Arguments& arguments() const
195 {
196 return m_arguments;
197 }
198
199private:
200 Arguments m_arguments;
201};
202
203class ClosePage {
204public:
205 typedef std::tuple<bool> Arguments;
206
207 static IPC::StringReference receiverName() { return messageReceiverName(); }
208 static IPC::StringReference name() { return IPC::StringReference("ClosePage"); }
209 static const bool isSync = false;
210
211 explicit ClosePage(bool stopResponsivenessTimer)
212 : m_arguments(stopResponsivenessTimer)
213 {
214 }
215
216 const Arguments& arguments() const
217 {
218 return m_arguments;
219 }
220
221private:
222 Arguments m_arguments;
223};
224
225class RunJavaScriptAlert {
226public:
227 typedef std::tuple<uint64_t, const WebCore::SecurityOriginData&, const String&> Arguments;
228
229 static IPC::StringReference receiverName() { return messageReceiverName(); }
230 static IPC::StringReference name() { return IPC::StringReference("RunJavaScriptAlert"); }
231 static const bool isSync = true;
232
233 using DelayedReply = CompletionHandler<void()>;
234 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
235 using Reply = std::tuple<>;
236 using ReplyArguments = std::tuple<>;
237 RunJavaScriptAlert(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, const String& message)
238 : m_arguments(frameID, frameSecurityOrigin, message)
239 {
240 }
241
242 const Arguments& arguments() const
243 {
244 return m_arguments;
245 }
246
247private:
248 Arguments m_arguments;
249};
250
251class RunJavaScriptConfirm {
252public:
253 typedef std::tuple<uint64_t, const WebCore::SecurityOriginData&, const String&> Arguments;
254
255 static IPC::StringReference receiverName() { return messageReceiverName(); }
256 static IPC::StringReference name() { return IPC::StringReference("RunJavaScriptConfirm"); }
257 static const bool isSync = true;
258
259 using DelayedReply = CompletionHandler<void(bool result)>;
260 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool result);
261 using Reply = std::tuple<bool&>;
262 using ReplyArguments = std::tuple<bool>;
263 RunJavaScriptConfirm(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, const String& message)
264 : m_arguments(frameID, frameSecurityOrigin, message)
265 {
266 }
267
268 const Arguments& arguments() const
269 {
270 return m_arguments;
271 }
272
273private:
274 Arguments m_arguments;
275};
276
277class RunJavaScriptPrompt {
278public:
279 typedef std::tuple<uint64_t, const WebCore::SecurityOriginData&, const String&, const String&> Arguments;
280
281 static IPC::StringReference receiverName() { return messageReceiverName(); }
282 static IPC::StringReference name() { return IPC::StringReference("RunJavaScriptPrompt"); }
283 static const bool isSync = true;
284
285 using DelayedReply = CompletionHandler<void(const String& result)>;
286 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const String& result);
287 using Reply = std::tuple<String&>;
288 using ReplyArguments = std::tuple<String>;
289 RunJavaScriptPrompt(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, const String& message, const String& defaultValue)
290 : m_arguments(frameID, frameSecurityOrigin, message, defaultValue)
291 {
292 }
293
294 const Arguments& arguments() const
295 {
296 return m_arguments;
297 }
298
299private:
300 Arguments m_arguments;
301};
302
303class MouseDidMoveOverElement {
304public:
305 typedef std::tuple<const WebKit::WebHitTestResultData&, uint32_t, const WebKit::UserData&> Arguments;
306
307 static IPC::StringReference receiverName() { return messageReceiverName(); }
308 static IPC::StringReference name() { return IPC::StringReference("MouseDidMoveOverElement"); }
309 static const bool isSync = false;
310
311 MouseDidMoveOverElement(const WebKit::WebHitTestResultData& hitTestResultData, uint32_t modifiers, const WebKit::UserData& userData)
312 : m_arguments(hitTestResultData, modifiers, userData)
313 {
314 }
315
316 const Arguments& arguments() const
317 {
318 return m_arguments;
319 }
320
321private:
322 Arguments m_arguments;
323};
324
325#if ENABLE(NETSCAPE_PLUGIN_API)
326class UnavailablePluginButtonClicked {
327public:
328 typedef std::tuple<uint32_t, const String&, const String&, const String&, const String&, const String&> Arguments;
329
330 static IPC::StringReference receiverName() { return messageReceiverName(); }
331 static IPC::StringReference name() { return IPC::StringReference("UnavailablePluginButtonClicked"); }
332 static const bool isSync = false;
333
334 UnavailablePluginButtonClicked(uint32_t pluginUnavailabilityReason, const String& mimeType, const String& pluginURLString, const String& pluginspageAttributeURLString, const String& frameURLString, const String& pageURLString)
335 : m_arguments(pluginUnavailabilityReason, mimeType, pluginURLString, pluginspageAttributeURLString, frameURLString, pageURLString)
336 {
337 }
338
339 const Arguments& arguments() const
340 {
341 return m_arguments;
342 }
343
344private:
345 Arguments m_arguments;
346};
347#endif
348
349#if ENABLE(WEBGL)
350class WebGLPolicyForURL {
351public:
352 typedef std::tuple<const URL&> Arguments;
353
354 static IPC::StringReference receiverName() { return messageReceiverName(); }
355 static IPC::StringReference name() { return IPC::StringReference("WebGLPolicyForURL"); }
356 static const bool isSync = true;
357
358 using DelayedReply = CompletionHandler<void(uint32_t loadPolicy)>;
359 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, uint32_t loadPolicy);
360 using Reply = std::tuple<uint32_t&>;
361 using ReplyArguments = std::tuple<uint32_t>;
362 explicit WebGLPolicyForURL(const URL& url)
363 : m_arguments(url)
364 {
365 }
366
367 const Arguments& arguments() const
368 {
369 return m_arguments;
370 }
371
372private:
373 Arguments m_arguments;
374};
375#endif
376
377#if ENABLE(WEBGL)
378class ResolveWebGLPolicyForURL {
379public:
380 typedef std::tuple<const URL&> Arguments;
381
382 static IPC::StringReference receiverName() { return messageReceiverName(); }
383 static IPC::StringReference name() { return IPC::StringReference("ResolveWebGLPolicyForURL"); }
384 static const bool isSync = true;
385
386 using DelayedReply = CompletionHandler<void(uint32_t loadPolicy)>;
387 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, uint32_t loadPolicy);
388 using Reply = std::tuple<uint32_t&>;
389 using ReplyArguments = std::tuple<uint32_t>;
390 explicit ResolveWebGLPolicyForURL(const URL& url)
391 : m_arguments(url)
392 {
393 }
394
395 const Arguments& arguments() const
396 {
397 return m_arguments;
398 }
399
400private:
401 Arguments m_arguments;
402};
403#endif
404
405class DidChangeViewportProperties {
406public:
407 typedef std::tuple<const WebCore::ViewportAttributes&> Arguments;
408
409 static IPC::StringReference receiverName() { return messageReceiverName(); }
410 static IPC::StringReference name() { return IPC::StringReference("DidChangeViewportProperties"); }
411 static const bool isSync = false;
412
413 explicit DidChangeViewportProperties(const WebCore::ViewportAttributes& attributes)
414 : m_arguments(attributes)
415 {
416 }
417
418 const Arguments& arguments() const
419 {
420 return m_arguments;
421 }
422
423private:
424 Arguments m_arguments;
425};
426
427class DidReceiveEvent {
428public:
429 typedef std::tuple<uint32_t, bool> Arguments;
430
431 static IPC::StringReference receiverName() { return messageReceiverName(); }
432 static IPC::StringReference name() { return IPC::StringReference("DidReceiveEvent"); }
433 static const bool isSync = false;
434
435 DidReceiveEvent(uint32_t type, bool handled)
436 : m_arguments(type, handled)
437 {
438 }
439
440 const Arguments& arguments() const
441 {
442 return m_arguments;
443 }
444
445private:
446 Arguments m_arguments;
447};
448
449#if !PLATFORM(IOS_FAMILY)
450class SetCursor {
451public:
452 typedef std::tuple<const WebCore::Cursor&> Arguments;
453
454 static IPC::StringReference receiverName() { return messageReceiverName(); }
455 static IPC::StringReference name() { return IPC::StringReference("SetCursor"); }
456 static const bool isSync = false;
457
458 explicit SetCursor(const WebCore::Cursor& cursor)
459 : m_arguments(cursor)
460 {
461 }
462
463 const Arguments& arguments() const
464 {
465 return m_arguments;
466 }
467
468private:
469 Arguments m_arguments;
470};
471#endif
472
473#if !PLATFORM(IOS_FAMILY)
474class SetCursorHiddenUntilMouseMoves {
475public:
476 typedef std::tuple<bool> Arguments;
477
478 static IPC::StringReference receiverName() { return messageReceiverName(); }
479 static IPC::StringReference name() { return IPC::StringReference("SetCursorHiddenUntilMouseMoves"); }
480 static const bool isSync = false;
481
482 explicit SetCursorHiddenUntilMouseMoves(bool hiddenUntilMouseMoves)
483 : m_arguments(hiddenUntilMouseMoves)
484 {
485 }
486
487 const Arguments& arguments() const
488 {
489 return m_arguments;
490 }
491
492private:
493 Arguments m_arguments;
494};
495#endif
496
497class SetStatusText {
498public:
499 typedef std::tuple<const String&> Arguments;
500
501 static IPC::StringReference receiverName() { return messageReceiverName(); }
502 static IPC::StringReference name() { return IPC::StringReference("SetStatusText"); }
503 static const bool isSync = false;
504
505 explicit SetStatusText(const String& statusText)
506 : m_arguments(statusText)
507 {
508 }
509
510 const Arguments& arguments() const
511 {
512 return m_arguments;
513 }
514
515private:
516 Arguments m_arguments;
517};
518
519class SetToolTip {
520public:
521 typedef std::tuple<const String&> Arguments;
522
523 static IPC::StringReference receiverName() { return messageReceiverName(); }
524 static IPC::StringReference name() { return IPC::StringReference("SetToolTip"); }
525 static const bool isSync = false;
526
527 explicit SetToolTip(const String& toolTip)
528 : m_arguments(toolTip)
529 {
530 }
531
532 const Arguments& arguments() const
533 {
534 return m_arguments;
535 }
536
537private:
538 Arguments m_arguments;
539};
540
541class SetFocus {
542public:
543 typedef std::tuple<bool> Arguments;
544
545 static IPC::StringReference receiverName() { return messageReceiverName(); }
546 static IPC::StringReference name() { return IPC::StringReference("SetFocus"); }
547 static const bool isSync = false;
548
549 explicit SetFocus(bool focused)
550 : m_arguments(focused)
551 {
552 }
553
554 const Arguments& arguments() const
555 {
556 return m_arguments;
557 }
558
559private:
560 Arguments m_arguments;
561};
562
563class TakeFocus {
564public:
565 typedef std::tuple<uint32_t> Arguments;
566
567 static IPC::StringReference receiverName() { return messageReceiverName(); }
568 static IPC::StringReference name() { return IPC::StringReference("TakeFocus"); }
569 static const bool isSync = false;
570
571 explicit TakeFocus(uint32_t direction)
572 : m_arguments(direction)
573 {
574 }
575
576 const Arguments& arguments() const
577 {
578 return m_arguments;
579 }
580
581private:
582 Arguments m_arguments;
583};
584
585class FocusedFrameChanged {
586public:
587 typedef std::tuple<uint64_t> Arguments;
588
589 static IPC::StringReference receiverName() { return messageReceiverName(); }
590 static IPC::StringReference name() { return IPC::StringReference("FocusedFrameChanged"); }
591 static const bool isSync = false;
592
593 explicit FocusedFrameChanged(uint64_t frameID)
594 : m_arguments(frameID)
595 {
596 }
597
598 const Arguments& arguments() const
599 {
600 return m_arguments;
601 }
602
603private:
604 Arguments m_arguments;
605};
606
607class FrameSetLargestFrameChanged {
608public:
609 typedef std::tuple<uint64_t> Arguments;
610
611 static IPC::StringReference receiverName() { return messageReceiverName(); }
612 static IPC::StringReference name() { return IPC::StringReference("FrameSetLargestFrameChanged"); }
613 static const bool isSync = false;
614
615 explicit FrameSetLargestFrameChanged(uint64_t frameID)
616 : m_arguments(frameID)
617 {
618 }
619
620 const Arguments& arguments() const
621 {
622 return m_arguments;
623 }
624
625private:
626 Arguments m_arguments;
627};
628
629class SetRenderTreeSize {
630public:
631 typedef std::tuple<uint64_t> Arguments;
632
633 static IPC::StringReference receiverName() { return messageReceiverName(); }
634 static IPC::StringReference name() { return IPC::StringReference("SetRenderTreeSize"); }
635 static const bool isSync = false;
636
637 explicit SetRenderTreeSize(uint64_t treeSize)
638 : m_arguments(treeSize)
639 {
640 }
641
642 const Arguments& arguments() const
643 {
644 return m_arguments;
645 }
646
647private:
648 Arguments m_arguments;
649};
650
651class SetToolbarsAreVisible {
652public:
653 typedef std::tuple<bool> Arguments;
654
655 static IPC::StringReference receiverName() { return messageReceiverName(); }
656 static IPC::StringReference name() { return IPC::StringReference("SetToolbarsAreVisible"); }
657 static const bool isSync = false;
658
659 explicit SetToolbarsAreVisible(bool toolbarsAreVisible)
660 : m_arguments(toolbarsAreVisible)
661 {
662 }
663
664 const Arguments& arguments() const
665 {
666 return m_arguments;
667 }
668
669private:
670 Arguments m_arguments;
671};
672
673class GetToolbarsAreVisible {
674public:
675 typedef std::tuple<> Arguments;
676
677 static IPC::StringReference receiverName() { return messageReceiverName(); }
678 static IPC::StringReference name() { return IPC::StringReference("GetToolbarsAreVisible"); }
679 static const bool isSync = true;
680
681 using DelayedReply = CompletionHandler<void(bool toolbarsAreVisible)>;
682 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool toolbarsAreVisible);
683 using Reply = std::tuple<bool&>;
684 using ReplyArguments = std::tuple<bool>;
685 const Arguments& arguments() const
686 {
687 return m_arguments;
688 }
689
690private:
691 Arguments m_arguments;
692};
693
694class SetMenuBarIsVisible {
695public:
696 typedef std::tuple<bool> Arguments;
697
698 static IPC::StringReference receiverName() { return messageReceiverName(); }
699 static IPC::StringReference name() { return IPC::StringReference("SetMenuBarIsVisible"); }
700 static const bool isSync = false;
701
702 explicit SetMenuBarIsVisible(bool menuBarIsVisible)
703 : m_arguments(menuBarIsVisible)
704 {
705 }
706
707 const Arguments& arguments() const
708 {
709 return m_arguments;
710 }
711
712private:
713 Arguments m_arguments;
714};
715
716class GetMenuBarIsVisible {
717public:
718 typedef std::tuple<> Arguments;
719
720 static IPC::StringReference receiverName() { return messageReceiverName(); }
721 static IPC::StringReference name() { return IPC::StringReference("GetMenuBarIsVisible"); }
722 static const bool isSync = true;
723
724 using DelayedReply = CompletionHandler<void(bool menuBarIsVisible)>;
725 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool menuBarIsVisible);
726 using Reply = std::tuple<bool&>;
727 using ReplyArguments = std::tuple<bool>;
728 const Arguments& arguments() const
729 {
730 return m_arguments;
731 }
732
733private:
734 Arguments m_arguments;
735};
736
737class SetStatusBarIsVisible {
738public:
739 typedef std::tuple<bool> Arguments;
740
741 static IPC::StringReference receiverName() { return messageReceiverName(); }
742 static IPC::StringReference name() { return IPC::StringReference("SetStatusBarIsVisible"); }
743 static const bool isSync = false;
744
745 explicit SetStatusBarIsVisible(bool statusBarIsVisible)
746 : m_arguments(statusBarIsVisible)
747 {
748 }
749
750 const Arguments& arguments() const
751 {
752 return m_arguments;
753 }
754
755private:
756 Arguments m_arguments;
757};
758
759class GetStatusBarIsVisible {
760public:
761 typedef std::tuple<> Arguments;
762
763 static IPC::StringReference receiverName() { return messageReceiverName(); }
764 static IPC::StringReference name() { return IPC::StringReference("GetStatusBarIsVisible"); }
765 static const bool isSync = true;
766
767 using DelayedReply = CompletionHandler<void(bool statusBarIsVisible)>;
768 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool statusBarIsVisible);
769 using Reply = std::tuple<bool&>;
770 using ReplyArguments = std::tuple<bool>;
771 const Arguments& arguments() const
772 {
773 return m_arguments;
774 }
775
776private:
777 Arguments m_arguments;
778};
779
780class SetIsResizable {
781public:
782 typedef std::tuple<bool> Arguments;
783
784 static IPC::StringReference receiverName() { return messageReceiverName(); }
785 static IPC::StringReference name() { return IPC::StringReference("SetIsResizable"); }
786 static const bool isSync = false;
787
788 explicit SetIsResizable(bool isResizable)
789 : m_arguments(isResizable)
790 {
791 }
792
793 const Arguments& arguments() const
794 {
795 return m_arguments;
796 }
797
798private:
799 Arguments m_arguments;
800};
801
802class SetWindowFrame {
803public:
804 typedef std::tuple<const WebCore::FloatRect&> Arguments;
805
806 static IPC::StringReference receiverName() { return messageReceiverName(); }
807 static IPC::StringReference name() { return IPC::StringReference("SetWindowFrame"); }
808 static const bool isSync = false;
809
810 explicit SetWindowFrame(const WebCore::FloatRect& windowFrame)
811 : m_arguments(windowFrame)
812 {
813 }
814
815 const Arguments& arguments() const
816 {
817 return m_arguments;
818 }
819
820private:
821 Arguments m_arguments;
822};
823
824class GetWindowFrame {
825public:
826 typedef std::tuple<> Arguments;
827
828 static IPC::StringReference receiverName() { return messageReceiverName(); }
829 static IPC::StringReference name() { return IPC::StringReference("GetWindowFrame"); }
830 static const bool isSync = true;
831
832 using DelayedReply = CompletionHandler<void(const WebCore::FloatRect& windowFrame)>;
833 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const WebCore::FloatRect& windowFrame);
834 using Reply = std::tuple<WebCore::FloatRect&>;
835 using ReplyArguments = std::tuple<WebCore::FloatRect>;
836 const Arguments& arguments() const
837 {
838 return m_arguments;
839 }
840
841private:
842 Arguments m_arguments;
843};
844
845class ScreenToRootView {
846public:
847 typedef std::tuple<const WebCore::IntPoint&> Arguments;
848
849 static IPC::StringReference receiverName() { return messageReceiverName(); }
850 static IPC::StringReference name() { return IPC::StringReference("ScreenToRootView"); }
851 static const bool isSync = true;
852
853 using DelayedReply = CompletionHandler<void(const WebCore::IntPoint& windowPoint)>;
854 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const WebCore::IntPoint& windowPoint);
855 using Reply = std::tuple<WebCore::IntPoint&>;
856 using ReplyArguments = std::tuple<WebCore::IntPoint>;
857 explicit ScreenToRootView(const WebCore::IntPoint& screenPoint)
858 : m_arguments(screenPoint)
859 {
860 }
861
862 const Arguments& arguments() const
863 {
864 return m_arguments;
865 }
866
867private:
868 Arguments m_arguments;
869};
870
871class RootViewToScreen {
872public:
873 typedef std::tuple<const WebCore::IntRect&> Arguments;
874
875 static IPC::StringReference receiverName() { return messageReceiverName(); }
876 static IPC::StringReference name() { return IPC::StringReference("RootViewToScreen"); }
877 static const bool isSync = true;
878
879 using DelayedReply = CompletionHandler<void(const WebCore::IntRect& screenFrame)>;
880 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const WebCore::IntRect& screenFrame);
881 using Reply = std::tuple<WebCore::IntRect&>;
882 using ReplyArguments = std::tuple<WebCore::IntRect>;
883 explicit RootViewToScreen(const WebCore::IntRect& rect)
884 : m_arguments(rect)
885 {
886 }
887
888 const Arguments& arguments() const
889 {
890 return m_arguments;
891 }
892
893private:
894 Arguments m_arguments;
895};
896
897class AccessibilityScreenToRootView {
898public:
899 typedef std::tuple<const WebCore::IntPoint&> Arguments;
900
901 static IPC::StringReference receiverName() { return messageReceiverName(); }
902 static IPC::StringReference name() { return IPC::StringReference("AccessibilityScreenToRootView"); }
903 static const bool isSync = true;
904
905 using DelayedReply = CompletionHandler<void(const WebCore::IntPoint& windowPoint)>;
906 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const WebCore::IntPoint& windowPoint);
907 using Reply = std::tuple<WebCore::IntPoint&>;
908 using ReplyArguments = std::tuple<WebCore::IntPoint>;
909 explicit AccessibilityScreenToRootView(const WebCore::IntPoint& screenPoint)
910 : m_arguments(screenPoint)
911 {
912 }
913
914 const Arguments& arguments() const
915 {
916 return m_arguments;
917 }
918
919private:
920 Arguments m_arguments;
921};
922
923class RootViewToAccessibilityScreen {
924public:
925 typedef std::tuple<const WebCore::IntRect&> Arguments;
926
927 static IPC::StringReference receiverName() { return messageReceiverName(); }
928 static IPC::StringReference name() { return IPC::StringReference("RootViewToAccessibilityScreen"); }
929 static const bool isSync = true;
930
931 using DelayedReply = CompletionHandler<void(const WebCore::IntRect& screenFrame)>;
932 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const WebCore::IntRect& screenFrame);
933 using Reply = std::tuple<WebCore::IntRect&>;
934 using ReplyArguments = std::tuple<WebCore::IntRect>;
935 explicit RootViewToAccessibilityScreen(const WebCore::IntRect& rect)
936 : m_arguments(rect)
937 {
938 }
939
940 const Arguments& arguments() const
941 {
942 return m_arguments;
943 }
944
945private:
946 Arguments m_arguments;
947};
948
949#if PLATFORM(COCOA)
950class ShowValidationMessage {
951public:
952 typedef std::tuple<const WebCore::IntRect&, const String&> Arguments;
953
954 static IPC::StringReference receiverName() { return messageReceiverName(); }
955 static IPC::StringReference name() { return IPC::StringReference("ShowValidationMessage"); }
956 static const bool isSync = false;
957
958 ShowValidationMessage(const WebCore::IntRect& anchorRect, const String& message)
959 : m_arguments(anchorRect, message)
960 {
961 }
962
963 const Arguments& arguments() const
964 {
965 return m_arguments;
966 }
967
968private:
969 Arguments m_arguments;
970};
971#endif
972
973#if PLATFORM(COCOA)
974class HideValidationMessage {
975public:
976 typedef std::tuple<> Arguments;
977
978 static IPC::StringReference receiverName() { return messageReceiverName(); }
979 static IPC::StringReference name() { return IPC::StringReference("HideValidationMessage"); }
980 static const bool isSync = false;
981
982 const Arguments& arguments() const
983 {
984 return m_arguments;
985 }
986
987private:
988 Arguments m_arguments;
989};
990#endif
991
992class RunBeforeUnloadConfirmPanel {
993public:
994 typedef std::tuple<uint64_t, const WebCore::SecurityOriginData&, const String&> Arguments;
995
996 static IPC::StringReference receiverName() { return messageReceiverName(); }
997 static IPC::StringReference name() { return IPC::StringReference("RunBeforeUnloadConfirmPanel"); }
998 static const bool isSync = true;
999
1000 using DelayedReply = CompletionHandler<void(bool shouldClose)>;
1001 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool shouldClose);
1002 using Reply = std::tuple<bool&>;
1003 using ReplyArguments = std::tuple<bool>;
1004 RunBeforeUnloadConfirmPanel(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, const String& message)
1005 : m_arguments(frameID, frameSecurityOrigin, message)
1006 {
1007 }
1008
1009 const Arguments& arguments() const
1010 {
1011 return m_arguments;
1012 }
1013
1014private:
1015 Arguments m_arguments;
1016};
1017
1018class PageDidScroll {
1019public:
1020 typedef std::tuple<> Arguments;
1021
1022 static IPC::StringReference receiverName() { return messageReceiverName(); }
1023 static IPC::StringReference name() { return IPC::StringReference("PageDidScroll"); }
1024 static const bool isSync = false;
1025
1026 const Arguments& arguments() const
1027 {
1028 return m_arguments;
1029 }
1030
1031private:
1032 Arguments m_arguments;
1033};
1034
1035class RunOpenPanel {
1036public:
1037 typedef std::tuple<uint64_t, const WebCore::SecurityOriginData&, const WebCore::FileChooserSettings&> Arguments;
1038
1039 static IPC::StringReference receiverName() { return messageReceiverName(); }
1040 static IPC::StringReference name() { return IPC::StringReference("RunOpenPanel"); }
1041 static const bool isSync = false;
1042
1043 RunOpenPanel(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, const WebCore::FileChooserSettings& parameters)
1044 : m_arguments(frameID, frameSecurityOrigin, parameters)
1045 {
1046 }
1047
1048 const Arguments& arguments() const
1049 {
1050 return m_arguments;
1051 }
1052
1053private:
1054 Arguments m_arguments;
1055};
1056
1057class ShowShareSheet {
1058public:
1059 typedef std::tuple<const WebCore::ShareDataWithParsedURL&, uint64_t> Arguments;
1060
1061 static IPC::StringReference receiverName() { return messageReceiverName(); }
1062 static IPC::StringReference name() { return IPC::StringReference("ShowShareSheet"); }
1063 static const bool isSync = false;
1064
1065 ShowShareSheet(const WebCore::ShareDataWithParsedURL& shareData, uint64_t callbackID)
1066 : m_arguments(shareData, callbackID)
1067 {
1068 }
1069
1070 const Arguments& arguments() const
1071 {
1072 return m_arguments;
1073 }
1074
1075private:
1076 Arguments m_arguments;
1077};
1078
1079class PrintFrame {
1080public:
1081 typedef std::tuple<uint64_t> Arguments;
1082
1083 static IPC::StringReference receiverName() { return messageReceiverName(); }
1084 static IPC::StringReference name() { return IPC::StringReference("PrintFrame"); }
1085 static const bool isSync = true;
1086
1087 using DelayedReply = CompletionHandler<void()>;
1088 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
1089 using Reply = std::tuple<>;
1090 using ReplyArguments = std::tuple<>;
1091 explicit PrintFrame(uint64_t frameID)
1092 : m_arguments(frameID)
1093 {
1094 }
1095
1096 const Arguments& arguments() const
1097 {
1098 return m_arguments;
1099 }
1100
1101private:
1102 Arguments m_arguments;
1103};
1104
1105class RunModal {
1106public:
1107 typedef std::tuple<> Arguments;
1108
1109 static IPC::StringReference receiverName() { return messageReceiverName(); }
1110 static IPC::StringReference name() { return IPC::StringReference("RunModal"); }
1111 static const bool isSync = false;
1112
1113 const Arguments& arguments() const
1114 {
1115 return m_arguments;
1116 }
1117
1118private:
1119 Arguments m_arguments;
1120};
1121
1122class NotifyScrollerThumbIsVisibleInRect {
1123public:
1124 typedef std::tuple<const WebCore::IntRect&> Arguments;
1125
1126 static IPC::StringReference receiverName() { return messageReceiverName(); }
1127 static IPC::StringReference name() { return IPC::StringReference("NotifyScrollerThumbIsVisibleInRect"); }
1128 static const bool isSync = false;
1129
1130 explicit NotifyScrollerThumbIsVisibleInRect(const WebCore::IntRect& scrollerThumb)
1131 : m_arguments(scrollerThumb)
1132 {
1133 }
1134
1135 const Arguments& arguments() const
1136 {
1137 return m_arguments;
1138 }
1139
1140private:
1141 Arguments m_arguments;
1142};
1143
1144class RecommendedScrollbarStyleDidChange {
1145public:
1146 typedef std::tuple<int32_t> Arguments;
1147
1148 static IPC::StringReference receiverName() { return messageReceiverName(); }
1149 static IPC::StringReference name() { return IPC::StringReference("RecommendedScrollbarStyleDidChange"); }
1150 static const bool isSync = false;
1151
1152 explicit RecommendedScrollbarStyleDidChange(int32_t newStyle)
1153 : m_arguments(newStyle)
1154 {
1155 }
1156
1157 const Arguments& arguments() const
1158 {
1159 return m_arguments;
1160 }
1161
1162private:
1163 Arguments m_arguments;
1164};
1165
1166class DidChangeScrollbarsForMainFrame {
1167public:
1168 typedef std::tuple<bool, bool> Arguments;
1169
1170 static IPC::StringReference receiverName() { return messageReceiverName(); }
1171 static IPC::StringReference name() { return IPC::StringReference("DidChangeScrollbarsForMainFrame"); }
1172 static const bool isSync = false;
1173
1174 DidChangeScrollbarsForMainFrame(bool hasHorizontalScrollbar, bool hasVerticalScrollbar)
1175 : m_arguments(hasHorizontalScrollbar, hasVerticalScrollbar)
1176 {
1177 }
1178
1179 const Arguments& arguments() const
1180 {
1181 return m_arguments;
1182 }
1183
1184private:
1185 Arguments m_arguments;
1186};
1187
1188class DidChangeScrollOffsetPinningForMainFrame {
1189public:
1190 typedef std::tuple<bool, bool, bool, bool> Arguments;
1191
1192 static IPC::StringReference receiverName() { return messageReceiverName(); }
1193 static IPC::StringReference name() { return IPC::StringReference("DidChangeScrollOffsetPinningForMainFrame"); }
1194 static const bool isSync = false;
1195
1196 DidChangeScrollOffsetPinningForMainFrame(bool pinnedToLeftSide, bool pinnedToRightSide, bool pinnedToTopSide, bool pinnedToBottomSide)
1197 : m_arguments(pinnedToLeftSide, pinnedToRightSide, pinnedToTopSide, pinnedToBottomSide)
1198 {
1199 }
1200
1201 const Arguments& arguments() const
1202 {
1203 return m_arguments;
1204 }
1205
1206private:
1207 Arguments m_arguments;
1208};
1209
1210class DidChangePageCount {
1211public:
1212 typedef std::tuple<const unsigned&> Arguments;
1213
1214 static IPC::StringReference receiverName() { return messageReceiverName(); }
1215 static IPC::StringReference name() { return IPC::StringReference("DidChangePageCount"); }
1216 static const bool isSync = false;
1217
1218 explicit DidChangePageCount(const unsigned& pageCount)
1219 : m_arguments(pageCount)
1220 {
1221 }
1222
1223 const Arguments& arguments() const
1224 {
1225 return m_arguments;
1226 }
1227
1228private:
1229 Arguments m_arguments;
1230};
1231
1232class PageExtendedBackgroundColorDidChange {
1233public:
1234 typedef std::tuple<const WebCore::Color&> Arguments;
1235
1236 static IPC::StringReference receiverName() { return messageReceiverName(); }
1237 static IPC::StringReference name() { return IPC::StringReference("PageExtendedBackgroundColorDidChange"); }
1238 static const bool isSync = false;
1239
1240 explicit PageExtendedBackgroundColorDidChange(const WebCore::Color& backgroundColor)
1241 : m_arguments(backgroundColor)
1242 {
1243 }
1244
1245 const Arguments& arguments() const
1246 {
1247 return m_arguments;
1248 }
1249
1250private:
1251 Arguments m_arguments;
1252};
1253
1254#if ENABLE(NETSCAPE_PLUGIN_API)
1255class DidFailToInitializePlugin {
1256public:
1257 typedef std::tuple<const String&, const String&, const String&> Arguments;
1258
1259 static IPC::StringReference receiverName() { return messageReceiverName(); }
1260 static IPC::StringReference name() { return IPC::StringReference("DidFailToInitializePlugin"); }
1261 static const bool isSync = false;
1262
1263 DidFailToInitializePlugin(const String& mimeType, const String& frameURLString, const String& pageURLString)
1264 : m_arguments(mimeType, frameURLString, pageURLString)
1265 {
1266 }
1267
1268 const Arguments& arguments() const
1269 {
1270 return m_arguments;
1271 }
1272
1273private:
1274 Arguments m_arguments;
1275};
1276#endif
1277
1278#if ENABLE(NETSCAPE_PLUGIN_API)
1279class DidBlockInsecurePluginVersion {
1280public:
1281 typedef std::tuple<const String&, const String&, const String&, const String&, bool> Arguments;
1282
1283 static IPC::StringReference receiverName() { return messageReceiverName(); }
1284 static IPC::StringReference name() { return IPC::StringReference("DidBlockInsecurePluginVersion"); }
1285 static const bool isSync = false;
1286
1287 DidBlockInsecurePluginVersion(const String& mimeType, const String& pluginURLString, const String& frameURLString, const String& pageURLString, bool replacementObscured)
1288 : m_arguments(mimeType, pluginURLString, frameURLString, pageURLString, replacementObscured)
1289 {
1290 }
1291
1292 const Arguments& arguments() const
1293 {
1294 return m_arguments;
1295 }
1296
1297private:
1298 Arguments m_arguments;
1299};
1300#endif
1301
1302class SetCanShortCircuitHorizontalWheelEvents {
1303public:
1304 typedef std::tuple<bool> Arguments;
1305
1306 static IPC::StringReference receiverName() { return messageReceiverName(); }
1307 static IPC::StringReference name() { return IPC::StringReference("SetCanShortCircuitHorizontalWheelEvents"); }
1308 static const bool isSync = false;
1309
1310 explicit SetCanShortCircuitHorizontalWheelEvents(bool canShortCircuitHorizontalWheelEvents)
1311 : m_arguments(canShortCircuitHorizontalWheelEvents)
1312 {
1313 }
1314
1315 const Arguments& arguments() const
1316 {
1317 return m_arguments;
1318 }
1319
1320private:
1321 Arguments m_arguments;
1322};
1323
1324class DidChangeContentSize {
1325public:
1326 typedef std::tuple<const WebCore::IntSize&> Arguments;
1327
1328 static IPC::StringReference receiverName() { return messageReceiverName(); }
1329 static IPC::StringReference name() { return IPC::StringReference("DidChangeContentSize"); }
1330 static const bool isSync = false;
1331
1332 explicit DidChangeContentSize(const WebCore::IntSize& newSize)
1333 : m_arguments(newSize)
1334 {
1335 }
1336
1337 const Arguments& arguments() const
1338 {
1339 return m_arguments;
1340 }
1341
1342private:
1343 Arguments m_arguments;
1344};
1345
1346class DidChangeIntrinsicContentSize {
1347public:
1348 typedef std::tuple<const WebCore::IntSize&> Arguments;
1349
1350 static IPC::StringReference receiverName() { return messageReceiverName(); }
1351 static IPC::StringReference name() { return IPC::StringReference("DidChangeIntrinsicContentSize"); }
1352 static const bool isSync = false;
1353
1354 explicit DidChangeIntrinsicContentSize(const WebCore::IntSize& newIntrinsicContentSize)
1355 : m_arguments(newIntrinsicContentSize)
1356 {
1357 }
1358
1359 const Arguments& arguments() const
1360 {
1361 return m_arguments;
1362 }
1363
1364private:
1365 Arguments m_arguments;
1366};
1367
1368#if ENABLE(INPUT_TYPE_COLOR)
1369class ShowColorPicker {
1370public:
1371 typedef std::tuple<const WebCore::Color&, const WebCore::IntRect&, const Vector<WebCore::Color>&> Arguments;
1372
1373 static IPC::StringReference receiverName() { return messageReceiverName(); }
1374 static IPC::StringReference name() { return IPC::StringReference("ShowColorPicker"); }
1375 static const bool isSync = false;
1376
1377 ShowColorPicker(const WebCore::Color& initialColor, const WebCore::IntRect& elementRect, const Vector<WebCore::Color>& suggestions)
1378 : m_arguments(initialColor, elementRect, suggestions)
1379 {
1380 }
1381
1382 const Arguments& arguments() const
1383 {
1384 return m_arguments;
1385 }
1386
1387private:
1388 Arguments m_arguments;
1389};
1390#endif
1391
1392#if ENABLE(INPUT_TYPE_COLOR)
1393class SetColorPickerColor {
1394public:
1395 typedef std::tuple<const WebCore::Color&> Arguments;
1396
1397 static IPC::StringReference receiverName() { return messageReceiverName(); }
1398 static IPC::StringReference name() { return IPC::StringReference("SetColorPickerColor"); }
1399 static const bool isSync = false;
1400
1401 explicit SetColorPickerColor(const WebCore::Color& color)
1402 : m_arguments(color)
1403 {
1404 }
1405
1406 const Arguments& arguments() const
1407 {
1408 return m_arguments;
1409 }
1410
1411private:
1412 Arguments m_arguments;
1413};
1414#endif
1415
1416#if ENABLE(INPUT_TYPE_COLOR)
1417class EndColorPicker {
1418public:
1419 typedef std::tuple<> Arguments;
1420
1421 static IPC::StringReference receiverName() { return messageReceiverName(); }
1422 static IPC::StringReference name() { return IPC::StringReference("EndColorPicker"); }
1423 static const bool isSync = false;
1424
1425 const Arguments& arguments() const
1426 {
1427 return m_arguments;
1428 }
1429
1430private:
1431 Arguments m_arguments;
1432};
1433#endif
1434
1435#if ENABLE(DATALIST_ELEMENT)
1436class ShowDataListSuggestions {
1437public:
1438 typedef std::tuple<const WebCore::DataListSuggestionInformation&> Arguments;
1439
1440 static IPC::StringReference receiverName() { return messageReceiverName(); }
1441 static IPC::StringReference name() { return IPC::StringReference("ShowDataListSuggestions"); }
1442 static const bool isSync = false;
1443
1444 explicit ShowDataListSuggestions(const WebCore::DataListSuggestionInformation& suggestionInformation)
1445 : m_arguments(suggestionInformation)
1446 {
1447 }
1448
1449 const Arguments& arguments() const
1450 {
1451 return m_arguments;
1452 }
1453
1454private:
1455 Arguments m_arguments;
1456};
1457#endif
1458
1459#if ENABLE(DATALIST_ELEMENT)
1460class HandleKeydownInDataList {
1461public:
1462 typedef std::tuple<const String&> Arguments;
1463
1464 static IPC::StringReference receiverName() { return messageReceiverName(); }
1465 static IPC::StringReference name() { return IPC::StringReference("HandleKeydownInDataList"); }
1466 static const bool isSync = false;
1467
1468 explicit HandleKeydownInDataList(const String& key)
1469 : m_arguments(key)
1470 {
1471 }
1472
1473 const Arguments& arguments() const
1474 {
1475 return m_arguments;
1476 }
1477
1478private:
1479 Arguments m_arguments;
1480};
1481#endif
1482
1483#if ENABLE(DATALIST_ELEMENT)
1484class EndDataListSuggestions {
1485public:
1486 typedef std::tuple<> Arguments;
1487
1488 static IPC::StringReference receiverName() { return messageReceiverName(); }
1489 static IPC::StringReference name() { return IPC::StringReference("EndDataListSuggestions"); }
1490 static const bool isSync = false;
1491
1492 const Arguments& arguments() const
1493 {
1494 return m_arguments;
1495 }
1496
1497private:
1498 Arguments m_arguments;
1499};
1500#endif
1501
1502class DecidePolicyForResponse {
1503public:
1504 typedef std::tuple<uint64_t, const WebCore::SecurityOriginData&, const WebCore::PolicyCheckIdentifier&, uint64_t, const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, bool, const String&, uint64_t, const WebKit::UserData&> Arguments;
1505
1506 static IPC::StringReference receiverName() { return messageReceiverName(); }
1507 static IPC::StringReference name() { return IPC::StringReference("DecidePolicyForResponse"); }
1508 static const bool isSync = false;
1509
1510 DecidePolicyForResponse(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, const WebCore::PolicyCheckIdentifier& policyCheckIdentifier, uint64_t navigationID, const WebCore::ResourceResponse& response, const WebCore::ResourceRequest& request, bool canShowMIMEType, const String& downloadAttribute, uint64_t listenerID, const WebKit::UserData& userData)
1511 : m_arguments(frameID, frameSecurityOrigin, policyCheckIdentifier, navigationID, response, request, canShowMIMEType, downloadAttribute, listenerID, userData)
1512 {
1513 }
1514
1515 const Arguments& arguments() const
1516 {
1517 return m_arguments;
1518 }
1519
1520private:
1521 Arguments m_arguments;
1522};
1523
1524class DecidePolicyForNavigationActionAsync {
1525public:
1526 typedef std::tuple<uint64_t, const WebCore::SecurityOriginData&, const WebCore::PolicyCheckIdentifier&, uint64_t, const WebKit::NavigationActionData&, const WebKit::FrameInfoData&, const Optional<WebCore::PageIdentifier>&, const WebCore::ResourceRequest&, const WebCore::ResourceRequest&, const IPC::FormDataReference&, const WebCore::ResourceResponse&, const WebKit::UserData&, uint64_t> Arguments;
1527
1528 static IPC::StringReference receiverName() { return messageReceiverName(); }
1529 static IPC::StringReference name() { return IPC::StringReference("DecidePolicyForNavigationActionAsync"); }
1530 static const bool isSync = false;
1531
1532 DecidePolicyForNavigationActionAsync(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, const WebCore::PolicyCheckIdentifier& policyCheckIdentifier, uint64_t navigationID, const WebKit::NavigationActionData& navigationActionData, const WebKit::FrameInfoData& originatingFrameInfoData, const Optional<WebCore::PageIdentifier>& originatingPageID, const WebCore::ResourceRequest& originalRequest, const WebCore::ResourceRequest& request, const IPC::FormDataReference& requestBody, const WebCore::ResourceResponse& redirectResponse, const WebKit::UserData& userData, uint64_t listenerID)
1533 : m_arguments(frameID, frameSecurityOrigin, policyCheckIdentifier, navigationID, navigationActionData, originatingFrameInfoData, originatingPageID, originalRequest, request, requestBody, redirectResponse, userData, listenerID)
1534 {
1535 }
1536
1537 const Arguments& arguments() const
1538 {
1539 return m_arguments;
1540 }
1541
1542private:
1543 Arguments m_arguments;
1544};
1545
1546class DecidePolicyForNavigationActionSync {
1547public:
1548 typedef std::tuple<uint64_t, bool, const WebCore::SecurityOriginData&, const WebCore::PolicyCheckIdentifier&, uint64_t, const WebKit::NavigationActionData&, const WebKit::FrameInfoData&, const Optional<WebCore::PageIdentifier>&, const WebCore::ResourceRequest&, const WebCore::ResourceRequest&, const IPC::FormDataReference&, const WebCore::ResourceResponse&, const WebKit::UserData&> Arguments;
1549
1550 static IPC::StringReference receiverName() { return messageReceiverName(); }
1551 static IPC::StringReference name() { return IPC::StringReference("DecidePolicyForNavigationActionSync"); }
1552 static const bool isSync = true;
1553
1554 using DelayedReply = CompletionHandler<void(const WebCore::PolicyCheckIdentifier& policyCheckIdentifier, WebCore::PolicyAction policyAction, uint64_t newNavigationID, const WebKit::DownloadID& downloadID, const Optional<WebKit::WebsitePoliciesData>& websitePolicies)>;
1555 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const WebCore::PolicyCheckIdentifier& policyCheckIdentifier, WebCore::PolicyAction policyAction, uint64_t newNavigationID, const WebKit::DownloadID& downloadID, const Optional<WebKit::WebsitePoliciesData>& websitePolicies);
1556 using Reply = std::tuple<WebCore::PolicyCheckIdentifier&, WebCore::PolicyAction&, uint64_t&, WebKit::DownloadID&, Optional<WebKit::WebsitePoliciesData>&>;
1557 using ReplyArguments = std::tuple<WebCore::PolicyCheckIdentifier, WebCore::PolicyAction, uint64_t, WebKit::DownloadID, Optional<WebKit::WebsitePoliciesData>>;
1558 DecidePolicyForNavigationActionSync(uint64_t frameID, bool isMainFrame, const WebCore::SecurityOriginData& frameSecurityOrigin, const WebCore::PolicyCheckIdentifier& policyCheckIdentifier, uint64_t navigationID, const WebKit::NavigationActionData& navigationActionData, const WebKit::FrameInfoData& originatingFrameInfoData, const Optional<WebCore::PageIdentifier>& originatingPageID, const WebCore::ResourceRequest& originalRequest, const WebCore::ResourceRequest& request, const IPC::FormDataReference& requestBody, const WebCore::ResourceResponse& redirectResponse, const WebKit::UserData& userData)
1559 : m_arguments(frameID, isMainFrame, frameSecurityOrigin, policyCheckIdentifier, navigationID, navigationActionData, originatingFrameInfoData, originatingPageID, originalRequest, request, requestBody, redirectResponse, userData)
1560 {
1561 }
1562
1563 const Arguments& arguments() const
1564 {
1565 return m_arguments;
1566 }
1567
1568private:
1569 Arguments m_arguments;
1570};
1571
1572class DecidePolicyForNewWindowAction {
1573public:
1574 typedef std::tuple<uint64_t, const WebCore::SecurityOriginData&, const WebCore::PolicyCheckIdentifier&, const WebKit::NavigationActionData&, const WebCore::ResourceRequest&, const String&, uint64_t, const WebKit::UserData&> Arguments;
1575
1576 static IPC::StringReference receiverName() { return messageReceiverName(); }
1577 static IPC::StringReference name() { return IPC::StringReference("DecidePolicyForNewWindowAction"); }
1578 static const bool isSync = false;
1579
1580 DecidePolicyForNewWindowAction(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, const WebCore::PolicyCheckIdentifier& policyCheckIdentifier, const WebKit::NavigationActionData& navigationActionData, const WebCore::ResourceRequest& request, const String& frameName, uint64_t listenerID, const WebKit::UserData& userData)
1581 : m_arguments(frameID, frameSecurityOrigin, policyCheckIdentifier, navigationActionData, request, frameName, listenerID, userData)
1582 {
1583 }
1584
1585 const Arguments& arguments() const
1586 {
1587 return m_arguments;
1588 }
1589
1590private:
1591 Arguments m_arguments;
1592};
1593
1594class UnableToImplementPolicy {
1595public:
1596 typedef std::tuple<uint64_t, const WebCore::ResourceError&, const WebKit::UserData&> Arguments;
1597
1598 static IPC::StringReference receiverName() { return messageReceiverName(); }
1599 static IPC::StringReference name() { return IPC::StringReference("UnableToImplementPolicy"); }
1600 static const bool isSync = false;
1601
1602 UnableToImplementPolicy(uint64_t frameID, const WebCore::ResourceError& error, const WebKit::UserData& userData)
1603 : m_arguments(frameID, error, userData)
1604 {
1605 }
1606
1607 const Arguments& arguments() const
1608 {
1609 return m_arguments;
1610 }
1611
1612private:
1613 Arguments m_arguments;
1614};
1615
1616class DidChangeProgress {
1617public:
1618 typedef std::tuple<double> Arguments;
1619
1620 static IPC::StringReference receiverName() { return messageReceiverName(); }
1621 static IPC::StringReference name() { return IPC::StringReference("DidChangeProgress"); }
1622 static const bool isSync = false;
1623
1624 explicit DidChangeProgress(double value)
1625 : m_arguments(value)
1626 {
1627 }
1628
1629 const Arguments& arguments() const
1630 {
1631 return m_arguments;
1632 }
1633
1634private:
1635 Arguments m_arguments;
1636};
1637
1638class DidFinishProgress {
1639public:
1640 typedef std::tuple<> Arguments;
1641
1642 static IPC::StringReference receiverName() { return messageReceiverName(); }
1643 static IPC::StringReference name() { return IPC::StringReference("DidFinishProgress"); }
1644 static const bool isSync = false;
1645
1646 const Arguments& arguments() const
1647 {
1648 return m_arguments;
1649 }
1650
1651private:
1652 Arguments m_arguments;
1653};
1654
1655class DidStartProgress {
1656public:
1657 typedef std::tuple<> Arguments;
1658
1659 static IPC::StringReference receiverName() { return messageReceiverName(); }
1660 static IPC::StringReference name() { return IPC::StringReference("DidStartProgress"); }
1661 static const bool isSync = false;
1662
1663 const Arguments& arguments() const
1664 {
1665 return m_arguments;
1666 }
1667
1668private:
1669 Arguments m_arguments;
1670};
1671
1672class SetNetworkRequestsInProgress {
1673public:
1674 typedef std::tuple<bool> Arguments;
1675
1676 static IPC::StringReference receiverName() { return messageReceiverName(); }
1677 static IPC::StringReference name() { return IPC::StringReference("SetNetworkRequestsInProgress"); }
1678 static const bool isSync = false;
1679
1680 explicit SetNetworkRequestsInProgress(bool networkRequestsInProgress)
1681 : m_arguments(networkRequestsInProgress)
1682 {
1683 }
1684
1685 const Arguments& arguments() const
1686 {
1687 return m_arguments;
1688 }
1689
1690private:
1691 Arguments m_arguments;
1692};
1693
1694class DidCreateMainFrame {
1695public:
1696 typedef std::tuple<uint64_t> Arguments;
1697
1698 static IPC::StringReference receiverName() { return messageReceiverName(); }
1699 static IPC::StringReference name() { return IPC::StringReference("DidCreateMainFrame"); }
1700 static const bool isSync = false;
1701
1702 explicit DidCreateMainFrame(uint64_t frameID)
1703 : m_arguments(frameID)
1704 {
1705 }
1706
1707 const Arguments& arguments() const
1708 {
1709 return m_arguments;
1710 }
1711
1712private:
1713 Arguments m_arguments;
1714};
1715
1716class DidCreateSubframe {
1717public:
1718 typedef std::tuple<uint64_t> Arguments;
1719
1720 static IPC::StringReference receiverName() { return messageReceiverName(); }
1721 static IPC::StringReference name() { return IPC::StringReference("DidCreateSubframe"); }
1722 static const bool isSync = false;
1723
1724 explicit DidCreateSubframe(uint64_t frameID)
1725 : m_arguments(frameID)
1726 {
1727 }
1728
1729 const Arguments& arguments() const
1730 {
1731 return m_arguments;
1732 }
1733
1734private:
1735 Arguments m_arguments;
1736};
1737
1738class DidCreateWindow {
1739public:
1740 typedef std::tuple<uint64_t, const WebCore::GlobalWindowIdentifier&> Arguments;
1741
1742 static IPC::StringReference receiverName() { return messageReceiverName(); }
1743 static IPC::StringReference name() { return IPC::StringReference("DidCreateWindow"); }
1744 static const bool isSync = false;
1745
1746 DidCreateWindow(uint64_t frameID, const WebCore::GlobalWindowIdentifier& windowIdentifier)
1747 : m_arguments(frameID, windowIdentifier)
1748 {
1749 }
1750
1751 const Arguments& arguments() const
1752 {
1753 return m_arguments;
1754 }
1755
1756private:
1757 Arguments m_arguments;
1758};
1759
1760class DidStartProvisionalLoadForFrame {
1761public:
1762 typedef std::tuple<uint64_t, uint64_t, const URL&, const URL&, const WebKit::UserData&> Arguments;
1763
1764 static IPC::StringReference receiverName() { return messageReceiverName(); }
1765 static IPC::StringReference name() { return IPC::StringReference("DidStartProvisionalLoadForFrame"); }
1766 static const bool isSync = false;
1767
1768 DidStartProvisionalLoadForFrame(uint64_t frameID, uint64_t navigationID, const URL& url, const URL& unreachableURL, const WebKit::UserData& userData)
1769 : m_arguments(frameID, navigationID, url, unreachableURL, userData)
1770 {
1771 }
1772
1773 const Arguments& arguments() const
1774 {
1775 return m_arguments;
1776 }
1777
1778private:
1779 Arguments m_arguments;
1780};
1781
1782class DidReceiveServerRedirectForProvisionalLoadForFrame {
1783public:
1784 typedef std::tuple<uint64_t, uint64_t, const WebCore::ResourceRequest&, const WebKit::UserData&> Arguments;
1785
1786 static IPC::StringReference receiverName() { return messageReceiverName(); }
1787 static IPC::StringReference name() { return IPC::StringReference("DidReceiveServerRedirectForProvisionalLoadForFrame"); }
1788 static const bool isSync = false;
1789
1790 DidReceiveServerRedirectForProvisionalLoadForFrame(uint64_t frameID, uint64_t navigationID, const WebCore::ResourceRequest& request, const WebKit::UserData& userData)
1791 : m_arguments(frameID, navigationID, request, userData)
1792 {
1793 }
1794
1795 const Arguments& arguments() const
1796 {
1797 return m_arguments;
1798 }
1799
1800private:
1801 Arguments m_arguments;
1802};
1803
1804class WillPerformClientRedirectForFrame {
1805public:
1806 typedef std::tuple<uint64_t, const String&, double, WebCore::LockBackForwardList> Arguments;
1807
1808 static IPC::StringReference receiverName() { return messageReceiverName(); }
1809 static IPC::StringReference name() { return IPC::StringReference("WillPerformClientRedirectForFrame"); }
1810 static const bool isSync = false;
1811
1812 WillPerformClientRedirectForFrame(uint64_t frameID, const String& url, double delay, WebCore::LockBackForwardList lockBackForwardList)
1813 : m_arguments(frameID, url, delay, lockBackForwardList)
1814 {
1815 }
1816
1817 const Arguments& arguments() const
1818 {
1819 return m_arguments;
1820 }
1821
1822private:
1823 Arguments m_arguments;
1824};
1825
1826class DidCancelClientRedirectForFrame {
1827public:
1828 typedef std::tuple<uint64_t> Arguments;
1829
1830 static IPC::StringReference receiverName() { return messageReceiverName(); }
1831 static IPC::StringReference name() { return IPC::StringReference("DidCancelClientRedirectForFrame"); }
1832 static const bool isSync = false;
1833
1834 explicit DidCancelClientRedirectForFrame(uint64_t frameID)
1835 : m_arguments(frameID)
1836 {
1837 }
1838
1839 const Arguments& arguments() const
1840 {
1841 return m_arguments;
1842 }
1843
1844private:
1845 Arguments m_arguments;
1846};
1847
1848class DidChangeProvisionalURLForFrame {
1849public:
1850 typedef std::tuple<uint64_t, uint64_t, const URL&> Arguments;
1851
1852 static IPC::StringReference receiverName() { return messageReceiverName(); }
1853 static IPC::StringReference name() { return IPC::StringReference("DidChangeProvisionalURLForFrame"); }
1854 static const bool isSync = false;
1855
1856 DidChangeProvisionalURLForFrame(uint64_t frameID, uint64_t navigationID, const URL& url)
1857 : m_arguments(frameID, navigationID, url)
1858 {
1859 }
1860
1861 const Arguments& arguments() const
1862 {
1863 return m_arguments;
1864 }
1865
1866private:
1867 Arguments m_arguments;
1868};
1869
1870class DidFailProvisionalLoadForFrame {
1871public:
1872 typedef std::tuple<uint64_t, const WebCore::SecurityOriginData&, uint64_t, const String&, const WebCore::ResourceError&, WebCore::WillContinueLoading, const WebKit::UserData&> Arguments;
1873
1874 static IPC::StringReference receiverName() { return messageReceiverName(); }
1875 static IPC::StringReference name() { return IPC::StringReference("DidFailProvisionalLoadForFrame"); }
1876 static const bool isSync = false;
1877
1878 DidFailProvisionalLoadForFrame(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, const String& provisionalURL, const WebCore::ResourceError& error, WebCore::WillContinueLoading willContinueLoading, const WebKit::UserData& userData)
1879 : m_arguments(frameID, frameSecurityOrigin, navigationID, provisionalURL, error, willContinueLoading, userData)
1880 {
1881 }
1882
1883 const Arguments& arguments() const
1884 {
1885 return m_arguments;
1886 }
1887
1888private:
1889 Arguments m_arguments;
1890};
1891
1892class DidCommitLoadForFrame {
1893public:
1894 typedef std::tuple<uint64_t, uint64_t, const String&, bool, uint32_t, const WebCore::CertificateInfo&, bool, const Optional<WebCore::HasInsecureContent>&, const WebKit::UserData&> Arguments;
1895
1896 static IPC::StringReference receiverName() { return messageReceiverName(); }
1897 static IPC::StringReference name() { return IPC::StringReference("DidCommitLoadForFrame"); }
1898 static const bool isSync = false;
1899
1900 DidCommitLoadForFrame(uint64_t frameID, uint64_t navigationID, const String& mimeType, bool hasCustomContentProvider, uint32_t loadType, const WebCore::CertificateInfo& certificateInfo, bool containsPluginDocument, const Optional<WebCore::HasInsecureContent>& forcedHasInsecureContent, const WebKit::UserData& userData)
1901 : m_arguments(frameID, navigationID, mimeType, hasCustomContentProvider, loadType, certificateInfo, containsPluginDocument, forcedHasInsecureContent, userData)
1902 {
1903 }
1904
1905 const Arguments& arguments() const
1906 {
1907 return m_arguments;
1908 }
1909
1910private:
1911 Arguments m_arguments;
1912};
1913
1914class DidFailLoadForFrame {
1915public:
1916 typedef std::tuple<uint64_t, uint64_t, const WebCore::ResourceError&, const WebKit::UserData&> Arguments;
1917
1918 static IPC::StringReference receiverName() { return messageReceiverName(); }
1919 static IPC::StringReference name() { return IPC::StringReference("DidFailLoadForFrame"); }
1920 static const bool isSync = false;
1921
1922 DidFailLoadForFrame(uint64_t frameID, uint64_t navigationID, const WebCore::ResourceError& error, const WebKit::UserData& userData)
1923 : m_arguments(frameID, navigationID, error, userData)
1924 {
1925 }
1926
1927 const Arguments& arguments() const
1928 {
1929 return m_arguments;
1930 }
1931
1932private:
1933 Arguments m_arguments;
1934};
1935
1936class DidFinishDocumentLoadForFrame {
1937public:
1938 typedef std::tuple<uint64_t, uint64_t, const WebKit::UserData&> Arguments;
1939
1940 static IPC::StringReference receiverName() { return messageReceiverName(); }
1941 static IPC::StringReference name() { return IPC::StringReference("DidFinishDocumentLoadForFrame"); }
1942 static const bool isSync = false;
1943
1944 DidFinishDocumentLoadForFrame(uint64_t frameID, uint64_t navigationID, const WebKit::UserData& userData)
1945 : m_arguments(frameID, navigationID, userData)
1946 {
1947 }
1948
1949 const Arguments& arguments() const
1950 {
1951 return m_arguments;
1952 }
1953
1954private:
1955 Arguments m_arguments;
1956};
1957
1958class DidFinishLoadForFrame {
1959public:
1960 typedef std::tuple<uint64_t, uint64_t, const WebKit::UserData&> Arguments;
1961
1962 static IPC::StringReference receiverName() { return messageReceiverName(); }
1963 static IPC::StringReference name() { return IPC::StringReference("DidFinishLoadForFrame"); }
1964 static const bool isSync = false;
1965
1966 DidFinishLoadForFrame(uint64_t frameID, uint64_t navigationID, const WebKit::UserData& userData)
1967 : m_arguments(frameID, navigationID, userData)
1968 {
1969 }
1970
1971 const Arguments& arguments() const
1972 {
1973 return m_arguments;
1974 }
1975
1976private:
1977 Arguments m_arguments;
1978};
1979
1980class DidFirstLayoutForFrame {
1981public:
1982 typedef std::tuple<uint64_t, const WebKit::UserData&> Arguments;
1983
1984 static IPC::StringReference receiverName() { return messageReceiverName(); }
1985 static IPC::StringReference name() { return IPC::StringReference("DidFirstLayoutForFrame"); }
1986 static const bool isSync = false;
1987
1988 DidFirstLayoutForFrame(uint64_t frameID, const WebKit::UserData& userData)
1989 : m_arguments(frameID, userData)
1990 {
1991 }
1992
1993 const Arguments& arguments() const
1994 {
1995 return m_arguments;
1996 }
1997
1998private:
1999 Arguments m_arguments;
2000};
2001
2002class DidFirstVisuallyNonEmptyLayoutForFrame {
2003public:
2004 typedef std::tuple<uint64_t, const WebKit::UserData&> Arguments;
2005
2006 static IPC::StringReference receiverName() { return messageReceiverName(); }
2007 static IPC::StringReference name() { return IPC::StringReference("DidFirstVisuallyNonEmptyLayoutForFrame"); }
2008 static const bool isSync = false;
2009
2010 DidFirstVisuallyNonEmptyLayoutForFrame(uint64_t frameID, const WebKit::UserData& userData)
2011 : m_arguments(frameID, userData)
2012 {
2013 }
2014
2015 const Arguments& arguments() const
2016 {
2017 return m_arguments;
2018 }
2019
2020private:
2021 Arguments m_arguments;
2022};
2023
2024class DidReachLayoutMilestone {
2025public:
2026 typedef std::tuple<const OptionSet<WebCore::LayoutMilestone>&> Arguments;
2027
2028 static IPC::StringReference receiverName() { return messageReceiverName(); }
2029 static IPC::StringReference name() { return IPC::StringReference("DidReachLayoutMilestone"); }
2030 static const bool isSync = false;
2031
2032 explicit DidReachLayoutMilestone(const OptionSet<WebCore::LayoutMilestone>& layoutMilestones)
2033 : m_arguments(layoutMilestones)
2034 {
2035 }
2036
2037 const Arguments& arguments() const
2038 {
2039 return m_arguments;
2040 }
2041
2042private:
2043 Arguments m_arguments;
2044};
2045
2046class DidReceiveTitleForFrame {
2047public:
2048 typedef std::tuple<uint64_t, const String&, const WebKit::UserData&> Arguments;
2049
2050 static IPC::StringReference receiverName() { return messageReceiverName(); }
2051 static IPC::StringReference name() { return IPC::StringReference("DidReceiveTitleForFrame"); }
2052 static const bool isSync = false;
2053
2054 DidReceiveTitleForFrame(uint64_t frameID, const String& title, const WebKit::UserData& userData)
2055 : m_arguments(frameID, title, userData)
2056 {
2057 }
2058
2059 const Arguments& arguments() const
2060 {
2061 return m_arguments;
2062 }
2063
2064private:
2065 Arguments m_arguments;
2066};
2067
2068class DidDisplayInsecureContentForFrame {
2069public:
2070 typedef std::tuple<uint64_t, const WebKit::UserData&> Arguments;
2071
2072 static IPC::StringReference receiverName() { return messageReceiverName(); }
2073 static IPC::StringReference name() { return IPC::StringReference("DidDisplayInsecureContentForFrame"); }
2074 static const bool isSync = false;
2075
2076 DidDisplayInsecureContentForFrame(uint64_t frameID, const WebKit::UserData& userData)
2077 : m_arguments(frameID, userData)
2078 {
2079 }
2080
2081 const Arguments& arguments() const
2082 {
2083 return m_arguments;
2084 }
2085
2086private:
2087 Arguments m_arguments;
2088};
2089
2090class DidRunInsecureContentForFrame {
2091public:
2092 typedef std::tuple<uint64_t, const WebKit::UserData&> Arguments;
2093
2094 static IPC::StringReference receiverName() { return messageReceiverName(); }
2095 static IPC::StringReference name() { return IPC::StringReference("DidRunInsecureContentForFrame"); }
2096 static const bool isSync = false;
2097
2098 DidRunInsecureContentForFrame(uint64_t frameID, const WebKit::UserData& userData)
2099 : m_arguments(frameID, userData)
2100 {
2101 }
2102
2103 const Arguments& arguments() const
2104 {
2105 return m_arguments;
2106 }
2107
2108private:
2109 Arguments m_arguments;
2110};
2111
2112class DidDetectXSSForFrame {
2113public:
2114 typedef std::tuple<uint64_t, const WebKit::UserData&> Arguments;
2115
2116 static IPC::StringReference receiverName() { return messageReceiverName(); }
2117 static IPC::StringReference name() { return IPC::StringReference("DidDetectXSSForFrame"); }
2118 static const bool isSync = false;
2119
2120 DidDetectXSSForFrame(uint64_t frameID, const WebKit::UserData& userData)
2121 : m_arguments(frameID, userData)
2122 {
2123 }
2124
2125 const Arguments& arguments() const
2126 {
2127 return m_arguments;
2128 }
2129
2130private:
2131 Arguments m_arguments;
2132};
2133
2134class DidSameDocumentNavigationForFrame {
2135public:
2136 typedef std::tuple<uint64_t, uint64_t, uint32_t, const URL&, const WebKit::UserData&> Arguments;
2137
2138 static IPC::StringReference receiverName() { return messageReceiverName(); }
2139 static IPC::StringReference name() { return IPC::StringReference("DidSameDocumentNavigationForFrame"); }
2140 static const bool isSync = false;
2141
2142 DidSameDocumentNavigationForFrame(uint64_t frameID, uint64_t navigationID, uint32_t type, const URL& url, const WebKit::UserData& userData)
2143 : m_arguments(frameID, navigationID, type, url, userData)
2144 {
2145 }
2146
2147 const Arguments& arguments() const
2148 {
2149 return m_arguments;
2150 }
2151
2152private:
2153 Arguments m_arguments;
2154};
2155
2156class DidChangeMainDocument {
2157public:
2158 typedef std::tuple<uint64_t> Arguments;
2159
2160 static IPC::StringReference receiverName() { return messageReceiverName(); }
2161 static IPC::StringReference name() { return IPC::StringReference("DidChangeMainDocument"); }
2162 static const bool isSync = false;
2163
2164 explicit DidChangeMainDocument(uint64_t frameID)
2165 : m_arguments(frameID)
2166 {
2167 }
2168
2169 const Arguments& arguments() const
2170 {
2171 return m_arguments;
2172 }
2173
2174private:
2175 Arguments m_arguments;
2176};
2177
2178class DidExplicitOpenForFrame {
2179public:
2180 typedef std::tuple<uint64_t, const URL&> Arguments;
2181
2182 static IPC::StringReference receiverName() { return messageReceiverName(); }
2183 static IPC::StringReference name() { return IPC::StringReference("DidExplicitOpenForFrame"); }
2184 static const bool isSync = false;
2185
2186 DidExplicitOpenForFrame(uint64_t frameID, const URL& url)
2187 : m_arguments(frameID, url)
2188 {
2189 }
2190
2191 const Arguments& arguments() const
2192 {
2193 return m_arguments;
2194 }
2195
2196private:
2197 Arguments m_arguments;
2198};
2199
2200class DidDestroyNavigation {
2201public:
2202 typedef std::tuple<uint64_t> Arguments;
2203
2204 static IPC::StringReference receiverName() { return messageReceiverName(); }
2205 static IPC::StringReference name() { return IPC::StringReference("DidDestroyNavigation"); }
2206 static const bool isSync = false;
2207
2208 explicit DidDestroyNavigation(uint64_t navigationID)
2209 : m_arguments(navigationID)
2210 {
2211 }
2212
2213 const Arguments& arguments() const
2214 {
2215 return m_arguments;
2216 }
2217
2218private:
2219 Arguments m_arguments;
2220};
2221
2222class HasInsecureContent {
2223public:
2224 typedef std::tuple<> Arguments;
2225
2226 static IPC::StringReference receiverName() { return messageReceiverName(); }
2227 static IPC::StringReference name() { return IPC::StringReference("HasInsecureContent"); }
2228 static const bool isSync = true;
2229
2230 using DelayedReply = CompletionHandler<void(WebCore::HasInsecureContent hasInsecureContent)>;
2231 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, WebCore::HasInsecureContent hasInsecureContent);
2232 using Reply = std::tuple<WebCore::HasInsecureContent&>;
2233 using ReplyArguments = std::tuple<WebCore::HasInsecureContent>;
2234 const Arguments& arguments() const
2235 {
2236 return m_arguments;
2237 }
2238
2239private:
2240 Arguments m_arguments;
2241};
2242
2243class MainFramePluginHandlesPageScaleGestureDidChange {
2244public:
2245 typedef std::tuple<bool> Arguments;
2246
2247 static IPC::StringReference receiverName() { return messageReceiverName(); }
2248 static IPC::StringReference name() { return IPC::StringReference("MainFramePluginHandlesPageScaleGestureDidChange"); }
2249 static const bool isSync = false;
2250
2251 explicit MainFramePluginHandlesPageScaleGestureDidChange(bool mainFramePluginHandlesPageScaleGesture)
2252 : m_arguments(mainFramePluginHandlesPageScaleGesture)
2253 {
2254 }
2255
2256 const Arguments& arguments() const
2257 {
2258 return m_arguments;
2259 }
2260
2261private:
2262 Arguments m_arguments;
2263};
2264
2265class FrameDidBecomeFrameSet {
2266public:
2267 typedef std::tuple<uint64_t, bool> Arguments;
2268
2269 static IPC::StringReference receiverName() { return messageReceiverName(); }
2270 static IPC::StringReference name() { return IPC::StringReference("FrameDidBecomeFrameSet"); }
2271 static const bool isSync = false;
2272
2273 FrameDidBecomeFrameSet(uint64_t frameID, bool value)
2274 : m_arguments(frameID, value)
2275 {
2276 }
2277
2278 const Arguments& arguments() const
2279 {
2280 return m_arguments;
2281 }
2282
2283private:
2284 Arguments m_arguments;
2285};
2286
2287class DidNavigateWithNavigationData {
2288public:
2289 typedef std::tuple<const WebKit::WebNavigationDataStore&, uint64_t> Arguments;
2290
2291 static IPC::StringReference receiverName() { return messageReceiverName(); }
2292 static IPC::StringReference name() { return IPC::StringReference("DidNavigateWithNavigationData"); }
2293 static const bool isSync = false;
2294
2295 DidNavigateWithNavigationData(const WebKit::WebNavigationDataStore& store, uint64_t frameID)
2296 : m_arguments(store, frameID)
2297 {
2298 }
2299
2300 const Arguments& arguments() const
2301 {
2302 return m_arguments;
2303 }
2304
2305private:
2306 Arguments m_arguments;
2307};
2308
2309class DidPerformClientRedirect {
2310public:
2311 typedef std::tuple<const String&, const String&, uint64_t> Arguments;
2312
2313 static IPC::StringReference receiverName() { return messageReceiverName(); }
2314 static IPC::StringReference name() { return IPC::StringReference("DidPerformClientRedirect"); }
2315 static const bool isSync = false;
2316
2317 DidPerformClientRedirect(const String& sourceURLString, const String& destinationURLString, uint64_t frameID)
2318 : m_arguments(sourceURLString, destinationURLString, frameID)
2319 {
2320 }
2321
2322 const Arguments& arguments() const
2323 {
2324 return m_arguments;
2325 }
2326
2327private:
2328 Arguments m_arguments;
2329};
2330
2331class DidPerformServerRedirect {
2332public:
2333 typedef std::tuple<const String&, const String&, uint64_t> Arguments;
2334
2335 static IPC::StringReference receiverName() { return messageReceiverName(); }
2336 static IPC::StringReference name() { return IPC::StringReference("DidPerformServerRedirect"); }
2337 static const bool isSync = false;
2338
2339 DidPerformServerRedirect(const String& sourceURLString, const String& destinationURLString, uint64_t frameID)
2340 : m_arguments(sourceURLString, destinationURLString, frameID)
2341 {
2342 }
2343
2344 const Arguments& arguments() const
2345 {
2346 return m_arguments;
2347 }
2348
2349private:
2350 Arguments m_arguments;
2351};
2352
2353class DidUpdateHistoryTitle {
2354public:
2355 typedef std::tuple<const String&, const String&, uint64_t> Arguments;
2356
2357 static IPC::StringReference receiverName() { return messageReceiverName(); }
2358 static IPC::StringReference name() { return IPC::StringReference("DidUpdateHistoryTitle"); }
2359 static const bool isSync = false;
2360
2361 DidUpdateHistoryTitle(const String& title, const String& url, uint64_t frameID)
2362 : m_arguments(title, url, frameID)
2363 {
2364 }
2365
2366 const Arguments& arguments() const
2367 {
2368 return m_arguments;
2369 }
2370
2371private:
2372 Arguments m_arguments;
2373};
2374
2375class DidFinishLoadingDataForCustomContentProvider {
2376public:
2377 typedef std::tuple<const String&, const IPC::DataReference&> Arguments;
2378
2379 static IPC::StringReference receiverName() { return messageReceiverName(); }
2380 static IPC::StringReference name() { return IPC::StringReference("DidFinishLoadingDataForCustomContentProvider"); }
2381 static const bool isSync = false;
2382
2383 DidFinishLoadingDataForCustomContentProvider(const String& suggestedFilename, const IPC::DataReference& data)
2384 : m_arguments(suggestedFilename, data)
2385 {
2386 }
2387
2388 const Arguments& arguments() const
2389 {
2390 return m_arguments;
2391 }
2392
2393private:
2394 Arguments m_arguments;
2395};
2396
2397class WillSubmitForm {
2398public:
2399 typedef std::tuple<uint64_t, uint64_t, const Vector<std::pair<String, String>>&, uint64_t, const WebKit::UserData&> Arguments;
2400
2401 static IPC::StringReference receiverName() { return messageReceiverName(); }
2402 static IPC::StringReference name() { return IPC::StringReference("WillSubmitForm"); }
2403 static const bool isSync = false;
2404
2405 WillSubmitForm(uint64_t frameID, uint64_t sourceFrameID, const Vector<std::pair<String, String>>& textFieldValues, uint64_t listenerID, const WebKit::UserData& userData)
2406 : m_arguments(frameID, sourceFrameID, textFieldValues, listenerID, userData)
2407 {
2408 }
2409
2410 const Arguments& arguments() const
2411 {
2412 return m_arguments;
2413 }
2414
2415private:
2416 Arguments m_arguments;
2417};
2418
2419class VoidCallback {
2420public:
2421 typedef std::tuple<const WebKit::CallbackID&> Arguments;
2422
2423 static IPC::StringReference receiverName() { return messageReceiverName(); }
2424 static IPC::StringReference name() { return IPC::StringReference("VoidCallback"); }
2425 static const bool isSync = false;
2426
2427 explicit VoidCallback(const WebKit::CallbackID& callbackID)
2428 : m_arguments(callbackID)
2429 {
2430 }
2431
2432 const Arguments& arguments() const
2433 {
2434 return m_arguments;
2435 }
2436
2437private:
2438 Arguments m_arguments;
2439};
2440
2441class DataCallback {
2442public:
2443 typedef std::tuple<const IPC::SharedBufferDataReference&, const WebKit::CallbackID&> Arguments;
2444
2445 static IPC::StringReference receiverName() { return messageReceiverName(); }
2446 static IPC::StringReference name() { return IPC::StringReference("DataCallback"); }
2447 static const bool isSync = false;
2448
2449 DataCallback(const IPC::SharedBufferDataReference& resultData, const WebKit::CallbackID& callbackID)
2450 : m_arguments(resultData, callbackID)
2451 {
2452 }
2453
2454 const Arguments& arguments() const
2455 {
2456 return m_arguments;
2457 }
2458
2459private:
2460 Arguments m_arguments;
2461};
2462
2463class ImageCallback {
2464public:
2465 typedef std::tuple<const WebKit::ShareableBitmap::Handle&, const WebKit::CallbackID&> Arguments;
2466
2467 static IPC::StringReference receiverName() { return messageReceiverName(); }
2468 static IPC::StringReference name() { return IPC::StringReference("ImageCallback"); }
2469 static const bool isSync = false;
2470
2471 ImageCallback(const WebKit::ShareableBitmap::Handle& bitmapHandle, const WebKit::CallbackID& callbackID)
2472 : m_arguments(bitmapHandle, callbackID)
2473 {
2474 }
2475
2476 const Arguments& arguments() const
2477 {
2478 return m_arguments;
2479 }
2480
2481private:
2482 Arguments m_arguments;
2483};
2484
2485class StringCallback {
2486public:
2487 typedef std::tuple<const String&, const WebKit::CallbackID&> Arguments;
2488
2489 static IPC::StringReference receiverName() { return messageReceiverName(); }
2490 static IPC::StringReference name() { return IPC::StringReference("StringCallback"); }
2491 static const bool isSync = false;
2492
2493 StringCallback(const String& resultString, const WebKit::CallbackID& callbackID)
2494 : m_arguments(resultString, callbackID)
2495 {
2496 }
2497
2498 const Arguments& arguments() const
2499 {
2500 return m_arguments;
2501 }
2502
2503private:
2504 Arguments m_arguments;
2505};
2506
2507class InvalidateStringCallback {
2508public:
2509 typedef std::tuple<const WebKit::CallbackID&> Arguments;
2510
2511 static IPC::StringReference receiverName() { return messageReceiverName(); }
2512 static IPC::StringReference name() { return IPC::StringReference("InvalidateStringCallback"); }
2513 static const bool isSync = false;
2514
2515 explicit InvalidateStringCallback(const WebKit::CallbackID& callbackID)
2516 : m_arguments(callbackID)
2517 {
2518 }
2519
2520 const Arguments& arguments() const
2521 {
2522 return m_arguments;
2523 }
2524
2525private:
2526 Arguments m_arguments;
2527};
2528
2529class ScriptValueCallback {
2530public:
2531 typedef std::tuple<const IPC::DataReference&, bool, const WebCore::ExceptionDetails&, const WebKit::CallbackID&> Arguments;
2532
2533 static IPC::StringReference receiverName() { return messageReceiverName(); }
2534 static IPC::StringReference name() { return IPC::StringReference("ScriptValueCallback"); }
2535 static const bool isSync = false;
2536
2537 ScriptValueCallback(const IPC::DataReference& resultData, bool hadException, const WebCore::ExceptionDetails& details, const WebKit::CallbackID& callbackID)
2538 : m_arguments(resultData, hadException, details, callbackID)
2539 {
2540 }
2541
2542 const Arguments& arguments() const
2543 {
2544 return m_arguments;
2545 }
2546
2547private:
2548 Arguments m_arguments;
2549};
2550
2551class ComputedPagesCallback {
2552public:
2553 typedef std::tuple<const Vector<WebCore::IntRect>&, double, const WebCore::RectEdges<float>&, const WebKit::CallbackID&> Arguments;
2554
2555 static IPC::StringReference receiverName() { return messageReceiverName(); }
2556 static IPC::StringReference name() { return IPC::StringReference("ComputedPagesCallback"); }
2557 static const bool isSync = false;
2558
2559 ComputedPagesCallback(const Vector<WebCore::IntRect>& pageRects, double totalScaleFactorForPrinting, const WebCore::RectEdges<float>& computedPageMargin, const WebKit::CallbackID& callbackID)
2560 : m_arguments(pageRects, totalScaleFactorForPrinting, computedPageMargin, callbackID)
2561 {
2562 }
2563
2564 const Arguments& arguments() const
2565 {
2566 return m_arguments;
2567 }
2568
2569private:
2570 Arguments m_arguments;
2571};
2572
2573class ValidateCommandCallback {
2574public:
2575 typedef std::tuple<const String&, bool, int32_t, const WebKit::CallbackID&> Arguments;
2576
2577 static IPC::StringReference receiverName() { return messageReceiverName(); }
2578 static IPC::StringReference name() { return IPC::StringReference("ValidateCommandCallback"); }
2579 static const bool isSync = false;
2580
2581 ValidateCommandCallback(const String& command, bool isEnabled, int32_t state, const WebKit::CallbackID& callbackID)
2582 : m_arguments(command, isEnabled, state, callbackID)
2583 {
2584 }
2585
2586 const Arguments& arguments() const
2587 {
2588 return m_arguments;
2589 }
2590
2591private:
2592 Arguments m_arguments;
2593};
2594
2595class EditingRangeCallback {
2596public:
2597 typedef std::tuple<const WebKit::EditingRange&, const WebKit::CallbackID&> Arguments;
2598
2599 static IPC::StringReference receiverName() { return messageReceiverName(); }
2600 static IPC::StringReference name() { return IPC::StringReference("EditingRangeCallback"); }
2601 static const bool isSync = false;
2602
2603 EditingRangeCallback(const WebKit::EditingRange& range, const WebKit::CallbackID& callbackID)
2604 : m_arguments(range, callbackID)
2605 {
2606 }
2607
2608 const Arguments& arguments() const
2609 {
2610 return m_arguments;
2611 }
2612
2613private:
2614 Arguments m_arguments;
2615};
2616
2617class UnsignedCallback {
2618public:
2619 typedef std::tuple<uint64_t, const WebKit::CallbackID&> Arguments;
2620
2621 static IPC::StringReference receiverName() { return messageReceiverName(); }
2622 static IPC::StringReference name() { return IPC::StringReference("UnsignedCallback"); }
2623 static const bool isSync = false;
2624
2625 UnsignedCallback(uint64_t result, const WebKit::CallbackID& callbackID)
2626 : m_arguments(result, callbackID)
2627 {
2628 }
2629
2630 const Arguments& arguments() const
2631 {
2632 return m_arguments;
2633 }
2634
2635private:
2636 Arguments m_arguments;
2637};
2638
2639class RectForCharacterRangeCallback {
2640public:
2641 typedef std::tuple<const WebCore::IntRect&, const WebKit::EditingRange&, const WebKit::CallbackID&> Arguments;
2642
2643 static IPC::StringReference receiverName() { return messageReceiverName(); }
2644 static IPC::StringReference name() { return IPC::StringReference("RectForCharacterRangeCallback"); }
2645 static const bool isSync = false;
2646
2647 RectForCharacterRangeCallback(const WebCore::IntRect& rect, const WebKit::EditingRange& actualRange, const WebKit::CallbackID& callbackID)
2648 : m_arguments(rect, actualRange, callbackID)
2649 {
2650 }
2651
2652 const Arguments& arguments() const
2653 {
2654 return m_arguments;
2655 }
2656
2657private:
2658 Arguments m_arguments;
2659};
2660
2661#if ENABLE(APPLICATION_MANIFEST)
2662class ApplicationManifestCallback {
2663public:
2664 typedef std::tuple<const Optional<WebCore::ApplicationManifest>&, const WebKit::CallbackID&> Arguments;
2665
2666 static IPC::StringReference receiverName() { return messageReceiverName(); }
2667 static IPC::StringReference name() { return IPC::StringReference("ApplicationManifestCallback"); }
2668 static const bool isSync = false;
2669
2670 ApplicationManifestCallback(const Optional<WebCore::ApplicationManifest>& manifest, const WebKit::CallbackID& callbackID)
2671 : m_arguments(manifest, callbackID)
2672 {
2673 }
2674
2675 const Arguments& arguments() const
2676 {
2677 return m_arguments;
2678 }
2679
2680private:
2681 Arguments m_arguments;
2682};
2683#endif
2684
2685#if PLATFORM(MAC)
2686class AttributedStringForCharacterRangeCallback {
2687public:
2688 typedef std::tuple<const WebKit::AttributedString&, const WebKit::EditingRange&, const WebKit::CallbackID&> Arguments;
2689
2690 static IPC::StringReference receiverName() { return messageReceiverName(); }
2691 static IPC::StringReference name() { return IPC::StringReference("AttributedStringForCharacterRangeCallback"); }
2692 static const bool isSync = false;
2693
2694 AttributedStringForCharacterRangeCallback(const WebKit::AttributedString& string, const WebKit::EditingRange& actualRange, const WebKit::CallbackID& callbackID)
2695 : m_arguments(string, actualRange, callbackID)
2696 {
2697 }
2698
2699 const Arguments& arguments() const
2700 {
2701 return m_arguments;
2702 }
2703
2704private:
2705 Arguments m_arguments;
2706};
2707#endif
2708
2709#if PLATFORM(MAC)
2710class FontAtSelectionCallback {
2711public:
2712 typedef std::tuple<const String&, double, bool, const WebKit::CallbackID&> Arguments;
2713
2714 static IPC::StringReference receiverName() { return messageReceiverName(); }
2715 static IPC::StringReference name() { return IPC::StringReference("FontAtSelectionCallback"); }
2716 static const bool isSync = false;
2717
2718 FontAtSelectionCallback(const String& fontName, double fontSize, bool selectioHasMultipleFonts, const WebKit::CallbackID& callbackID)
2719 : m_arguments(fontName, fontSize, selectioHasMultipleFonts, callbackID)
2720 {
2721 }
2722
2723 const Arguments& arguments() const
2724 {
2725 return m_arguments;
2726 }
2727
2728private:
2729 Arguments m_arguments;
2730};
2731#endif
2732
2733class FontAttributesCallback {
2734public:
2735 typedef std::tuple<const WebCore::FontAttributes&, const WebKit::CallbackID&> Arguments;
2736
2737 static IPC::StringReference receiverName() { return messageReceiverName(); }
2738 static IPC::StringReference name() { return IPC::StringReference("FontAttributesCallback"); }
2739 static const bool isSync = false;
2740
2741 FontAttributesCallback(const WebCore::FontAttributes& attributes, const WebKit::CallbackID& callbackID)
2742 : m_arguments(attributes, callbackID)
2743 {
2744 }
2745
2746 const Arguments& arguments() const
2747 {
2748 return m_arguments;
2749 }
2750
2751private:
2752 Arguments m_arguments;
2753};
2754
2755#if PLATFORM(IOS_FAMILY)
2756class GestureCallback {
2757public:
2758 typedef std::tuple<const WebCore::IntPoint&, uint32_t, uint32_t, uint32_t, const WebKit::CallbackID&> Arguments;
2759
2760 static IPC::StringReference receiverName() { return messageReceiverName(); }
2761 static IPC::StringReference name() { return IPC::StringReference("GestureCallback"); }
2762 static const bool isSync = false;
2763
2764 GestureCallback(const WebCore::IntPoint& point, uint32_t gestureType, uint32_t gestureState, uint32_t flags, const WebKit::CallbackID& callbackID)
2765 : m_arguments(point, gestureType, gestureState, flags, callbackID)
2766 {
2767 }
2768
2769 const Arguments& arguments() const
2770 {
2771 return m_arguments;
2772 }
2773
2774private:
2775 Arguments m_arguments;
2776};
2777#endif
2778
2779#if PLATFORM(IOS_FAMILY)
2780class TouchesCallback {
2781public:
2782 typedef std::tuple<const WebCore::IntPoint&, uint32_t, uint32_t, const WebKit::CallbackID&> Arguments;
2783
2784 static IPC::StringReference receiverName() { return messageReceiverName(); }
2785 static IPC::StringReference name() { return IPC::StringReference("TouchesCallback"); }
2786 static const bool isSync = false;
2787
2788 TouchesCallback(const WebCore::IntPoint& point, uint32_t touches, uint32_t flags, const WebKit::CallbackID& callbackID)
2789 : m_arguments(point, touches, flags, callbackID)
2790 {
2791 }
2792
2793 const Arguments& arguments() const
2794 {
2795 return m_arguments;
2796 }
2797
2798private:
2799 Arguments m_arguments;
2800};
2801#endif
2802
2803#if PLATFORM(IOS_FAMILY)
2804class SelectionContextCallback {
2805public:
2806 typedef std::tuple<const String&, const String&, const String&, const WebKit::CallbackID&> Arguments;
2807
2808 static IPC::StringReference receiverName() { return messageReceiverName(); }
2809 static IPC::StringReference name() { return IPC::StringReference("SelectionContextCallback"); }
2810 static const bool isSync = false;
2811
2812 SelectionContextCallback(const String& selectedText, const String& beforeText, const String& afterText, const WebKit::CallbackID& callbackID)
2813 : m_arguments(selectedText, beforeText, afterText, callbackID)
2814 {
2815 }
2816
2817 const Arguments& arguments() const
2818 {
2819 return m_arguments;
2820 }
2821
2822private:
2823 Arguments m_arguments;
2824};
2825#endif
2826
2827#if PLATFORM(IOS_FAMILY)
2828class InterpretKeyEvent {
2829public:
2830 typedef std::tuple<const WebKit::EditorState&, bool> Arguments;
2831
2832 static IPC::StringReference receiverName() { return messageReceiverName(); }
2833 static IPC::StringReference name() { return IPC::StringReference("InterpretKeyEvent"); }
2834 static const bool isSync = true;
2835
2836 using DelayedReply = CompletionHandler<void(bool handled)>;
2837 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool handled);
2838 using Reply = std::tuple<bool&>;
2839 using ReplyArguments = std::tuple<bool>;
2840 InterpretKeyEvent(const WebKit::EditorState& state, bool isCharEvent)
2841 : m_arguments(state, isCharEvent)
2842 {
2843 }
2844
2845 const Arguments& arguments() const
2846 {
2847 return m_arguments;
2848 }
2849
2850private:
2851 Arguments m_arguments;
2852};
2853#endif
2854
2855#if PLATFORM(IOS_FAMILY)
2856class DidReceivePositionInformation {
2857public:
2858 typedef std::tuple<const WebKit::InteractionInformationAtPosition&> Arguments;
2859
2860 static IPC::StringReference receiverName() { return messageReceiverName(); }
2861 static IPC::StringReference name() { return IPC::StringReference("DidReceivePositionInformation"); }
2862 static const bool isSync = false;
2863
2864 explicit DidReceivePositionInformation(const WebKit::InteractionInformationAtPosition& information)
2865 : m_arguments(information)
2866 {
2867 }
2868
2869 const Arguments& arguments() const
2870 {
2871 return m_arguments;
2872 }
2873
2874private:
2875 Arguments m_arguments;
2876};
2877#endif
2878
2879#if PLATFORM(IOS_FAMILY)
2880class SaveImageToLibrary {
2881public:
2882 typedef std::tuple<const WebKit::SharedMemory::Handle&, uint64_t> Arguments;
2883
2884 static IPC::StringReference receiverName() { return messageReceiverName(); }
2885 static IPC::StringReference name() { return IPC::StringReference("SaveImageToLibrary"); }
2886 static const bool isSync = false;
2887
2888 SaveImageToLibrary(const WebKit::SharedMemory::Handle& handle, uint64_t size)
2889 : m_arguments(handle, size)
2890 {
2891 }
2892
2893 const Arguments& arguments() const
2894 {
2895 return m_arguments;
2896 }
2897
2898private:
2899 Arguments m_arguments;
2900};
2901#endif
2902
2903#if PLATFORM(IOS_FAMILY)
2904class ShowPlaybackTargetPicker {
2905public:
2906 typedef std::tuple<bool, const WebCore::IntRect&, WebCore::RouteSharingPolicy, const String&> Arguments;
2907
2908 static IPC::StringReference receiverName() { return messageReceiverName(); }
2909 static IPC::StringReference name() { return IPC::StringReference("ShowPlaybackTargetPicker"); }
2910 static const bool isSync = false;
2911
2912 ShowPlaybackTargetPicker(bool hasVideo, const WebCore::IntRect& elementRect, WebCore::RouteSharingPolicy policy, const String& routingContextUID)
2913 : m_arguments(hasVideo, elementRect, policy, routingContextUID)
2914 {
2915 }
2916
2917 const Arguments& arguments() const
2918 {
2919 return m_arguments;
2920 }
2921
2922private:
2923 Arguments m_arguments;
2924};
2925#endif
2926
2927#if PLATFORM(IOS_FAMILY)
2928class CommitPotentialTapFailed {
2929public:
2930 typedef std::tuple<> Arguments;
2931
2932 static IPC::StringReference receiverName() { return messageReceiverName(); }
2933 static IPC::StringReference name() { return IPC::StringReference("CommitPotentialTapFailed"); }
2934 static const bool isSync = false;
2935
2936 const Arguments& arguments() const
2937 {
2938 return m_arguments;
2939 }
2940
2941private:
2942 Arguments m_arguments;
2943};
2944#endif
2945
2946#if PLATFORM(IOS_FAMILY)
2947class DidNotHandleTapAsClick {
2948public:
2949 typedef std::tuple<const WebCore::IntPoint&> Arguments;
2950
2951 static IPC::StringReference receiverName() { return messageReceiverName(); }
2952 static IPC::StringReference name() { return IPC::StringReference("DidNotHandleTapAsClick"); }
2953 static const bool isSync = false;
2954
2955 explicit DidNotHandleTapAsClick(const WebCore::IntPoint& point)
2956 : m_arguments(point)
2957 {
2958 }
2959
2960 const Arguments& arguments() const
2961 {
2962 return m_arguments;
2963 }
2964
2965private:
2966 Arguments m_arguments;
2967};
2968#endif
2969
2970#if PLATFORM(IOS_FAMILY)
2971class DidCompleteSyntheticClick {
2972public:
2973 typedef std::tuple<> Arguments;
2974
2975 static IPC::StringReference receiverName() { return messageReceiverName(); }
2976 static IPC::StringReference name() { return IPC::StringReference("DidCompleteSyntheticClick"); }
2977 static const bool isSync = false;
2978
2979 const Arguments& arguments() const
2980 {
2981 return m_arguments;
2982 }
2983
2984private:
2985 Arguments m_arguments;
2986};
2987#endif
2988
2989#if PLATFORM(IOS_FAMILY)
2990class DisableDoubleTapGesturesDuringTapIfNecessary {
2991public:
2992 typedef std::tuple<uint64_t> Arguments;
2993
2994 static IPC::StringReference receiverName() { return messageReceiverName(); }
2995 static IPC::StringReference name() { return IPC::StringReference("DisableDoubleTapGesturesDuringTapIfNecessary"); }
2996 static const bool isSync = false;
2997
2998 explicit DisableDoubleTapGesturesDuringTapIfNecessary(uint64_t requestID)
2999 : m_arguments(requestID)
3000 {
3001 }
3002
3003 const Arguments& arguments() const
3004 {
3005 return m_arguments;
3006 }
3007
3008private:
3009 Arguments m_arguments;
3010};
3011#endif
3012
3013#if PLATFORM(IOS_FAMILY)
3014class HandleSmartMagnificationInformationForPotentialTap {
3015public:
3016 typedef std::tuple<uint64_t, const WebCore::FloatRect&, bool, double, double> Arguments;
3017
3018 static IPC::StringReference receiverName() { return messageReceiverName(); }
3019 static IPC::StringReference name() { return IPC::StringReference("HandleSmartMagnificationInformationForPotentialTap"); }
3020 static const bool isSync = false;
3021
3022 HandleSmartMagnificationInformationForPotentialTap(uint64_t requestID, const WebCore::FloatRect& renderRect, bool fitEntireRect, double viewportMinimumScale, double viewportMaximumScale)
3023 : m_arguments(requestID, renderRect, fitEntireRect, viewportMinimumScale, viewportMaximumScale)
3024 {
3025 }
3026
3027 const Arguments& arguments() const
3028 {
3029 return m_arguments;
3030 }
3031
3032private:
3033 Arguments m_arguments;
3034};
3035#endif
3036
3037#if PLATFORM(IOS_FAMILY)
3038class DrawToPDFCallback {
3039public:
3040 typedef std::tuple<const IPC::DataReference&, const WebKit::CallbackID&> Arguments;
3041
3042 static IPC::StringReference receiverName() { return messageReceiverName(); }
3043 static IPC::StringReference name() { return IPC::StringReference("DrawToPDFCallback"); }
3044 static const bool isSync = false;
3045
3046 DrawToPDFCallback(const IPC::DataReference& pdfData, const WebKit::CallbackID& callbackID)
3047 : m_arguments(pdfData, callbackID)
3048 {
3049 }
3050
3051 const Arguments& arguments() const
3052 {
3053 return m_arguments;
3054 }
3055
3056private:
3057 Arguments m_arguments;
3058};
3059#endif
3060
3061#if PLATFORM(IOS_FAMILY)
3062class SelectionRectsCallback {
3063public:
3064 typedef std::tuple<const Vector<WebCore::SelectionRect>&, const WebKit::CallbackID&> Arguments;
3065
3066 static IPC::StringReference receiverName() { return messageReceiverName(); }
3067 static IPC::StringReference name() { return IPC::StringReference("SelectionRectsCallback"); }
3068 static const bool isSync = false;
3069
3070 SelectionRectsCallback(const Vector<WebCore::SelectionRect>& selectionRects, const WebKit::CallbackID& callbackID)
3071 : m_arguments(selectionRects, callbackID)
3072 {
3073 }
3074
3075 const Arguments& arguments() const
3076 {
3077 return m_arguments;
3078 }
3079
3080private:
3081 Arguments m_arguments;
3082};
3083#endif
3084
3085#if ENABLE(DATA_DETECTION)
3086class SetDataDetectionResult {
3087public:
3088 typedef std::tuple<const WebKit::DataDetectionResult&> Arguments;
3089
3090 static IPC::StringReference receiverName() { return messageReceiverName(); }
3091 static IPC::StringReference name() { return IPC::StringReference("SetDataDetectionResult"); }
3092 static const bool isSync = false;
3093
3094 explicit SetDataDetectionResult(const WebKit::DataDetectionResult& dataDetectionResult)
3095 : m_arguments(dataDetectionResult)
3096 {
3097 }
3098
3099 const Arguments& arguments() const
3100 {
3101 return m_arguments;
3102 }
3103
3104private:
3105 Arguments m_arguments;
3106};
3107#endif
3108
3109#if PLATFORM(GTK)
3110class PrintFinishedCallback {
3111public:
3112 typedef std::tuple<const WebCore::ResourceError&, const WebKit::CallbackID&> Arguments;
3113
3114 static IPC::StringReference receiverName() { return messageReceiverName(); }
3115 static IPC::StringReference name() { return IPC::StringReference("PrintFinishedCallback"); }
3116 static const bool isSync = false;
3117
3118 PrintFinishedCallback(const WebCore::ResourceError& error, const WebKit::CallbackID& callbackID)
3119 : m_arguments(error, callbackID)
3120 {
3121 }
3122
3123 const Arguments& arguments() const
3124 {
3125 return m_arguments;
3126 }
3127
3128private:
3129 Arguments m_arguments;
3130};
3131#endif
3132
3133#if PLATFORM(COCOA)
3134class MachSendRightCallback {
3135public:
3136 typedef std::tuple<const MachSendRight&, const WebKit::CallbackID&> Arguments;
3137
3138 static IPC::StringReference receiverName() { return messageReceiverName(); }
3139 static IPC::StringReference name() { return IPC::StringReference("MachSendRightCallback"); }
3140 static const bool isSync = false;
3141
3142 MachSendRightCallback(const MachSendRight& sendRight, const WebKit::CallbackID& callbackID)
3143 : m_arguments(sendRight, callbackID)
3144 {
3145 }
3146
3147 const Arguments& arguments() const
3148 {
3149 return m_arguments;
3150 }
3151
3152private:
3153 Arguments m_arguments;
3154};
3155#endif
3156
3157#if PLATFORM(COCOA)
3158class NowPlayingInfoCallback {
3159public:
3160 typedef std::tuple<bool, bool, const String&, double, double, uint64_t, const WebKit::CallbackID&> Arguments;
3161
3162 static IPC::StringReference receiverName() { return messageReceiverName(); }
3163 static IPC::StringReference name() { return IPC::StringReference("NowPlayingInfoCallback"); }
3164 static const bool isSync = false;
3165
3166 NowPlayingInfoCallback(bool active, bool registeredAsNowPlayingApplication, const String& title, double duration, double elapsedTime, uint64_t uniqueIdentifier, const WebKit::CallbackID& callbackID)
3167 : m_arguments(active, registeredAsNowPlayingApplication, title, duration, elapsedTime, uniqueIdentifier, callbackID)
3168 {
3169 }
3170
3171 const Arguments& arguments() const
3172 {
3173 return m_arguments;
3174 }
3175
3176private:
3177 Arguments m_arguments;
3178};
3179#endif
3180
3181class PageScaleFactorDidChange {
3182public:
3183 typedef std::tuple<double> Arguments;
3184
3185 static IPC::StringReference receiverName() { return messageReceiverName(); }
3186 static IPC::StringReference name() { return IPC::StringReference("PageScaleFactorDidChange"); }
3187 static const bool isSync = false;
3188
3189 explicit PageScaleFactorDidChange(double scaleFactor)
3190 : m_arguments(scaleFactor)
3191 {
3192 }
3193
3194 const Arguments& arguments() const
3195 {
3196 return m_arguments;
3197 }
3198
3199private:
3200 Arguments m_arguments;
3201};
3202
3203class PluginScaleFactorDidChange {
3204public:
3205 typedef std::tuple<double> Arguments;
3206
3207 static IPC::StringReference receiverName() { return messageReceiverName(); }
3208 static IPC::StringReference name() { return IPC::StringReference("PluginScaleFactorDidChange"); }
3209 static const bool isSync = false;
3210
3211 explicit PluginScaleFactorDidChange(double zoomFactor)
3212 : m_arguments(zoomFactor)
3213 {
3214 }
3215
3216 const Arguments& arguments() const
3217 {
3218 return m_arguments;
3219 }
3220
3221private:
3222 Arguments m_arguments;
3223};
3224
3225class PluginZoomFactorDidChange {
3226public:
3227 typedef std::tuple<double> Arguments;
3228
3229 static IPC::StringReference receiverName() { return messageReceiverName(); }
3230 static IPC::StringReference name() { return IPC::StringReference("PluginZoomFactorDidChange"); }
3231 static const bool isSync = false;
3232
3233 explicit PluginZoomFactorDidChange(double zoomFactor)
3234 : m_arguments(zoomFactor)
3235 {
3236 }
3237
3238 const Arguments& arguments() const
3239 {
3240 return m_arguments;
3241 }
3242
3243private:
3244 Arguments m_arguments;
3245};
3246
3247#if USE(ATK)
3248class BindAccessibilityTree {
3249public:
3250 typedef std::tuple<const String&> Arguments;
3251
3252 static IPC::StringReference receiverName() { return messageReceiverName(); }
3253 static IPC::StringReference name() { return IPC::StringReference("BindAccessibilityTree"); }
3254 static const bool isSync = false;
3255
3256 explicit BindAccessibilityTree(const String& plugID)
3257 : m_arguments(plugID)
3258 {
3259 }
3260
3261 const Arguments& arguments() const
3262 {
3263 return m_arguments;
3264 }
3265
3266private:
3267 Arguments m_arguments;
3268};
3269#endif
3270
3271#if PLATFORM(GTK)
3272class SetInputMethodState {
3273public:
3274 typedef std::tuple<bool> Arguments;
3275
3276 static IPC::StringReference receiverName() { return messageReceiverName(); }
3277 static IPC::StringReference name() { return IPC::StringReference("SetInputMethodState"); }
3278 static const bool isSync = false;
3279
3280 explicit SetInputMethodState(bool enabled)
3281 : m_arguments(enabled)
3282 {
3283 }
3284
3285 const Arguments& arguments() const
3286 {
3287 return m_arguments;
3288 }
3289
3290private:
3291 Arguments m_arguments;
3292};
3293#endif
3294
3295class BackForwardAddItem {
3296public:
3297 typedef std::tuple<const WebKit::BackForwardListItemState&> Arguments;
3298
3299 static IPC::StringReference receiverName() { return messageReceiverName(); }
3300 static IPC::StringReference name() { return IPC::StringReference("BackForwardAddItem"); }
3301 static const bool isSync = false;
3302
3303 explicit BackForwardAddItem(const WebKit::BackForwardListItemState& itemState)
3304 : m_arguments(itemState)
3305 {
3306 }
3307
3308 const Arguments& arguments() const
3309 {
3310 return m_arguments;
3311 }
3312
3313private:
3314 Arguments m_arguments;
3315};
3316
3317class BackForwardGoToItem {
3318public:
3319 typedef std::tuple<const WebCore::BackForwardItemIdentifier&> Arguments;
3320
3321 static IPC::StringReference receiverName() { return messageReceiverName(); }
3322 static IPC::StringReference name() { return IPC::StringReference("BackForwardGoToItem"); }
3323 static const bool isSync = true;
3324
3325 using DelayedReply = CompletionHandler<void(const WebKit::SandboxExtension::Handle& sandboxExtensionHandle)>;
3326 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const WebKit::SandboxExtension::Handle& sandboxExtensionHandle);
3327 using Reply = std::tuple<WebKit::SandboxExtension::Handle&>;
3328 using ReplyArguments = std::tuple<WebKit::SandboxExtension::Handle>;
3329 explicit BackForwardGoToItem(const WebCore::BackForwardItemIdentifier& itemID)
3330 : m_arguments(itemID)
3331 {
3332 }
3333
3334 const Arguments& arguments() const
3335 {
3336 return m_arguments;
3337 }
3338
3339private:
3340 Arguments m_arguments;
3341};
3342
3343class BackForwardItemAtIndex {
3344public:
3345 typedef std::tuple<int32_t> Arguments;
3346
3347 static IPC::StringReference receiverName() { return messageReceiverName(); }
3348 static IPC::StringReference name() { return IPC::StringReference("BackForwardItemAtIndex"); }
3349 static const bool isSync = true;
3350
3351 using DelayedReply = CompletionHandler<void(const Optional<WebCore::BackForwardItemIdentifier>& itemID)>;
3352 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const Optional<WebCore::BackForwardItemIdentifier>& itemID);
3353 using Reply = std::tuple<Optional<WebCore::BackForwardItemIdentifier>&>;
3354 using ReplyArguments = std::tuple<Optional<WebCore::BackForwardItemIdentifier>>;
3355 explicit BackForwardItemAtIndex(int32_t itemIndex)
3356 : m_arguments(itemIndex)
3357 {
3358 }
3359
3360 const Arguments& arguments() const
3361 {
3362 return m_arguments;
3363 }
3364
3365private:
3366 Arguments m_arguments;
3367};
3368
3369class BackForwardBackListCount {
3370public:
3371 typedef std::tuple<> Arguments;
3372
3373 static IPC::StringReference receiverName() { return messageReceiverName(); }
3374 static IPC::StringReference name() { return IPC::StringReference("BackForwardBackListCount"); }
3375 static const bool isSync = true;
3376
3377 using DelayedReply = CompletionHandler<void(uint32_t count)>;
3378 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, uint32_t count);
3379 using Reply = std::tuple<uint32_t&>;
3380 using ReplyArguments = std::tuple<uint32_t>;
3381 const Arguments& arguments() const
3382 {
3383 return m_arguments;
3384 }
3385
3386private:
3387 Arguments m_arguments;
3388};
3389
3390class BackForwardForwardListCount {
3391public:
3392 typedef std::tuple<> Arguments;
3393
3394 static IPC::StringReference receiverName() { return messageReceiverName(); }
3395 static IPC::StringReference name() { return IPC::StringReference("BackForwardForwardListCount"); }
3396 static const bool isSync = true;
3397
3398 using DelayedReply = CompletionHandler<void(uint32_t count)>;
3399 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, uint32_t count);
3400 using Reply = std::tuple<uint32_t&>;
3401 using ReplyArguments = std::tuple<uint32_t>;
3402 const Arguments& arguments() const
3403 {
3404 return m_arguments;
3405 }
3406
3407private:
3408 Arguments m_arguments;
3409};
3410
3411class BackForwardClear {
3412public:
3413 typedef std::tuple<> Arguments;
3414
3415 static IPC::StringReference receiverName() { return messageReceiverName(); }
3416 static IPC::StringReference name() { return IPC::StringReference("BackForwardClear"); }
3417 static const bool isSync = false;
3418
3419 const Arguments& arguments() const
3420 {
3421 return m_arguments;
3422 }
3423
3424private:
3425 Arguments m_arguments;
3426};
3427
3428class WillGoToBackForwardListItem {
3429public:
3430 typedef std::tuple<const WebCore::BackForwardItemIdentifier&, bool> Arguments;
3431
3432 static IPC::StringReference receiverName() { return messageReceiverName(); }
3433 static IPC::StringReference name() { return IPC::StringReference("WillGoToBackForwardListItem"); }
3434 static const bool isSync = false;
3435
3436 WillGoToBackForwardListItem(const WebCore::BackForwardItemIdentifier& itemID, bool inPageCache)
3437 : m_arguments(itemID, inPageCache)
3438 {
3439 }
3440
3441 const Arguments& arguments() const
3442 {
3443 return m_arguments;
3444 }
3445
3446private:
3447 Arguments m_arguments;
3448};
3449
3450class RegisterEditCommandForUndo {
3451public:
3452 typedef std::tuple<uint64_t, const String&> Arguments;
3453
3454 static IPC::StringReference receiverName() { return messageReceiverName(); }
3455 static IPC::StringReference name() { return IPC::StringReference("RegisterEditCommandForUndo"); }
3456 static const bool isSync = false;
3457
3458 RegisterEditCommandForUndo(uint64_t commandID, const String& label)
3459 : m_arguments(commandID, label)
3460 {
3461 }
3462
3463 const Arguments& arguments() const
3464 {
3465 return m_arguments;
3466 }
3467
3468private:
3469 Arguments m_arguments;
3470};
3471
3472class ClearAllEditCommands {
3473public:
3474 typedef std::tuple<> Arguments;
3475
3476 static IPC::StringReference receiverName() { return messageReceiverName(); }
3477 static IPC::StringReference name() { return IPC::StringReference("ClearAllEditCommands"); }
3478 static const bool isSync = false;
3479
3480 const Arguments& arguments() const
3481 {
3482 return m_arguments;
3483 }
3484
3485private:
3486 Arguments m_arguments;
3487};
3488
3489class RegisterInsertionUndoGrouping {
3490public:
3491 typedef std::tuple<> Arguments;
3492
3493 static IPC::StringReference receiverName() { return messageReceiverName(); }
3494 static IPC::StringReference name() { return IPC::StringReference("RegisterInsertionUndoGrouping"); }
3495 static const bool isSync = false;
3496
3497 const Arguments& arguments() const
3498 {
3499 return m_arguments;
3500 }
3501
3502private:
3503 Arguments m_arguments;
3504};
3505
3506class CanUndoRedo {
3507public:
3508 typedef std::tuple<WebKit::UndoOrRedo> Arguments;
3509
3510 static IPC::StringReference receiverName() { return messageReceiverName(); }
3511 static IPC::StringReference name() { return IPC::StringReference("CanUndoRedo"); }
3512 static const bool isSync = true;
3513
3514 using DelayedReply = CompletionHandler<void(bool result)>;
3515 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool result);
3516 using Reply = std::tuple<bool&>;
3517 using ReplyArguments = std::tuple<bool>;
3518 explicit CanUndoRedo(WebKit::UndoOrRedo undoOrRedo)
3519 : m_arguments(undoOrRedo)
3520 {
3521 }
3522
3523 const Arguments& arguments() const
3524 {
3525 return m_arguments;
3526 }
3527
3528private:
3529 Arguments m_arguments;
3530};
3531
3532class ExecuteUndoRedo {
3533public:
3534 typedef std::tuple<WebKit::UndoOrRedo> Arguments;
3535
3536 static IPC::StringReference receiverName() { return messageReceiverName(); }
3537 static IPC::StringReference name() { return IPC::StringReference("ExecuteUndoRedo"); }
3538 static const bool isSync = true;
3539
3540 using DelayedReply = CompletionHandler<void()>;
3541 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
3542 using Reply = std::tuple<>;
3543 using ReplyArguments = std::tuple<>;
3544 explicit ExecuteUndoRedo(WebKit::UndoOrRedo undoOrRedo)
3545 : m_arguments(undoOrRedo)
3546 {
3547 }
3548
3549 const Arguments& arguments() const
3550 {
3551 return m_arguments;
3552 }
3553
3554private:
3555 Arguments m_arguments;
3556};
3557
3558class LogDiagnosticMessage {
3559public:
3560 typedef std::tuple<const String&, const String&, WebCore::ShouldSample> Arguments;
3561
3562 static IPC::StringReference receiverName() { return messageReceiverName(); }
3563 static IPC::StringReference name() { return IPC::StringReference("LogDiagnosticMessage"); }
3564 static const bool isSync = false;
3565
3566 LogDiagnosticMessage(const String& message, const String& description, WebCore::ShouldSample shouldSample)
3567 : m_arguments(message, description, shouldSample)
3568 {
3569 }
3570
3571 const Arguments& arguments() const
3572 {
3573 return m_arguments;
3574 }
3575
3576private:
3577 Arguments m_arguments;
3578};
3579
3580class LogDiagnosticMessageWithResult {
3581public:
3582 typedef std::tuple<const String&, const String&, uint32_t, WebCore::ShouldSample> Arguments;
3583
3584 static IPC::StringReference receiverName() { return messageReceiverName(); }
3585 static IPC::StringReference name() { return IPC::StringReference("LogDiagnosticMessageWithResult"); }
3586 static const bool isSync = false;
3587
3588 LogDiagnosticMessageWithResult(const String& message, const String& description, uint32_t result, WebCore::ShouldSample shouldSample)
3589 : m_arguments(message, description, result, shouldSample)
3590 {
3591 }
3592
3593 const Arguments& arguments() const
3594 {
3595 return m_arguments;
3596 }
3597
3598private:
3599 Arguments m_arguments;
3600};
3601
3602class LogDiagnosticMessageWithValue {
3603public:
3604 typedef std::tuple<const String&, const String&, double, const unsigned&, WebCore::ShouldSample> Arguments;
3605
3606 static IPC::StringReference receiverName() { return messageReceiverName(); }
3607 static IPC::StringReference name() { return IPC::StringReference("LogDiagnosticMessageWithValue"); }
3608 static const bool isSync = false;
3609
3610 LogDiagnosticMessageWithValue(const String& message, const String& description, double value, const unsigned& significantFigures, WebCore::ShouldSample shouldSample)
3611 : m_arguments(message, description, value, significantFigures, shouldSample)
3612 {
3613 }
3614
3615 const Arguments& arguments() const
3616 {
3617 return m_arguments;
3618 }
3619
3620private:
3621 Arguments m_arguments;
3622};
3623
3624class LogDiagnosticMessageWithEnhancedPrivacy {
3625public:
3626 typedef std::tuple<const String&, const String&, WebCore::ShouldSample> Arguments;
3627
3628 static IPC::StringReference receiverName() { return messageReceiverName(); }
3629 static IPC::StringReference name() { return IPC::StringReference("LogDiagnosticMessageWithEnhancedPrivacy"); }
3630 static const bool isSync = false;
3631
3632 LogDiagnosticMessageWithEnhancedPrivacy(const String& message, const String& description, WebCore::ShouldSample shouldSample)
3633 : m_arguments(message, description, shouldSample)
3634 {
3635 }
3636
3637 const Arguments& arguments() const
3638 {
3639 return m_arguments;
3640 }
3641
3642private:
3643 Arguments m_arguments;
3644};
3645
3646class LogDiagnosticMessageWithValueDictionary {
3647public:
3648 typedef std::tuple<const String&, const String&, const WebCore::DiagnosticLoggingClient::ValueDictionary&, WebCore::ShouldSample> Arguments;
3649
3650 static IPC::StringReference receiverName() { return messageReceiverName(); }
3651 static IPC::StringReference name() { return IPC::StringReference("LogDiagnosticMessageWithValueDictionary"); }
3652 static const bool isSync = false;
3653
3654 LogDiagnosticMessageWithValueDictionary(const String& message, const String& description, const WebCore::DiagnosticLoggingClient::ValueDictionary& value, WebCore::ShouldSample shouldSample)
3655 : m_arguments(message, description, value, shouldSample)
3656 {
3657 }
3658
3659 const Arguments& arguments() const
3660 {
3661 return m_arguments;
3662 }
3663
3664private:
3665 Arguments m_arguments;
3666};
3667
3668class LogScrollingEvent {
3669public:
3670 typedef std::tuple<uint32_t, const MonotonicTime&, uint64_t> Arguments;
3671
3672 static IPC::StringReference receiverName() { return messageReceiverName(); }
3673 static IPC::StringReference name() { return IPC::StringReference("LogScrollingEvent"); }
3674 static const bool isSync = false;
3675
3676 LogScrollingEvent(uint32_t eventType, const MonotonicTime& timestamp, uint64_t data)
3677 : m_arguments(eventType, timestamp, data)
3678 {
3679 }
3680
3681 const Arguments& arguments() const
3682 {
3683 return m_arguments;
3684 }
3685
3686private:
3687 Arguments m_arguments;
3688};
3689
3690class EditorStateChanged {
3691public:
3692 typedef std::tuple<const WebKit::EditorState&> Arguments;
3693
3694 static IPC::StringReference receiverName() { return messageReceiverName(); }
3695 static IPC::StringReference name() { return IPC::StringReference("EditorStateChanged"); }
3696 static const bool isSync = false;
3697
3698 explicit EditorStateChanged(const WebKit::EditorState& editorState)
3699 : m_arguments(editorState)
3700 {
3701 }
3702
3703 const Arguments& arguments() const
3704 {
3705 return m_arguments;
3706 }
3707
3708private:
3709 Arguments m_arguments;
3710};
3711
3712class CompositionWasCanceled {
3713public:
3714 typedef std::tuple<> Arguments;
3715
3716 static IPC::StringReference receiverName() { return messageReceiverName(); }
3717 static IPC::StringReference name() { return IPC::StringReference("CompositionWasCanceled"); }
3718 static const bool isSync = false;
3719
3720 const Arguments& arguments() const
3721 {
3722 return m_arguments;
3723 }
3724
3725private:
3726 Arguments m_arguments;
3727};
3728
3729class SetHasHadSelectionChangesFromUserInteraction {
3730public:
3731 typedef std::tuple<bool> Arguments;
3732
3733 static IPC::StringReference receiverName() { return messageReceiverName(); }
3734 static IPC::StringReference name() { return IPC::StringReference("SetHasHadSelectionChangesFromUserInteraction"); }
3735 static const bool isSync = false;
3736
3737 explicit SetHasHadSelectionChangesFromUserInteraction(bool hasHadUserSelectionChanges)
3738 : m_arguments(hasHadUserSelectionChanges)
3739 {
3740 }
3741
3742 const Arguments& arguments() const
3743 {
3744 return m_arguments;
3745 }
3746
3747private:
3748 Arguments m_arguments;
3749};
3750
3751class SetIsTouchBarUpdateSupressedForHiddenContentEditable {
3752public:
3753 typedef std::tuple<bool> Arguments;
3754
3755 static IPC::StringReference receiverName() { return messageReceiverName(); }
3756 static IPC::StringReference name() { return IPC::StringReference("SetIsTouchBarUpdateSupressedForHiddenContentEditable"); }
3757 static const bool isSync = false;
3758
3759 explicit SetIsTouchBarUpdateSupressedForHiddenContentEditable(bool isTouchBarUpdateSupressed)
3760 : m_arguments(isTouchBarUpdateSupressed)
3761 {
3762 }
3763
3764 const Arguments& arguments() const
3765 {
3766 return m_arguments;
3767 }
3768
3769private:
3770 Arguments m_arguments;
3771};
3772
3773class SetIsNeverRichlyEditableForTouchBar {
3774public:
3775 typedef std::tuple<bool> Arguments;
3776
3777 static IPC::StringReference receiverName() { return messageReceiverName(); }
3778 static IPC::StringReference name() { return IPC::StringReference("SetIsNeverRichlyEditableForTouchBar"); }
3779 static const bool isSync = false;
3780
3781 explicit SetIsNeverRichlyEditableForTouchBar(bool isNeverRichlyEditable)
3782 : m_arguments(isNeverRichlyEditable)
3783 {
3784 }
3785
3786 const Arguments& arguments() const
3787 {
3788 return m_arguments;
3789 }
3790
3791private:
3792 Arguments m_arguments;
3793};
3794
3795class RequestDOMPasteAccess {
3796public:
3797 typedef std::tuple<const WebCore::IntRect&, const String&> Arguments;
3798
3799 static IPC::StringReference receiverName() { return messageReceiverName(); }
3800 static IPC::StringReference name() { return IPC::StringReference("RequestDOMPasteAccess"); }
3801 static const bool isSync = true;
3802
3803 using DelayedReply = CompletionHandler<void(WebCore::DOMPasteAccessResponse response)>;
3804 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, WebCore::DOMPasteAccessResponse response);
3805 using Reply = std::tuple<WebCore::DOMPasteAccessResponse&>;
3806 using ReplyArguments = std::tuple<WebCore::DOMPasteAccessResponse>;
3807 RequestDOMPasteAccess(const WebCore::IntRect& elementRect, const String& originIdentifier)
3808 : m_arguments(elementRect, originIdentifier)
3809 {
3810 }
3811
3812 const Arguments& arguments() const
3813 {
3814 return m_arguments;
3815 }
3816
3817private:
3818 Arguments m_arguments;
3819};
3820
3821class DidCountStringMatches {
3822public:
3823 typedef std::tuple<const String&, uint32_t> Arguments;
3824
3825 static IPC::StringReference receiverName() { return messageReceiverName(); }
3826 static IPC::StringReference name() { return IPC::StringReference("DidCountStringMatches"); }
3827 static const bool isSync = false;
3828
3829 DidCountStringMatches(const String& string, uint32_t matchCount)
3830 : m_arguments(string, matchCount)
3831 {
3832 }
3833
3834 const Arguments& arguments() const
3835 {
3836 return m_arguments;
3837 }
3838
3839private:
3840 Arguments m_arguments;
3841};
3842
3843class SetTextIndicator {
3844public:
3845 typedef std::tuple<const WebCore::TextIndicatorData&, uint64_t> Arguments;
3846
3847 static IPC::StringReference receiverName() { return messageReceiverName(); }
3848 static IPC::StringReference name() { return IPC::StringReference("SetTextIndicator"); }
3849 static const bool isSync = false;
3850
3851 SetTextIndicator(const WebCore::TextIndicatorData& indicator, uint64_t lifetime)
3852 : m_arguments(indicator, lifetime)
3853 {
3854 }
3855
3856 const Arguments& arguments() const
3857 {
3858 return m_arguments;
3859 }
3860
3861private:
3862 Arguments m_arguments;
3863};
3864
3865class ClearTextIndicator {
3866public:
3867 typedef std::tuple<> Arguments;
3868
3869 static IPC::StringReference receiverName() { return messageReceiverName(); }
3870 static IPC::StringReference name() { return IPC::StringReference("ClearTextIndicator"); }
3871 static const bool isSync = false;
3872
3873 const Arguments& arguments() const
3874 {
3875 return m_arguments;
3876 }
3877
3878private:
3879 Arguments m_arguments;
3880};
3881
3882class DidFindString {
3883public:
3884 typedef std::tuple<const String&, const Vector<WebCore::IntRect>&, uint32_t, int32_t, bool> Arguments;
3885
3886 static IPC::StringReference receiverName() { return messageReceiverName(); }
3887 static IPC::StringReference name() { return IPC::StringReference("DidFindString"); }
3888 static const bool isSync = false;
3889
3890 DidFindString(const String& string, const Vector<WebCore::IntRect>& matchRect, uint32_t matchCount, int32_t matchIndex, bool didWrapAround)
3891 : m_arguments(string, matchRect, matchCount, matchIndex, didWrapAround)
3892 {
3893 }
3894
3895 const Arguments& arguments() const
3896 {
3897 return m_arguments;
3898 }
3899
3900private:
3901 Arguments m_arguments;
3902};
3903
3904class DidFailToFindString {
3905public:
3906 typedef std::tuple<const String&> Arguments;
3907
3908 static IPC::StringReference receiverName() { return messageReceiverName(); }
3909 static IPC::StringReference name() { return IPC::StringReference("DidFailToFindString"); }
3910 static const bool isSync = false;
3911
3912 explicit DidFailToFindString(const String& string)
3913 : m_arguments(string)
3914 {
3915 }
3916
3917 const Arguments& arguments() const
3918 {
3919 return m_arguments;
3920 }
3921
3922private:
3923 Arguments m_arguments;
3924};
3925
3926class DidFindStringMatches {
3927public:
3928 typedef std::tuple<const String&, const Vector<Vector<WebCore::IntRect>>&, int32_t> Arguments;
3929
3930 static IPC::StringReference receiverName() { return messageReceiverName(); }
3931 static IPC::StringReference name() { return IPC::StringReference("DidFindStringMatches"); }
3932 static const bool isSync = false;
3933
3934 DidFindStringMatches(const String& string, const Vector<Vector<WebCore::IntRect>>& matches, int32_t firstIndexAfterSelection)
3935 : m_arguments(string, matches, firstIndexAfterSelection)
3936 {
3937 }
3938
3939 const Arguments& arguments() const
3940 {
3941 return m_arguments;
3942 }
3943
3944private:
3945 Arguments m_arguments;
3946};
3947
3948class DidGetImageForFindMatch {
3949public:
3950 typedef std::tuple<const WebKit::ShareableBitmap::Handle&, uint32_t> Arguments;
3951
3952 static IPC::StringReference receiverName() { return messageReceiverName(); }
3953 static IPC::StringReference name() { return IPC::StringReference("DidGetImageForFindMatch"); }
3954 static const bool isSync = false;
3955
3956 DidGetImageForFindMatch(const WebKit::ShareableBitmap::Handle& contentImageHandle, uint32_t matchIndex)
3957 : m_arguments(contentImageHandle, matchIndex)
3958 {
3959 }
3960
3961 const Arguments& arguments() const
3962 {
3963 return m_arguments;
3964 }
3965
3966private:
3967 Arguments m_arguments;
3968};
3969
3970class ShowPopupMenu {
3971public:
3972 typedef std::tuple<const WebCore::IntRect&, uint64_t, const Vector<WebKit::WebPopupItem>&, int32_t, const WebKit::PlatformPopupMenuData&> Arguments;
3973
3974 static IPC::StringReference receiverName() { return messageReceiverName(); }
3975 static IPC::StringReference name() { return IPC::StringReference("ShowPopupMenu"); }
3976 static const bool isSync = false;
3977
3978 ShowPopupMenu(const WebCore::IntRect& rect, uint64_t textDirection, const Vector<WebKit::WebPopupItem>& items, int32_t selectedIndex, const WebKit::PlatformPopupMenuData& data)
3979 : m_arguments(rect, textDirection, items, selectedIndex, data)
3980 {
3981 }
3982
3983 const Arguments& arguments() const
3984 {
3985 return m_arguments;
3986 }
3987
3988private:
3989 Arguments m_arguments;
3990};
3991
3992class HidePopupMenu {
3993public:
3994 typedef std::tuple<> Arguments;
3995
3996 static IPC::StringReference receiverName() { return messageReceiverName(); }
3997 static IPC::StringReference name() { return IPC::StringReference("HidePopupMenu"); }
3998 static const bool isSync = false;
3999
4000 const Arguments& arguments() const
4001 {
4002 return m_arguments;
4003 }
4004
4005private:
4006 Arguments m_arguments;
4007};
4008
4009#if ENABLE(CONTEXT_MENUS)
4010class ShowContextMenu {
4011public:
4012 typedef std::tuple<const WebKit::ContextMenuContextData&, const WebKit::UserData&> Arguments;
4013
4014 static IPC::StringReference receiverName() { return messageReceiverName(); }
4015 static IPC::StringReference name() { return IPC::StringReference("ShowContextMenu"); }
4016 static const bool isSync = false;
4017
4018 ShowContextMenu(const WebKit::ContextMenuContextData& contextMenuContextData, const WebKit::UserData& userData)
4019 : m_arguments(contextMenuContextData, userData)
4020 {
4021 }
4022
4023 const Arguments& arguments() const
4024 {
4025 return m_arguments;
4026 }
4027
4028private:
4029 Arguments m_arguments;
4030};
4031#endif
4032
4033class ExceededDatabaseQuota {
4034public:
4035 typedef std::tuple<uint64_t, const String&, const String&, const String&, uint64_t, uint64_t, uint64_t, uint64_t> Arguments;
4036
4037 static IPC::StringReference receiverName() { return messageReceiverName(); }
4038 static IPC::StringReference name() { return IPC::StringReference("ExceededDatabaseQuota"); }
4039 static const bool isSync = true;
4040
4041 using DelayedReply = CompletionHandler<void(uint64_t newQuota)>;
4042 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, uint64_t newQuota);
4043 using Reply = std::tuple<uint64_t&>;
4044 using ReplyArguments = std::tuple<uint64_t>;
4045 ExceededDatabaseQuota(uint64_t frameID, const String& originIdentifier, const String& databaseName, const String& databaseDisplayName, uint64_t currentQuota, uint64_t currentOriginUsage, uint64_t currentDatabaseUsage, uint64_t expectedUsage)
4046 : m_arguments(frameID, originIdentifier, databaseName, databaseDisplayName, currentQuota, currentOriginUsage, currentDatabaseUsage, expectedUsage)
4047 {
4048 }
4049
4050 const Arguments& arguments() const
4051 {
4052 return m_arguments;
4053 }
4054
4055private:
4056 Arguments m_arguments;
4057};
4058
4059class ReachedApplicationCacheOriginQuota {
4060public:
4061 typedef std::tuple<const String&, uint64_t, uint64_t> Arguments;
4062
4063 static IPC::StringReference receiverName() { return messageReceiverName(); }
4064 static IPC::StringReference name() { return IPC::StringReference("ReachedApplicationCacheOriginQuota"); }
4065 static const bool isSync = true;
4066
4067 using DelayedReply = CompletionHandler<void(uint64_t newQuota)>;
4068 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, uint64_t newQuota);
4069 using Reply = std::tuple<uint64_t&>;
4070 using ReplyArguments = std::tuple<uint64_t>;
4071 ReachedApplicationCacheOriginQuota(const String& originIdentifier, uint64_t currentQuota, uint64_t totalBytesNeeded)
4072 : m_arguments(originIdentifier, currentQuota, totalBytesNeeded)
4073 {
4074 }
4075
4076 const Arguments& arguments() const
4077 {
4078 return m_arguments;
4079 }
4080
4081private:
4082 Arguments m_arguments;
4083};
4084
4085class RequestGeolocationPermissionForFrame {
4086public:
4087 typedef std::tuple<uint64_t, uint64_t, const String&> Arguments;
4088
4089 static IPC::StringReference receiverName() { return messageReceiverName(); }
4090 static IPC::StringReference name() { return IPC::StringReference("RequestGeolocationPermissionForFrame"); }
4091 static const bool isSync = false;
4092
4093 RequestGeolocationPermissionForFrame(uint64_t geolocationID, uint64_t frameID, const String& originIdentifier)
4094 : m_arguments(geolocationID, frameID, originIdentifier)
4095 {
4096 }
4097
4098 const Arguments& arguments() const
4099 {
4100 return m_arguments;
4101 }
4102
4103private:
4104 Arguments m_arguments;
4105};
4106
4107#if ENABLE(MEDIA_STREAM)
4108class RequestUserMediaPermissionForFrame {
4109public:
4110 typedef std::tuple<uint64_t, uint64_t, const WebCore::SecurityOriginData&, const WebCore::SecurityOriginData&, const WebCore::MediaStreamRequest&> Arguments;
4111
4112 static IPC::StringReference receiverName() { return messageReceiverName(); }
4113 static IPC::StringReference name() { return IPC::StringReference("RequestUserMediaPermissionForFrame"); }
4114 static const bool isSync = false;
4115
4116 RequestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, const WebCore::SecurityOriginData& userMediaDocumentOriginIdentifier, const WebCore::SecurityOriginData& topLevelDocumentOriginIdentifier, const WebCore::MediaStreamRequest& request)
4117 : m_arguments(userMediaID, frameID, userMediaDocumentOriginIdentifier, topLevelDocumentOriginIdentifier, request)
4118 {
4119 }
4120
4121 const Arguments& arguments() const
4122 {
4123 return m_arguments;
4124 }
4125
4126private:
4127 Arguments m_arguments;
4128};
4129#endif
4130
4131#if ENABLE(MEDIA_STREAM)
4132class EnumerateMediaDevicesForFrame {
4133public:
4134 typedef std::tuple<uint64_t, uint64_t, const WebCore::SecurityOriginData&, const WebCore::SecurityOriginData&> Arguments;
4135
4136 static IPC::StringReference receiverName() { return messageReceiverName(); }
4137 static IPC::StringReference name() { return IPC::StringReference("EnumerateMediaDevicesForFrame"); }
4138 static const bool isSync = false;
4139
4140 EnumerateMediaDevicesForFrame(uint64_t userMediaID, uint64_t frameID, const WebCore::SecurityOriginData& userMediaDocumentOriginIdentifier, const WebCore::SecurityOriginData& topLevelDocumentOriginIdentifier)
4141 : m_arguments(userMediaID, frameID, userMediaDocumentOriginIdentifier, topLevelDocumentOriginIdentifier)
4142 {
4143 }
4144
4145 const Arguments& arguments() const
4146 {
4147 return m_arguments;
4148 }
4149
4150private:
4151 Arguments m_arguments;
4152};
4153#endif
4154
4155#if ENABLE(MEDIA_STREAM)
4156class BeginMonitoringCaptureDevices {
4157public:
4158 typedef std::tuple<> Arguments;
4159
4160 static IPC::StringReference receiverName() { return messageReceiverName(); }
4161 static IPC::StringReference name() { return IPC::StringReference("BeginMonitoringCaptureDevices"); }
4162 static const bool isSync = false;
4163
4164 const Arguments& arguments() const
4165 {
4166 return m_arguments;
4167 }
4168
4169private:
4170 Arguments m_arguments;
4171};
4172#endif
4173
4174class RequestNotificationPermission {
4175public:
4176 typedef std::tuple<uint64_t, const String&> Arguments;
4177
4178 static IPC::StringReference receiverName() { return messageReceiverName(); }
4179 static IPC::StringReference name() { return IPC::StringReference("RequestNotificationPermission"); }
4180 static const bool isSync = false;
4181
4182 RequestNotificationPermission(uint64_t requestID, const String& originIdentifier)
4183 : m_arguments(requestID, originIdentifier)
4184 {
4185 }
4186
4187 const Arguments& arguments() const
4188 {
4189 return m_arguments;
4190 }
4191
4192private:
4193 Arguments m_arguments;
4194};
4195
4196class ShowNotification {
4197public:
4198 typedef std::tuple<const String&, const String&, const String&, const String&, const String&, WebCore::NotificationDirection, const String&, uint64_t> Arguments;
4199
4200 static IPC::StringReference receiverName() { return messageReceiverName(); }
4201 static IPC::StringReference name() { return IPC::StringReference("ShowNotification"); }
4202 static const bool isSync = false;
4203
4204 ShowNotification(const String& title, const String& body, const String& iconURL, const String& tag, const String& lang, WebCore::NotificationDirection dir, const String& originIdentifier, uint64_t notificationID)
4205 : m_arguments(title, body, iconURL, tag, lang, dir, originIdentifier, notificationID)
4206 {
4207 }
4208
4209 const Arguments& arguments() const
4210 {
4211 return m_arguments;
4212 }
4213
4214private:
4215 Arguments m_arguments;
4216};
4217
4218class CancelNotification {
4219public:
4220 typedef std::tuple<uint64_t> Arguments;
4221
4222 static IPC::StringReference receiverName() { return messageReceiverName(); }
4223 static IPC::StringReference name() { return IPC::StringReference("CancelNotification"); }
4224 static const bool isSync = false;
4225
4226 explicit CancelNotification(uint64_t notificationID)
4227 : m_arguments(notificationID)
4228 {
4229 }
4230
4231 const Arguments& arguments() const
4232 {
4233 return m_arguments;
4234 }
4235
4236private:
4237 Arguments m_arguments;
4238};
4239
4240class ClearNotifications {
4241public:
4242 typedef std::tuple<const Vector<uint64_t>&> Arguments;
4243
4244 static IPC::StringReference receiverName() { return messageReceiverName(); }
4245 static IPC::StringReference name() { return IPC::StringReference("ClearNotifications"); }
4246 static const bool isSync = false;
4247
4248 explicit ClearNotifications(const Vector<uint64_t>& notificationIDs)
4249 : m_arguments(notificationIDs)
4250 {
4251 }
4252
4253 const Arguments& arguments() const
4254 {
4255 return m_arguments;
4256 }
4257
4258private:
4259 Arguments m_arguments;
4260};
4261
4262class DidDestroyNotification {
4263public:
4264 typedef std::tuple<uint64_t> Arguments;
4265
4266 static IPC::StringReference receiverName() { return messageReceiverName(); }
4267 static IPC::StringReference name() { return IPC::StringReference("DidDestroyNotification"); }
4268 static const bool isSync = false;
4269
4270 explicit DidDestroyNotification(uint64_t notificationID)
4271 : m_arguments(notificationID)
4272 {
4273 }
4274
4275 const Arguments& arguments() const
4276 {
4277 return m_arguments;
4278 }
4279
4280private:
4281 Arguments m_arguments;
4282};
4283
4284#if USE(UNIFIED_TEXT_CHECKING)
4285class CheckTextOfParagraph {
4286public:
4287 typedef std::tuple<const String&, const OptionSet<WebCore::TextCheckingType>&, int32_t> Arguments;
4288
4289 static IPC::StringReference receiverName() { return messageReceiverName(); }
4290 static IPC::StringReference name() { return IPC::StringReference("CheckTextOfParagraph"); }
4291 static const bool isSync = true;
4292
4293 using DelayedReply = CompletionHandler<void(const Vector<WebCore::TextCheckingResult>& results)>;
4294 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const Vector<WebCore::TextCheckingResult>& results);
4295 using Reply = std::tuple<Vector<WebCore::TextCheckingResult>&>;
4296 using ReplyArguments = std::tuple<Vector<WebCore::TextCheckingResult>>;
4297 CheckTextOfParagraph(const String& text, const OptionSet<WebCore::TextCheckingType>& checkingTypes, int32_t insertionPoint)
4298 : m_arguments(text, checkingTypes, insertionPoint)
4299 {
4300 }
4301
4302 const Arguments& arguments() const
4303 {
4304 return m_arguments;
4305 }
4306
4307private:
4308 Arguments m_arguments;
4309};
4310#endif
4311
4312class CheckSpellingOfString {
4313public:
4314 typedef std::tuple<const String&> Arguments;
4315
4316 static IPC::StringReference receiverName() { return messageReceiverName(); }
4317 static IPC::StringReference name() { return IPC::StringReference("CheckSpellingOfString"); }
4318 static const bool isSync = true;
4319
4320 using DelayedReply = CompletionHandler<void(int32_t misspellingLocation, int32_t misspellingLength)>;
4321 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, int32_t misspellingLocation, int32_t misspellingLength);
4322 using Reply = std::tuple<int32_t&, int32_t&>;
4323 using ReplyArguments = std::tuple<int32_t, int32_t>;
4324 explicit CheckSpellingOfString(const String& text)
4325 : m_arguments(text)
4326 {
4327 }
4328
4329 const Arguments& arguments() const
4330 {
4331 return m_arguments;
4332 }
4333
4334private:
4335 Arguments m_arguments;
4336};
4337
4338class CheckGrammarOfString {
4339public:
4340 typedef std::tuple<const String&> Arguments;
4341
4342 static IPC::StringReference receiverName() { return messageReceiverName(); }
4343 static IPC::StringReference name() { return IPC::StringReference("CheckGrammarOfString"); }
4344 static const bool isSync = true;
4345
4346 using DelayedReply = CompletionHandler<void(const Vector<WebCore::GrammarDetail>& results, int32_t badGrammarLocation, int32_t badGrammarLength)>;
4347 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const Vector<WebCore::GrammarDetail>& results, int32_t badGrammarLocation, int32_t badGrammarLength);
4348 using Reply = std::tuple<Vector<WebCore::GrammarDetail>&, int32_t&, int32_t&>;
4349 using ReplyArguments = std::tuple<Vector<WebCore::GrammarDetail>, int32_t, int32_t>;
4350 explicit CheckGrammarOfString(const String& text)
4351 : m_arguments(text)
4352 {
4353 }
4354
4355 const Arguments& arguments() const
4356 {
4357 return m_arguments;
4358 }
4359
4360private:
4361 Arguments m_arguments;
4362};
4363
4364class SpellingUIIsShowing {
4365public:
4366 typedef std::tuple<> Arguments;
4367
4368 static IPC::StringReference receiverName() { return messageReceiverName(); }
4369 static IPC::StringReference name() { return IPC::StringReference("SpellingUIIsShowing"); }
4370 static const bool isSync = true;
4371
4372 using DelayedReply = CompletionHandler<void(bool isShowing)>;
4373 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool isShowing);
4374 using Reply = std::tuple<bool&>;
4375 using ReplyArguments = std::tuple<bool>;
4376 const Arguments& arguments() const
4377 {
4378 return m_arguments;
4379 }
4380
4381private:
4382 Arguments m_arguments;
4383};
4384
4385class UpdateSpellingUIWithMisspelledWord {
4386public:
4387 typedef std::tuple<const String&> Arguments;
4388
4389 static IPC::StringReference receiverName() { return messageReceiverName(); }
4390 static IPC::StringReference name() { return IPC::StringReference("UpdateSpellingUIWithMisspelledWord"); }
4391 static const bool isSync = false;
4392
4393 explicit UpdateSpellingUIWithMisspelledWord(const String& misspelledWord)
4394 : m_arguments(misspelledWord)
4395 {
4396 }
4397
4398 const Arguments& arguments() const
4399 {
4400 return m_arguments;
4401 }
4402
4403private:
4404 Arguments m_arguments;
4405};
4406
4407class UpdateSpellingUIWithGrammarString {
4408public:
4409 typedef std::tuple<const String&, const WebCore::GrammarDetail&> Arguments;
4410
4411 static IPC::StringReference receiverName() { return messageReceiverName(); }
4412 static IPC::StringReference name() { return IPC::StringReference("UpdateSpellingUIWithGrammarString"); }
4413 static const bool isSync = false;
4414
4415 UpdateSpellingUIWithGrammarString(const String& badGrammarPhrase, const WebCore::GrammarDetail& grammarDetail)
4416 : m_arguments(badGrammarPhrase, grammarDetail)
4417 {
4418 }
4419
4420 const Arguments& arguments() const
4421 {
4422 return m_arguments;
4423 }
4424
4425private:
4426 Arguments m_arguments;
4427};
4428
4429class GetGuessesForWord {
4430public:
4431 typedef std::tuple<const String&, const String&, int32_t> Arguments;
4432
4433 static IPC::StringReference receiverName() { return messageReceiverName(); }
4434 static IPC::StringReference name() { return IPC::StringReference("GetGuessesForWord"); }
4435 static const bool isSync = true;
4436
4437 using DelayedReply = CompletionHandler<void(const Vector<String>& guesses)>;
4438 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const Vector<String>& guesses);
4439 using Reply = std::tuple<Vector<String>&>;
4440 using ReplyArguments = std::tuple<Vector<String>>;
4441 GetGuessesForWord(const String& word, const String& context, int32_t insertionPoint)
4442 : m_arguments(word, context, insertionPoint)
4443 {
4444 }
4445
4446 const Arguments& arguments() const
4447 {
4448 return m_arguments;
4449 }
4450
4451private:
4452 Arguments m_arguments;
4453};
4454
4455class LearnWord {
4456public:
4457 typedef std::tuple<const String&> Arguments;
4458
4459 static IPC::StringReference receiverName() { return messageReceiverName(); }
4460 static IPC::StringReference name() { return IPC::StringReference("LearnWord"); }
4461 static const bool isSync = false;
4462
4463 explicit LearnWord(const String& word)
4464 : m_arguments(word)
4465 {
4466 }
4467
4468 const Arguments& arguments() const
4469 {
4470 return m_arguments;
4471 }
4472
4473private:
4474 Arguments m_arguments;
4475};
4476
4477class IgnoreWord {
4478public:
4479 typedef std::tuple<const String&> Arguments;
4480
4481 static IPC::StringReference receiverName() { return messageReceiverName(); }
4482 static IPC::StringReference name() { return IPC::StringReference("IgnoreWord"); }
4483 static const bool isSync = false;
4484
4485 explicit IgnoreWord(const String& word)
4486 : m_arguments(word)
4487 {
4488 }
4489
4490 const Arguments& arguments() const
4491 {
4492 return m_arguments;
4493 }
4494
4495private:
4496 Arguments m_arguments;
4497};
4498
4499class RequestCheckingOfString {
4500public:
4501 typedef std::tuple<uint64_t, const WebCore::TextCheckingRequestData&, int32_t> Arguments;
4502
4503 static IPC::StringReference receiverName() { return messageReceiverName(); }
4504 static IPC::StringReference name() { return IPC::StringReference("RequestCheckingOfString"); }
4505 static const bool isSync = false;
4506
4507 RequestCheckingOfString(uint64_t requestID, const WebCore::TextCheckingRequestData& request, int32_t insertionPoint)
4508 : m_arguments(requestID, request, insertionPoint)
4509 {
4510 }
4511
4512 const Arguments& arguments() const
4513 {
4514 return m_arguments;
4515 }
4516
4517private:
4518 Arguments m_arguments;
4519};
4520
4521#if ENABLE(DRAG_SUPPORT)
4522class DidPerformDragControllerAction {
4523public:
4524 typedef std::tuple<uint64_t, WebCore::DragHandlingMethod, bool, const unsigned&, const WebCore::IntRect&, const WebCore::IntRect&> Arguments;
4525
4526 static IPC::StringReference receiverName() { return messageReceiverName(); }
4527 static IPC::StringReference name() { return IPC::StringReference("DidPerformDragControllerAction"); }
4528 static const bool isSync = false;
4529
4530 DidPerformDragControllerAction(uint64_t dragOperation, WebCore::DragHandlingMethod dragHandlingMethod, bool mouseIsOverFileInput, const unsigned& numberOfItemsToBeAccepted, const WebCore::IntRect& insertionRect, const WebCore::IntRect& editableElementRect)
4531 : m_arguments(dragOperation, dragHandlingMethod, mouseIsOverFileInput, numberOfItemsToBeAccepted, insertionRect, editableElementRect)
4532 {
4533 }
4534
4535 const Arguments& arguments() const
4536 {
4537 return m_arguments;
4538 }
4539
4540private:
4541 Arguments m_arguments;
4542};
4543#endif
4544
4545#if ENABLE(DRAG_SUPPORT)
4546class DidEndDragging {
4547public:
4548 typedef std::tuple<> Arguments;
4549
4550 static IPC::StringReference receiverName() { return messageReceiverName(); }
4551 static IPC::StringReference name() { return IPC::StringReference("DidEndDragging"); }
4552 static const bool isSync = false;
4553
4554 const Arguments& arguments() const
4555 {
4556 return m_arguments;
4557 }
4558
4559private:
4560 Arguments m_arguments;
4561};
4562#endif
4563
4564#if PLATFORM(COCOA) && ENABLE(DRAG_SUPPORT)
4565class StartDrag {
4566public:
4567 typedef std::tuple<const WebCore::DragItem&, const WebKit::ShareableBitmap::Handle&> Arguments;
4568
4569 static IPC::StringReference receiverName() { return messageReceiverName(); }
4570 static IPC::StringReference name() { return IPC::StringReference("StartDrag"); }
4571 static const bool isSync = false;
4572
4573 StartDrag(const WebCore::DragItem& dragItem, const WebKit::ShareableBitmap::Handle& dragImage)
4574 : m_arguments(dragItem, dragImage)
4575 {
4576 }
4577
4578 const Arguments& arguments() const
4579 {
4580 return m_arguments;
4581 }
4582
4583private:
4584 Arguments m_arguments;
4585};
4586#endif
4587
4588#if PLATFORM(COCOA) && ENABLE(DRAG_SUPPORT)
4589class SetPromisedDataForImage {
4590public:
4591 typedef std::tuple<const String&, const WebKit::SharedMemory::Handle&, uint64_t, const String&, const String&, const String&, const String&, const String&, const WebKit::SharedMemory::Handle&, uint64_t> Arguments;
4592
4593 static IPC::StringReference receiverName() { return messageReceiverName(); }
4594 static IPC::StringReference name() { return IPC::StringReference("SetPromisedDataForImage"); }
4595 static const bool isSync = false;
4596
4597 SetPromisedDataForImage(const String& pasteboardName, const WebKit::SharedMemory::Handle& imageHandle, uint64_t imageSize, const String& filename, const String& extension, const String& title, const String& url, const String& visibleURL, const WebKit::SharedMemory::Handle& archiveHandle, uint64_t archiveSize)
4598 : m_arguments(pasteboardName, imageHandle, imageSize, filename, extension, title, url, visibleURL, archiveHandle, archiveSize)
4599 {
4600 }
4601
4602 const Arguments& arguments() const
4603 {
4604 return m_arguments;
4605 }
4606
4607private:
4608 Arguments m_arguments;
4609};
4610#endif
4611
4612#if PLATFORM(GTK) && ENABLE(DRAG_SUPPORT)
4613class StartDrag {
4614public:
4615 typedef std::tuple<const WebKit::WebSelectionData&, uint64_t, const WebKit::ShareableBitmap::Handle&> Arguments;
4616
4617 static IPC::StringReference receiverName() { return messageReceiverName(); }
4618 static IPC::StringReference name() { return IPC::StringReference("StartDrag"); }
4619 static const bool isSync = false;
4620
4621 StartDrag(const WebKit::WebSelectionData& selection, uint64_t dragOperation, const WebKit::ShareableBitmap::Handle& dragImage)
4622 : m_arguments(selection, dragOperation, dragImage)
4623 {
4624 }
4625
4626 const Arguments& arguments() const
4627 {
4628 return m_arguments;
4629 }
4630
4631private:
4632 Arguments m_arguments;
4633};
4634#endif
4635
4636#if ENABLE(DRAG_SUPPORT)
4637class DidPerformDragOperation {
4638public:
4639 typedef std::tuple<bool> Arguments;
4640
4641 static IPC::StringReference receiverName() { return messageReceiverName(); }
4642 static IPC::StringReference name() { return IPC::StringReference("DidPerformDragOperation"); }
4643 static const bool isSync = false;
4644
4645 explicit DidPerformDragOperation(bool handled)
4646 : m_arguments(handled)
4647 {
4648 }
4649
4650 const Arguments& arguments() const
4651 {
4652 return m_arguments;
4653 }
4654
4655private:
4656 Arguments m_arguments;
4657};
4658#endif
4659
4660#if ENABLE(DATA_INTERACTION)
4661class DidHandleDragStartRequest {
4662public:
4663 typedef std::tuple<bool> Arguments;
4664
4665 static IPC::StringReference receiverName() { return messageReceiverName(); }
4666 static IPC::StringReference name() { return IPC::StringReference("DidHandleDragStartRequest"); }
4667 static const bool isSync = false;
4668
4669 explicit DidHandleDragStartRequest(bool started)
4670 : m_arguments(started)
4671 {
4672 }
4673
4674 const Arguments& arguments() const
4675 {
4676 return m_arguments;
4677 }
4678
4679private:
4680 Arguments m_arguments;
4681};
4682#endif
4683
4684#if ENABLE(DATA_INTERACTION)
4685class DidHandleAdditionalDragItemsRequest {
4686public:
4687 typedef std::tuple<bool> Arguments;
4688
4689 static IPC::StringReference receiverName() { return messageReceiverName(); }
4690 static IPC::StringReference name() { return IPC::StringReference("DidHandleAdditionalDragItemsRequest"); }
4691 static const bool isSync = false;
4692
4693 explicit DidHandleAdditionalDragItemsRequest(bool added)
4694 : m_arguments(added)
4695 {
4696 }
4697
4698 const Arguments& arguments() const
4699 {
4700 return m_arguments;
4701 }
4702
4703private:
4704 Arguments m_arguments;
4705};
4706#endif
4707
4708#if ENABLE(DATA_INTERACTION)
4709class WillReceiveEditDragSnapshot {
4710public:
4711 typedef std::tuple<> Arguments;
4712
4713 static IPC::StringReference receiverName() { return messageReceiverName(); }
4714 static IPC::StringReference name() { return IPC::StringReference("WillReceiveEditDragSnapshot"); }
4715 static const bool isSync = false;
4716
4717 const Arguments& arguments() const
4718 {
4719 return m_arguments;
4720 }
4721
4722private:
4723 Arguments m_arguments;
4724};
4725#endif
4726
4727#if ENABLE(DATA_INTERACTION)
4728class DidReceiveEditDragSnapshot {
4729public:
4730 typedef std::tuple<const Optional<WebCore::TextIndicatorData>&> Arguments;
4731
4732 static IPC::StringReference receiverName() { return messageReceiverName(); }
4733 static IPC::StringReference name() { return IPC::StringReference("DidReceiveEditDragSnapshot"); }
4734 static const bool isSync = false;
4735
4736 explicit DidReceiveEditDragSnapshot(const Optional<WebCore::TextIndicatorData>& textIndicator)
4737 : m_arguments(textIndicator)
4738 {
4739 }
4740
4741 const Arguments& arguments() const
4742 {
4743 return m_arguments;
4744 }
4745
4746private:
4747 Arguments m_arguments;
4748};
4749#endif
4750
4751#if PLATFORM(COCOA)
4752class DidPerformDictionaryLookup {
4753public:
4754 typedef std::tuple<const WebCore::DictionaryPopupInfo&> Arguments;
4755
4756 static IPC::StringReference receiverName() { return messageReceiverName(); }
4757 static IPC::StringReference name() { return IPC::StringReference("DidPerformDictionaryLookup"); }
4758 static const bool isSync = false;
4759
4760 explicit DidPerformDictionaryLookup(const WebCore::DictionaryPopupInfo& dictionaryPopupInfo)
4761 : m_arguments(dictionaryPopupInfo)
4762 {
4763 }
4764
4765 const Arguments& arguments() const
4766 {
4767 return m_arguments;
4768 }
4769
4770private:
4771 Arguments m_arguments;
4772};
4773#endif
4774
4775#if PLATFORM(COCOA)
4776class ExecuteSavedCommandBySelector {
4777public:
4778 typedef std::tuple<const String&> Arguments;
4779
4780 static IPC::StringReference receiverName() { return messageReceiverName(); }
4781 static IPC::StringReference name() { return IPC::StringReference("ExecuteSavedCommandBySelector"); }
4782 static const bool isSync = true;
4783
4784 using DelayedReply = CompletionHandler<void(bool handled)>;
4785 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool handled);
4786 using Reply = std::tuple<bool&>;
4787 using ReplyArguments = std::tuple<bool>;
4788 explicit ExecuteSavedCommandBySelector(const String& selector)
4789 : m_arguments(selector)
4790 {
4791 }
4792
4793 const Arguments& arguments() const
4794 {
4795 return m_arguments;
4796 }
4797
4798private:
4799 Arguments m_arguments;
4800};
4801#endif
4802
4803#if PLATFORM(COCOA)
4804class RegisterWebProcessAccessibilityToken {
4805public:
4806 typedef std::tuple<const IPC::DataReference&> Arguments;
4807
4808 static IPC::StringReference receiverName() { return messageReceiverName(); }
4809 static IPC::StringReference name() { return IPC::StringReference("RegisterWebProcessAccessibilityToken"); }
4810 static const bool isSync = false;
4811
4812 explicit RegisterWebProcessAccessibilityToken(const IPC::DataReference& data)
4813 : m_arguments(data)
4814 {
4815 }
4816
4817 const Arguments& arguments() const
4818 {
4819 return m_arguments;
4820 }
4821
4822private:
4823 Arguments m_arguments;
4824};
4825#endif
4826
4827#if PLATFORM(COCOA)
4828class PluginFocusOrWindowFocusChanged {
4829public:
4830 typedef std::tuple<uint64_t, bool> Arguments;
4831
4832 static IPC::StringReference receiverName() { return messageReceiverName(); }
4833 static IPC::StringReference name() { return IPC::StringReference("PluginFocusOrWindowFocusChanged"); }
4834 static const bool isSync = false;
4835
4836 PluginFocusOrWindowFocusChanged(uint64_t pluginComplexTextInputIdentifier, bool pluginHasFocusAndWindowHasFocus)
4837 : m_arguments(pluginComplexTextInputIdentifier, pluginHasFocusAndWindowHasFocus)
4838 {
4839 }
4840
4841 const Arguments& arguments() const
4842 {
4843 return m_arguments;
4844 }
4845
4846private:
4847 Arguments m_arguments;
4848};
4849#endif
4850
4851#if PLATFORM(COCOA)
4852class SetPluginComplexTextInputState {
4853public:
4854 typedef std::tuple<uint64_t, uint64_t> Arguments;
4855
4856 static IPC::StringReference receiverName() { return messageReceiverName(); }
4857 static IPC::StringReference name() { return IPC::StringReference("SetPluginComplexTextInputState"); }
4858 static const bool isSync = false;
4859
4860 SetPluginComplexTextInputState(uint64_t pluginComplexTextInputIdentifier, uint64_t complexTextInputState)
4861 : m_arguments(pluginComplexTextInputIdentifier, complexTextInputState)
4862 {
4863 }
4864
4865 const Arguments& arguments() const
4866 {
4867 return m_arguments;
4868 }
4869
4870private:
4871 Arguments m_arguments;
4872};
4873#endif
4874
4875#if PLATFORM(COCOA)
4876class GetIsSpeaking {
4877public:
4878 typedef std::tuple<> Arguments;
4879
4880 static IPC::StringReference receiverName() { return messageReceiverName(); }
4881 static IPC::StringReference name() { return IPC::StringReference("GetIsSpeaking"); }
4882 static const bool isSync = true;
4883
4884 using DelayedReply = CompletionHandler<void(bool isSpeaking)>;
4885 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool isSpeaking);
4886 using Reply = std::tuple<bool&>;
4887 using ReplyArguments = std::tuple<bool>;
4888 const Arguments& arguments() const
4889 {
4890 return m_arguments;
4891 }
4892
4893private:
4894 Arguments m_arguments;
4895};
4896#endif
4897
4898#if PLATFORM(COCOA)
4899class Speak {
4900public:
4901 typedef std::tuple<const String&> Arguments;
4902
4903 static IPC::StringReference receiverName() { return messageReceiverName(); }
4904 static IPC::StringReference name() { return IPC::StringReference("Speak"); }
4905 static const bool isSync = false;
4906
4907 explicit Speak(const String& string)
4908 : m_arguments(string)
4909 {
4910 }
4911
4912 const Arguments& arguments() const
4913 {
4914 return m_arguments;
4915 }
4916
4917private:
4918 Arguments m_arguments;
4919};
4920#endif
4921
4922#if PLATFORM(COCOA)
4923class StopSpeaking {
4924public:
4925 typedef std::tuple<> Arguments;
4926
4927 static IPC::StringReference receiverName() { return messageReceiverName(); }
4928 static IPC::StringReference name() { return IPC::StringReference("StopSpeaking"); }
4929 static const bool isSync = false;
4930
4931 const Arguments& arguments() const
4932 {
4933 return m_arguments;
4934 }
4935
4936private:
4937 Arguments m_arguments;
4938};
4939#endif
4940
4941#if PLATFORM(COCOA)
4942class MakeFirstResponder {
4943public:
4944 typedef std::tuple<> Arguments;
4945
4946 static IPC::StringReference receiverName() { return messageReceiverName(); }
4947 static IPC::StringReference name() { return IPC::StringReference("MakeFirstResponder"); }
4948 static const bool isSync = false;
4949
4950 const Arguments& arguments() const
4951 {
4952 return m_arguments;
4953 }
4954
4955private:
4956 Arguments m_arguments;
4957};
4958#endif
4959
4960#if PLATFORM(COCOA)
4961class AssistiveTechnologyMakeFirstResponder {
4962public:
4963 typedef std::tuple<> Arguments;
4964
4965 static IPC::StringReference receiverName() { return messageReceiverName(); }
4966 static IPC::StringReference name() { return IPC::StringReference("AssistiveTechnologyMakeFirstResponder"); }
4967 static const bool isSync = false;
4968
4969 const Arguments& arguments() const
4970 {
4971 return m_arguments;
4972 }
4973
4974private:
4975 Arguments m_arguments;
4976};
4977#endif
4978
4979#if PLATFORM(COCOA)
4980class SearchWithSpotlight {
4981public:
4982 typedef std::tuple<const String&> Arguments;
4983
4984 static IPC::StringReference receiverName() { return messageReceiverName(); }
4985 static IPC::StringReference name() { return IPC::StringReference("SearchWithSpotlight"); }
4986 static const bool isSync = false;
4987
4988 explicit SearchWithSpotlight(const String& string)
4989 : m_arguments(string)
4990 {
4991 }
4992
4993 const Arguments& arguments() const
4994 {
4995 return m_arguments;
4996 }
4997
4998private:
4999 Arguments m_arguments;
5000};
5001#endif
5002
5003#if PLATFORM(COCOA)
5004class SearchTheWeb {
5005public:
5006 typedef std::tuple<const String&> Arguments;
5007
5008 static IPC::StringReference receiverName() { return messageReceiverName(); }
5009 static IPC::StringReference name() { return IPC::StringReference("SearchTheWeb"); }
5010 static const bool isSync = false;
5011
5012 explicit SearchTheWeb(const String& string)
5013 : m_arguments(string)
5014 {
5015 }
5016
5017 const Arguments& arguments() const
5018 {
5019 return m_arguments;
5020 }
5021
5022private:
5023 Arguments m_arguments;
5024};
5025#endif
5026
5027#if PLATFORM(COCOA)
5028class TouchBarMenuDataChanged {
5029public:
5030 typedef std::tuple<const WebKit::TouchBarMenuData&> Arguments;
5031
5032 static IPC::StringReference receiverName() { return messageReceiverName(); }
5033 static IPC::StringReference name() { return IPC::StringReference("TouchBarMenuDataChanged"); }
5034 static const bool isSync = false;
5035
5036 explicit TouchBarMenuDataChanged(const WebKit::TouchBarMenuData& touchBarMenuData)
5037 : m_arguments(touchBarMenuData)
5038 {
5039 }
5040
5041 const Arguments& arguments() const
5042 {
5043 return m_arguments;
5044 }
5045
5046private:
5047 Arguments m_arguments;
5048};
5049#endif
5050
5051#if PLATFORM(COCOA)
5052class TouchBarMenuItemDataAdded {
5053public:
5054 typedef std::tuple<const WebKit::TouchBarMenuItemData&> Arguments;
5055
5056 static IPC::StringReference receiverName() { return messageReceiverName(); }
5057 static IPC::StringReference name() { return IPC::StringReference("TouchBarMenuItemDataAdded"); }
5058 static const bool isSync = false;
5059
5060 explicit TouchBarMenuItemDataAdded(const WebKit::TouchBarMenuItemData& touchBarMenuItemData)
5061 : m_arguments(touchBarMenuItemData)
5062 {
5063 }
5064
5065 const Arguments& arguments() const
5066 {
5067 return m_arguments;
5068 }
5069
5070private:
5071 Arguments m_arguments;
5072};
5073#endif
5074
5075#if PLATFORM(COCOA)
5076class TouchBarMenuItemDataRemoved {
5077public:
5078 typedef std::tuple<const WebKit::TouchBarMenuItemData&> Arguments;
5079
5080 static IPC::StringReference receiverName() { return messageReceiverName(); }
5081 static IPC::StringReference name() { return IPC::StringReference("TouchBarMenuItemDataRemoved"); }
5082 static const bool isSync = false;
5083
5084 explicit TouchBarMenuItemDataRemoved(const WebKit::TouchBarMenuItemData& touchBarMenuItemData)
5085 : m_arguments(touchBarMenuItemData)
5086 {
5087 }
5088
5089 const Arguments& arguments() const
5090 {
5091 return m_arguments;
5092 }
5093
5094private:
5095 Arguments m_arguments;
5096};
5097#endif
5098
5099#if USE(APPKIT)
5100class SubstitutionsPanelIsShowing {
5101public:
5102 typedef std::tuple<> Arguments;
5103
5104 static IPC::StringReference receiverName() { return messageReceiverName(); }
5105 static IPC::StringReference name() { return IPC::StringReference("SubstitutionsPanelIsShowing"); }
5106 static const bool isSync = true;
5107
5108 using DelayedReply = CompletionHandler<void(bool isShowing)>;
5109 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool isShowing);
5110 using Reply = std::tuple<bool&>;
5111 using ReplyArguments = std::tuple<bool>;
5112 const Arguments& arguments() const
5113 {
5114 return m_arguments;
5115 }
5116
5117private:
5118 Arguments m_arguments;
5119};
5120#endif
5121
5122#if USE(AUTOMATIC_TEXT_REPLACEMENT)
5123class toggleSmartInsertDelete {
5124public:
5125 typedef std::tuple<> Arguments;
5126
5127 static IPC::StringReference receiverName() { return messageReceiverName(); }
5128 static IPC::StringReference name() { return IPC::StringReference("toggleSmartInsertDelete"); }
5129 static const bool isSync = false;
5130
5131 const Arguments& arguments() const
5132 {
5133 return m_arguments;
5134 }
5135
5136private:
5137 Arguments m_arguments;
5138};
5139#endif
5140
5141#if USE(AUTOMATIC_TEXT_REPLACEMENT)
5142class toggleAutomaticQuoteSubstitution {
5143public:
5144 typedef std::tuple<> Arguments;
5145
5146 static IPC::StringReference receiverName() { return messageReceiverName(); }
5147 static IPC::StringReference name() { return IPC::StringReference("toggleAutomaticQuoteSubstitution"); }
5148 static const bool isSync = false;
5149
5150 const Arguments& arguments() const
5151 {
5152 return m_arguments;
5153 }
5154
5155private:
5156 Arguments m_arguments;
5157};
5158#endif
5159
5160#if USE(AUTOMATIC_TEXT_REPLACEMENT)
5161class toggleAutomaticLinkDetection {
5162public:
5163 typedef std::tuple<> Arguments;
5164
5165 static IPC::StringReference receiverName() { return messageReceiverName(); }
5166 static IPC::StringReference name() { return IPC::StringReference("toggleAutomaticLinkDetection"); }
5167 static const bool isSync = false;
5168
5169 const Arguments& arguments() const
5170 {
5171 return m_arguments;
5172 }
5173
5174private:
5175 Arguments m_arguments;
5176};
5177#endif
5178
5179#if USE(AUTOMATIC_TEXT_REPLACEMENT)
5180class toggleAutomaticDashSubstitution {
5181public:
5182 typedef std::tuple<> Arguments;
5183
5184 static IPC::StringReference receiverName() { return messageReceiverName(); }
5185 static IPC::StringReference name() { return IPC::StringReference("toggleAutomaticDashSubstitution"); }
5186 static const bool isSync = false;
5187
5188 const Arguments& arguments() const
5189 {
5190 return m_arguments;
5191 }
5192
5193private:
5194 Arguments m_arguments;
5195};
5196#endif
5197
5198#if USE(AUTOMATIC_TEXT_REPLACEMENT)
5199class toggleAutomaticTextReplacement {
5200public:
5201 typedef std::tuple<> Arguments;
5202
5203 static IPC::StringReference receiverName() { return messageReceiverName(); }
5204 static IPC::StringReference name() { return IPC::StringReference("toggleAutomaticTextReplacement"); }
5205 static const bool isSync = false;
5206
5207 const Arguments& arguments() const
5208 {
5209 return m_arguments;
5210 }
5211
5212private:
5213 Arguments m_arguments;
5214};
5215#endif
5216
5217#if PLATFORM(MAC)
5218class ShowCorrectionPanel {
5219public:
5220 typedef std::tuple<int32_t, const WebCore::FloatRect&, const String&, const String&, const Vector<String>&> Arguments;
5221
5222 static IPC::StringReference receiverName() { return messageReceiverName(); }
5223 static IPC::StringReference name() { return IPC::StringReference("ShowCorrectionPanel"); }
5224 static const bool isSync = false;
5225
5226 ShowCorrectionPanel(int32_t panelType, const WebCore::FloatRect& boundingBoxOfReplacedString, const String& replacedString, const String& replacementString, const Vector<String>& alternativeReplacementStrings)
5227 : m_arguments(panelType, boundingBoxOfReplacedString, replacedString, replacementString, alternativeReplacementStrings)
5228 {
5229 }
5230
5231 const Arguments& arguments() const
5232 {
5233 return m_arguments;
5234 }
5235
5236private:
5237 Arguments m_arguments;
5238};
5239#endif
5240
5241#if PLATFORM(MAC)
5242class DismissCorrectionPanel {
5243public:
5244 typedef std::tuple<int32_t> Arguments;
5245
5246 static IPC::StringReference receiverName() { return messageReceiverName(); }
5247 static IPC::StringReference name() { return IPC::StringReference("DismissCorrectionPanel"); }
5248 static const bool isSync = false;
5249
5250 explicit DismissCorrectionPanel(int32_t reason)
5251 : m_arguments(reason)
5252 {
5253 }
5254
5255 const Arguments& arguments() const
5256 {
5257 return m_arguments;
5258 }
5259
5260private:
5261 Arguments m_arguments;
5262};
5263#endif
5264
5265#if PLATFORM(MAC)
5266class DismissCorrectionPanelSoon {
5267public:
5268 typedef std::tuple<int32_t> Arguments;
5269
5270 static IPC::StringReference receiverName() { return messageReceiverName(); }
5271 static IPC::StringReference name() { return IPC::StringReference("DismissCorrectionPanelSoon"); }
5272 static const bool isSync = true;
5273
5274 using DelayedReply = CompletionHandler<void(const String& result)>;
5275 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const String& result);
5276 using Reply = std::tuple<String&>;
5277 using ReplyArguments = std::tuple<String>;
5278 explicit DismissCorrectionPanelSoon(int32_t reason)
5279 : m_arguments(reason)
5280 {
5281 }
5282
5283 const Arguments& arguments() const
5284 {
5285 return m_arguments;
5286 }
5287
5288private:
5289 Arguments m_arguments;
5290};
5291#endif
5292
5293#if PLATFORM(MAC)
5294class RecordAutocorrectionResponse {
5295public:
5296 typedef std::tuple<int32_t, const String&, const String&> Arguments;
5297
5298 static IPC::StringReference receiverName() { return messageReceiverName(); }
5299 static IPC::StringReference name() { return IPC::StringReference("RecordAutocorrectionResponse"); }
5300 static const bool isSync = false;
5301
5302 RecordAutocorrectionResponse(int32_t response, const String& replacedString, const String& replacementString)
5303 : m_arguments(response, replacedString, replacementString)
5304 {
5305 }
5306
5307 const Arguments& arguments() const
5308 {
5309 return m_arguments;
5310 }
5311
5312private:
5313 Arguments m_arguments;
5314};
5315#endif
5316
5317#if PLATFORM(MAC)
5318class SetEditableElementIsFocused {
5319public:
5320 typedef std::tuple<bool> Arguments;
5321
5322 static IPC::StringReference receiverName() { return messageReceiverName(); }
5323 static IPC::StringReference name() { return IPC::StringReference("SetEditableElementIsFocused"); }
5324 static const bool isSync = false;
5325
5326 explicit SetEditableElementIsFocused(bool editableElementIsFocused)
5327 : m_arguments(editableElementIsFocused)
5328 {
5329 }
5330
5331 const Arguments& arguments() const
5332 {
5333 return m_arguments;
5334 }
5335
5336private:
5337 Arguments m_arguments;
5338};
5339#endif
5340
5341#if USE(DICTATION_ALTERNATIVES)
5342class ShowDictationAlternativeUI {
5343public:
5344 typedef std::tuple<const WebCore::FloatRect&, uint64_t> Arguments;
5345
5346 static IPC::StringReference receiverName() { return messageReceiverName(); }
5347 static IPC::StringReference name() { return IPC::StringReference("ShowDictationAlternativeUI"); }
5348 static const bool isSync = false;
5349
5350 ShowDictationAlternativeUI(const WebCore::FloatRect& boundingBoxOfDictatedText, uint64_t dictationContext)
5351 : m_arguments(boundingBoxOfDictatedText, dictationContext)
5352 {
5353 }
5354
5355 const Arguments& arguments() const
5356 {
5357 return m_arguments;
5358 }
5359
5360private:
5361 Arguments m_arguments;
5362};
5363#endif
5364
5365#if USE(DICTATION_ALTERNATIVES)
5366class RemoveDictationAlternatives {
5367public:
5368 typedef std::tuple<uint64_t> Arguments;
5369
5370 static IPC::StringReference receiverName() { return messageReceiverName(); }
5371 static IPC::StringReference name() { return IPC::StringReference("RemoveDictationAlternatives"); }
5372 static const bool isSync = false;
5373
5374 explicit RemoveDictationAlternatives(uint64_t dictationContext)
5375 : m_arguments(dictationContext)
5376 {
5377 }
5378
5379 const Arguments& arguments() const
5380 {
5381 return m_arguments;
5382 }
5383
5384private:
5385 Arguments m_arguments;
5386};
5387#endif
5388
5389#if USE(DICTATION_ALTERNATIVES)
5390class DictationAlternatives {
5391public:
5392 typedef std::tuple<uint64_t> Arguments;
5393
5394 static IPC::StringReference receiverName() { return messageReceiverName(); }
5395 static IPC::StringReference name() { return IPC::StringReference("DictationAlternatives"); }
5396 static const bool isSync = true;
5397
5398 using DelayedReply = CompletionHandler<void(const Vector<String>& alternatives)>;
5399 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const Vector<String>& alternatives);
5400 using Reply = std::tuple<Vector<String>&>;
5401 using ReplyArguments = std::tuple<Vector<String>>;
5402 explicit DictationAlternatives(uint64_t dictationContext)
5403 : m_arguments(dictationContext)
5404 {
5405 }
5406
5407 const Arguments& arguments() const
5408 {
5409 return m_arguments;
5410 }
5411
5412private:
5413 Arguments m_arguments;
5414};
5415#endif
5416
5417#if PLATFORM(X11)
5418class CreatePluginContainer {
5419public:
5420 typedef std::tuple<> Arguments;
5421
5422 static IPC::StringReference receiverName() { return messageReceiverName(); }
5423 static IPC::StringReference name() { return IPC::StringReference("CreatePluginContainer"); }
5424 static const bool isSync = true;
5425
5426 using DelayedReply = CompletionHandler<void(uint64_t windowID)>;
5427 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, uint64_t windowID);
5428 using Reply = std::tuple<uint64_t&>;
5429 using ReplyArguments = std::tuple<uint64_t>;
5430 const Arguments& arguments() const
5431 {
5432 return m_arguments;
5433 }
5434
5435private:
5436 Arguments m_arguments;
5437};
5438#endif
5439
5440#if PLATFORM(X11)
5441class WindowedPluginGeometryDidChange {
5442public:
5443 typedef std::tuple<const WebCore::IntRect&, const WebCore::IntRect&, uint64_t> Arguments;
5444
5445 static IPC::StringReference receiverName() { return messageReceiverName(); }
5446 static IPC::StringReference name() { return IPC::StringReference("WindowedPluginGeometryDidChange"); }
5447 static const bool isSync = false;
5448
5449 WindowedPluginGeometryDidChange(const WebCore::IntRect& frameRect, const WebCore::IntRect& clipRect, uint64_t windowID)
5450 : m_arguments(frameRect, clipRect, windowID)
5451 {
5452 }
5453
5454 const Arguments& arguments() const
5455 {
5456 return m_arguments;
5457 }
5458
5459private:
5460 Arguments m_arguments;
5461};
5462#endif
5463
5464#if PLATFORM(X11)
5465class WindowedPluginVisibilityDidChange {
5466public:
5467 typedef std::tuple<bool, uint64_t> Arguments;
5468
5469 static IPC::StringReference receiverName() { return messageReceiverName(); }
5470 static IPC::StringReference name() { return IPC::StringReference("WindowedPluginVisibilityDidChange"); }
5471 static const bool isSync = false;
5472
5473 WindowedPluginVisibilityDidChange(bool isVisible, uint64_t windowID)
5474 : m_arguments(isVisible, windowID)
5475 {
5476 }
5477
5478 const Arguments& arguments() const
5479 {
5480 return m_arguments;
5481 }
5482
5483private:
5484 Arguments m_arguments;
5485};
5486#endif
5487
5488#if PLATFORM(IOS_FAMILY)
5489class CouldNotRestorePageState {
5490public:
5491 typedef std::tuple<> Arguments;
5492
5493 static IPC::StringReference receiverName() { return messageReceiverName(); }
5494 static IPC::StringReference name() { return IPC::StringReference("CouldNotRestorePageState"); }
5495 static const bool isSync = false;
5496
5497 const Arguments& arguments() const
5498 {
5499 return m_arguments;
5500 }
5501
5502private:
5503 Arguments m_arguments;
5504};
5505#endif
5506
5507#if PLATFORM(IOS_FAMILY)
5508class RestorePageState {
5509public:
5510 typedef std::tuple<const Optional<WebCore::FloatPoint>&, const WebCore::FloatPoint&, const WebCore::RectEdges<float>&, double> Arguments;
5511
5512 static IPC::StringReference receiverName() { return messageReceiverName(); }
5513 static IPC::StringReference name() { return IPC::StringReference("RestorePageState"); }
5514 static const bool isSync = false;
5515
5516 RestorePageState(const Optional<WebCore::FloatPoint>& scrollPosition, const WebCore::FloatPoint& scrollOrigin, const WebCore::RectEdges<float>& obscuredInsetsOnSave, double scale)
5517 : m_arguments(scrollPosition, scrollOrigin, obscuredInsetsOnSave, scale)
5518 {
5519 }
5520
5521 const Arguments& arguments() const
5522 {
5523 return m_arguments;
5524 }
5525
5526private:
5527 Arguments m_arguments;
5528};
5529#endif
5530
5531#if PLATFORM(IOS_FAMILY)
5532class RestorePageCenterAndScale {
5533public:
5534 typedef std::tuple<const Optional<WebCore::FloatPoint>&, double> Arguments;
5535
5536 static IPC::StringReference receiverName() { return messageReceiverName(); }
5537 static IPC::StringReference name() { return IPC::StringReference("RestorePageCenterAndScale"); }
5538 static const bool isSync = false;
5539
5540 RestorePageCenterAndScale(const Optional<WebCore::FloatPoint>& unobscuredCenter, double scale)
5541 : m_arguments(unobscuredCenter, scale)
5542 {
5543 }
5544
5545 const Arguments& arguments() const
5546 {
5547 return m_arguments;
5548 }
5549
5550private:
5551 Arguments m_arguments;
5552};
5553#endif
5554
5555#if PLATFORM(IOS_FAMILY)
5556class DidGetTapHighlightGeometries {
5557public:
5558 typedef std::tuple<uint64_t, const WebCore::Color&, const Vector<WebCore::FloatQuad>&, const WebCore::IntSize&, const WebCore::IntSize&, const WebCore::IntSize&, const WebCore::IntSize&, bool> Arguments;
5559
5560 static IPC::StringReference receiverName() { return messageReceiverName(); }
5561 static IPC::StringReference name() { return IPC::StringReference("DidGetTapHighlightGeometries"); }
5562 static const bool isSync = false;
5563
5564 DidGetTapHighlightGeometries(uint64_t requestID, const WebCore::Color& color, const Vector<WebCore::FloatQuad>& geometries, const WebCore::IntSize& topLeftRadius, const WebCore::IntSize& topRightRadius, const WebCore::IntSize& bottomLeftRadius, const WebCore::IntSize& bottomRightRadius, bool nodeHasBuiltInClickHandling)
5565 : m_arguments(requestID, color, geometries, topLeftRadius, topRightRadius, bottomLeftRadius, bottomRightRadius, nodeHasBuiltInClickHandling)
5566 {
5567 }
5568
5569 const Arguments& arguments() const
5570 {
5571 return m_arguments;
5572 }
5573
5574private:
5575 Arguments m_arguments;
5576};
5577#endif
5578
5579#if PLATFORM(IOS_FAMILY)
5580class ElementDidFocus {
5581public:
5582 typedef std::tuple<const WebKit::FocusedElementInformation&, bool, bool, const OptionSet<WebCore::ActivityState::Flag>&, const WebKit::UserData&> Arguments;
5583
5584 static IPC::StringReference receiverName() { return messageReceiverName(); }
5585 static IPC::StringReference name() { return IPC::StringReference("ElementDidFocus"); }
5586 static const bool isSync = false;
5587
5588 ElementDidFocus(const WebKit::FocusedElementInformation& information, bool userIsInteracting, bool blurPreviousNode, const OptionSet<WebCore::ActivityState::Flag>& activityStateChanges, const WebKit::UserData& userData)
5589 : m_arguments(information, userIsInteracting, blurPreviousNode, activityStateChanges, userData)
5590 {
5591 }
5592
5593 const Arguments& arguments() const
5594 {
5595 return m_arguments;
5596 }
5597
5598private:
5599 Arguments m_arguments;
5600};
5601#endif
5602
5603#if PLATFORM(IOS_FAMILY)
5604class ElementDidBlur {
5605public:
5606 typedef std::tuple<> Arguments;
5607
5608 static IPC::StringReference receiverName() { return messageReceiverName(); }
5609 static IPC::StringReference name() { return IPC::StringReference("ElementDidBlur"); }
5610 static const bool isSync = false;
5611
5612 const Arguments& arguments() const
5613 {
5614 return m_arguments;
5615 }
5616
5617private:
5618 Arguments m_arguments;
5619};
5620#endif
5621
5622#if PLATFORM(IOS_FAMILY)
5623class FocusedElementDidChangeInputMode {
5624public:
5625 typedef std::tuple<WebCore::InputMode> Arguments;
5626
5627 static IPC::StringReference receiverName() { return messageReceiverName(); }
5628 static IPC::StringReference name() { return IPC::StringReference("FocusedElementDidChangeInputMode"); }
5629 static const bool isSync = false;
5630
5631 explicit FocusedElementDidChangeInputMode(WebCore::InputMode mode)
5632 : m_arguments(mode)
5633 {
5634 }
5635
5636 const Arguments& arguments() const
5637 {
5638 return m_arguments;
5639 }
5640
5641private:
5642 Arguments m_arguments;
5643};
5644#endif
5645
5646#if PLATFORM(IOS_FAMILY)
5647class ScrollingNodeScrollWillStartScroll {
5648public:
5649 typedef std::tuple<> Arguments;
5650
5651 static IPC::StringReference receiverName() { return messageReceiverName(); }
5652 static IPC::StringReference name() { return IPC::StringReference("ScrollingNodeScrollWillStartScroll"); }
5653 static const bool isSync = false;
5654
5655 const Arguments& arguments() const
5656 {
5657 return m_arguments;
5658 }
5659
5660private:
5661 Arguments m_arguments;
5662};
5663#endif
5664
5665#if PLATFORM(IOS_FAMILY)
5666class ScrollingNodeScrollDidEndScroll {
5667public:
5668 typedef std::tuple<> Arguments;
5669
5670 static IPC::StringReference receiverName() { return messageReceiverName(); }
5671 static IPC::StringReference name() { return IPC::StringReference("ScrollingNodeScrollDidEndScroll"); }
5672 static const bool isSync = false;
5673
5674 const Arguments& arguments() const
5675 {
5676 return m_arguments;
5677 }
5678
5679private:
5680 Arguments m_arguments;
5681};
5682#endif
5683
5684#if PLATFORM(IOS_FAMILY)
5685class ShowInspectorHighlight {
5686public:
5687 typedef std::tuple<const WebCore::Highlight&> Arguments;
5688
5689 static IPC::StringReference receiverName() { return messageReceiverName(); }
5690 static IPC::StringReference name() { return IPC::StringReference("ShowInspectorHighlight"); }
5691 static const bool isSync = false;
5692
5693 explicit ShowInspectorHighlight(const WebCore::Highlight& highlight)
5694 : m_arguments(highlight)
5695 {
5696 }
5697
5698 const Arguments& arguments() const
5699 {
5700 return m_arguments;
5701 }
5702
5703private:
5704 Arguments m_arguments;
5705};
5706#endif
5707
5708#if PLATFORM(IOS_FAMILY)
5709class HideInspectorHighlight {
5710public:
5711 typedef std::tuple<> Arguments;
5712
5713 static IPC::StringReference receiverName() { return messageReceiverName(); }
5714 static IPC::StringReference name() { return IPC::StringReference("HideInspectorHighlight"); }
5715 static const bool isSync = false;
5716
5717 const Arguments& arguments() const
5718 {
5719 return m_arguments;
5720 }
5721
5722private:
5723 Arguments m_arguments;
5724};
5725#endif
5726
5727#if PLATFORM(IOS_FAMILY)
5728class FocusedElementInformationCallback {
5729public:
5730 typedef std::tuple<const WebKit::FocusedElementInformation&, const WebKit::CallbackID&> Arguments;
5731
5732 static IPC::StringReference receiverName() { return messageReceiverName(); }
5733 static IPC::StringReference name() { return IPC::StringReference("FocusedElementInformationCallback"); }
5734 static const bool isSync = false;
5735
5736 FocusedElementInformationCallback(const WebKit::FocusedElementInformation& information, const WebKit::CallbackID& callbackID)
5737 : m_arguments(information, callbackID)
5738 {
5739 }
5740
5741 const Arguments& arguments() const
5742 {
5743 return m_arguments;
5744 }
5745
5746private:
5747 Arguments m_arguments;
5748};
5749#endif
5750
5751#if PLATFORM(IOS_FAMILY)
5752class ShowInspectorIndication {
5753public:
5754 typedef std::tuple<> Arguments;
5755
5756 static IPC::StringReference receiverName() { return messageReceiverName(); }
5757 static IPC::StringReference name() { return IPC::StringReference("ShowInspectorIndication"); }
5758 static const bool isSync = false;
5759
5760 const Arguments& arguments() const
5761 {
5762 return m_arguments;
5763 }
5764
5765private:
5766 Arguments m_arguments;
5767};
5768#endif
5769
5770#if PLATFORM(IOS_FAMILY)
5771class HideInspectorIndication {
5772public:
5773 typedef std::tuple<> Arguments;
5774
5775 static IPC::StringReference receiverName() { return messageReceiverName(); }
5776 static IPC::StringReference name() { return IPC::StringReference("HideInspectorIndication"); }
5777 static const bool isSync = false;
5778
5779 const Arguments& arguments() const
5780 {
5781 return m_arguments;
5782 }
5783
5784private:
5785 Arguments m_arguments;
5786};
5787#endif
5788
5789#if PLATFORM(IOS_FAMILY)
5790class EnableInspectorNodeSearch {
5791public:
5792 typedef std::tuple<> Arguments;
5793
5794 static IPC::StringReference receiverName() { return messageReceiverName(); }
5795 static IPC::StringReference name() { return IPC::StringReference("EnableInspectorNodeSearch"); }
5796 static const bool isSync = false;
5797
5798 const Arguments& arguments() const
5799 {
5800 return m_arguments;
5801 }
5802
5803private:
5804 Arguments m_arguments;
5805};
5806#endif
5807
5808#if PLATFORM(IOS_FAMILY)
5809class DisableInspectorNodeSearch {
5810public:
5811 typedef std::tuple<> Arguments;
5812
5813 static IPC::StringReference receiverName() { return messageReceiverName(); }
5814 static IPC::StringReference name() { return IPC::StringReference("DisableInspectorNodeSearch"); }
5815 static const bool isSync = false;
5816
5817 const Arguments& arguments() const
5818 {
5819 return m_arguments;
5820 }
5821
5822private:
5823 Arguments m_arguments;
5824};
5825#endif
5826
5827#if PLATFORM(IOS_FAMILY)
5828class UpdateStringForFind {
5829public:
5830 typedef std::tuple<const String&> Arguments;
5831
5832 static IPC::StringReference receiverName() { return messageReceiverName(); }
5833 static IPC::StringReference name() { return IPC::StringReference("UpdateStringForFind"); }
5834 static const bool isSync = false;
5835
5836 explicit UpdateStringForFind(const String& findString)
5837 : m_arguments(findString)
5838 {
5839 }
5840
5841 const Arguments& arguments() const
5842 {
5843 return m_arguments;
5844 }
5845
5846private:
5847 Arguments m_arguments;
5848};
5849#endif
5850
5851#if PLATFORM(IOS_FAMILY)
5852class HandleAutocorrectionContext {
5853public:
5854 typedef std::tuple<const WebKit::WebAutocorrectionContext&> Arguments;
5855
5856 static IPC::StringReference receiverName() { return messageReceiverName(); }
5857 static IPC::StringReference name() { return IPC::StringReference("HandleAutocorrectionContext"); }
5858 static const bool isSync = false;
5859
5860 explicit HandleAutocorrectionContext(const WebKit::WebAutocorrectionContext& context)
5861 : m_arguments(context)
5862 {
5863 }
5864
5865 const Arguments& arguments() const
5866 {
5867 return m_arguments;
5868 }
5869
5870private:
5871 Arguments m_arguments;
5872};
5873#endif
5874
5875class DidChangeInspectorFrontendCount {
5876public:
5877 typedef std::tuple<uint64_t> Arguments;
5878
5879 static IPC::StringReference receiverName() { return messageReceiverName(); }
5880 static IPC::StringReference name() { return IPC::StringReference("DidChangeInspectorFrontendCount"); }
5881 static const bool isSync = false;
5882
5883 explicit DidChangeInspectorFrontendCount(uint64_t count)
5884 : m_arguments(count)
5885 {
5886 }
5887
5888 const Arguments& arguments() const
5889 {
5890 return m_arguments;
5891 }
5892
5893private:
5894 Arguments m_arguments;
5895};
5896
5897class CreateInspectorTarget {
5898public:
5899 typedef std::tuple<const String&, Inspector::InspectorTargetType> Arguments;
5900
5901 static IPC::StringReference receiverName() { return messageReceiverName(); }
5902 static IPC::StringReference name() { return IPC::StringReference("CreateInspectorTarget"); }
5903 static const bool isSync = false;
5904
5905 CreateInspectorTarget(const String& targetId, Inspector::InspectorTargetType type)
5906 : m_arguments(targetId, type)
5907 {
5908 }
5909
5910 const Arguments& arguments() const
5911 {
5912 return m_arguments;
5913 }
5914
5915private:
5916 Arguments m_arguments;
5917};
5918
5919class DestroyInspectorTarget {
5920public:
5921 typedef std::tuple<const String&> Arguments;
5922
5923 static IPC::StringReference receiverName() { return messageReceiverName(); }
5924 static IPC::StringReference name() { return IPC::StringReference("DestroyInspectorTarget"); }
5925 static const bool isSync = false;
5926
5927 explicit DestroyInspectorTarget(const String& targetId)
5928 : m_arguments(targetId)
5929 {
5930 }
5931
5932 const Arguments& arguments() const
5933 {
5934 return m_arguments;
5935 }
5936
5937private:
5938 Arguments m_arguments;
5939};
5940
5941class SendMessageToInspectorFrontend {
5942public:
5943 typedef std::tuple<const String&, const String&> Arguments;
5944
5945 static IPC::StringReference receiverName() { return messageReceiverName(); }
5946 static IPC::StringReference name() { return IPC::StringReference("SendMessageToInspectorFrontend"); }
5947 static const bool isSync = false;
5948
5949 SendMessageToInspectorFrontend(const String& targetId, const String& message)
5950 : m_arguments(targetId, message)
5951 {
5952 }
5953
5954 const Arguments& arguments() const
5955 {
5956 return m_arguments;
5957 }
5958
5959private:
5960 Arguments m_arguments;
5961};
5962
5963class SaveRecentSearches {
5964public:
5965 typedef std::tuple<const String&, const Vector<WebCore::RecentSearch>&> Arguments;
5966
5967 static IPC::StringReference receiverName() { return messageReceiverName(); }
5968 static IPC::StringReference name() { return IPC::StringReference("SaveRecentSearches"); }
5969 static const bool isSync = false;
5970
5971 SaveRecentSearches(const String& name, const Vector<WebCore::RecentSearch>& searchItems)
5972 : m_arguments(name, searchItems)
5973 {
5974 }
5975
5976 const Arguments& arguments() const
5977 {
5978 return m_arguments;
5979 }
5980
5981private:
5982 Arguments m_arguments;
5983};
5984
5985class LoadRecentSearches {
5986public:
5987 typedef std::tuple<const String&> Arguments;
5988
5989 static IPC::StringReference receiverName() { return messageReceiverName(); }
5990 static IPC::StringReference name() { return IPC::StringReference("LoadRecentSearches"); }
5991 static const bool isSync = true;
5992
5993 using DelayedReply = CompletionHandler<void(const Vector<WebCore::RecentSearch>& result)>;
5994 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const Vector<WebCore::RecentSearch>& result);
5995 using Reply = std::tuple<Vector<WebCore::RecentSearch>&>;
5996 using ReplyArguments = std::tuple<Vector<WebCore::RecentSearch>>;
5997 explicit LoadRecentSearches(const String& name)
5998 : m_arguments(name)
5999 {
6000 }
6001
6002 const Arguments& arguments() const
6003 {
6004 return m_arguments;
6005 }
6006
6007private:
6008 Arguments m_arguments;
6009};
6010
6011class SavePDFToFileInDownloadsFolder {
6012public:
6013 typedef std::tuple<const String&, const URL&, const IPC::DataReference&> Arguments;
6014
6015 static IPC::StringReference receiverName() { return messageReceiverName(); }
6016 static IPC::StringReference name() { return IPC::StringReference("SavePDFToFileInDownloadsFolder"); }
6017 static const bool isSync = false;
6018
6019 SavePDFToFileInDownloadsFolder(const String& suggestedFilename, const URL& originatingURL, const IPC::DataReference& data)
6020 : m_arguments(suggestedFilename, originatingURL, data)
6021 {
6022 }
6023
6024 const Arguments& arguments() const
6025 {
6026 return m_arguments;
6027 }
6028
6029private:
6030 Arguments m_arguments;
6031};
6032
6033#if PLATFORM(COCOA)
6034class SavePDFToTemporaryFolderAndOpenWithNativeApplication {
6035public:
6036 typedef std::tuple<const String&, const String&, const IPC::DataReference&, const String&> Arguments;
6037
6038 static IPC::StringReference receiverName() { return messageReceiverName(); }
6039 static IPC::StringReference name() { return IPC::StringReference("SavePDFToTemporaryFolderAndOpenWithNativeApplication"); }
6040 static const bool isSync = false;
6041
6042 SavePDFToTemporaryFolderAndOpenWithNativeApplication(const String& suggestedFilename, const String& originatingURLString, const IPC::DataReference& data, const String& pdfUUID)
6043 : m_arguments(suggestedFilename, originatingURLString, data, pdfUUID)
6044 {
6045 }
6046
6047 const Arguments& arguments() const
6048 {
6049 return m_arguments;
6050 }
6051
6052private:
6053 Arguments m_arguments;
6054};
6055#endif
6056
6057#if PLATFORM(COCOA)
6058class OpenPDFFromTemporaryFolderWithNativeApplication {
6059public:
6060 typedef std::tuple<const String&> Arguments;
6061
6062 static IPC::StringReference receiverName() { return messageReceiverName(); }
6063 static IPC::StringReference name() { return IPC::StringReference("OpenPDFFromTemporaryFolderWithNativeApplication"); }
6064 static const bool isSync = false;
6065
6066 explicit OpenPDFFromTemporaryFolderWithNativeApplication(const String& pdfUUID)
6067 : m_arguments(pdfUUID)
6068 {
6069 }
6070
6071 const Arguments& arguments() const
6072 {
6073 return m_arguments;
6074 }
6075
6076private:
6077 Arguments m_arguments;
6078};
6079#endif
6080
6081#if ENABLE(PDFKIT_PLUGIN)
6082class ShowPDFContextMenu {
6083public:
6084 typedef std::tuple<const WebKit::PDFContextMenu&> Arguments;
6085
6086 static IPC::StringReference receiverName() { return messageReceiverName(); }
6087 static IPC::StringReference name() { return IPC::StringReference("ShowPDFContextMenu"); }
6088 static const bool isSync = true;
6089
6090 using DelayedReply = CompletionHandler<void(const Optional<int32_t>& selectedItem)>;
6091 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const Optional<int32_t>& selectedItem);
6092 using Reply = std::tuple<Optional<int32_t>&>;
6093 using ReplyArguments = std::tuple<Optional<int32_t>>;
6094 explicit ShowPDFContextMenu(const WebKit::PDFContextMenu& contextMenu)
6095 : m_arguments(contextMenu)
6096 {
6097 }
6098
6099 const Arguments& arguments() const
6100 {
6101 return m_arguments;
6102 }
6103
6104private:
6105 Arguments m_arguments;
6106};
6107#endif
6108
6109#if ENABLE(NETSCAPE_PLUGIN_API)
6110class FindPlugin {
6111public:
6112 typedef std::tuple<const String&, uint32_t, const String&, const String&, const String&, bool> Arguments;
6113
6114 static IPC::StringReference receiverName() { return messageReceiverName(); }
6115 static IPC::StringReference name() { return IPC::StringReference("FindPlugin"); }
6116 static const bool isSync = true;
6117
6118 using DelayedReply = CompletionHandler<void(uint64_t pluginProcessToken, const String& newMIMEType, uint32_t pluginLoadPolicy, const String& unavailabilityDescription, bool isUnsupported)>;
6119 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, uint64_t pluginProcessToken, const String& newMIMEType, uint32_t pluginLoadPolicy, const String& unavailabilityDescription, bool isUnsupported);
6120 using Reply = std::tuple<uint64_t&, String&, uint32_t&, String&, bool&>;
6121 using ReplyArguments = std::tuple<uint64_t, String, uint32_t, String, bool>;
6122 FindPlugin(const String& mimeType, uint32_t processType, const String& urlString, const String& frameURLString, const String& pageURLString, bool allowOnlyApplicationPlugins)
6123 : m_arguments(mimeType, processType, urlString, frameURLString, pageURLString, allowOnlyApplicationPlugins)
6124 {
6125 }
6126
6127 const Arguments& arguments() const
6128 {
6129 return m_arguments;
6130 }
6131
6132private:
6133 Arguments m_arguments;
6134};
6135#endif
6136
6137class DidUpdateActivityState {
6138public:
6139 typedef std::tuple<> Arguments;
6140
6141 static IPC::StringReference receiverName() { return messageReceiverName(); }
6142 static IPC::StringReference name() { return IPC::StringReference("DidUpdateActivityState"); }
6143 static const bool isSync = false;
6144
6145 const Arguments& arguments() const
6146 {
6147 return m_arguments;
6148 }
6149
6150private:
6151 Arguments m_arguments;
6152};
6153
6154class DidSaveToPageCache {
6155public:
6156 typedef std::tuple<> Arguments;
6157
6158 static IPC::StringReference receiverName() { return messageReceiverName(); }
6159 static IPC::StringReference name() { return IPC::StringReference("DidSaveToPageCache"); }
6160 static const bool isSync = false;
6161
6162 const Arguments& arguments() const
6163 {
6164 return m_arguments;
6165 }
6166
6167private:
6168 Arguments m_arguments;
6169};
6170
6171#if ENABLE(WEB_CRYPTO)
6172class WrapCryptoKey {
6173public:
6174 typedef std::tuple<const Vector<uint8_t>&> Arguments;
6175
6176 static IPC::StringReference receiverName() { return messageReceiverName(); }
6177 static IPC::StringReference name() { return IPC::StringReference("WrapCryptoKey"); }
6178 static const bool isSync = true;
6179
6180 using DelayedReply = CompletionHandler<void(bool succeeded, const Vector<uint8_t>& wrappedKey)>;
6181 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool succeeded, const Vector<uint8_t>& wrappedKey);
6182 using Reply = std::tuple<bool&, Vector<uint8_t>&>;
6183 using ReplyArguments = std::tuple<bool, Vector<uint8_t>>;
6184 explicit WrapCryptoKey(const Vector<uint8_t>& key)
6185 : m_arguments(key)
6186 {
6187 }
6188
6189 const Arguments& arguments() const
6190 {
6191 return m_arguments;
6192 }
6193
6194private:
6195 Arguments m_arguments;
6196};
6197#endif
6198
6199#if ENABLE(WEB_CRYPTO)
6200class UnwrapCryptoKey {
6201public:
6202 typedef std::tuple<const Vector<uint8_t>&> Arguments;
6203
6204 static IPC::StringReference receiverName() { return messageReceiverName(); }
6205 static IPC::StringReference name() { return IPC::StringReference("UnwrapCryptoKey"); }
6206 static const bool isSync = true;
6207
6208 using DelayedReply = CompletionHandler<void(bool succeeded, const Vector<uint8_t>& key)>;
6209 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, bool succeeded, const Vector<uint8_t>& key);
6210 using Reply = std::tuple<bool&, Vector<uint8_t>&>;
6211 using ReplyArguments = std::tuple<bool, Vector<uint8_t>>;
6212 explicit UnwrapCryptoKey(const Vector<uint8_t>& wrappedKey)
6213 : m_arguments(wrappedKey)
6214 {
6215 }
6216
6217 const Arguments& arguments() const
6218 {
6219 return m_arguments;
6220 }
6221
6222private:
6223 Arguments m_arguments;
6224};
6225#endif
6226
6227#if (ENABLE(TELEPHONE_NUMBER_DETECTION) && PLATFORM(MAC))
6228class ShowTelephoneNumberMenu {
6229public:
6230 typedef std::tuple<const String&, const WebCore::IntPoint&> Arguments;
6231
6232 static IPC::StringReference receiverName() { return messageReceiverName(); }
6233 static IPC::StringReference name() { return IPC::StringReference("ShowTelephoneNumberMenu"); }
6234 static const bool isSync = false;
6235
6236 ShowTelephoneNumberMenu(const String& telephoneNumber, const WebCore::IntPoint& point)
6237 : m_arguments(telephoneNumber, point)
6238 {
6239 }
6240
6241 const Arguments& arguments() const
6242 {
6243 return m_arguments;
6244 }
6245
6246private:
6247 Arguments m_arguments;
6248};
6249#endif
6250
6251#if USE(QUICK_LOOK)
6252class DidStartLoadForQuickLookDocumentInMainFrame {
6253public:
6254 typedef std::tuple<const String&, const String&> Arguments;
6255
6256 static IPC::StringReference receiverName() { return messageReceiverName(); }
6257 static IPC::StringReference name() { return IPC::StringReference("DidStartLoadForQuickLookDocumentInMainFrame"); }
6258 static const bool isSync = false;
6259
6260 DidStartLoadForQuickLookDocumentInMainFrame(const String& fileName, const String& uti)
6261 : m_arguments(fileName, uti)
6262 {
6263 }
6264
6265 const Arguments& arguments() const
6266 {
6267 return m_arguments;
6268 }
6269
6270private:
6271 Arguments m_arguments;
6272};
6273#endif
6274
6275#if USE(QUICK_LOOK)
6276class DidFinishLoadForQuickLookDocumentInMainFrame {
6277public:
6278 typedef std::tuple<const WebKit::QuickLookDocumentData&> Arguments;
6279
6280 static IPC::StringReference receiverName() { return messageReceiverName(); }
6281 static IPC::StringReference name() { return IPC::StringReference("DidFinishLoadForQuickLookDocumentInMainFrame"); }
6282 static const bool isSync = false;
6283
6284 explicit DidFinishLoadForQuickLookDocumentInMainFrame(const WebKit::QuickLookDocumentData& data)
6285 : m_arguments(data)
6286 {
6287 }
6288
6289 const Arguments& arguments() const
6290 {
6291 return m_arguments;
6292 }
6293
6294private:
6295 Arguments m_arguments;
6296};
6297#endif
6298
6299#if USE(QUICK_LOOK)
6300class DidRequestPasswordForQuickLookDocumentInMainFrame {
6301public:
6302 typedef std::tuple<const String&> Arguments;
6303
6304 static IPC::StringReference receiverName() { return messageReceiverName(); }
6305 static IPC::StringReference name() { return IPC::StringReference("DidRequestPasswordForQuickLookDocumentInMainFrame"); }
6306 static const bool isSync = false;
6307
6308 explicit DidRequestPasswordForQuickLookDocumentInMainFrame(const String& fileName)
6309 : m_arguments(fileName)
6310 {
6311 }
6312
6313 const Arguments& arguments() const
6314 {
6315 return m_arguments;
6316 }
6317
6318private:
6319 Arguments m_arguments;
6320};
6321#endif
6322
6323#if ENABLE(CONTENT_FILTERING)
6324class ContentFilterDidBlockLoadForFrame {
6325public:
6326 typedef std::tuple<const WebCore::ContentFilterUnblockHandler&, uint64_t> Arguments;
6327
6328 static IPC::StringReference receiverName() { return messageReceiverName(); }
6329 static IPC::StringReference name() { return IPC::StringReference("ContentFilterDidBlockLoadForFrame"); }
6330 static const bool isSync = false;
6331
6332 ContentFilterDidBlockLoadForFrame(const WebCore::ContentFilterUnblockHandler& unblockHandler, uint64_t frameID)
6333 : m_arguments(unblockHandler, frameID)
6334 {
6335 }
6336
6337 const Arguments& arguments() const
6338 {
6339 return m_arguments;
6340 }
6341
6342private:
6343 Arguments m_arguments;
6344};
6345#endif
6346
6347class IsPlayingMediaDidChange {
6348public:
6349 typedef std::tuple<const unsigned&, uint64_t> Arguments;
6350
6351 static IPC::StringReference receiverName() { return messageReceiverName(); }
6352 static IPC::StringReference name() { return IPC::StringReference("IsPlayingMediaDidChange"); }
6353 static const bool isSync = false;
6354
6355 IsPlayingMediaDidChange(const unsigned& state, uint64_t sourceElementID)
6356 : m_arguments(state, sourceElementID)
6357 {
6358 }
6359
6360 const Arguments& arguments() const
6361 {
6362 return m_arguments;
6363 }
6364
6365private:
6366 Arguments m_arguments;
6367};
6368
6369class HandleAutoplayEvent {
6370public:
6371 typedef std::tuple<WebCore::AutoplayEvent, const OptionSet<WebCore::AutoplayEventFlags>&> Arguments;
6372
6373 static IPC::StringReference receiverName() { return messageReceiverName(); }
6374 static IPC::StringReference name() { return IPC::StringReference("HandleAutoplayEvent"); }
6375 static const bool isSync = false;
6376
6377 HandleAutoplayEvent(WebCore::AutoplayEvent event, const OptionSet<WebCore::AutoplayEventFlags>& flags)
6378 : m_arguments(event, flags)
6379 {
6380 }
6381
6382 const Arguments& arguments() const
6383 {
6384 return m_arguments;
6385 }
6386
6387private:
6388 Arguments m_arguments;
6389};
6390
6391#if ENABLE(MEDIA_SESSION)
6392class HasMediaSessionWithActiveMediaElementsDidChange {
6393public:
6394 typedef std::tuple<bool> Arguments;
6395
6396 static IPC::StringReference receiverName() { return messageReceiverName(); }
6397 static IPC::StringReference name() { return IPC::StringReference("HasMediaSessionWithActiveMediaElementsDidChange"); }
6398 static const bool isSync = false;
6399
6400 explicit HasMediaSessionWithActiveMediaElementsDidChange(bool state)
6401 : m_arguments(state)
6402 {
6403 }
6404
6405 const Arguments& arguments() const
6406 {
6407 return m_arguments;
6408 }
6409
6410private:
6411 Arguments m_arguments;
6412};
6413#endif
6414
6415#if ENABLE(MEDIA_SESSION)
6416class MediaSessionMetadataDidChange {
6417public:
6418 typedef std::tuple<const WebCore::MediaSessionMetadata&> Arguments;
6419
6420 static IPC::StringReference receiverName() { return messageReceiverName(); }
6421 static IPC::StringReference name() { return IPC::StringReference("MediaSessionMetadataDidChange"); }
6422 static const bool isSync = false;
6423
6424 explicit MediaSessionMetadataDidChange(const WebCore::MediaSessionMetadata& metadata)
6425 : m_arguments(metadata)
6426 {
6427 }
6428
6429 const Arguments& arguments() const
6430 {
6431 return m_arguments;
6432 }
6433
6434private:
6435 Arguments m_arguments;
6436};
6437#endif
6438
6439#if ENABLE(MEDIA_SESSION)
6440class FocusedContentMediaElementDidChange {
6441public:
6442 typedef std::tuple<uint64_t> Arguments;
6443
6444 static IPC::StringReference receiverName() { return messageReceiverName(); }
6445 static IPC::StringReference name() { return IPC::StringReference("FocusedContentMediaElementDidChange"); }
6446 static const bool isSync = false;
6447
6448 explicit FocusedContentMediaElementDidChange(uint64_t elementID)
6449 : m_arguments(elementID)
6450 {
6451 }
6452
6453 const Arguments& arguments() const
6454 {
6455 return m_arguments;
6456 }
6457
6458private:
6459 Arguments m_arguments;
6460};
6461#endif
6462
6463#if PLATFORM(MAC)
6464class DidPerformImmediateActionHitTest {
6465public:
6466 typedef std::tuple<const WebKit::WebHitTestResultData&, bool, const WebKit::UserData&> Arguments;
6467
6468 static IPC::StringReference receiverName() { return messageReceiverName(); }
6469 static IPC::StringReference name() { return IPC::StringReference("DidPerformImmediateActionHitTest"); }
6470 static const bool isSync = false;
6471
6472 DidPerformImmediateActionHitTest(const WebKit::WebHitTestResultData& result, bool contentPreventsDefault, const WebKit::UserData& userData)
6473 : m_arguments(result, contentPreventsDefault, userData)
6474 {
6475 }
6476
6477 const Arguments& arguments() const
6478 {
6479 return m_arguments;
6480 }
6481
6482private:
6483 Arguments m_arguments;
6484};
6485#endif
6486
6487class HandleMessage {
6488public:
6489 typedef std::tuple<const String&, const WebKit::UserData&> Arguments;
6490
6491 static IPC::StringReference receiverName() { return messageReceiverName(); }
6492 static IPC::StringReference name() { return IPC::StringReference("HandleMessage"); }
6493 static const bool isSync = false;
6494
6495 HandleMessage(const String& messageName, const WebKit::UserData& messageBody)
6496 : m_arguments(messageName, messageBody)
6497 {
6498 }
6499
6500 const Arguments& arguments() const
6501 {
6502 return m_arguments;
6503 }
6504
6505private:
6506 Arguments m_arguments;
6507};
6508
6509class HandleSynchronousMessage {
6510public:
6511 typedef std::tuple<const String&, const WebKit::UserData&> Arguments;
6512
6513 static IPC::StringReference receiverName() { return messageReceiverName(); }
6514 static IPC::StringReference name() { return IPC::StringReference("HandleSynchronousMessage"); }
6515 static const bool isSync = true;
6516
6517 using DelayedReply = CompletionHandler<void(const WebKit::UserData& returnData)>;
6518 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const WebKit::UserData& returnData);
6519 using Reply = std::tuple<WebKit::UserData&>;
6520 using ReplyArguments = std::tuple<WebKit::UserData>;
6521 HandleSynchronousMessage(const String& messageName, const WebKit::UserData& messageBody)
6522 : m_arguments(messageName, messageBody)
6523 {
6524 }
6525
6526 const Arguments& arguments() const
6527 {
6528 return m_arguments;
6529 }
6530
6531private:
6532 Arguments m_arguments;
6533};
6534
6535class HandleAutoFillButtonClick {
6536public:
6537 typedef std::tuple<const WebKit::UserData&> Arguments;
6538
6539 static IPC::StringReference receiverName() { return messageReceiverName(); }
6540 static IPC::StringReference name() { return IPC::StringReference("HandleAutoFillButtonClick"); }
6541 static const bool isSync = false;
6542
6543 explicit HandleAutoFillButtonClick(const WebKit::UserData& userData)
6544 : m_arguments(userData)
6545 {
6546 }
6547
6548 const Arguments& arguments() const
6549 {
6550 return m_arguments;
6551 }
6552
6553private:
6554 Arguments m_arguments;
6555};
6556
6557class DidResignInputElementStrongPasswordAppearance {
6558public:
6559 typedef std::tuple<const WebKit::UserData&> Arguments;
6560
6561 static IPC::StringReference receiverName() { return messageReceiverName(); }
6562 static IPC::StringReference name() { return IPC::StringReference("DidResignInputElementStrongPasswordAppearance"); }
6563 static const bool isSync = false;
6564
6565 explicit DidResignInputElementStrongPasswordAppearance(const WebKit::UserData& userData)
6566 : m_arguments(userData)
6567 {
6568 }
6569
6570 const Arguments& arguments() const
6571 {
6572 return m_arguments;
6573 }
6574
6575private:
6576 Arguments m_arguments;
6577};
6578
6579class ContentRuleListNotification {
6580public:
6581 typedef std::tuple<const URL&, const WebCore::ContentRuleListResults&> Arguments;
6582
6583 static IPC::StringReference receiverName() { return messageReceiverName(); }
6584 static IPC::StringReference name() { return IPC::StringReference("ContentRuleListNotification"); }
6585 static const bool isSync = false;
6586
6587 ContentRuleListNotification(const URL& url, const WebCore::ContentRuleListResults& results)
6588 : m_arguments(url, results)
6589 {
6590 }
6591
6592 const Arguments& arguments() const
6593 {
6594 return m_arguments;
6595 }
6596
6597private:
6598 Arguments m_arguments;
6599};
6600
6601#if ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS_FAMILY)
6602class AddPlaybackTargetPickerClient {
6603public:
6604 typedef std::tuple<uint64_t> Arguments;
6605
6606 static IPC::StringReference receiverName() { return messageReceiverName(); }
6607 static IPC::StringReference name() { return IPC::StringReference("AddPlaybackTargetPickerClient"); }
6608 static const bool isSync = false;
6609
6610 explicit AddPlaybackTargetPickerClient(uint64_t contextId)
6611 : m_arguments(contextId)
6612 {
6613 }
6614
6615 const Arguments& arguments() const
6616 {
6617 return m_arguments;
6618 }
6619
6620private:
6621 Arguments m_arguments;
6622};
6623#endif
6624
6625#if ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS_FAMILY)
6626class RemovePlaybackTargetPickerClient {
6627public:
6628 typedef std::tuple<uint64_t> Arguments;
6629
6630 static IPC::StringReference receiverName() { return messageReceiverName(); }
6631 static IPC::StringReference name() { return IPC::StringReference("RemovePlaybackTargetPickerClient"); }
6632 static const bool isSync = false;
6633
6634 explicit RemovePlaybackTargetPickerClient(uint64_t contextId)
6635 : m_arguments(contextId)
6636 {
6637 }
6638
6639 const Arguments& arguments() const
6640 {
6641 return m_arguments;
6642 }
6643
6644private:
6645 Arguments m_arguments;
6646};
6647#endif
6648
6649#if ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS_FAMILY)
6650class ShowPlaybackTargetPicker {
6651public:
6652 typedef std::tuple<uint64_t, const WebCore::FloatRect&, bool> Arguments;
6653
6654 static IPC::StringReference receiverName() { return messageReceiverName(); }
6655 static IPC::StringReference name() { return IPC::StringReference("ShowPlaybackTargetPicker"); }
6656 static const bool isSync = false;
6657
6658 ShowPlaybackTargetPicker(uint64_t clientId, const WebCore::FloatRect& pickerLocation, bool hasVideo)
6659 : m_arguments(clientId, pickerLocation, hasVideo)
6660 {
6661 }
6662
6663 const Arguments& arguments() const
6664 {
6665 return m_arguments;
6666 }
6667
6668private:
6669 Arguments m_arguments;
6670};
6671#endif
6672
6673#if ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS_FAMILY)
6674class PlaybackTargetPickerClientStateDidChange {
6675public:
6676 typedef std::tuple<uint64_t, const unsigned&> Arguments;
6677
6678 static IPC::StringReference receiverName() { return messageReceiverName(); }
6679 static IPC::StringReference name() { return IPC::StringReference("PlaybackTargetPickerClientStateDidChange"); }
6680 static const bool isSync = false;
6681
6682 PlaybackTargetPickerClientStateDidChange(uint64_t contextId, const unsigned& mediaState)
6683 : m_arguments(contextId, mediaState)
6684 {
6685 }
6686
6687 const Arguments& arguments() const
6688 {
6689 return m_arguments;
6690 }
6691
6692private:
6693 Arguments m_arguments;
6694};
6695#endif
6696
6697#if ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS_FAMILY)
6698class SetMockMediaPlaybackTargetPickerEnabled {
6699public:
6700 typedef std::tuple<bool> Arguments;
6701
6702 static IPC::StringReference receiverName() { return messageReceiverName(); }
6703 static IPC::StringReference name() { return IPC::StringReference("SetMockMediaPlaybackTargetPickerEnabled"); }
6704 static const bool isSync = false;
6705
6706 explicit SetMockMediaPlaybackTargetPickerEnabled(bool enabled)
6707 : m_arguments(enabled)
6708 {
6709 }
6710
6711 const Arguments& arguments() const
6712 {
6713 return m_arguments;
6714 }
6715
6716private:
6717 Arguments m_arguments;
6718};
6719#endif
6720
6721#if ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS_FAMILY)
6722class SetMockMediaPlaybackTargetPickerState {
6723public:
6724 typedef std::tuple<const String&, const unsigned&> Arguments;
6725
6726 static IPC::StringReference receiverName() { return messageReceiverName(); }
6727 static IPC::StringReference name() { return IPC::StringReference("SetMockMediaPlaybackTargetPickerState"); }
6728 static const bool isSync = false;
6729
6730 SetMockMediaPlaybackTargetPickerState(const String& name, const unsigned& pickerState)
6731 : m_arguments(name, pickerState)
6732 {
6733 }
6734
6735 const Arguments& arguments() const
6736 {
6737 return m_arguments;
6738 }
6739
6740private:
6741 Arguments m_arguments;
6742};
6743#endif
6744
6745#if ENABLE(POINTER_LOCK)
6746class RequestPointerLock {
6747public:
6748 typedef std::tuple<> Arguments;
6749
6750 static IPC::StringReference receiverName() { return messageReceiverName(); }
6751 static IPC::StringReference name() { return IPC::StringReference("RequestPointerLock"); }
6752 static const bool isSync = false;
6753
6754 const Arguments& arguments() const
6755 {
6756 return m_arguments;
6757 }
6758
6759private:
6760 Arguments m_arguments;
6761};
6762#endif
6763
6764#if ENABLE(POINTER_LOCK)
6765class RequestPointerUnlock {
6766public:
6767 typedef std::tuple<> Arguments;
6768
6769 static IPC::StringReference receiverName() { return messageReceiverName(); }
6770 static IPC::StringReference name() { return IPC::StringReference("RequestPointerUnlock"); }
6771 static const bool isSync = false;
6772
6773 const Arguments& arguments() const
6774 {
6775 return m_arguments;
6776 }
6777
6778private:
6779 Arguments m_arguments;
6780};
6781#endif
6782
6783class DidFailToSuspendAfterProcessSwap {
6784public:
6785 typedef std::tuple<> Arguments;
6786
6787 static IPC::StringReference receiverName() { return messageReceiverName(); }
6788 static IPC::StringReference name() { return IPC::StringReference("DidFailToSuspendAfterProcessSwap"); }
6789 static const bool isSync = false;
6790
6791 const Arguments& arguments() const
6792 {
6793 return m_arguments;
6794 }
6795
6796private:
6797 Arguments m_arguments;
6798};
6799
6800class DidSuspendAfterProcessSwap {
6801public:
6802 typedef std::tuple<> Arguments;
6803
6804 static IPC::StringReference receiverName() { return messageReceiverName(); }
6805 static IPC::StringReference name() { return IPC::StringReference("DidSuspendAfterProcessSwap"); }
6806 static const bool isSync = false;
6807
6808 const Arguments& arguments() const
6809 {
6810 return m_arguments;
6811 }
6812
6813private:
6814 Arguments m_arguments;
6815};
6816
6817class ImageOrMediaDocumentSizeChanged {
6818public:
6819 typedef std::tuple<const WebCore::IntSize&> Arguments;
6820
6821 static IPC::StringReference receiverName() { return messageReceiverName(); }
6822 static IPC::StringReference name() { return IPC::StringReference("ImageOrMediaDocumentSizeChanged"); }
6823 static const bool isSync = false;
6824
6825 explicit ImageOrMediaDocumentSizeChanged(const WebCore::IntSize& newSize)
6826 : m_arguments(newSize)
6827 {
6828 }
6829
6830 const Arguments& arguments() const
6831 {
6832 return m_arguments;
6833 }
6834
6835private:
6836 Arguments m_arguments;
6837};
6838
6839class UseFixedLayoutDidChange {
6840public:
6841 typedef std::tuple<bool> Arguments;
6842
6843 static IPC::StringReference receiverName() { return messageReceiverName(); }
6844 static IPC::StringReference name() { return IPC::StringReference("UseFixedLayoutDidChange"); }
6845 static const bool isSync = false;
6846
6847 explicit UseFixedLayoutDidChange(bool useFixedLayout)
6848 : m_arguments(useFixedLayout)
6849 {
6850 }
6851
6852 const Arguments& arguments() const
6853 {
6854 return m_arguments;
6855 }
6856
6857private:
6858 Arguments m_arguments;
6859};
6860
6861class FixedLayoutSizeDidChange {
6862public:
6863 typedef std::tuple<const WebCore::IntSize&> Arguments;
6864
6865 static IPC::StringReference receiverName() { return messageReceiverName(); }
6866 static IPC::StringReference name() { return IPC::StringReference("FixedLayoutSizeDidChange"); }
6867 static const bool isSync = false;
6868
6869 explicit FixedLayoutSizeDidChange(const WebCore::IntSize& fixedLayoutSize)
6870 : m_arguments(fixedLayoutSize)
6871 {
6872 }
6873
6874 const Arguments& arguments() const
6875 {
6876 return m_arguments;
6877 }
6878
6879private:
6880 Arguments m_arguments;
6881};
6882
6883#if ENABLE(VIDEO) && USE(GSTREAMER)
6884class RequestInstallMissingMediaPlugins {
6885public:
6886 typedef std::tuple<const String&, const String&> Arguments;
6887
6888 static IPC::StringReference receiverName() { return messageReceiverName(); }
6889 static IPC::StringReference name() { return IPC::StringReference("RequestInstallMissingMediaPlugins"); }
6890 static const bool isSync = false;
6891
6892 RequestInstallMissingMediaPlugins(const String& details, const String& description)
6893 : m_arguments(details, description)
6894 {
6895 }
6896
6897 const Arguments& arguments() const
6898 {
6899 return m_arguments;
6900 }
6901
6902private:
6903 Arguments m_arguments;
6904};
6905#endif
6906
6907class DidRestoreScrollPosition {
6908public:
6909 typedef std::tuple<> Arguments;
6910
6911 static IPC::StringReference receiverName() { return messageReceiverName(); }
6912 static IPC::StringReference name() { return IPC::StringReference("DidRestoreScrollPosition"); }
6913 static const bool isSync = false;
6914
6915 const Arguments& arguments() const
6916 {
6917 return m_arguments;
6918 }
6919
6920private:
6921 Arguments m_arguments;
6922};
6923
6924class GetLoadDecisionForIcon {
6925public:
6926 typedef std::tuple<const WebCore::LinkIcon&, const WebKit::CallbackID&> Arguments;
6927
6928 static IPC::StringReference receiverName() { return messageReceiverName(); }
6929 static IPC::StringReference name() { return IPC::StringReference("GetLoadDecisionForIcon"); }
6930 static const bool isSync = false;
6931
6932 GetLoadDecisionForIcon(const WebCore::LinkIcon& icon, const WebKit::CallbackID& callbackID)
6933 : m_arguments(icon, callbackID)
6934 {
6935 }
6936
6937 const Arguments& arguments() const
6938 {
6939 return m_arguments;
6940 }
6941
6942private:
6943 Arguments m_arguments;
6944};
6945
6946class FinishedLoadingIcon {
6947public:
6948 typedef std::tuple<const WebKit::CallbackID&, const IPC::DataReference&> Arguments;
6949
6950 static IPC::StringReference receiverName() { return messageReceiverName(); }
6951 static IPC::StringReference name() { return IPC::StringReference("FinishedLoadingIcon"); }
6952 static const bool isSync = false;
6953
6954 FinishedLoadingIcon(const WebKit::CallbackID& callbackID, const IPC::DataReference& data)
6955 : m_arguments(callbackID, data)
6956 {
6957 }
6958
6959 const Arguments& arguments() const
6960 {
6961 return m_arguments;
6962 }
6963
6964private:
6965 Arguments m_arguments;
6966};
6967
6968#if PLATFORM(MAC)
6969class DidHandleAcceptedCandidate {
6970public:
6971 typedef std::tuple<> Arguments;
6972
6973 static IPC::StringReference receiverName() { return messageReceiverName(); }
6974 static IPC::StringReference name() { return IPC::StringReference("DidHandleAcceptedCandidate"); }
6975 static const bool isSync = false;
6976
6977 const Arguments& arguments() const
6978 {
6979 return m_arguments;
6980 }
6981
6982private:
6983 Arguments m_arguments;
6984};
6985#endif
6986
6987class SetIsUsingHighPerformanceWebGL {
6988public:
6989 typedef std::tuple<bool> Arguments;
6990
6991 static IPC::StringReference receiverName() { return messageReceiverName(); }
6992 static IPC::StringReference name() { return IPC::StringReference("SetIsUsingHighPerformanceWebGL"); }
6993 static const bool isSync = false;
6994
6995 explicit SetIsUsingHighPerformanceWebGL(bool isUsingHighPerformanceWebGL)
6996 : m_arguments(isUsingHighPerformanceWebGL)
6997 {
6998 }
6999
7000 const Arguments& arguments() const
7001 {
7002 return m_arguments;
7003 }
7004
7005private:
7006 Arguments m_arguments;
7007};
7008
7009class StartURLSchemeTask {
7010public:
7011 typedef std::tuple<const WebKit::URLSchemeTaskParameters&> Arguments;
7012
7013 static IPC::StringReference receiverName() { return messageReceiverName(); }
7014 static IPC::StringReference name() { return IPC::StringReference("StartURLSchemeTask"); }
7015 static const bool isSync = false;
7016
7017 explicit StartURLSchemeTask(const WebKit::URLSchemeTaskParameters& parameters)
7018 : m_arguments(parameters)
7019 {
7020 }
7021
7022 const Arguments& arguments() const
7023 {
7024 return m_arguments;
7025 }
7026
7027private:
7028 Arguments m_arguments;
7029};
7030
7031class StopURLSchemeTask {
7032public:
7033 typedef std::tuple<uint64_t, uint64_t> Arguments;
7034
7035 static IPC::StringReference receiverName() { return messageReceiverName(); }
7036 static IPC::StringReference name() { return IPC::StringReference("StopURLSchemeTask"); }
7037 static const bool isSync = false;
7038
7039 StopURLSchemeTask(uint64_t handlerIdentifier, uint64_t taskIdentifier)
7040 : m_arguments(handlerIdentifier, taskIdentifier)
7041 {
7042 }
7043
7044 const Arguments& arguments() const
7045 {
7046 return m_arguments;
7047 }
7048
7049private:
7050 Arguments m_arguments;
7051};
7052
7053class LoadSynchronousURLSchemeTask {
7054public:
7055 typedef std::tuple<const WebKit::URLSchemeTaskParameters&> Arguments;
7056
7057 static IPC::StringReference receiverName() { return messageReceiverName(); }
7058 static IPC::StringReference name() { return IPC::StringReference("LoadSynchronousURLSchemeTask"); }
7059 static const bool isSync = true;
7060
7061 using DelayedReply = CompletionHandler<void(const WebCore::ResourceResponse& response, const WebCore::ResourceError& error, const IPC::DataReference& data)>;
7062 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const WebCore::ResourceResponse& response, const WebCore::ResourceError& error, const IPC::DataReference& data);
7063 using Reply = std::tuple<WebCore::ResourceResponse&, WebCore::ResourceError&, IPC::DataReference&>;
7064 using ReplyArguments = std::tuple<WebCore::ResourceResponse, WebCore::ResourceError, IPC::DataReference>;
7065 explicit LoadSynchronousURLSchemeTask(const WebKit::URLSchemeTaskParameters& parameters)
7066 : m_arguments(parameters)
7067 {
7068 }
7069
7070 const Arguments& arguments() const
7071 {
7072 return m_arguments;
7073 }
7074
7075private:
7076 Arguments m_arguments;
7077};
7078
7079#if ENABLE(DEVICE_ORIENTATION)
7080class ShouldAllowDeviceOrientationAndMotionAccess {
7081public:
7082 typedef std::tuple<uint64_t, const WebCore::SecurityOriginData&, bool> Arguments;
7083
7084 static IPC::StringReference receiverName() { return messageReceiverName(); }
7085 static IPC::StringReference name() { return IPC::StringReference("ShouldAllowDeviceOrientationAndMotionAccess"); }
7086 static const bool isSync = false;
7087
7088 static void callReply(IPC::Decoder&, CompletionHandler<void(WebCore::DeviceOrientationOrMotionPermissionState&&)>&&);
7089 static void cancelReply(CompletionHandler<void(WebCore::DeviceOrientationOrMotionPermissionState&&)>&&);
7090 static IPC::StringReference asyncMessageReplyName() { return { "ShouldAllowDeviceOrientationAndMotionAccessReply" }; }
7091 using AsyncReply = CompletionHandler<void(WebCore::DeviceOrientationOrMotionPermissionState permissionState)>;
7092 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, WebCore::DeviceOrientationOrMotionPermissionState permissionState);
7093 using Reply = std::tuple<WebCore::DeviceOrientationOrMotionPermissionState&>;
7094 using ReplyArguments = std::tuple<WebCore::DeviceOrientationOrMotionPermissionState>;
7095 ShouldAllowDeviceOrientationAndMotionAccess(uint64_t frameID, const WebCore::SecurityOriginData& origin, bool mayPrompt)
7096 : m_arguments(frameID, origin, mayPrompt)
7097 {
7098 }
7099
7100 const Arguments& arguments() const
7101 {
7102 return m_arguments;
7103 }
7104
7105private:
7106 Arguments m_arguments;
7107};
7108#endif
7109
7110#if ENABLE(ATTACHMENT_ELEMENT)
7111class RegisterAttachmentIdentifierFromData {
7112public:
7113 typedef std::tuple<const String&, const String&, const String&, const IPC::SharedBufferDataReference&> Arguments;
7114
7115 static IPC::StringReference receiverName() { return messageReceiverName(); }
7116 static IPC::StringReference name() { return IPC::StringReference("RegisterAttachmentIdentifierFromData"); }
7117 static const bool isSync = false;
7118
7119 RegisterAttachmentIdentifierFromData(const String& identifier, const String& contentType, const String& preferredFileName, const IPC::SharedBufferDataReference& data)
7120 : m_arguments(identifier, contentType, preferredFileName, data)
7121 {
7122 }
7123
7124 const Arguments& arguments() const
7125 {
7126 return m_arguments;
7127 }
7128
7129private:
7130 Arguments m_arguments;
7131};
7132#endif
7133
7134#if ENABLE(ATTACHMENT_ELEMENT)
7135class RegisterAttachmentIdentifierFromFilePath {
7136public:
7137 typedef std::tuple<const String&, const String&, const String&> Arguments;
7138
7139 static IPC::StringReference receiverName() { return messageReceiverName(); }
7140 static IPC::StringReference name() { return IPC::StringReference("RegisterAttachmentIdentifierFromFilePath"); }
7141 static const bool isSync = false;
7142
7143 RegisterAttachmentIdentifierFromFilePath(const String& identifier, const String& contentType, const String& filePath)
7144 : m_arguments(identifier, contentType, filePath)
7145 {
7146 }
7147
7148 const Arguments& arguments() const
7149 {
7150 return m_arguments;
7151 }
7152
7153private:
7154 Arguments m_arguments;
7155};
7156#endif
7157
7158#if ENABLE(ATTACHMENT_ELEMENT)
7159class RegisterAttachmentIdentifier {
7160public:
7161 typedef std::tuple<const String&> Arguments;
7162
7163 static IPC::StringReference receiverName() { return messageReceiverName(); }
7164 static IPC::StringReference name() { return IPC::StringReference("RegisterAttachmentIdentifier"); }
7165 static const bool isSync = false;
7166
7167 explicit RegisterAttachmentIdentifier(const String& identifier)
7168 : m_arguments(identifier)
7169 {
7170 }
7171
7172 const Arguments& arguments() const
7173 {
7174 return m_arguments;
7175 }
7176
7177private:
7178 Arguments m_arguments;
7179};
7180#endif
7181
7182#if ENABLE(ATTACHMENT_ELEMENT)
7183class registerAttachmentsFromSerializedData {
7184public:
7185 typedef std::tuple<const Vector<WebCore::SerializedAttachmentData>&> Arguments;
7186
7187 static IPC::StringReference receiverName() { return messageReceiverName(); }
7188 static IPC::StringReference name() { return IPC::StringReference("registerAttachmentsFromSerializedData"); }
7189 static const bool isSync = false;
7190
7191 explicit registerAttachmentsFromSerializedData(const Vector<WebCore::SerializedAttachmentData>& data)
7192 : m_arguments(data)
7193 {
7194 }
7195
7196 const Arguments& arguments() const
7197 {
7198 return m_arguments;
7199 }
7200
7201private:
7202 Arguments m_arguments;
7203};
7204#endif
7205
7206#if ENABLE(ATTACHMENT_ELEMENT)
7207class CloneAttachmentData {
7208public:
7209 typedef std::tuple<const String&, const String&> Arguments;
7210
7211 static IPC::StringReference receiverName() { return messageReceiverName(); }
7212 static IPC::StringReference name() { return IPC::StringReference("CloneAttachmentData"); }
7213 static const bool isSync = false;
7214
7215 CloneAttachmentData(const String& fromIdentifier, const String& toIdentifier)
7216 : m_arguments(fromIdentifier, toIdentifier)
7217 {
7218 }
7219
7220 const Arguments& arguments() const
7221 {
7222 return m_arguments;
7223 }
7224
7225private:
7226 Arguments m_arguments;
7227};
7228#endif
7229
7230#if ENABLE(ATTACHMENT_ELEMENT)
7231class DidInsertAttachmentWithIdentifier {
7232public:
7233 typedef std::tuple<const String&, const String&, bool> Arguments;
7234
7235 static IPC::StringReference receiverName() { return messageReceiverName(); }
7236 static IPC::StringReference name() { return IPC::StringReference("DidInsertAttachmentWithIdentifier"); }
7237 static const bool isSync = false;
7238
7239 DidInsertAttachmentWithIdentifier(const String& identifier, const String& source, bool hasEnclosingImage)
7240 : m_arguments(identifier, source, hasEnclosingImage)
7241 {
7242 }
7243
7244 const Arguments& arguments() const
7245 {
7246 return m_arguments;
7247 }
7248
7249private:
7250 Arguments m_arguments;
7251};
7252#endif
7253
7254#if ENABLE(ATTACHMENT_ELEMENT)
7255class DidRemoveAttachmentWithIdentifier {
7256public:
7257 typedef std::tuple<const String&> Arguments;
7258
7259 static IPC::StringReference receiverName() { return messageReceiverName(); }
7260 static IPC::StringReference name() { return IPC::StringReference("DidRemoveAttachmentWithIdentifier"); }
7261 static const bool isSync = false;
7262
7263 explicit DidRemoveAttachmentWithIdentifier(const String& identifier)
7264 : m_arguments(identifier)
7265 {
7266 }
7267
7268 const Arguments& arguments() const
7269 {
7270 return m_arguments;
7271 }
7272
7273private:
7274 Arguments m_arguments;
7275};
7276#endif
7277
7278#if ENABLE(ATTACHMENT_ELEMENT)
7279class SerializedAttachmentDataForIdentifiers {
7280public:
7281 typedef std::tuple<const Vector<String>&> Arguments;
7282
7283 static IPC::StringReference receiverName() { return messageReceiverName(); }
7284 static IPC::StringReference name() { return IPC::StringReference("SerializedAttachmentDataForIdentifiers"); }
7285 static const bool isSync = true;
7286
7287 using DelayedReply = CompletionHandler<void(const Vector<WebCore::SerializedAttachmentData>& seralizedData)>;
7288 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const Vector<WebCore::SerializedAttachmentData>& seralizedData);
7289 using Reply = std::tuple<Vector<WebCore::SerializedAttachmentData>&>;
7290 using ReplyArguments = std::tuple<Vector<WebCore::SerializedAttachmentData>>;
7291 explicit SerializedAttachmentDataForIdentifiers(const Vector<String>& identifiers)
7292 : m_arguments(identifiers)
7293 {
7294 }
7295
7296 const Arguments& arguments() const
7297 {
7298 return m_arguments;
7299 }
7300
7301private:
7302 Arguments m_arguments;
7303};
7304#endif
7305
7306class SignedPublicKeyAndChallengeString {
7307public:
7308 typedef std::tuple<const unsigned&, const String&, const URL&> Arguments;
7309
7310 static IPC::StringReference receiverName() { return messageReceiverName(); }
7311 static IPC::StringReference name() { return IPC::StringReference("SignedPublicKeyAndChallengeString"); }
7312 static const bool isSync = true;
7313
7314 using DelayedReply = CompletionHandler<void(const String& result)>;
7315 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const String& result);
7316 using Reply = std::tuple<String&>;
7317 using ReplyArguments = std::tuple<String>;
7318 SignedPublicKeyAndChallengeString(const unsigned& keySizeIndex, const String& challengeString, const URL& url)
7319 : m_arguments(keySizeIndex, challengeString, url)
7320 {
7321 }
7322
7323 const Arguments& arguments() const
7324 {
7325 return m_arguments;
7326 }
7327
7328private:
7329 Arguments m_arguments;
7330};
7331
7332#if ENABLE(SPEECH_SYNTHESIS)
7333class SpeechSynthesisVoiceList {
7334public:
7335 typedef std::tuple<> Arguments;
7336
7337 static IPC::StringReference receiverName() { return messageReceiverName(); }
7338 static IPC::StringReference name() { return IPC::StringReference("SpeechSynthesisVoiceList"); }
7339 static const bool isSync = true;
7340
7341 using DelayedReply = CompletionHandler<void(const Vector<WebKit::WebSpeechSynthesisVoice>& voiceList)>;
7342 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const Vector<WebKit::WebSpeechSynthesisVoice>& voiceList);
7343 using Reply = std::tuple<Vector<WebKit::WebSpeechSynthesisVoice>&>;
7344 using ReplyArguments = std::tuple<Vector<WebKit::WebSpeechSynthesisVoice>>;
7345 const Arguments& arguments() const
7346 {
7347 return m_arguments;
7348 }
7349
7350private:
7351 Arguments m_arguments;
7352};
7353#endif
7354
7355#if ENABLE(SPEECH_SYNTHESIS)
7356class SpeechSynthesisSpeak {
7357public:
7358 typedef std::tuple<const String&, const String&, float, float, float, const MonotonicTime&, const String&, const String&, const String&, bool, bool> Arguments;
7359
7360 static IPC::StringReference receiverName() { return messageReceiverName(); }
7361 static IPC::StringReference name() { return IPC::StringReference("SpeechSynthesisSpeak"); }
7362 static const bool isSync = false;
7363
7364 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
7365 static void cancelReply(CompletionHandler<void()>&&);
7366 static IPC::StringReference asyncMessageReplyName() { return { "SpeechSynthesisSpeakReply" }; }
7367 using AsyncReply = CompletionHandler<void()>;
7368 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
7369 using Reply = std::tuple<>;
7370 using ReplyArguments = std::tuple<>;
7371 SpeechSynthesisSpeak(const String& text, const String& lang, float volume, float rate, float pitch, const MonotonicTime& startTime, const String& voiceURI, const String& voiceName, const String& voiceLang, bool localService, bool defaultVoice)
7372 : m_arguments(text, lang, volume, rate, pitch, startTime, voiceURI, voiceName, voiceLang, localService, defaultVoice)
7373 {
7374 }
7375
7376 const Arguments& arguments() const
7377 {
7378 return m_arguments;
7379 }
7380
7381private:
7382 Arguments m_arguments;
7383};
7384#endif
7385
7386#if ENABLE(SPEECH_SYNTHESIS)
7387class SpeechSynthesisCancel {
7388public:
7389 typedef std::tuple<> Arguments;
7390
7391 static IPC::StringReference receiverName() { return messageReceiverName(); }
7392 static IPC::StringReference name() { return IPC::StringReference("SpeechSynthesisCancel"); }
7393 static const bool isSync = false;
7394
7395 const Arguments& arguments() const
7396 {
7397 return m_arguments;
7398 }
7399
7400private:
7401 Arguments m_arguments;
7402};
7403#endif
7404
7405#if ENABLE(SPEECH_SYNTHESIS)
7406class SpeechSynthesisPause {
7407public:
7408 typedef std::tuple<> Arguments;
7409
7410 static IPC::StringReference receiverName() { return messageReceiverName(); }
7411 static IPC::StringReference name() { return IPC::StringReference("SpeechSynthesisPause"); }
7412 static const bool isSync = false;
7413
7414 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
7415 static void cancelReply(CompletionHandler<void()>&&);
7416 static IPC::StringReference asyncMessageReplyName() { return { "SpeechSynthesisPauseReply" }; }
7417 using AsyncReply = CompletionHandler<void()>;
7418 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
7419 using Reply = std::tuple<>;
7420 using ReplyArguments = std::tuple<>;
7421 const Arguments& arguments() const
7422 {
7423 return m_arguments;
7424 }
7425
7426private:
7427 Arguments m_arguments;
7428};
7429#endif
7430
7431#if ENABLE(SPEECH_SYNTHESIS)
7432class SpeechSynthesisResume {
7433public:
7434 typedef std::tuple<> Arguments;
7435
7436 static IPC::StringReference receiverName() { return messageReceiverName(); }
7437 static IPC::StringReference name() { return IPC::StringReference("SpeechSynthesisResume"); }
7438 static const bool isSync = false;
7439
7440 static void callReply(IPC::Decoder&, CompletionHandler<void()>&&);
7441 static void cancelReply(CompletionHandler<void()>&&);
7442 static IPC::StringReference asyncMessageReplyName() { return { "SpeechSynthesisResumeReply" }; }
7443 using AsyncReply = CompletionHandler<void()>;
7444 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&);
7445 using Reply = std::tuple<>;
7446 using ReplyArguments = std::tuple<>;
7447 const Arguments& arguments() const
7448 {
7449 return m_arguments;
7450 }
7451
7452private:
7453 Arguments m_arguments;
7454};
7455#endif
7456
7457class ConfigureLoggingChannel {
7458public:
7459 typedef std::tuple<const String&, WTFLogChannelState, WTFLogLevel> Arguments;
7460
7461 static IPC::StringReference receiverName() { return messageReceiverName(); }
7462 static IPC::StringReference name() { return IPC::StringReference("ConfigureLoggingChannel"); }
7463 static const bool isSync = false;
7464
7465 ConfigureLoggingChannel(const String& channelName, WTFLogChannelState state, WTFLogLevel level)
7466 : m_arguments(channelName, state, level)
7467 {
7468 }
7469
7470 const Arguments& arguments() const
7471 {
7472 return m_arguments;
7473 }
7474
7475private:
7476 Arguments m_arguments;
7477};
7478
7479#if PLATFORM(GTK)
7480class ShowEmojiPicker {
7481public:
7482 typedef std::tuple<const WebCore::IntRect&> Arguments;
7483
7484 static IPC::StringReference receiverName() { return messageReceiverName(); }
7485 static IPC::StringReference name() { return IPC::StringReference("ShowEmojiPicker"); }
7486 static const bool isSync = false;
7487
7488 static void callReply(IPC::Decoder&, CompletionHandler<void(String&&)>&&);
7489 static void cancelReply(CompletionHandler<void(String&&)>&&);
7490 static IPC::StringReference asyncMessageReplyName() { return { "ShowEmojiPickerReply" }; }
7491 using AsyncReply = CompletionHandler<void(const String& result)>;
7492 static void send(std::unique_ptr<IPC::Encoder>&&, IPC::Connection&, const String& result);
7493 using Reply = std::tuple<String&>;
7494 using ReplyArguments = std::tuple<String>;
7495 explicit ShowEmojiPicker(const WebCore::IntRect& caretRect)
7496 : m_arguments(caretRect)
7497 {
7498 }
7499
7500 const Arguments& arguments() const
7501 {
7502 return m_arguments;
7503 }
7504
7505private:
7506 Arguments m_arguments;
7507};
7508#endif
7509
7510#if HAVE(VISIBILITY_PROPAGATION_VIEW)
7511class DidCreateContextForVisibilityPropagation {
7512public:
7513 typedef std::tuple<const WebKit::LayerHostingContextID&> Arguments;
7514
7515 static IPC::StringReference receiverName() { return messageReceiverName(); }
7516 static IPC::StringReference name() { return IPC::StringReference("DidCreateContextForVisibilityPropagation"); }
7517 static const bool isSync = false;
7518
7519 explicit DidCreateContextForVisibilityPropagation(const WebKit::LayerHostingContextID& contextID)
7520 : m_arguments(contextID)
7521 {
7522 }
7523
7524 const Arguments& arguments() const
7525 {
7526 return m_arguments;
7527 }
7528
7529private:
7530 Arguments m_arguments;
7531};
7532#endif
7533
7534} // namespace WebPageProxy
7535} // namespace Messages
7536