Line data Source code
1 : //
2 : // Automatically generated by ipdlc.
3 : // Edit at your own risk
4 : //
5 :
6 :
7 : #include "mozilla/dom/PFilePicker.h"
8 :
9 : namespace mozilla {
10 : namespace dom {
11 : namespace PFilePicker {
12 :
13 : nsresult
14 0 : CreateEndpoints(
15 : base::ProcessId aParentDestPid,
16 : base::ProcessId aChildDestPid,
17 : mozilla::ipc::Endpoint<mozilla::dom::PFilePickerParent>* aParent,
18 : mozilla::ipc::Endpoint<mozilla::dom::PFilePickerChild>* aChild)
19 : {
20 0 : return mozilla::ipc::CreateEndpoints(mozilla::ipc::PrivateIPDLInterface(), aParentDestPid, aChildDestPid, PFilePickerMsgStart, PFilePickerMsgStartChild, aParent, aChild);
21 : }
22 : void
23 0 : Transition(
24 : MessageType msg,
25 : State* next)
26 : {
27 0 : switch ((*(next))) {
28 : case __Null:
29 0 : if ((Msg___delete____ID) == (msg)) {
30 0 : (*(next)) = __Dead;
31 : }
32 0 : break;
33 : case __Dead:
34 0 : mozilla::ipc::LogicError("__delete__()d actor");
35 0 : break;
36 : default:
37 0 : mozilla::ipc::LogicError("corrupted actor state");
38 0 : break;
39 : }
40 0 : }
41 : IPC::Message*
42 0 : Msg_Open(int32_t routingId)
43 : {
44 0 : return new IPC::Message(routingId, Msg_Open__ID, 0, IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, "PFilePicker::Msg_Open", true);
45 : }
46 : IPC::Message*
47 0 : Msg___delete__(int32_t routingId)
48 : {
49 0 : return new IPC::Message(routingId, Msg___delete____ID, 0, IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, "PFilePicker::Msg___delete__", true);
50 : }
51 : IPC::Message*
52 0 : Reply___delete__(int32_t routingId)
53 : {
54 0 : return new IPC::Message(routingId, Reply___delete____ID, 0, IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, "PFilePicker::Reply___delete__", true);
55 : }
56 :
57 : } // namespace PFilePicker
58 : } // namespace dom
59 : } // namespace mozilla
60 :
61 : //-----------------------------------------------------------------------------
62 : // Method definitions for the IPDL type |struct InputBlobs|
63 : //
64 : namespace mozilla {
65 : namespace dom {
66 0 : MOZ_IMPLICIT InputBlobs::InputBlobs()
67 : {
68 0 : Init();
69 0 : }
70 :
71 0 : InputBlobs::~InputBlobs()
72 : {
73 0 : }
74 :
75 0 : auto InputBlobs::operator==(const InputBlobs& _o) const -> bool
76 : {
77 0 : if ((!((blobs()) == ((_o).blobs())))) {
78 0 : return false;
79 : }
80 0 : return true;
81 : }
82 :
83 0 : auto InputBlobs::operator!=(const InputBlobs& _o) const -> bool
84 : {
85 0 : return (!(operator==(_o)));
86 : }
87 :
88 0 : auto InputBlobs::Init() -> void
89 : {
90 0 : }
91 :
92 0 : auto InputBlobs::Assign(const nsTArray<IPCBlob>& _blobs) -> void
93 : {
94 0 : blobs_ = _blobs;
95 0 : }
96 :
97 : } // namespace dom
98 : } // namespace mozilla
99 :
100 : //-----------------------------------------------------------------------------
101 : // Method definitions for the IPDL type |struct InputDirectory|
102 : //
103 : namespace mozilla {
104 : namespace dom {
105 0 : MOZ_IMPLICIT InputDirectory::InputDirectory() :
106 0 : directoryPath_()
107 : {
108 0 : Init();
109 0 : }
110 :
111 0 : InputDirectory::~InputDirectory()
112 : {
113 0 : }
114 :
115 0 : auto InputDirectory::operator==(const InputDirectory& _o) const -> bool
116 : {
117 0 : if ((!((directoryPath()) == ((_o).directoryPath())))) {
118 0 : return false;
119 : }
120 0 : return true;
121 : }
122 :
123 0 : auto InputDirectory::operator!=(const InputDirectory& _o) const -> bool
124 : {
125 0 : return (!(operator==(_o)));
126 : }
127 :
128 0 : auto InputDirectory::Init() -> void
129 : {
130 0 : }
131 :
132 0 : auto InputDirectory::Assign(const nsString& _directoryPath) -> void
133 : {
134 0 : directoryPath_ = _directoryPath;
135 0 : }
136 :
137 : } // namespace dom
138 : } // namespace mozilla
139 :
140 : //-----------------------------------------------------------------------------
141 : // Method definitions for the IPDL type |union MaybeInputData|
142 : //
143 : namespace mozilla {
144 : namespace dom {
145 0 : auto MaybeInputData::MaybeDestroy(Type aNewType) -> bool
146 : {
147 0 : if ((mType) == (T__None)) {
148 0 : return true;
149 : }
150 0 : if ((mType) == (aNewType)) {
151 0 : return false;
152 : }
153 0 : switch (mType) {
154 : case TInputBlobs:
155 : {
156 0 : (ptr_InputBlobs())->~InputBlobs__tdef();
157 0 : break;
158 : }
159 : case TInputDirectory:
160 : {
161 0 : (ptr_InputDirectory())->~InputDirectory__tdef();
162 0 : break;
163 : }
164 : case Tvoid_t:
165 : {
166 0 : (ptr_void_t())->~void_t__tdef();
167 0 : break;
168 : }
169 : default:
170 : {
171 0 : mozilla::ipc::LogicError("not reached");
172 0 : break;
173 : }
174 : }
175 0 : return true;
176 : }
177 :
178 0 : MOZ_IMPLICIT MaybeInputData::MaybeInputData(const InputBlobs& aOther)
179 : {
180 0 : new (mozilla::KnownNotNull, ptr_InputBlobs()) InputBlobs(aOther);
181 0 : mType = TInputBlobs;
182 0 : }
183 :
184 0 : MOZ_IMPLICIT MaybeInputData::MaybeInputData(const InputDirectory& aOther)
185 : {
186 0 : new (mozilla::KnownNotNull, ptr_InputDirectory()) InputDirectory(aOther);
187 0 : mType = TInputDirectory;
188 0 : }
189 :
190 0 : MOZ_IMPLICIT MaybeInputData::MaybeInputData(const void_t& aOther)
191 : {
192 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
193 0 : mType = Tvoid_t;
194 0 : }
195 :
196 0 : MOZ_IMPLICIT MaybeInputData::MaybeInputData(const MaybeInputData& aOther)
197 : {
198 0 : (aOther).AssertSanity();
199 0 : switch ((aOther).type()) {
200 : case TInputBlobs:
201 : {
202 0 : new (mozilla::KnownNotNull, ptr_InputBlobs()) InputBlobs((aOther).get_InputBlobs());
203 0 : break;
204 : }
205 : case TInputDirectory:
206 : {
207 0 : new (mozilla::KnownNotNull, ptr_InputDirectory()) InputDirectory((aOther).get_InputDirectory());
208 0 : break;
209 : }
210 : case Tvoid_t:
211 : {
212 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
213 0 : break;
214 : }
215 : case T__None:
216 : {
217 0 : break;
218 : }
219 : default:
220 : {
221 0 : mozilla::ipc::LogicError("unreached");
222 0 : return;
223 : }
224 : }
225 0 : mType = (aOther).type();
226 : }
227 :
228 0 : MaybeInputData::~MaybeInputData()
229 : {
230 0 : static_cast<void>(MaybeDestroy(T__None));
231 0 : }
232 :
233 0 : auto MaybeInputData::operator=(const InputBlobs& aRhs) -> MaybeInputData&
234 : {
235 0 : if (MaybeDestroy(TInputBlobs)) {
236 0 : new (mozilla::KnownNotNull, ptr_InputBlobs()) InputBlobs;
237 : }
238 0 : (*(ptr_InputBlobs())) = aRhs;
239 0 : mType = TInputBlobs;
240 0 : return (*(this));
241 : }
242 :
243 0 : auto MaybeInputData::operator=(const InputDirectory& aRhs) -> MaybeInputData&
244 : {
245 0 : if (MaybeDestroy(TInputDirectory)) {
246 0 : new (mozilla::KnownNotNull, ptr_InputDirectory()) InputDirectory;
247 : }
248 0 : (*(ptr_InputDirectory())) = aRhs;
249 0 : mType = TInputDirectory;
250 0 : return (*(this));
251 : }
252 :
253 0 : auto MaybeInputData::operator=(const void_t& aRhs) -> MaybeInputData&
254 : {
255 0 : if (MaybeDestroy(Tvoid_t)) {
256 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
257 : }
258 0 : (*(ptr_void_t())) = aRhs;
259 0 : mType = Tvoid_t;
260 0 : return (*(this));
261 : }
262 :
263 0 : auto MaybeInputData::operator=(const MaybeInputData& aRhs) -> MaybeInputData&
264 : {
265 0 : (aRhs).AssertSanity();
266 0 : Type t = (aRhs).type();
267 0 : switch (t) {
268 : case TInputBlobs:
269 : {
270 0 : if (MaybeDestroy(t)) {
271 0 : new (mozilla::KnownNotNull, ptr_InputBlobs()) InputBlobs;
272 : }
273 0 : (*(ptr_InputBlobs())) = (aRhs).get_InputBlobs();
274 0 : break;
275 : }
276 : case TInputDirectory:
277 : {
278 0 : if (MaybeDestroy(t)) {
279 0 : new (mozilla::KnownNotNull, ptr_InputDirectory()) InputDirectory;
280 : }
281 0 : (*(ptr_InputDirectory())) = (aRhs).get_InputDirectory();
282 0 : break;
283 : }
284 : case Tvoid_t:
285 : {
286 0 : if (MaybeDestroy(t)) {
287 0 : new (mozilla::KnownNotNull, ptr_void_t()) void_t;
288 : }
289 0 : (*(ptr_void_t())) = (aRhs).get_void_t();
290 0 : break;
291 : }
292 : case T__None:
293 : {
294 0 : static_cast<void>(MaybeDestroy(t));
295 0 : break;
296 : }
297 : default:
298 : {
299 0 : mozilla::ipc::LogicError("unreached");
300 0 : break;
301 : }
302 : }
303 0 : mType = t;
304 0 : return (*(this));
305 : }
306 :
307 0 : auto MaybeInputData::operator==(const InputBlobs& aRhs) const -> bool
308 : {
309 0 : return (get_InputBlobs()) == (aRhs);
310 : }
311 :
312 0 : auto MaybeInputData::operator==(const InputDirectory& aRhs) const -> bool
313 : {
314 0 : return (get_InputDirectory()) == (aRhs);
315 : }
316 :
317 0 : auto MaybeInputData::operator==(const void_t& aRhs) const -> bool
318 : {
319 0 : return (get_void_t()) == (aRhs);
320 : }
321 :
322 0 : auto MaybeInputData::operator==(const MaybeInputData& aRhs) const -> bool
323 : {
324 0 : if ((type()) != ((aRhs).type())) {
325 0 : return false;
326 : }
327 :
328 0 : switch (type()) {
329 : case TInputBlobs:
330 : {
331 0 : return (get_InputBlobs()) == ((aRhs).get_InputBlobs());
332 : }
333 : case TInputDirectory:
334 : {
335 0 : return (get_InputDirectory()) == ((aRhs).get_InputDirectory());
336 : }
337 : case Tvoid_t:
338 : {
339 0 : return (get_void_t()) == ((aRhs).get_void_t());
340 : }
341 : default:
342 : {
343 0 : mozilla::ipc::LogicError("unreached");
344 0 : return false;
345 : }
346 : }
347 : }
348 :
349 0 : auto MaybeInputData::get(InputBlobs* aOutValue) const -> void
350 : {
351 0 : (*(aOutValue)) = get_InputBlobs();
352 0 : }
353 :
354 0 : auto MaybeInputData::get(InputDirectory* aOutValue) const -> void
355 : {
356 0 : (*(aOutValue)) = get_InputDirectory();
357 0 : }
358 :
359 0 : auto MaybeInputData::get(void_t* aOutValue) const -> void
360 : {
361 0 : (*(aOutValue)) = get_void_t();
362 0 : }
363 :
364 : } // namespace dom
365 : } // namespace mozilla
|
