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