fidl_fuchsia_ui_test_context/
fidl_fuchsia_ui_test_context.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![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    /// Optional. If it has a value, the width and height must not be zero.
21    pub display_dimensions: Option<fidl_fuchsia_math::SizeU>,
22    /// Optional. If it has a value, it must not be zero.
23    pub display_refresh_rate_millihertz: Option<u32>,
24    /// Optional. If it has a value, it must not be zero.
25    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    /// Optional. If it has a value, the width and height must not be zero.
43    pub display_dimensions: Option<fidl_fuchsia_math::SizeU>,
44    /// Optional. If it has a value, it must not be zero.
45    pub display_refresh_rate_millihertz: Option<u32>,
46    /// Optional. If it has a value, it must not be zero.
47    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    /// Waits until an event arrives and returns it. It is safe for other
115    /// threads to make concurrent requests while waiting for an event.
116    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    /// Create a new Proxy for fuchsia.ui.test.context/RealmFactory.
190    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    /// Get a Stream of events from the remote end of the protocol.
196    ///
197    /// # Panics
198    ///
199    /// Panics if the event stream was already taken.
200    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 of the event that was sent.
282        ordinal: u64,
283    },
284}
285
286impl RealmFactoryEvent {
287    /// Decodes a message buffer as a [`RealmFactoryEvent`].
288    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
306/// A Stream of incoming requests for fuchsia.ui.test.context/RealmFactory.
307pub 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                // A message has been received from the channel
379                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/// RealmFactory creates test realm for UI related tests, and give the realm
439/// proxy to test suite so that test suite can access protocols in test realm.
440/// Protocols served by Scenic, SceneManager and A11yManager are available.
441#[derive(Debug)]
442pub enum RealmFactoryRequest {
443    CreateRealm {
444        payload: RealmFactoryCreateRealmRequest,
445        responder: RealmFactoryCreateRealmResponder,
446    },
447    /// An interaction was received which does not match any known method.
448    #[non_exhaustive]
449    _UnknownMethod {
450        /// Ordinal of the method that was called.
451        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    /// Name of the method defined in FIDL
470    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
523/// Set the the channel to be shutdown (see [`RealmFactoryControlHandle::shutdown`])
524/// if the responder is dropped without sending a response, so that the client
525/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
526impl std::ops::Drop for RealmFactoryCreateRealmResponder {
527    fn drop(&mut self) {
528        self.control_handle.shutdown();
529        // Safety: drops once, never accessed again
530        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        // Safety: drops once, never accessed again due to mem::forget
543        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
544        // Prevent Drop from running (which would shut down the channel)
545        std::mem::forget(self);
546    }
547}
548
549impl RealmFactoryCreateRealmResponder {
550    /// Sends a response to the FIDL transaction.
551    ///
552    /// Sets the channel to shutdown if an error occurs.
553    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    /// Similar to "send" but does not shutdown the channel if an error occurs.
566    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    /// Waits until an event arrives and returns it. It is safe for other
651    /// threads to make concurrent requests while waiting for an event.
652    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    /// Create a new Proxy for fuchsia.ui.test.context/ScenicRealmFactory.
726    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    /// Get a Stream of events from the remote end of the protocol.
733    ///
734    /// # Panics
735    ///
736    /// Panics if the event stream was already taken.
737    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 of the event that was sent.
821        ordinal: u64,
822    },
823}
824
825impl ScenicRealmFactoryEvent {
826    /// Decodes a message buffer as a [`ScenicRealmFactoryEvent`].
827    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
846/// A Stream of incoming requests for fuchsia.ui.test.context/ScenicRealmFactory.
847pub 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                // A message has been received from the channel
919                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/// ScenicRealmFactory creates test realm for Scenic related tests, and give
968/// the realm proxy to test suite so that test suite can access protocols in
969/// test realm. Only the protocols served by Scenic are available.
970#[derive(Debug)]
971pub enum ScenicRealmFactoryRequest {
972    CreateRealm {
973        payload: ScenicRealmFactoryCreateRealmRequest,
974        responder: ScenicRealmFactoryCreateRealmResponder,
975    },
976    /// An interaction was received which does not match any known method.
977    #[non_exhaustive]
978    _UnknownMethod {
979        /// Ordinal of the method that was called.
980        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    /// Name of the method defined in FIDL
1000    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
1055/// Set the the channel to be shutdown (see [`ScenicRealmFactoryControlHandle::shutdown`])
1056/// if the responder is dropped without sending a response, so that the client
1057/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1058impl std::ops::Drop for ScenicRealmFactoryCreateRealmResponder {
1059    fn drop(&mut self) {
1060        self.control_handle.shutdown();
1061        // Safety: drops once, never accessed again
1062        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        // Safety: drops once, never accessed again due to mem::forget
1075        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1076        // Prevent Drop from running (which would shut down the channel)
1077        std::mem::forget(self);
1078    }
1079}
1080
1081impl ScenicRealmFactoryCreateRealmResponder {
1082    /// Sends a response to the FIDL transaction.
1083    ///
1084    /// Sets the channel to shutdown if an error occurs.
1085    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    /// Similar to "send" but does not shutdown the channel if an error occurs.
1098    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            // Vector header
1191            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            // Calling encoder.out_of_line_offset(0) is not allowed.
1195            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1209            // are envelope_size bytes.
1210            let cur_offset: usize = (1 - 1) * envelope_size;
1211
1212            // Zero reserved fields.
1213            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1214
1215            // Safety:
1216            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1217            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1218            //   envelope_size bytes, there is always sufficient room.
1219            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1241            // are envelope_size bytes.
1242            let cur_offset: usize = (2 - 1) * envelope_size;
1243
1244            // Zero reserved fields.
1245            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1246
1247            // Safety:
1248            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1249            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1250            //   envelope_size bytes, there is always sufficient room.
1251            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1269            // are envelope_size bytes.
1270            let cur_offset: usize = (3 - 1) * envelope_size;
1271
1272            // Zero reserved fields.
1273            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1274
1275            // Safety:
1276            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1277            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1278            //   envelope_size bytes, there is always sufficient room.
1279            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1297            // are envelope_size bytes.
1298            let cur_offset: usize = (4 - 1) * envelope_size;
1299
1300            // Zero reserved fields.
1301            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1302
1303            // Safety:
1304            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1305            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1306            //   envelope_size bytes, there is always sufficient room.
1307            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1325            // are envelope_size bytes.
1326            let cur_offset: usize = (5 - 1) * envelope_size;
1327
1328            // Zero reserved fields.
1329            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1330
1331            // Safety:
1332            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1333            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1334            //   envelope_size bytes, there is always sufficient room.
1335            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1353            // are envelope_size bytes.
1354            let cur_offset: usize = (6 - 1) * envelope_size;
1355
1356            // Zero reserved fields.
1357            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1358
1359            // Safety:
1360            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1361            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1362            //   envelope_size bytes, there is always sufficient room.
1363            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            // Calling decoder.out_of_line_offset(0) is not allowed.
1404            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            // Decode the envelope for each type.
1412            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            // Decode unknown envelopes for gaps in ordinals.
1421            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            // Decode unknown envelopes for gaps in ordinals.
1485            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            // Decode unknown envelopes for gaps in ordinals.
1537            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            // Decode unknown envelopes for gaps in ordinals.
1589            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            // Decode unknown envelopes for gaps in ordinals.
1646            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            // Decode unknown envelopes for gaps in ordinals.
1698            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            // Decode the remaining unknown envelopes.
1746            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            // Vector header
1824            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            // Calling encoder.out_of_line_offset(0) is not allowed.
1828            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1842            // are envelope_size bytes.
1843            let cur_offset: usize = (1 - 1) * envelope_size;
1844
1845            // Zero reserved fields.
1846            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1847
1848            // Safety:
1849            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1850            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1851            //   envelope_size bytes, there is always sufficient room.
1852            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1874            // are envelope_size bytes.
1875            let cur_offset: usize = (2 - 1) * envelope_size;
1876
1877            // Zero reserved fields.
1878            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1879
1880            // Safety:
1881            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1882            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1883            //   envelope_size bytes, there is always sufficient room.
1884            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1902            // are envelope_size bytes.
1903            let cur_offset: usize = (3 - 1) * envelope_size;
1904
1905            // Zero reserved fields.
1906            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1907
1908            // Safety:
1909            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1910            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1911            //   envelope_size bytes, there is always sufficient room.
1912            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1930            // are envelope_size bytes.
1931            let cur_offset: usize = (4 - 1) * envelope_size;
1932
1933            // Zero reserved fields.
1934            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1935
1936            // Safety:
1937            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1938            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1939            //   envelope_size bytes, there is always sufficient room.
1940            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1958            // are envelope_size bytes.
1959            let cur_offset: usize = (5 - 1) * envelope_size;
1960
1961            // Zero reserved fields.
1962            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1963
1964            // Safety:
1965            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1966            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1967            //   envelope_size bytes, there is always sufficient room.
1968            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1986            // are envelope_size bytes.
1987            let cur_offset: usize = (6 - 1) * envelope_size;
1988
1989            // Zero reserved fields.
1990            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1991
1992            // Safety:
1993            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1994            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1995            //   envelope_size bytes, there is always sufficient room.
1996            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2014            // are envelope_size bytes.
2015            let cur_offset: usize = (7 - 1) * envelope_size;
2016
2017            // Zero reserved fields.
2018            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2019
2020            // Safety:
2021            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2022            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2023            //   envelope_size bytes, there is always sufficient room.
2024            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            // Calling decoder.out_of_line_offset(0) is not allowed.
2065            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            // Decode the envelope for each type.
2073            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            // Decode unknown envelopes for gaps in ordinals.
2082            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            // Decode unknown envelopes for gaps in ordinals.
2146            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            // Decode unknown envelopes for gaps in ordinals.
2198            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            // Decode unknown envelopes for gaps in ordinals.
2250            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            // Decode unknown envelopes for gaps in ordinals.
2302            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            // Decode unknown envelopes for gaps in ordinals.
2359            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            // Decode unknown envelopes for gaps in ordinals.
2411            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            // Decode the remaining unknown envelopes.
2459            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}