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