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