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