Use Forward.h instead of forward-declaring WTF::String
[WebKit-https.git] / Source / WebKit / Scripts / webkit / LegacyMessages-expected.h
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 #if (ENABLE(WEBKIT2) && (NESTED_MASTER_CONDITION || MASTER_OR && MASTER_AND))
28
29 #include "ArgumentCoders.h"
30 #include "Connection.h"
31 #include "Plugin.h"
32 #include <WebCore/GraphicsLayer.h>
33 #include <WebCore/KeyboardEvent.h>
34 #include <WebCore/PluginData.h>
35 #include <utility>
36 #include <wtf/Forward.h>
37 #include <wtf/HashMap.h>
38 #include <wtf/ThreadSafeRefCounted.h>
39 #include <wtf/Vector.h>
40 #include <wtf/text/WTFString.h>
41
42 namespace IPC {
43     class MachPort;
44     class Connection;
45     class DummyType;
46 }
47
48 namespace WebKit {
49     class WebTouchEvent;
50     class WebPreferencesStore;
51 }
52
53 namespace Messages {
54 namespace WebPage {
55
56 static inline IPC::StringReference messageReceiverName()
57 {
58     return IPC::StringReference("WebPage");
59 }
60
61 class LoadURL {
62 public:
63     typedef std::tuple<const String&> Arguments;
64
65     static IPC::StringReference receiverName() { return messageReceiverName(); }
66     static IPC::StringReference name() { return IPC::StringReference("LoadURL"); }
67     static const bool isSync = false;
68
69     explicit LoadURL(const String& url)
70         : m_arguments(url)
71     {
72     }
73
74     const Arguments& arguments() const
75     {
76         return m_arguments;
77     }
78
79 private:
80     Arguments m_arguments;
81 };
82
83 #if ENABLE(TOUCH_EVENTS)
84 class LoadSomething {
85 public:
86     typedef std::tuple<const String&> Arguments;
87
88     static IPC::StringReference receiverName() { return messageReceiverName(); }
89     static IPC::StringReference name() { return IPC::StringReference("LoadSomething"); }
90     static const bool isSync = false;
91
92     explicit LoadSomething(const String& url)
93         : m_arguments(url)
94     {
95     }
96
97     const Arguments& arguments() const
98     {
99         return m_arguments;
100     }
101
102 private:
103     Arguments m_arguments;
104 };
105 #endif
106
107 #if (ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION || SOME_OTHER_MESSAGE_CONDITION))
108 class TouchEvent {
109 public:
110     typedef std::tuple<const WebKit::WebTouchEvent&> Arguments;
111
112     static IPC::StringReference receiverName() { return messageReceiverName(); }
113     static IPC::StringReference name() { return IPC::StringReference("TouchEvent"); }
114     static const bool isSync = false;
115
116     explicit TouchEvent(const WebKit::WebTouchEvent& event)
117         : m_arguments(event)
118     {
119     }
120
121     const Arguments& arguments() const
122     {
123         return m_arguments;
124     }
125
126 private:
127     Arguments m_arguments;
128 };
129 #endif
130
131 #if (ENABLE(TOUCH_EVENTS) && (NESTED_MESSAGE_CONDITION && SOME_OTHER_MESSAGE_CONDITION))
132 class AddEvent {
133 public:
134     typedef std::tuple<const WebKit::WebTouchEvent&> Arguments;
135
136     static IPC::StringReference receiverName() { return messageReceiverName(); }
137     static IPC::StringReference name() { return IPC::StringReference("AddEvent"); }
138     static const bool isSync = false;
139
140     explicit AddEvent(const WebKit::WebTouchEvent& event)
141         : m_arguments(event)
142     {
143     }
144
145     const Arguments& arguments() const
146     {
147         return m_arguments;
148     }
149
150 private:
151     Arguments m_arguments;
152 };
153 #endif
154
155 #if ENABLE(TOUCH_EVENTS)
156 class LoadSomethingElse {
157 public:
158     typedef std::tuple<const String&> Arguments;
159
160     static IPC::StringReference receiverName() { return messageReceiverName(); }
161     static IPC::StringReference name() { return IPC::StringReference("LoadSomethingElse"); }
162     static const bool isSync = false;
163
164     explicit LoadSomethingElse(const String& url)
165         : m_arguments(url)
166     {
167     }
168
169     const Arguments& arguments() const
170     {
171         return m_arguments;
172     }
173
174 private:
175     Arguments m_arguments;
176 };
177 #endif
178
179 class DidReceivePolicyDecision {
180 public:
181     typedef std::tuple<uint64_t, uint64_t, uint32_t> Arguments;
182
183     static IPC::StringReference receiverName() { return messageReceiverName(); }
184     static IPC::StringReference name() { return IPC::StringReference("DidReceivePolicyDecision"); }
185     static const bool isSync = false;
186
187     DidReceivePolicyDecision(uint64_t frameID, uint64_t listenerID, uint32_t policyAction)
188         : m_arguments(frameID, listenerID, policyAction)
189     {
190     }
191
192     const Arguments& arguments() const
193     {
194         return m_arguments;
195     }
196
197 private:
198     Arguments m_arguments;
199 };
200
201 class Close {
202 public:
203     typedef std::tuple<> Arguments;
204
205     static IPC::StringReference receiverName() { return messageReceiverName(); }
206     static IPC::StringReference name() { return IPC::StringReference("Close"); }
207     static const bool isSync = false;
208
209     const Arguments& arguments() const
210     {
211         return m_arguments;
212     }
213
214 private:
215     Arguments m_arguments;
216 };
217
218 class PreferencesDidChange {
219 public:
220     typedef std::tuple<const WebKit::WebPreferencesStore&> Arguments;
221
222     static IPC::StringReference receiverName() { return messageReceiverName(); }
223     static IPC::StringReference name() { return IPC::StringReference("PreferencesDidChange"); }
224     static const bool isSync = false;
225
226     explicit PreferencesDidChange(const WebKit::WebPreferencesStore& store)
227         : m_arguments(store)
228     {
229     }
230
231     const Arguments& arguments() const
232     {
233         return m_arguments;
234     }
235
236 private:
237     Arguments m_arguments;
238 };
239
240 class SendDoubleAndFloat {
241 public:
242     typedef std::tuple<double, float> Arguments;
243
244     static IPC::StringReference receiverName() { return messageReceiverName(); }
245     static IPC::StringReference name() { return IPC::StringReference("SendDoubleAndFloat"); }
246     static const bool isSync = false;
247
248     SendDoubleAndFloat(double d, float f)
249         : m_arguments(d, f)
250     {
251     }
252
253     const Arguments& arguments() const
254     {
255         return m_arguments;
256     }
257
258 private:
259     Arguments m_arguments;
260 };
261
262 class SendInts {
263 public:
264     typedef std::tuple<const Vector<uint64_t>&, const Vector<Vector<uint64_t>>&> Arguments;
265
266     static IPC::StringReference receiverName() { return messageReceiverName(); }
267     static IPC::StringReference name() { return IPC::StringReference("SendInts"); }
268     static const bool isSync = false;
269
270     SendInts(const Vector<uint64_t>& ints, const Vector<Vector<uint64_t>>& intVectors)
271         : m_arguments(ints, intVectors)
272     {
273     }
274
275     const Arguments& arguments() const
276     {
277         return m_arguments;
278     }
279
280 private:
281     Arguments m_arguments;
282 };
283
284 class CreatePlugin {
285 public:
286     typedef std::tuple<uint64_t, const WebKit::Plugin::Parameters&> Arguments;
287
288     static IPC::StringReference receiverName() { return messageReceiverName(); }
289     static IPC::StringReference name() { return IPC::StringReference("CreatePlugin"); }
290     static const bool isSync = true;
291
292     typedef std::tuple<bool&> Reply;
293     CreatePlugin(uint64_t pluginInstanceID, const WebKit::Plugin::Parameters& parameters)
294         : m_arguments(pluginInstanceID, parameters)
295     {
296     }
297
298     const Arguments& arguments() const
299     {
300         return m_arguments;
301     }
302
303 private:
304     Arguments m_arguments;
305 };
306
307 class RunJavaScriptAlert {
308 public:
309     typedef std::tuple<uint64_t, const String&> Arguments;
310
311     static IPC::StringReference receiverName() { return messageReceiverName(); }
312     static IPC::StringReference name() { return IPC::StringReference("RunJavaScriptAlert"); }
313     static const bool isSync = true;
314
315     typedef std::tuple<> Reply;
316     RunJavaScriptAlert(uint64_t frameID, const String& message)
317         : m_arguments(frameID, message)
318     {
319     }
320
321     const Arguments& arguments() const
322     {
323         return m_arguments;
324     }
325
326 private:
327     Arguments m_arguments;
328 };
329
330 class GetPlugins {
331 public:
332     typedef std::tuple<bool> Arguments;
333
334     static IPC::StringReference receiverName() { return messageReceiverName(); }
335     static IPC::StringReference name() { return IPC::StringReference("GetPlugins"); }
336     static const bool isSync = true;
337
338     typedef std::tuple<Vector<WebCore::PluginInfo>&> Reply;
339     explicit GetPlugins(bool refresh)
340         : m_arguments(refresh)
341     {
342     }
343
344     const Arguments& arguments() const
345     {
346         return m_arguments;
347     }
348
349 private:
350     Arguments m_arguments;
351 };
352
353 class GetPluginProcessConnection {
354 public:
355     typedef std::tuple<const String&> Arguments;
356
357     static IPC::StringReference receiverName() { return messageReceiverName(); }
358     static IPC::StringReference name() { return IPC::StringReference("GetPluginProcessConnection"); }
359     static const bool isSync = true;
360
361     struct DelayedReply : public ThreadSafeRefCounted<DelayedReply> {
362         DelayedReply(Ref<IPC::Connection>&&, std::unique_ptr<IPC::Encoder>);
363         ~DelayedReply();
364
365         bool send(const IPC::Connection::Handle& connectionHandle);
366
367     private:
368         RefPtr<IPC::Connection> m_connection;
369         std::unique_ptr<IPC::Encoder> m_encoder;
370     };
371
372     typedef std::tuple<IPC::Connection::Handle&> Reply;
373     explicit GetPluginProcessConnection(const String& pluginPath)
374         : m_arguments(pluginPath)
375     {
376     }
377
378     const Arguments& arguments() const
379     {
380         return m_arguments;
381     }
382
383 private:
384     Arguments m_arguments;
385 };
386
387 class TestMultipleAttributes {
388 public:
389     typedef std::tuple<> Arguments;
390
391     static IPC::StringReference receiverName() { return messageReceiverName(); }
392     static IPC::StringReference name() { return IPC::StringReference("TestMultipleAttributes"); }
393     static const bool isSync = true;
394
395     struct DelayedReply : public ThreadSafeRefCounted<DelayedReply> {
396         DelayedReply(Ref<IPC::Connection>&&, std::unique_ptr<IPC::Encoder>);
397         ~DelayedReply();
398
399         bool send();
400
401     private:
402         RefPtr<IPC::Connection> m_connection;
403         std::unique_ptr<IPC::Encoder> m_encoder;
404     };
405
406     typedef std::tuple<> Reply;
407     const Arguments& arguments() const
408     {
409         return m_arguments;
410     }
411
412 private:
413     Arguments m_arguments;
414 };
415
416 class TestParameterAttributes {
417 public:
418     typedef std::tuple<uint64_t, double, double> Arguments;
419
420     static IPC::StringReference receiverName() { return messageReceiverName(); }
421     static IPC::StringReference name() { return IPC::StringReference("TestParameterAttributes"); }
422     static const bool isSync = false;
423
424     TestParameterAttributes(uint64_t foo, double bar, double baz)
425         : m_arguments(foo, bar, baz)
426     {
427     }
428
429     const Arguments& arguments() const
430     {
431         return m_arguments;
432     }
433
434 private:
435     Arguments m_arguments;
436 };
437
438 class TemplateTest {
439 public:
440     typedef std::tuple<const HashMap<String, std::pair<String, uint64_t>>&> Arguments;
441
442     static IPC::StringReference receiverName() { return messageReceiverName(); }
443     static IPC::StringReference name() { return IPC::StringReference("TemplateTest"); }
444     static const bool isSync = false;
445
446     explicit TemplateTest(const HashMap<String, std::pair<String, uint64_t>>& a)
447         : m_arguments(a)
448     {
449     }
450
451     const Arguments& arguments() const
452     {
453         return m_arguments;
454     }
455
456 private:
457     Arguments m_arguments;
458 };
459
460 class SetVideoLayerID {
461 public:
462     typedef std::tuple<const WebCore::GraphicsLayer::PlatformLayerID&> Arguments;
463
464     static IPC::StringReference receiverName() { return messageReceiverName(); }
465     static IPC::StringReference name() { return IPC::StringReference("SetVideoLayerID"); }
466     static const bool isSync = false;
467
468     explicit SetVideoLayerID(const WebCore::GraphicsLayer::PlatformLayerID& videoLayerID)
469         : m_arguments(videoLayerID)
470     {
471     }
472
473     const Arguments& arguments() const
474     {
475         return m_arguments;
476     }
477
478 private:
479     Arguments m_arguments;
480 };
481
482 #if PLATFORM(MAC)
483 class DidCreateWebProcessConnection {
484 public:
485     typedef std::tuple<const IPC::MachPort&> Arguments;
486
487     static IPC::StringReference receiverName() { return messageReceiverName(); }
488     static IPC::StringReference name() { return IPC::StringReference("DidCreateWebProcessConnection"); }
489     static const bool isSync = false;
490
491     explicit DidCreateWebProcessConnection(const IPC::MachPort& connectionIdentifier)
492         : m_arguments(connectionIdentifier)
493     {
494     }
495
496     const Arguments& arguments() const
497     {
498         return m_arguments;
499     }
500
501 private:
502     Arguments m_arguments;
503 };
504 #endif
505
506 #if PLATFORM(MAC)
507 class InterpretKeyEvent {
508 public:
509     typedef std::tuple<uint32_t> Arguments;
510
511     static IPC::StringReference receiverName() { return messageReceiverName(); }
512     static IPC::StringReference name() { return IPC::StringReference("InterpretKeyEvent"); }
513     static const bool isSync = true;
514
515     typedef std::tuple<Vector<WebCore::KeypressCommand>&> Reply;
516     explicit InterpretKeyEvent(uint32_t type)
517         : m_arguments(type)
518     {
519     }
520
521     const Arguments& arguments() const
522     {
523         return m_arguments;
524     }
525
526 private:
527     Arguments m_arguments;
528 };
529 #endif
530
531 #if ENABLE(DEPRECATED_FEATURE)
532 class DeprecatedOperation {
533 public:
534     typedef std::tuple<const IPC::DummyType&> Arguments;
535
536     static IPC::StringReference receiverName() { return messageReceiverName(); }
537     static IPC::StringReference name() { return IPC::StringReference("DeprecatedOperation"); }
538     static const bool isSync = false;
539
540     explicit DeprecatedOperation(const IPC::DummyType& dummy)
541         : m_arguments(dummy)
542     {
543     }
544
545     const Arguments& arguments() const
546     {
547         return m_arguments;
548     }
549
550 private:
551     Arguments m_arguments;
552 };
553 #endif
554
555 #if ENABLE(EXPERIMENTAL_FEATURE)
556 class ExperimentalOperation {
557 public:
558     typedef std::tuple<const IPC::DummyType&> Arguments;
559
560     static IPC::StringReference receiverName() { return messageReceiverName(); }
561     static IPC::StringReference name() { return IPC::StringReference("ExperimentalOperation"); }
562     static const bool isSync = false;
563
564     explicit ExperimentalOperation(const IPC::DummyType& dummy)
565         : m_arguments(dummy)
566     {
567     }
568
569     const Arguments& arguments() const
570     {
571         return m_arguments;
572     }
573
574 private:
575     Arguments m_arguments;
576 };
577 #endif
578
579 } // namespace WebPage
580 } // namespace Messages
581
582 #endif // (ENABLE(WEBKIT2) && (NESTED_MASTER_CONDITION || MASTER_OR && MASTER_AND))