1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_ui_test_context__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Default, PartialEq)]
15pub struct RealmFactoryCreateRealmRequest {
16 pub realm_server:
17 Option<fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>>,
18 pub display_rotation: Option<u32>,
19 pub device_pixel_ratio: Option<f32>,
20 pub display_dimensions: Option<fidl_fuchsia_math::SizeU>,
22 pub display_refresh_rate_millihertz: Option<u32>,
24 pub display_max_layer_count: Option<u32>,
26 #[doc(hidden)]
27 pub __source_breaking: fidl::marker::SourceBreaking,
28}
29
30impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
31 for RealmFactoryCreateRealmRequest
32{
33}
34
35#[derive(Debug, Default, PartialEq)]
36pub struct ScenicRealmFactoryCreateRealmRequest {
37 pub realm_server:
38 Option<fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>>,
39 pub renderer: Option<RendererType>,
40 pub display_rotation: Option<u64>,
41 pub display_composition: Option<bool>,
42 pub display_dimensions: Option<fidl_fuchsia_math::SizeU>,
44 pub display_refresh_rate_millihertz: Option<u32>,
46 pub display_max_layer_count: Option<u32>,
48 #[doc(hidden)]
49 pub __source_breaking: fidl::marker::SourceBreaking,
50}
51
52impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
53 for ScenicRealmFactoryCreateRealmRequest
54{
55}
56
57#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
58pub struct RealmFactoryMarker;
59
60impl fidl::endpoints::ProtocolMarker for RealmFactoryMarker {
61 type Proxy = RealmFactoryProxy;
62 type RequestStream = RealmFactoryRequestStream;
63 #[cfg(target_os = "fuchsia")]
64 type SynchronousProxy = RealmFactorySynchronousProxy;
65
66 const DEBUG_NAME: &'static str = "fuchsia.ui.test.context.RealmFactory";
67}
68impl fidl::endpoints::DiscoverableProtocolMarker for RealmFactoryMarker {}
69pub type RealmFactoryCreateRealmResult = Result<(), fidl_fuchsia_testing_harness::OperationError>;
70
71pub trait RealmFactoryProxyInterface: Send + Sync {
72 type CreateRealmResponseFut: std::future::Future<Output = Result<RealmFactoryCreateRealmResult, fidl::Error>>
73 + Send;
74 fn r#create_realm(
75 &self,
76 payload: RealmFactoryCreateRealmRequest,
77 ) -> Self::CreateRealmResponseFut;
78}
79#[derive(Debug)]
80#[cfg(target_os = "fuchsia")]
81pub struct RealmFactorySynchronousProxy {
82 client: fidl::client::sync::Client,
83}
84
85#[cfg(target_os = "fuchsia")]
86impl fidl::endpoints::SynchronousProxy for RealmFactorySynchronousProxy {
87 type Proxy = RealmFactoryProxy;
88 type Protocol = RealmFactoryMarker;
89
90 fn from_channel(inner: fidl::Channel) -> Self {
91 Self::new(inner)
92 }
93
94 fn into_channel(self) -> fidl::Channel {
95 self.client.into_channel()
96 }
97
98 fn as_channel(&self) -> &fidl::Channel {
99 self.client.as_channel()
100 }
101}
102
103#[cfg(target_os = "fuchsia")]
104impl RealmFactorySynchronousProxy {
105 pub fn new(channel: fidl::Channel) -> Self {
106 let protocol_name = <RealmFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
107 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
108 }
109
110 pub fn into_channel(self) -> fidl::Channel {
111 self.client.into_channel()
112 }
113
114 pub fn wait_for_event(
117 &self,
118 deadline: zx::MonotonicInstant,
119 ) -> Result<RealmFactoryEvent, fidl::Error> {
120 RealmFactoryEvent::decode(self.client.wait_for_event(deadline)?)
121 }
122
123 pub fn r#create_realm(
124 &self,
125 mut payload: RealmFactoryCreateRealmRequest,
126 ___deadline: zx::MonotonicInstant,
127 ) -> Result<RealmFactoryCreateRealmResult, fidl::Error> {
128 let _response = self
129 .client
130 .send_query::<RealmFactoryCreateRealmRequest, fidl::encoding::FlexibleResultType<
131 fidl::encoding::EmptyStruct,
132 fidl_fuchsia_testing_harness::OperationError,
133 >>(
134 &mut payload,
135 0x6e1c904f44c7d0fc,
136 fidl::encoding::DynamicFlags::FLEXIBLE,
137 ___deadline,
138 )?
139 .into_result::<RealmFactoryMarker>("create_realm")?;
140 Ok(_response.map(|x| x))
141 }
142}
143
144#[cfg(target_os = "fuchsia")]
145impl From<RealmFactorySynchronousProxy> for zx::Handle {
146 fn from(value: RealmFactorySynchronousProxy) -> Self {
147 value.into_channel().into()
148 }
149}
150
151#[cfg(target_os = "fuchsia")]
152impl From<fidl::Channel> for RealmFactorySynchronousProxy {
153 fn from(value: fidl::Channel) -> Self {
154 Self::new(value)
155 }
156}
157
158#[cfg(target_os = "fuchsia")]
159impl fidl::endpoints::FromClient for RealmFactorySynchronousProxy {
160 type Protocol = RealmFactoryMarker;
161
162 fn from_client(value: fidl::endpoints::ClientEnd<RealmFactoryMarker>) -> Self {
163 Self::new(value.into_channel())
164 }
165}
166
167#[derive(Debug, Clone)]
168pub struct RealmFactoryProxy {
169 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
170}
171
172impl fidl::endpoints::Proxy for RealmFactoryProxy {
173 type Protocol = RealmFactoryMarker;
174
175 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
176 Self::new(inner)
177 }
178
179 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
180 self.client.into_channel().map_err(|client| Self { client })
181 }
182
183 fn as_channel(&self) -> &::fidl::AsyncChannel {
184 self.client.as_channel()
185 }
186}
187
188impl RealmFactoryProxy {
189 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
191 let protocol_name = <RealmFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
192 Self { client: fidl::client::Client::new(channel, protocol_name) }
193 }
194
195 pub fn take_event_stream(&self) -> RealmFactoryEventStream {
201 RealmFactoryEventStream { event_receiver: self.client.take_event_receiver() }
202 }
203
204 pub fn r#create_realm(
205 &self,
206 mut payload: RealmFactoryCreateRealmRequest,
207 ) -> fidl::client::QueryResponseFut<
208 RealmFactoryCreateRealmResult,
209 fidl::encoding::DefaultFuchsiaResourceDialect,
210 > {
211 RealmFactoryProxyInterface::r#create_realm(self, payload)
212 }
213}
214
215impl RealmFactoryProxyInterface for RealmFactoryProxy {
216 type CreateRealmResponseFut = fidl::client::QueryResponseFut<
217 RealmFactoryCreateRealmResult,
218 fidl::encoding::DefaultFuchsiaResourceDialect,
219 >;
220 fn r#create_realm(
221 &self,
222 mut payload: RealmFactoryCreateRealmRequest,
223 ) -> Self::CreateRealmResponseFut {
224 fn _decode(
225 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
226 ) -> Result<RealmFactoryCreateRealmResult, fidl::Error> {
227 let _response = fidl::client::decode_transaction_body::<
228 fidl::encoding::FlexibleResultType<
229 fidl::encoding::EmptyStruct,
230 fidl_fuchsia_testing_harness::OperationError,
231 >,
232 fidl::encoding::DefaultFuchsiaResourceDialect,
233 0x6e1c904f44c7d0fc,
234 >(_buf?)?
235 .into_result::<RealmFactoryMarker>("create_realm")?;
236 Ok(_response.map(|x| x))
237 }
238 self.client
239 .send_query_and_decode::<RealmFactoryCreateRealmRequest, RealmFactoryCreateRealmResult>(
240 &mut payload,
241 0x6e1c904f44c7d0fc,
242 fidl::encoding::DynamicFlags::FLEXIBLE,
243 _decode,
244 )
245 }
246}
247
248pub struct RealmFactoryEventStream {
249 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
250}
251
252impl std::marker::Unpin for RealmFactoryEventStream {}
253
254impl futures::stream::FusedStream for RealmFactoryEventStream {
255 fn is_terminated(&self) -> bool {
256 self.event_receiver.is_terminated()
257 }
258}
259
260impl futures::Stream for RealmFactoryEventStream {
261 type Item = Result<RealmFactoryEvent, fidl::Error>;
262
263 fn poll_next(
264 mut self: std::pin::Pin<&mut Self>,
265 cx: &mut std::task::Context<'_>,
266 ) -> std::task::Poll<Option<Self::Item>> {
267 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
268 &mut self.event_receiver,
269 cx
270 )?) {
271 Some(buf) => std::task::Poll::Ready(Some(RealmFactoryEvent::decode(buf))),
272 None => std::task::Poll::Ready(None),
273 }
274 }
275}
276
277#[derive(Debug)]
278pub enum RealmFactoryEvent {
279 #[non_exhaustive]
280 _UnknownEvent {
281 ordinal: u64,
283 },
284}
285
286impl RealmFactoryEvent {
287 fn decode(
289 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
290 ) -> Result<RealmFactoryEvent, fidl::Error> {
291 let (bytes, _handles) = buf.split_mut();
292 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
293 debug_assert_eq!(tx_header.tx_id, 0);
294 match tx_header.ordinal {
295 _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
296 Ok(RealmFactoryEvent::_UnknownEvent { ordinal: tx_header.ordinal })
297 }
298 _ => Err(fidl::Error::UnknownOrdinal {
299 ordinal: tx_header.ordinal,
300 protocol_name: <RealmFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
301 }),
302 }
303 }
304}
305
306pub struct RealmFactoryRequestStream {
308 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
309 is_terminated: bool,
310}
311
312impl std::marker::Unpin for RealmFactoryRequestStream {}
313
314impl futures::stream::FusedStream for RealmFactoryRequestStream {
315 fn is_terminated(&self) -> bool {
316 self.is_terminated
317 }
318}
319
320impl fidl::endpoints::RequestStream for RealmFactoryRequestStream {
321 type Protocol = RealmFactoryMarker;
322 type ControlHandle = RealmFactoryControlHandle;
323
324 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
325 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
326 }
327
328 fn control_handle(&self) -> Self::ControlHandle {
329 RealmFactoryControlHandle { inner: self.inner.clone() }
330 }
331
332 fn into_inner(
333 self,
334 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
335 {
336 (self.inner, self.is_terminated)
337 }
338
339 fn from_inner(
340 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
341 is_terminated: bool,
342 ) -> Self {
343 Self { inner, is_terminated }
344 }
345}
346
347impl futures::Stream for RealmFactoryRequestStream {
348 type Item = Result<RealmFactoryRequest, fidl::Error>;
349
350 fn poll_next(
351 mut self: std::pin::Pin<&mut Self>,
352 cx: &mut std::task::Context<'_>,
353 ) -> std::task::Poll<Option<Self::Item>> {
354 let this = &mut *self;
355 if this.inner.check_shutdown(cx) {
356 this.is_terminated = true;
357 return std::task::Poll::Ready(None);
358 }
359 if this.is_terminated {
360 panic!("polled RealmFactoryRequestStream after completion");
361 }
362 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
363 |bytes, handles| {
364 match this.inner.channel().read_etc(cx, bytes, handles) {
365 std::task::Poll::Ready(Ok(())) => {}
366 std::task::Poll::Pending => return std::task::Poll::Pending,
367 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
368 this.is_terminated = true;
369 return std::task::Poll::Ready(None);
370 }
371 std::task::Poll::Ready(Err(e)) => {
372 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
373 e.into(),
374 ))));
375 }
376 }
377
378 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
380
381 std::task::Poll::Ready(Some(match header.ordinal {
382 0x6e1c904f44c7d0fc => {
383 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
384 let mut req = fidl::new_empty!(
385 RealmFactoryCreateRealmRequest,
386 fidl::encoding::DefaultFuchsiaResourceDialect
387 );
388 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmFactoryCreateRealmRequest>(&header, _body_bytes, handles, &mut req)?;
389 let control_handle =
390 RealmFactoryControlHandle { inner: this.inner.clone() };
391 Ok(RealmFactoryRequest::CreateRealm {
392 payload: req,
393 responder: RealmFactoryCreateRealmResponder {
394 control_handle: std::mem::ManuallyDrop::new(control_handle),
395 tx_id: header.tx_id,
396 },
397 })
398 }
399 _ if header.tx_id == 0
400 && header
401 .dynamic_flags()
402 .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
403 {
404 Ok(RealmFactoryRequest::_UnknownMethod {
405 ordinal: header.ordinal,
406 control_handle: RealmFactoryControlHandle { inner: this.inner.clone() },
407 method_type: fidl::MethodType::OneWay,
408 })
409 }
410 _ if header
411 .dynamic_flags()
412 .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
413 {
414 this.inner.send_framework_err(
415 fidl::encoding::FrameworkErr::UnknownMethod,
416 header.tx_id,
417 header.ordinal,
418 header.dynamic_flags(),
419 (bytes, handles),
420 )?;
421 Ok(RealmFactoryRequest::_UnknownMethod {
422 ordinal: header.ordinal,
423 control_handle: RealmFactoryControlHandle { inner: this.inner.clone() },
424 method_type: fidl::MethodType::TwoWay,
425 })
426 }
427 _ => Err(fidl::Error::UnknownOrdinal {
428 ordinal: header.ordinal,
429 protocol_name:
430 <RealmFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
431 }),
432 }))
433 },
434 )
435 }
436}
437
438#[derive(Debug)]
442pub enum RealmFactoryRequest {
443 CreateRealm {
444 payload: RealmFactoryCreateRealmRequest,
445 responder: RealmFactoryCreateRealmResponder,
446 },
447 #[non_exhaustive]
449 _UnknownMethod {
450 ordinal: u64,
452 control_handle: RealmFactoryControlHandle,
453 method_type: fidl::MethodType,
454 },
455}
456
457impl RealmFactoryRequest {
458 #[allow(irrefutable_let_patterns)]
459 pub fn into_create_realm(
460 self,
461 ) -> Option<(RealmFactoryCreateRealmRequest, RealmFactoryCreateRealmResponder)> {
462 if let RealmFactoryRequest::CreateRealm { payload, responder } = self {
463 Some((payload, responder))
464 } else {
465 None
466 }
467 }
468
469 pub fn method_name(&self) -> &'static str {
471 match *self {
472 RealmFactoryRequest::CreateRealm { .. } => "create_realm",
473 RealmFactoryRequest::_UnknownMethod {
474 method_type: fidl::MethodType::OneWay, ..
475 } => "unknown one-way method",
476 RealmFactoryRequest::_UnknownMethod {
477 method_type: fidl::MethodType::TwoWay, ..
478 } => "unknown two-way method",
479 }
480 }
481}
482
483#[derive(Debug, Clone)]
484pub struct RealmFactoryControlHandle {
485 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
486}
487
488impl fidl::endpoints::ControlHandle for RealmFactoryControlHandle {
489 fn shutdown(&self) {
490 self.inner.shutdown()
491 }
492 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
493 self.inner.shutdown_with_epitaph(status)
494 }
495
496 fn is_closed(&self) -> bool {
497 self.inner.channel().is_closed()
498 }
499 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
500 self.inner.channel().on_closed()
501 }
502
503 #[cfg(target_os = "fuchsia")]
504 fn signal_peer(
505 &self,
506 clear_mask: zx::Signals,
507 set_mask: zx::Signals,
508 ) -> Result<(), zx_status::Status> {
509 use fidl::Peered;
510 self.inner.channel().signal_peer(clear_mask, set_mask)
511 }
512}
513
514impl RealmFactoryControlHandle {}
515
516#[must_use = "FIDL methods require a response to be sent"]
517#[derive(Debug)]
518pub struct RealmFactoryCreateRealmResponder {
519 control_handle: std::mem::ManuallyDrop<RealmFactoryControlHandle>,
520 tx_id: u32,
521}
522
523impl std::ops::Drop for RealmFactoryCreateRealmResponder {
527 fn drop(&mut self) {
528 self.control_handle.shutdown();
529 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
531 }
532}
533
534impl fidl::endpoints::Responder for RealmFactoryCreateRealmResponder {
535 type ControlHandle = RealmFactoryControlHandle;
536
537 fn control_handle(&self) -> &RealmFactoryControlHandle {
538 &self.control_handle
539 }
540
541 fn drop_without_shutdown(mut self) {
542 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
544 std::mem::forget(self);
546 }
547}
548
549impl RealmFactoryCreateRealmResponder {
550 pub fn send(
554 self,
555 mut result: Result<(), fidl_fuchsia_testing_harness::OperationError>,
556 ) -> Result<(), fidl::Error> {
557 let _result = self.send_raw(result);
558 if _result.is_err() {
559 self.control_handle.shutdown();
560 }
561 self.drop_without_shutdown();
562 _result
563 }
564
565 pub fn send_no_shutdown_on_err(
567 self,
568 mut result: Result<(), fidl_fuchsia_testing_harness::OperationError>,
569 ) -> Result<(), fidl::Error> {
570 let _result = self.send_raw(result);
571 self.drop_without_shutdown();
572 _result
573 }
574
575 fn send_raw(
576 &self,
577 mut result: Result<(), fidl_fuchsia_testing_harness::OperationError>,
578 ) -> Result<(), fidl::Error> {
579 self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
580 fidl::encoding::EmptyStruct,
581 fidl_fuchsia_testing_harness::OperationError,
582 >>(
583 fidl::encoding::FlexibleResult::new(result),
584 self.tx_id,
585 0x6e1c904f44c7d0fc,
586 fidl::encoding::DynamicFlags::FLEXIBLE,
587 )
588 }
589}
590
591#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
592pub struct ScenicRealmFactoryMarker;
593
594impl fidl::endpoints::ProtocolMarker for ScenicRealmFactoryMarker {
595 type Proxy = ScenicRealmFactoryProxy;
596 type RequestStream = ScenicRealmFactoryRequestStream;
597 #[cfg(target_os = "fuchsia")]
598 type SynchronousProxy = ScenicRealmFactorySynchronousProxy;
599
600 const DEBUG_NAME: &'static str = "fuchsia.ui.test.context.ScenicRealmFactory";
601}
602impl fidl::endpoints::DiscoverableProtocolMarker for ScenicRealmFactoryMarker {}
603pub type ScenicRealmFactoryCreateRealmResult =
604 Result<(), fidl_fuchsia_testing_harness::OperationError>;
605
606pub trait ScenicRealmFactoryProxyInterface: Send + Sync {
607 type CreateRealmResponseFut: std::future::Future<Output = Result<ScenicRealmFactoryCreateRealmResult, fidl::Error>>
608 + Send;
609 fn r#create_realm(
610 &self,
611 payload: ScenicRealmFactoryCreateRealmRequest,
612 ) -> Self::CreateRealmResponseFut;
613}
614#[derive(Debug)]
615#[cfg(target_os = "fuchsia")]
616pub struct ScenicRealmFactorySynchronousProxy {
617 client: fidl::client::sync::Client,
618}
619
620#[cfg(target_os = "fuchsia")]
621impl fidl::endpoints::SynchronousProxy for ScenicRealmFactorySynchronousProxy {
622 type Proxy = ScenicRealmFactoryProxy;
623 type Protocol = ScenicRealmFactoryMarker;
624
625 fn from_channel(inner: fidl::Channel) -> Self {
626 Self::new(inner)
627 }
628
629 fn into_channel(self) -> fidl::Channel {
630 self.client.into_channel()
631 }
632
633 fn as_channel(&self) -> &fidl::Channel {
634 self.client.as_channel()
635 }
636}
637
638#[cfg(target_os = "fuchsia")]
639impl ScenicRealmFactorySynchronousProxy {
640 pub fn new(channel: fidl::Channel) -> Self {
641 let protocol_name =
642 <ScenicRealmFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
643 Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
644 }
645
646 pub fn into_channel(self) -> fidl::Channel {
647 self.client.into_channel()
648 }
649
650 pub fn wait_for_event(
653 &self,
654 deadline: zx::MonotonicInstant,
655 ) -> Result<ScenicRealmFactoryEvent, fidl::Error> {
656 ScenicRealmFactoryEvent::decode(self.client.wait_for_event(deadline)?)
657 }
658
659 pub fn r#create_realm(
660 &self,
661 mut payload: ScenicRealmFactoryCreateRealmRequest,
662 ___deadline: zx::MonotonicInstant,
663 ) -> Result<ScenicRealmFactoryCreateRealmResult, fidl::Error> {
664 let _response = self
665 .client
666 .send_query::<ScenicRealmFactoryCreateRealmRequest, fidl::encoding::FlexibleResultType<
667 fidl::encoding::EmptyStruct,
668 fidl_fuchsia_testing_harness::OperationError,
669 >>(
670 &mut payload,
671 0x11f2157d1648e6ba,
672 fidl::encoding::DynamicFlags::FLEXIBLE,
673 ___deadline,
674 )?
675 .into_result::<ScenicRealmFactoryMarker>("create_realm")?;
676 Ok(_response.map(|x| x))
677 }
678}
679
680#[cfg(target_os = "fuchsia")]
681impl From<ScenicRealmFactorySynchronousProxy> for zx::Handle {
682 fn from(value: ScenicRealmFactorySynchronousProxy) -> Self {
683 value.into_channel().into()
684 }
685}
686
687#[cfg(target_os = "fuchsia")]
688impl From<fidl::Channel> for ScenicRealmFactorySynchronousProxy {
689 fn from(value: fidl::Channel) -> Self {
690 Self::new(value)
691 }
692}
693
694#[cfg(target_os = "fuchsia")]
695impl fidl::endpoints::FromClient for ScenicRealmFactorySynchronousProxy {
696 type Protocol = ScenicRealmFactoryMarker;
697
698 fn from_client(value: fidl::endpoints::ClientEnd<ScenicRealmFactoryMarker>) -> Self {
699 Self::new(value.into_channel())
700 }
701}
702
703#[derive(Debug, Clone)]
704pub struct ScenicRealmFactoryProxy {
705 client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
706}
707
708impl fidl::endpoints::Proxy for ScenicRealmFactoryProxy {
709 type Protocol = ScenicRealmFactoryMarker;
710
711 fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
712 Self::new(inner)
713 }
714
715 fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
716 self.client.into_channel().map_err(|client| Self { client })
717 }
718
719 fn as_channel(&self) -> &::fidl::AsyncChannel {
720 self.client.as_channel()
721 }
722}
723
724impl ScenicRealmFactoryProxy {
725 pub fn new(channel: ::fidl::AsyncChannel) -> Self {
727 let protocol_name =
728 <ScenicRealmFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
729 Self { client: fidl::client::Client::new(channel, protocol_name) }
730 }
731
732 pub fn take_event_stream(&self) -> ScenicRealmFactoryEventStream {
738 ScenicRealmFactoryEventStream { event_receiver: self.client.take_event_receiver() }
739 }
740
741 pub fn r#create_realm(
742 &self,
743 mut payload: ScenicRealmFactoryCreateRealmRequest,
744 ) -> fidl::client::QueryResponseFut<
745 ScenicRealmFactoryCreateRealmResult,
746 fidl::encoding::DefaultFuchsiaResourceDialect,
747 > {
748 ScenicRealmFactoryProxyInterface::r#create_realm(self, payload)
749 }
750}
751
752impl ScenicRealmFactoryProxyInterface for ScenicRealmFactoryProxy {
753 type CreateRealmResponseFut = fidl::client::QueryResponseFut<
754 ScenicRealmFactoryCreateRealmResult,
755 fidl::encoding::DefaultFuchsiaResourceDialect,
756 >;
757 fn r#create_realm(
758 &self,
759 mut payload: ScenicRealmFactoryCreateRealmRequest,
760 ) -> Self::CreateRealmResponseFut {
761 fn _decode(
762 mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
763 ) -> Result<ScenicRealmFactoryCreateRealmResult, fidl::Error> {
764 let _response = fidl::client::decode_transaction_body::<
765 fidl::encoding::FlexibleResultType<
766 fidl::encoding::EmptyStruct,
767 fidl_fuchsia_testing_harness::OperationError,
768 >,
769 fidl::encoding::DefaultFuchsiaResourceDialect,
770 0x11f2157d1648e6ba,
771 >(_buf?)?
772 .into_result::<ScenicRealmFactoryMarker>("create_realm")?;
773 Ok(_response.map(|x| x))
774 }
775 self.client.send_query_and_decode::<
776 ScenicRealmFactoryCreateRealmRequest,
777 ScenicRealmFactoryCreateRealmResult,
778 >(
779 &mut payload,
780 0x11f2157d1648e6ba,
781 fidl::encoding::DynamicFlags::FLEXIBLE,
782 _decode,
783 )
784 }
785}
786
787pub struct ScenicRealmFactoryEventStream {
788 event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
789}
790
791impl std::marker::Unpin for ScenicRealmFactoryEventStream {}
792
793impl futures::stream::FusedStream for ScenicRealmFactoryEventStream {
794 fn is_terminated(&self) -> bool {
795 self.event_receiver.is_terminated()
796 }
797}
798
799impl futures::Stream for ScenicRealmFactoryEventStream {
800 type Item = Result<ScenicRealmFactoryEvent, fidl::Error>;
801
802 fn poll_next(
803 mut self: std::pin::Pin<&mut Self>,
804 cx: &mut std::task::Context<'_>,
805 ) -> std::task::Poll<Option<Self::Item>> {
806 match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
807 &mut self.event_receiver,
808 cx
809 )?) {
810 Some(buf) => std::task::Poll::Ready(Some(ScenicRealmFactoryEvent::decode(buf))),
811 None => std::task::Poll::Ready(None),
812 }
813 }
814}
815
816#[derive(Debug)]
817pub enum ScenicRealmFactoryEvent {
818 #[non_exhaustive]
819 _UnknownEvent {
820 ordinal: u64,
822 },
823}
824
825impl ScenicRealmFactoryEvent {
826 fn decode(
828 mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
829 ) -> Result<ScenicRealmFactoryEvent, fidl::Error> {
830 let (bytes, _handles) = buf.split_mut();
831 let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
832 debug_assert_eq!(tx_header.tx_id, 0);
833 match tx_header.ordinal {
834 _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
835 Ok(ScenicRealmFactoryEvent::_UnknownEvent { ordinal: tx_header.ordinal })
836 }
837 _ => Err(fidl::Error::UnknownOrdinal {
838 ordinal: tx_header.ordinal,
839 protocol_name:
840 <ScenicRealmFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
841 }),
842 }
843 }
844}
845
846pub struct ScenicRealmFactoryRequestStream {
848 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
849 is_terminated: bool,
850}
851
852impl std::marker::Unpin for ScenicRealmFactoryRequestStream {}
853
854impl futures::stream::FusedStream for ScenicRealmFactoryRequestStream {
855 fn is_terminated(&self) -> bool {
856 self.is_terminated
857 }
858}
859
860impl fidl::endpoints::RequestStream for ScenicRealmFactoryRequestStream {
861 type Protocol = ScenicRealmFactoryMarker;
862 type ControlHandle = ScenicRealmFactoryControlHandle;
863
864 fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
865 Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
866 }
867
868 fn control_handle(&self) -> Self::ControlHandle {
869 ScenicRealmFactoryControlHandle { inner: self.inner.clone() }
870 }
871
872 fn into_inner(
873 self,
874 ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
875 {
876 (self.inner, self.is_terminated)
877 }
878
879 fn from_inner(
880 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
881 is_terminated: bool,
882 ) -> Self {
883 Self { inner, is_terminated }
884 }
885}
886
887impl futures::Stream for ScenicRealmFactoryRequestStream {
888 type Item = Result<ScenicRealmFactoryRequest, fidl::Error>;
889
890 fn poll_next(
891 mut self: std::pin::Pin<&mut Self>,
892 cx: &mut std::task::Context<'_>,
893 ) -> std::task::Poll<Option<Self::Item>> {
894 let this = &mut *self;
895 if this.inner.check_shutdown(cx) {
896 this.is_terminated = true;
897 return std::task::Poll::Ready(None);
898 }
899 if this.is_terminated {
900 panic!("polled ScenicRealmFactoryRequestStream after completion");
901 }
902 fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
903 |bytes, handles| {
904 match this.inner.channel().read_etc(cx, bytes, handles) {
905 std::task::Poll::Ready(Ok(())) => {}
906 std::task::Poll::Pending => return std::task::Poll::Pending,
907 std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
908 this.is_terminated = true;
909 return std::task::Poll::Ready(None);
910 }
911 std::task::Poll::Ready(Err(e)) => {
912 return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
913 e.into(),
914 ))));
915 }
916 }
917
918 let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
920
921 std::task::Poll::Ready(Some(match header.ordinal {
922 0x11f2157d1648e6ba => {
923 header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
924 let mut req = fidl::new_empty!(ScenicRealmFactoryCreateRealmRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
925 fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ScenicRealmFactoryCreateRealmRequest>(&header, _body_bytes, handles, &mut req)?;
926 let control_handle = ScenicRealmFactoryControlHandle {
927 inner: this.inner.clone(),
928 };
929 Ok(ScenicRealmFactoryRequest::CreateRealm {payload: req,
930 responder: ScenicRealmFactoryCreateRealmResponder {
931 control_handle: std::mem::ManuallyDrop::new(control_handle),
932 tx_id: header.tx_id,
933 },
934 })
935 }
936 _ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
937 Ok(ScenicRealmFactoryRequest::_UnknownMethod {
938 ordinal: header.ordinal,
939 control_handle: ScenicRealmFactoryControlHandle { inner: this.inner.clone() },
940 method_type: fidl::MethodType::OneWay,
941 })
942 }
943 _ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
944 this.inner.send_framework_err(
945 fidl::encoding::FrameworkErr::UnknownMethod,
946 header.tx_id,
947 header.ordinal,
948 header.dynamic_flags(),
949 (bytes, handles),
950 )?;
951 Ok(ScenicRealmFactoryRequest::_UnknownMethod {
952 ordinal: header.ordinal,
953 control_handle: ScenicRealmFactoryControlHandle { inner: this.inner.clone() },
954 method_type: fidl::MethodType::TwoWay,
955 })
956 }
957 _ => Err(fidl::Error::UnknownOrdinal {
958 ordinal: header.ordinal,
959 protocol_name: <ScenicRealmFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
960 }),
961 }))
962 },
963 )
964 }
965}
966
967#[derive(Debug)]
971pub enum ScenicRealmFactoryRequest {
972 CreateRealm {
973 payload: ScenicRealmFactoryCreateRealmRequest,
974 responder: ScenicRealmFactoryCreateRealmResponder,
975 },
976 #[non_exhaustive]
978 _UnknownMethod {
979 ordinal: u64,
981 control_handle: ScenicRealmFactoryControlHandle,
982 method_type: fidl::MethodType,
983 },
984}
985
986impl ScenicRealmFactoryRequest {
987 #[allow(irrefutable_let_patterns)]
988 pub fn into_create_realm(
989 self,
990 ) -> Option<(ScenicRealmFactoryCreateRealmRequest, ScenicRealmFactoryCreateRealmResponder)>
991 {
992 if let ScenicRealmFactoryRequest::CreateRealm { payload, responder } = self {
993 Some((payload, responder))
994 } else {
995 None
996 }
997 }
998
999 pub fn method_name(&self) -> &'static str {
1001 match *self {
1002 ScenicRealmFactoryRequest::CreateRealm { .. } => "create_realm",
1003 ScenicRealmFactoryRequest::_UnknownMethod {
1004 method_type: fidl::MethodType::OneWay,
1005 ..
1006 } => "unknown one-way method",
1007 ScenicRealmFactoryRequest::_UnknownMethod {
1008 method_type: fidl::MethodType::TwoWay,
1009 ..
1010 } => "unknown two-way method",
1011 }
1012 }
1013}
1014
1015#[derive(Debug, Clone)]
1016pub struct ScenicRealmFactoryControlHandle {
1017 inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1018}
1019
1020impl fidl::endpoints::ControlHandle for ScenicRealmFactoryControlHandle {
1021 fn shutdown(&self) {
1022 self.inner.shutdown()
1023 }
1024 fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1025 self.inner.shutdown_with_epitaph(status)
1026 }
1027
1028 fn is_closed(&self) -> bool {
1029 self.inner.channel().is_closed()
1030 }
1031 fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1032 self.inner.channel().on_closed()
1033 }
1034
1035 #[cfg(target_os = "fuchsia")]
1036 fn signal_peer(
1037 &self,
1038 clear_mask: zx::Signals,
1039 set_mask: zx::Signals,
1040 ) -> Result<(), zx_status::Status> {
1041 use fidl::Peered;
1042 self.inner.channel().signal_peer(clear_mask, set_mask)
1043 }
1044}
1045
1046impl ScenicRealmFactoryControlHandle {}
1047
1048#[must_use = "FIDL methods require a response to be sent"]
1049#[derive(Debug)]
1050pub struct ScenicRealmFactoryCreateRealmResponder {
1051 control_handle: std::mem::ManuallyDrop<ScenicRealmFactoryControlHandle>,
1052 tx_id: u32,
1053}
1054
1055impl std::ops::Drop for ScenicRealmFactoryCreateRealmResponder {
1059 fn drop(&mut self) {
1060 self.control_handle.shutdown();
1061 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1063 }
1064}
1065
1066impl fidl::endpoints::Responder for ScenicRealmFactoryCreateRealmResponder {
1067 type ControlHandle = ScenicRealmFactoryControlHandle;
1068
1069 fn control_handle(&self) -> &ScenicRealmFactoryControlHandle {
1070 &self.control_handle
1071 }
1072
1073 fn drop_without_shutdown(mut self) {
1074 unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1076 std::mem::forget(self);
1078 }
1079}
1080
1081impl ScenicRealmFactoryCreateRealmResponder {
1082 pub fn send(
1086 self,
1087 mut result: Result<(), fidl_fuchsia_testing_harness::OperationError>,
1088 ) -> Result<(), fidl::Error> {
1089 let _result = self.send_raw(result);
1090 if _result.is_err() {
1091 self.control_handle.shutdown();
1092 }
1093 self.drop_without_shutdown();
1094 _result
1095 }
1096
1097 pub fn send_no_shutdown_on_err(
1099 self,
1100 mut result: Result<(), fidl_fuchsia_testing_harness::OperationError>,
1101 ) -> Result<(), fidl::Error> {
1102 let _result = self.send_raw(result);
1103 self.drop_without_shutdown();
1104 _result
1105 }
1106
1107 fn send_raw(
1108 &self,
1109 mut result: Result<(), fidl_fuchsia_testing_harness::OperationError>,
1110 ) -> Result<(), fidl::Error> {
1111 self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
1112 fidl::encoding::EmptyStruct,
1113 fidl_fuchsia_testing_harness::OperationError,
1114 >>(
1115 fidl::encoding::FlexibleResult::new(result),
1116 self.tx_id,
1117 0x11f2157d1648e6ba,
1118 fidl::encoding::DynamicFlags::FLEXIBLE,
1119 )
1120 }
1121}
1122
1123mod internal {
1124 use super::*;
1125
1126 impl RealmFactoryCreateRealmRequest {
1127 #[inline(always)]
1128 fn max_ordinal_present(&self) -> u64 {
1129 if let Some(_) = self.display_max_layer_count {
1130 return 6;
1131 }
1132 if let Some(_) = self.display_refresh_rate_millihertz {
1133 return 5;
1134 }
1135 if let Some(_) = self.display_dimensions {
1136 return 4;
1137 }
1138 if let Some(_) = self.device_pixel_ratio {
1139 return 3;
1140 }
1141 if let Some(_) = self.display_rotation {
1142 return 2;
1143 }
1144 if let Some(_) = self.realm_server {
1145 return 1;
1146 }
1147 0
1148 }
1149 }
1150
1151 impl fidl::encoding::ResourceTypeMarker for RealmFactoryCreateRealmRequest {
1152 type Borrowed<'a> = &'a mut Self;
1153 fn take_or_borrow<'a>(
1154 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1155 ) -> Self::Borrowed<'a> {
1156 value
1157 }
1158 }
1159
1160 unsafe impl fidl::encoding::TypeMarker for RealmFactoryCreateRealmRequest {
1161 type Owned = Self;
1162
1163 #[inline(always)]
1164 fn inline_align(_context: fidl::encoding::Context) -> usize {
1165 8
1166 }
1167
1168 #[inline(always)]
1169 fn inline_size(_context: fidl::encoding::Context) -> usize {
1170 16
1171 }
1172 }
1173
1174 unsafe impl
1175 fidl::encoding::Encode<
1176 RealmFactoryCreateRealmRequest,
1177 fidl::encoding::DefaultFuchsiaResourceDialect,
1178 > for &mut RealmFactoryCreateRealmRequest
1179 {
1180 unsafe fn encode(
1181 self,
1182 encoder: &mut fidl::encoding::Encoder<
1183 '_,
1184 fidl::encoding::DefaultFuchsiaResourceDialect,
1185 >,
1186 offset: usize,
1187 mut depth: fidl::encoding::Depth,
1188 ) -> fidl::Result<()> {
1189 encoder.debug_check_bounds::<RealmFactoryCreateRealmRequest>(offset);
1190 let max_ordinal: u64 = self.max_ordinal_present();
1192 encoder.write_num(max_ordinal, offset);
1193 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1194 if max_ordinal == 0 {
1196 return Ok(());
1197 }
1198 depth.increment()?;
1199 let envelope_size = 8;
1200 let bytes_len = max_ordinal as usize * envelope_size;
1201 #[allow(unused_variables)]
1202 let offset = encoder.out_of_line_offset(bytes_len);
1203 let mut _prev_end_offset: usize = 0;
1204 if 1 > max_ordinal {
1205 return Ok(());
1206 }
1207
1208 let cur_offset: usize = (1 - 1) * envelope_size;
1211
1212 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1214
1215 fidl::encoding::encode_in_envelope_optional::<
1220 fidl::encoding::Endpoint<
1221 fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
1222 >,
1223 fidl::encoding::DefaultFuchsiaResourceDialect,
1224 >(
1225 self.realm_server.as_mut().map(
1226 <fidl::encoding::Endpoint<
1227 fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
1228 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
1229 ),
1230 encoder,
1231 offset + cur_offset,
1232 depth,
1233 )?;
1234
1235 _prev_end_offset = cur_offset + envelope_size;
1236 if 2 > max_ordinal {
1237 return Ok(());
1238 }
1239
1240 let cur_offset: usize = (2 - 1) * envelope_size;
1243
1244 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1246
1247 fidl::encoding::encode_in_envelope_optional::<
1252 u32,
1253 fidl::encoding::DefaultFuchsiaResourceDialect,
1254 >(
1255 self.display_rotation
1256 .as_ref()
1257 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1258 encoder,
1259 offset + cur_offset,
1260 depth,
1261 )?;
1262
1263 _prev_end_offset = cur_offset + envelope_size;
1264 if 3 > max_ordinal {
1265 return Ok(());
1266 }
1267
1268 let cur_offset: usize = (3 - 1) * envelope_size;
1271
1272 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1274
1275 fidl::encoding::encode_in_envelope_optional::<
1280 f32,
1281 fidl::encoding::DefaultFuchsiaResourceDialect,
1282 >(
1283 self.device_pixel_ratio
1284 .as_ref()
1285 .map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
1286 encoder,
1287 offset + cur_offset,
1288 depth,
1289 )?;
1290
1291 _prev_end_offset = cur_offset + envelope_size;
1292 if 4 > max_ordinal {
1293 return Ok(());
1294 }
1295
1296 let cur_offset: usize = (4 - 1) * envelope_size;
1299
1300 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1302
1303 fidl::encoding::encode_in_envelope_optional::<
1308 fidl_fuchsia_math::SizeU,
1309 fidl::encoding::DefaultFuchsiaResourceDialect,
1310 >(
1311 self.display_dimensions
1312 .as_ref()
1313 .map(<fidl_fuchsia_math::SizeU as fidl::encoding::ValueTypeMarker>::borrow),
1314 encoder,
1315 offset + cur_offset,
1316 depth,
1317 )?;
1318
1319 _prev_end_offset = cur_offset + envelope_size;
1320 if 5 > max_ordinal {
1321 return Ok(());
1322 }
1323
1324 let cur_offset: usize = (5 - 1) * envelope_size;
1327
1328 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1330
1331 fidl::encoding::encode_in_envelope_optional::<
1336 u32,
1337 fidl::encoding::DefaultFuchsiaResourceDialect,
1338 >(
1339 self.display_refresh_rate_millihertz
1340 .as_ref()
1341 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1342 encoder,
1343 offset + cur_offset,
1344 depth,
1345 )?;
1346
1347 _prev_end_offset = cur_offset + envelope_size;
1348 if 6 > max_ordinal {
1349 return Ok(());
1350 }
1351
1352 let cur_offset: usize = (6 - 1) * envelope_size;
1355
1356 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1358
1359 fidl::encoding::encode_in_envelope_optional::<
1364 u32,
1365 fidl::encoding::DefaultFuchsiaResourceDialect,
1366 >(
1367 self.display_max_layer_count
1368 .as_ref()
1369 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1370 encoder,
1371 offset + cur_offset,
1372 depth,
1373 )?;
1374
1375 _prev_end_offset = cur_offset + envelope_size;
1376
1377 Ok(())
1378 }
1379 }
1380
1381 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1382 for RealmFactoryCreateRealmRequest
1383 {
1384 #[inline(always)]
1385 fn new_empty() -> Self {
1386 Self::default()
1387 }
1388
1389 unsafe fn decode(
1390 &mut self,
1391 decoder: &mut fidl::encoding::Decoder<
1392 '_,
1393 fidl::encoding::DefaultFuchsiaResourceDialect,
1394 >,
1395 offset: usize,
1396 mut depth: fidl::encoding::Depth,
1397 ) -> fidl::Result<()> {
1398 decoder.debug_check_bounds::<Self>(offset);
1399 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1400 None => return Err(fidl::Error::NotNullable),
1401 Some(len) => len,
1402 };
1403 if len == 0 {
1405 return Ok(());
1406 };
1407 depth.increment()?;
1408 let envelope_size = 8;
1409 let bytes_len = len * envelope_size;
1410 let offset = decoder.out_of_line_offset(bytes_len)?;
1411 let mut _next_ordinal_to_read = 0;
1413 let mut next_offset = offset;
1414 let end_offset = offset + bytes_len;
1415 _next_ordinal_to_read += 1;
1416 if next_offset >= end_offset {
1417 return Ok(());
1418 }
1419
1420 while _next_ordinal_to_read < 1 {
1422 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1423 _next_ordinal_to_read += 1;
1424 next_offset += envelope_size;
1425 }
1426
1427 let next_out_of_line = decoder.next_out_of_line();
1428 let handles_before = decoder.remaining_handles();
1429 if let Some((inlined, num_bytes, num_handles)) =
1430 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1431 {
1432 let member_inline_size = <fidl::encoding::Endpoint<
1433 fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
1434 > as fidl::encoding::TypeMarker>::inline_size(
1435 decoder.context
1436 );
1437 if inlined != (member_inline_size <= 4) {
1438 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1439 }
1440 let inner_offset;
1441 let mut inner_depth = depth.clone();
1442 if inlined {
1443 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1444 inner_offset = next_offset;
1445 } else {
1446 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1447 inner_depth.increment()?;
1448 }
1449 let val_ref = self.realm_server.get_or_insert_with(|| {
1450 fidl::new_empty!(
1451 fidl::encoding::Endpoint<
1452 fidl::endpoints::ServerEnd<
1453 fidl_fuchsia_testing_harness::RealmProxy_Marker,
1454 >,
1455 >,
1456 fidl::encoding::DefaultFuchsiaResourceDialect
1457 )
1458 });
1459 fidl::decode!(
1460 fidl::encoding::Endpoint<
1461 fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
1462 >,
1463 fidl::encoding::DefaultFuchsiaResourceDialect,
1464 val_ref,
1465 decoder,
1466 inner_offset,
1467 inner_depth
1468 )?;
1469 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1470 {
1471 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1472 }
1473 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1474 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1475 }
1476 }
1477
1478 next_offset += envelope_size;
1479 _next_ordinal_to_read += 1;
1480 if next_offset >= end_offset {
1481 return Ok(());
1482 }
1483
1484 while _next_ordinal_to_read < 2 {
1486 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1487 _next_ordinal_to_read += 1;
1488 next_offset += envelope_size;
1489 }
1490
1491 let next_out_of_line = decoder.next_out_of_line();
1492 let handles_before = decoder.remaining_handles();
1493 if let Some((inlined, num_bytes, num_handles)) =
1494 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1495 {
1496 let member_inline_size =
1497 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1498 if inlined != (member_inline_size <= 4) {
1499 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1500 }
1501 let inner_offset;
1502 let mut inner_depth = depth.clone();
1503 if inlined {
1504 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1505 inner_offset = next_offset;
1506 } else {
1507 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1508 inner_depth.increment()?;
1509 }
1510 let val_ref = self.display_rotation.get_or_insert_with(|| {
1511 fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
1512 });
1513 fidl::decode!(
1514 u32,
1515 fidl::encoding::DefaultFuchsiaResourceDialect,
1516 val_ref,
1517 decoder,
1518 inner_offset,
1519 inner_depth
1520 )?;
1521 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1522 {
1523 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1524 }
1525 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1526 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1527 }
1528 }
1529
1530 next_offset += envelope_size;
1531 _next_ordinal_to_read += 1;
1532 if next_offset >= end_offset {
1533 return Ok(());
1534 }
1535
1536 while _next_ordinal_to_read < 3 {
1538 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1539 _next_ordinal_to_read += 1;
1540 next_offset += envelope_size;
1541 }
1542
1543 let next_out_of_line = decoder.next_out_of_line();
1544 let handles_before = decoder.remaining_handles();
1545 if let Some((inlined, num_bytes, num_handles)) =
1546 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1547 {
1548 let member_inline_size =
1549 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1550 if inlined != (member_inline_size <= 4) {
1551 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1552 }
1553 let inner_offset;
1554 let mut inner_depth = depth.clone();
1555 if inlined {
1556 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1557 inner_offset = next_offset;
1558 } else {
1559 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1560 inner_depth.increment()?;
1561 }
1562 let val_ref = self.device_pixel_ratio.get_or_insert_with(|| {
1563 fidl::new_empty!(f32, fidl::encoding::DefaultFuchsiaResourceDialect)
1564 });
1565 fidl::decode!(
1566 f32,
1567 fidl::encoding::DefaultFuchsiaResourceDialect,
1568 val_ref,
1569 decoder,
1570 inner_offset,
1571 inner_depth
1572 )?;
1573 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1574 {
1575 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1576 }
1577 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1578 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1579 }
1580 }
1581
1582 next_offset += envelope_size;
1583 _next_ordinal_to_read += 1;
1584 if next_offset >= end_offset {
1585 return Ok(());
1586 }
1587
1588 while _next_ordinal_to_read < 4 {
1590 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1591 _next_ordinal_to_read += 1;
1592 next_offset += envelope_size;
1593 }
1594
1595 let next_out_of_line = decoder.next_out_of_line();
1596 let handles_before = decoder.remaining_handles();
1597 if let Some((inlined, num_bytes, num_handles)) =
1598 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1599 {
1600 let member_inline_size =
1601 <fidl_fuchsia_math::SizeU as fidl::encoding::TypeMarker>::inline_size(
1602 decoder.context,
1603 );
1604 if inlined != (member_inline_size <= 4) {
1605 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1606 }
1607 let inner_offset;
1608 let mut inner_depth = depth.clone();
1609 if inlined {
1610 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1611 inner_offset = next_offset;
1612 } else {
1613 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1614 inner_depth.increment()?;
1615 }
1616 let val_ref = self.display_dimensions.get_or_insert_with(|| {
1617 fidl::new_empty!(
1618 fidl_fuchsia_math::SizeU,
1619 fidl::encoding::DefaultFuchsiaResourceDialect
1620 )
1621 });
1622 fidl::decode!(
1623 fidl_fuchsia_math::SizeU,
1624 fidl::encoding::DefaultFuchsiaResourceDialect,
1625 val_ref,
1626 decoder,
1627 inner_offset,
1628 inner_depth
1629 )?;
1630 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1631 {
1632 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1633 }
1634 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1635 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1636 }
1637 }
1638
1639 next_offset += envelope_size;
1640 _next_ordinal_to_read += 1;
1641 if next_offset >= end_offset {
1642 return Ok(());
1643 }
1644
1645 while _next_ordinal_to_read < 5 {
1647 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1648 _next_ordinal_to_read += 1;
1649 next_offset += envelope_size;
1650 }
1651
1652 let next_out_of_line = decoder.next_out_of_line();
1653 let handles_before = decoder.remaining_handles();
1654 if let Some((inlined, num_bytes, num_handles)) =
1655 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1656 {
1657 let member_inline_size =
1658 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1659 if inlined != (member_inline_size <= 4) {
1660 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1661 }
1662 let inner_offset;
1663 let mut inner_depth = depth.clone();
1664 if inlined {
1665 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1666 inner_offset = next_offset;
1667 } else {
1668 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1669 inner_depth.increment()?;
1670 }
1671 let val_ref = self.display_refresh_rate_millihertz.get_or_insert_with(|| {
1672 fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
1673 });
1674 fidl::decode!(
1675 u32,
1676 fidl::encoding::DefaultFuchsiaResourceDialect,
1677 val_ref,
1678 decoder,
1679 inner_offset,
1680 inner_depth
1681 )?;
1682 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1683 {
1684 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1685 }
1686 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1687 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1688 }
1689 }
1690
1691 next_offset += envelope_size;
1692 _next_ordinal_to_read += 1;
1693 if next_offset >= end_offset {
1694 return Ok(());
1695 }
1696
1697 while _next_ordinal_to_read < 6 {
1699 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1700 _next_ordinal_to_read += 1;
1701 next_offset += envelope_size;
1702 }
1703
1704 let next_out_of_line = decoder.next_out_of_line();
1705 let handles_before = decoder.remaining_handles();
1706 if let Some((inlined, num_bytes, num_handles)) =
1707 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1708 {
1709 let member_inline_size =
1710 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1711 if inlined != (member_inline_size <= 4) {
1712 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1713 }
1714 let inner_offset;
1715 let mut inner_depth = depth.clone();
1716 if inlined {
1717 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1718 inner_offset = next_offset;
1719 } else {
1720 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1721 inner_depth.increment()?;
1722 }
1723 let val_ref = self.display_max_layer_count.get_or_insert_with(|| {
1724 fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
1725 });
1726 fidl::decode!(
1727 u32,
1728 fidl::encoding::DefaultFuchsiaResourceDialect,
1729 val_ref,
1730 decoder,
1731 inner_offset,
1732 inner_depth
1733 )?;
1734 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1735 {
1736 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1737 }
1738 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1739 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1740 }
1741 }
1742
1743 next_offset += envelope_size;
1744
1745 while next_offset < end_offset {
1747 _next_ordinal_to_read += 1;
1748 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1749 next_offset += envelope_size;
1750 }
1751
1752 Ok(())
1753 }
1754 }
1755
1756 impl ScenicRealmFactoryCreateRealmRequest {
1757 #[inline(always)]
1758 fn max_ordinal_present(&self) -> u64 {
1759 if let Some(_) = self.display_max_layer_count {
1760 return 7;
1761 }
1762 if let Some(_) = self.display_refresh_rate_millihertz {
1763 return 6;
1764 }
1765 if let Some(_) = self.display_dimensions {
1766 return 5;
1767 }
1768 if let Some(_) = self.display_composition {
1769 return 4;
1770 }
1771 if let Some(_) = self.display_rotation {
1772 return 3;
1773 }
1774 if let Some(_) = self.renderer {
1775 return 2;
1776 }
1777 if let Some(_) = self.realm_server {
1778 return 1;
1779 }
1780 0
1781 }
1782 }
1783
1784 impl fidl::encoding::ResourceTypeMarker for ScenicRealmFactoryCreateRealmRequest {
1785 type Borrowed<'a> = &'a mut Self;
1786 fn take_or_borrow<'a>(
1787 value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1788 ) -> Self::Borrowed<'a> {
1789 value
1790 }
1791 }
1792
1793 unsafe impl fidl::encoding::TypeMarker for ScenicRealmFactoryCreateRealmRequest {
1794 type Owned = Self;
1795
1796 #[inline(always)]
1797 fn inline_align(_context: fidl::encoding::Context) -> usize {
1798 8
1799 }
1800
1801 #[inline(always)]
1802 fn inline_size(_context: fidl::encoding::Context) -> usize {
1803 16
1804 }
1805 }
1806
1807 unsafe impl
1808 fidl::encoding::Encode<
1809 ScenicRealmFactoryCreateRealmRequest,
1810 fidl::encoding::DefaultFuchsiaResourceDialect,
1811 > for &mut ScenicRealmFactoryCreateRealmRequest
1812 {
1813 unsafe fn encode(
1814 self,
1815 encoder: &mut fidl::encoding::Encoder<
1816 '_,
1817 fidl::encoding::DefaultFuchsiaResourceDialect,
1818 >,
1819 offset: usize,
1820 mut depth: fidl::encoding::Depth,
1821 ) -> fidl::Result<()> {
1822 encoder.debug_check_bounds::<ScenicRealmFactoryCreateRealmRequest>(offset);
1823 let max_ordinal: u64 = self.max_ordinal_present();
1825 encoder.write_num(max_ordinal, offset);
1826 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1827 if max_ordinal == 0 {
1829 return Ok(());
1830 }
1831 depth.increment()?;
1832 let envelope_size = 8;
1833 let bytes_len = max_ordinal as usize * envelope_size;
1834 #[allow(unused_variables)]
1835 let offset = encoder.out_of_line_offset(bytes_len);
1836 let mut _prev_end_offset: usize = 0;
1837 if 1 > max_ordinal {
1838 return Ok(());
1839 }
1840
1841 let cur_offset: usize = (1 - 1) * envelope_size;
1844
1845 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1847
1848 fidl::encoding::encode_in_envelope_optional::<
1853 fidl::encoding::Endpoint<
1854 fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
1855 >,
1856 fidl::encoding::DefaultFuchsiaResourceDialect,
1857 >(
1858 self.realm_server.as_mut().map(
1859 <fidl::encoding::Endpoint<
1860 fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
1861 > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
1862 ),
1863 encoder,
1864 offset + cur_offset,
1865 depth,
1866 )?;
1867
1868 _prev_end_offset = cur_offset + envelope_size;
1869 if 2 > max_ordinal {
1870 return Ok(());
1871 }
1872
1873 let cur_offset: usize = (2 - 1) * envelope_size;
1876
1877 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1879
1880 fidl::encoding::encode_in_envelope_optional::<
1885 RendererType,
1886 fidl::encoding::DefaultFuchsiaResourceDialect,
1887 >(
1888 self.renderer
1889 .as_ref()
1890 .map(<RendererType as fidl::encoding::ValueTypeMarker>::borrow),
1891 encoder,
1892 offset + cur_offset,
1893 depth,
1894 )?;
1895
1896 _prev_end_offset = cur_offset + envelope_size;
1897 if 3 > max_ordinal {
1898 return Ok(());
1899 }
1900
1901 let cur_offset: usize = (3 - 1) * envelope_size;
1904
1905 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1907
1908 fidl::encoding::encode_in_envelope_optional::<
1913 u64,
1914 fidl::encoding::DefaultFuchsiaResourceDialect,
1915 >(
1916 self.display_rotation
1917 .as_ref()
1918 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1919 encoder,
1920 offset + cur_offset,
1921 depth,
1922 )?;
1923
1924 _prev_end_offset = cur_offset + envelope_size;
1925 if 4 > max_ordinal {
1926 return Ok(());
1927 }
1928
1929 let cur_offset: usize = (4 - 1) * envelope_size;
1932
1933 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1935
1936 fidl::encoding::encode_in_envelope_optional::<
1941 bool,
1942 fidl::encoding::DefaultFuchsiaResourceDialect,
1943 >(
1944 self.display_composition
1945 .as_ref()
1946 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1947 encoder,
1948 offset + cur_offset,
1949 depth,
1950 )?;
1951
1952 _prev_end_offset = cur_offset + envelope_size;
1953 if 5 > max_ordinal {
1954 return Ok(());
1955 }
1956
1957 let cur_offset: usize = (5 - 1) * envelope_size;
1960
1961 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1963
1964 fidl::encoding::encode_in_envelope_optional::<
1969 fidl_fuchsia_math::SizeU,
1970 fidl::encoding::DefaultFuchsiaResourceDialect,
1971 >(
1972 self.display_dimensions
1973 .as_ref()
1974 .map(<fidl_fuchsia_math::SizeU as fidl::encoding::ValueTypeMarker>::borrow),
1975 encoder,
1976 offset + cur_offset,
1977 depth,
1978 )?;
1979
1980 _prev_end_offset = cur_offset + envelope_size;
1981 if 6 > max_ordinal {
1982 return Ok(());
1983 }
1984
1985 let cur_offset: usize = (6 - 1) * envelope_size;
1988
1989 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1991
1992 fidl::encoding::encode_in_envelope_optional::<
1997 u32,
1998 fidl::encoding::DefaultFuchsiaResourceDialect,
1999 >(
2000 self.display_refresh_rate_millihertz
2001 .as_ref()
2002 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2003 encoder,
2004 offset + cur_offset,
2005 depth,
2006 )?;
2007
2008 _prev_end_offset = cur_offset + envelope_size;
2009 if 7 > max_ordinal {
2010 return Ok(());
2011 }
2012
2013 let cur_offset: usize = (7 - 1) * envelope_size;
2016
2017 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2019
2020 fidl::encoding::encode_in_envelope_optional::<
2025 u32,
2026 fidl::encoding::DefaultFuchsiaResourceDialect,
2027 >(
2028 self.display_max_layer_count
2029 .as_ref()
2030 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2031 encoder,
2032 offset + cur_offset,
2033 depth,
2034 )?;
2035
2036 _prev_end_offset = cur_offset + envelope_size;
2037
2038 Ok(())
2039 }
2040 }
2041
2042 impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2043 for ScenicRealmFactoryCreateRealmRequest
2044 {
2045 #[inline(always)]
2046 fn new_empty() -> Self {
2047 Self::default()
2048 }
2049
2050 unsafe fn decode(
2051 &mut self,
2052 decoder: &mut fidl::encoding::Decoder<
2053 '_,
2054 fidl::encoding::DefaultFuchsiaResourceDialect,
2055 >,
2056 offset: usize,
2057 mut depth: fidl::encoding::Depth,
2058 ) -> fidl::Result<()> {
2059 decoder.debug_check_bounds::<Self>(offset);
2060 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2061 None => return Err(fidl::Error::NotNullable),
2062 Some(len) => len,
2063 };
2064 if len == 0 {
2066 return Ok(());
2067 };
2068 depth.increment()?;
2069 let envelope_size = 8;
2070 let bytes_len = len * envelope_size;
2071 let offset = decoder.out_of_line_offset(bytes_len)?;
2072 let mut _next_ordinal_to_read = 0;
2074 let mut next_offset = offset;
2075 let end_offset = offset + bytes_len;
2076 _next_ordinal_to_read += 1;
2077 if next_offset >= end_offset {
2078 return Ok(());
2079 }
2080
2081 while _next_ordinal_to_read < 1 {
2083 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2084 _next_ordinal_to_read += 1;
2085 next_offset += envelope_size;
2086 }
2087
2088 let next_out_of_line = decoder.next_out_of_line();
2089 let handles_before = decoder.remaining_handles();
2090 if let Some((inlined, num_bytes, num_handles)) =
2091 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2092 {
2093 let member_inline_size = <fidl::encoding::Endpoint<
2094 fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
2095 > as fidl::encoding::TypeMarker>::inline_size(
2096 decoder.context
2097 );
2098 if inlined != (member_inline_size <= 4) {
2099 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2100 }
2101 let inner_offset;
2102 let mut inner_depth = depth.clone();
2103 if inlined {
2104 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2105 inner_offset = next_offset;
2106 } else {
2107 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2108 inner_depth.increment()?;
2109 }
2110 let val_ref = self.realm_server.get_or_insert_with(|| {
2111 fidl::new_empty!(
2112 fidl::encoding::Endpoint<
2113 fidl::endpoints::ServerEnd<
2114 fidl_fuchsia_testing_harness::RealmProxy_Marker,
2115 >,
2116 >,
2117 fidl::encoding::DefaultFuchsiaResourceDialect
2118 )
2119 });
2120 fidl::decode!(
2121 fidl::encoding::Endpoint<
2122 fidl::endpoints::ServerEnd<fidl_fuchsia_testing_harness::RealmProxy_Marker>,
2123 >,
2124 fidl::encoding::DefaultFuchsiaResourceDialect,
2125 val_ref,
2126 decoder,
2127 inner_offset,
2128 inner_depth
2129 )?;
2130 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2131 {
2132 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2133 }
2134 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2135 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2136 }
2137 }
2138
2139 next_offset += envelope_size;
2140 _next_ordinal_to_read += 1;
2141 if next_offset >= end_offset {
2142 return Ok(());
2143 }
2144
2145 while _next_ordinal_to_read < 2 {
2147 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2148 _next_ordinal_to_read += 1;
2149 next_offset += envelope_size;
2150 }
2151
2152 let next_out_of_line = decoder.next_out_of_line();
2153 let handles_before = decoder.remaining_handles();
2154 if let Some((inlined, num_bytes, num_handles)) =
2155 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2156 {
2157 let member_inline_size =
2158 <RendererType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2159 if inlined != (member_inline_size <= 4) {
2160 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2161 }
2162 let inner_offset;
2163 let mut inner_depth = depth.clone();
2164 if inlined {
2165 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2166 inner_offset = next_offset;
2167 } else {
2168 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2169 inner_depth.increment()?;
2170 }
2171 let val_ref = self.renderer.get_or_insert_with(|| {
2172 fidl::new_empty!(RendererType, fidl::encoding::DefaultFuchsiaResourceDialect)
2173 });
2174 fidl::decode!(
2175 RendererType,
2176 fidl::encoding::DefaultFuchsiaResourceDialect,
2177 val_ref,
2178 decoder,
2179 inner_offset,
2180 inner_depth
2181 )?;
2182 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2183 {
2184 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2185 }
2186 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2187 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2188 }
2189 }
2190
2191 next_offset += envelope_size;
2192 _next_ordinal_to_read += 1;
2193 if next_offset >= end_offset {
2194 return Ok(());
2195 }
2196
2197 while _next_ordinal_to_read < 3 {
2199 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2200 _next_ordinal_to_read += 1;
2201 next_offset += envelope_size;
2202 }
2203
2204 let next_out_of_line = decoder.next_out_of_line();
2205 let handles_before = decoder.remaining_handles();
2206 if let Some((inlined, num_bytes, num_handles)) =
2207 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2208 {
2209 let member_inline_size =
2210 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2211 if inlined != (member_inline_size <= 4) {
2212 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2213 }
2214 let inner_offset;
2215 let mut inner_depth = depth.clone();
2216 if inlined {
2217 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2218 inner_offset = next_offset;
2219 } else {
2220 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2221 inner_depth.increment()?;
2222 }
2223 let val_ref = self.display_rotation.get_or_insert_with(|| {
2224 fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
2225 });
2226 fidl::decode!(
2227 u64,
2228 fidl::encoding::DefaultFuchsiaResourceDialect,
2229 val_ref,
2230 decoder,
2231 inner_offset,
2232 inner_depth
2233 )?;
2234 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2235 {
2236 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2237 }
2238 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2239 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2240 }
2241 }
2242
2243 next_offset += envelope_size;
2244 _next_ordinal_to_read += 1;
2245 if next_offset >= end_offset {
2246 return Ok(());
2247 }
2248
2249 while _next_ordinal_to_read < 4 {
2251 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2252 _next_ordinal_to_read += 1;
2253 next_offset += envelope_size;
2254 }
2255
2256 let next_out_of_line = decoder.next_out_of_line();
2257 let handles_before = decoder.remaining_handles();
2258 if let Some((inlined, num_bytes, num_handles)) =
2259 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2260 {
2261 let member_inline_size =
2262 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2263 if inlined != (member_inline_size <= 4) {
2264 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2265 }
2266 let inner_offset;
2267 let mut inner_depth = depth.clone();
2268 if inlined {
2269 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2270 inner_offset = next_offset;
2271 } else {
2272 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2273 inner_depth.increment()?;
2274 }
2275 let val_ref = self.display_composition.get_or_insert_with(|| {
2276 fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
2277 });
2278 fidl::decode!(
2279 bool,
2280 fidl::encoding::DefaultFuchsiaResourceDialect,
2281 val_ref,
2282 decoder,
2283 inner_offset,
2284 inner_depth
2285 )?;
2286 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2287 {
2288 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2289 }
2290 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2291 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2292 }
2293 }
2294
2295 next_offset += envelope_size;
2296 _next_ordinal_to_read += 1;
2297 if next_offset >= end_offset {
2298 return Ok(());
2299 }
2300
2301 while _next_ordinal_to_read < 5 {
2303 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2304 _next_ordinal_to_read += 1;
2305 next_offset += envelope_size;
2306 }
2307
2308 let next_out_of_line = decoder.next_out_of_line();
2309 let handles_before = decoder.remaining_handles();
2310 if let Some((inlined, num_bytes, num_handles)) =
2311 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2312 {
2313 let member_inline_size =
2314 <fidl_fuchsia_math::SizeU as fidl::encoding::TypeMarker>::inline_size(
2315 decoder.context,
2316 );
2317 if inlined != (member_inline_size <= 4) {
2318 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2319 }
2320 let inner_offset;
2321 let mut inner_depth = depth.clone();
2322 if inlined {
2323 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2324 inner_offset = next_offset;
2325 } else {
2326 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2327 inner_depth.increment()?;
2328 }
2329 let val_ref = self.display_dimensions.get_or_insert_with(|| {
2330 fidl::new_empty!(
2331 fidl_fuchsia_math::SizeU,
2332 fidl::encoding::DefaultFuchsiaResourceDialect
2333 )
2334 });
2335 fidl::decode!(
2336 fidl_fuchsia_math::SizeU,
2337 fidl::encoding::DefaultFuchsiaResourceDialect,
2338 val_ref,
2339 decoder,
2340 inner_offset,
2341 inner_depth
2342 )?;
2343 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2344 {
2345 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2346 }
2347 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2348 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2349 }
2350 }
2351
2352 next_offset += envelope_size;
2353 _next_ordinal_to_read += 1;
2354 if next_offset >= end_offset {
2355 return Ok(());
2356 }
2357
2358 while _next_ordinal_to_read < 6 {
2360 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2361 _next_ordinal_to_read += 1;
2362 next_offset += envelope_size;
2363 }
2364
2365 let next_out_of_line = decoder.next_out_of_line();
2366 let handles_before = decoder.remaining_handles();
2367 if let Some((inlined, num_bytes, num_handles)) =
2368 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2369 {
2370 let member_inline_size =
2371 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2372 if inlined != (member_inline_size <= 4) {
2373 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2374 }
2375 let inner_offset;
2376 let mut inner_depth = depth.clone();
2377 if inlined {
2378 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2379 inner_offset = next_offset;
2380 } else {
2381 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2382 inner_depth.increment()?;
2383 }
2384 let val_ref = self.display_refresh_rate_millihertz.get_or_insert_with(|| {
2385 fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
2386 });
2387 fidl::decode!(
2388 u32,
2389 fidl::encoding::DefaultFuchsiaResourceDialect,
2390 val_ref,
2391 decoder,
2392 inner_offset,
2393 inner_depth
2394 )?;
2395 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2396 {
2397 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2398 }
2399 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2400 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2401 }
2402 }
2403
2404 next_offset += envelope_size;
2405 _next_ordinal_to_read += 1;
2406 if next_offset >= end_offset {
2407 return Ok(());
2408 }
2409
2410 while _next_ordinal_to_read < 7 {
2412 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2413 _next_ordinal_to_read += 1;
2414 next_offset += envelope_size;
2415 }
2416
2417 let next_out_of_line = decoder.next_out_of_line();
2418 let handles_before = decoder.remaining_handles();
2419 if let Some((inlined, num_bytes, num_handles)) =
2420 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2421 {
2422 let member_inline_size =
2423 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2424 if inlined != (member_inline_size <= 4) {
2425 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2426 }
2427 let inner_offset;
2428 let mut inner_depth = depth.clone();
2429 if inlined {
2430 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2431 inner_offset = next_offset;
2432 } else {
2433 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2434 inner_depth.increment()?;
2435 }
2436 let val_ref = self.display_max_layer_count.get_or_insert_with(|| {
2437 fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
2438 });
2439 fidl::decode!(
2440 u32,
2441 fidl::encoding::DefaultFuchsiaResourceDialect,
2442 val_ref,
2443 decoder,
2444 inner_offset,
2445 inner_depth
2446 )?;
2447 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2448 {
2449 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2450 }
2451 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2452 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2453 }
2454 }
2455
2456 next_offset += envelope_size;
2457
2458 while next_offset < end_offset {
2460 _next_ordinal_to_read += 1;
2461 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2462 next_offset += envelope_size;
2463 }
2464
2465 Ok(())
2466 }
2467 }
2468}