fidl_fuchsia_web__common/
fidl_fuchsia_web__common.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::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub type CookieName = String;
12
13/// Unique identifier of a navigation. Can be used to correlate different phases for the
14/// same navigation. Guaranteed to be unique for all navigations in the same [`Context`].
15pub type NavigationId = u64;
16
17pub type Url = String;
18
19pub type UrlHostName = String;
20
21pub type UrlSchemeAndHostName = String;
22
23pub type UrlSchemeName = String;
24
25pub const MAX_HEADERS_COUNT: i32 = 4096;
26
27pub const MAX_HOST_LENGTH: i32 = 255;
28
29pub const MAX_RULE_COUNT: i32 = 4096;
30
31pub const MAX_SCHEME_AND_HOST_LENGTH: i32 = 513;
32
33pub const MAX_URL_LENGTH: i32 = 65536;
34
35pub const MAX_URL_SCHEME_NAME_LENGTH: i32 = 255;
36
37bitflags! {
38    /// Feature flags that allow augmenting Context behavior. Some features require additional services
39    /// in the service directory provided during context initialization. See
40    /// [`CreateContextParams.service_directory`].
41    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
42    pub struct ContextFeatureFlags: u64 {
43        /// Enables network access. Requires the following services:
44        /// - [`fuchsia.net.interfaces/State`]
45        /// - [`fuchsia.net.name/Lookup`]
46        /// - [`fuchsia.posix.socket/Provider`]
47        const NETWORK = 1;
48        /// Enables audio input and output. Requires the following services:
49        /// - [`fuchsia.media/Audio`]
50        /// - [`fuchsia.media/AudioDeviceEnumerator`]
51        /// - [`fuchsia.media/SessionAudioConsumerFactory`]
52        const AUDIO = 2;
53        /// Enables GPU-accelerated rendering of the web content. Requires the following services:
54        /// - [`fuchsia.vulkan.loader/Loader`]
55        /// The following service is required in order to collect Vulkan trace data.
56        /// - [`fuchsia.tracing.provider.Registry`]
57        const VULKAN = 4;
58        /// Enables hardware video decoding.
59        /// [`ContextFeatureFlags.VULKAN`] must be enabled as well.
60        /// Requires the following service:
61        /// - [`fuchsia.mediacodec/CodecFactory`]
62        const HARDWARE_VIDEO_DECODER = 8;
63        /// Disables video codecs that cannot be decoded in hardware.
64        /// Software decoders will only be used as fallbacks for hardware decoders, such as when
65        /// insufficient resources are available.
66        /// Requires [`ContextFeatureFlags.HARDWARE_VIDEO_DECODER`].
67        const HARDWARE_VIDEO_DECODER_ONLY = 16;
68        /// Enables Widevine CDM modules for EME API.
69        /// [`ContextFeatureFlags.VULKAN`] must be enabled as well.
70        /// Requires [`fuchsia.media.drm/Widevine`] service. Requires that a `cdm_data_directory` be
71        /// specified in [`CreateContextParams`].
72        const WIDEVINE_CDM = 32;
73        /// Allows embedders to render web content without graphical output or Scenic.
74        /// Not compatible with [`ContextFeatureFlags.VULKAN`].
75        const HEADLESS = 64;
76        /// Report telemetry data to the [`fuchsia.legacymetrics/MetricsRecorder`].
77        const LEGACYMETRICS = 128;
78        /// Enables input events for keyboard keypresses.
79        /// Requires [`fuchsia.ui.input3/Keyboard`], from which the events are obtained.
80        const KEYBOARD = 256;
81        /// Enables the use of onscreen virtual keyboards. The implementation will manage the state of
82        /// the keyboard in response to input/focus events in web content.
83        /// Requires the [`fuchsia.input.virtualkeyboard/ControllerCreator`] service and
84        /// [`ContextFeatureFlags.KEYBOARD`].
85        const VIRTUAL_KEYBOARD = 512;
86        /// Disables dynamic generation of machine-code from scripts (e.g. JavaScript) and other
87        /// technologies (e.g. WebAssembly). This should typically result in scripts being executed
88        /// by an interpreter, with associated loss in performance. Other technologies relying on
89        /// dynamic code generation may be provided in a limited form where feasible, or unavailable
90        /// if interpreting would render them unusable (as is likely the case for WebAssembly).
91        /// [`fuchsia.kernel/VmexResource`] is not required if this option is set.
92        const DISABLE_DYNAMIC_CODE_GENERATION = 1024;
93    }
94}
95
96impl ContextFeatureFlags {}
97
98bitflags! {
99    /// Identifies the types of input events which may be handled by a View.
100    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
101    pub struct InputTypes: u64 {
102        /// Keyboard events.
103        const KEY = 1;
104        /// Mouse button events, for any button.
105        const MOUSE_CLICK = 2;
106        /// Mouse scroll wheel events.
107        const MOUSE_WHEEL = 4;
108        /// Mouse movement events.
109        const MOUSE_MOVE = 8;
110        /// Single tapping with one finger.
111        const GESTURE_TAP = 16;
112        /// Pinching (for zooming).
113        const GESTURE_PINCH = 32;
114        /// Dragging a finger (for scrolling).
115        const GESTURE_DRAG = 64;
116        /// Matches all input types.
117        const ALL = 9223372036854775808;
118    }
119}
120
121impl InputTypes {}
122
123bitflags! {
124    /// Flags clients can set when connecting a [`NavigationEventListener`] to indicates interest in
125    /// optional features.
126    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
127    pub struct NavigationEventListenerFlags: u64 {
128        /// Enables `favicon` field in [`NavigationState`].
129        const FAVICON = 1;
130    }
131}
132
133impl NavigationEventListenerFlags {}
134
135bitflags! {
136    /// Identifies a navigation phase.
137    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
138    pub struct NavigationPhase: u32 {
139        /// Navigation is being started.
140        const START = 1;
141        /// Navigation was redirected.
142        const REDIRECT = 2;
143        /// Navigation response is being processed. At this point navigation hasn't been committed
144        /// yet, so it is not too late to cancel it.
145        const PROCESS_RESPONSE = 4;
146        /// Navigation has failed.
147        const FAIL = 8;
148    }
149}
150
151impl NavigationPhase {}
152
153/// Controls whether [`Frame.ConfigureInputTypes()`] should allow or deny processing of the
154/// specified [`InputTypes`].
155#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
156#[repr(i32)]
157pub enum AllowInputState {
158    Allow = 1,
159    Deny = 2,
160}
161
162impl AllowInputState {
163    #[inline]
164    pub fn from_primitive(prim: i32) -> Option<Self> {
165        match prim {
166            1 => Some(Self::Allow),
167            2 => Some(Self::Deny),
168            _ => None,
169        }
170    }
171
172    #[inline]
173    pub const fn into_primitive(self) -> i32 {
174        self as i32
175    }
176}
177
178/// Specifies the policy for automatic (non user-initiated) playback of video and audio content.
179#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
180#[repr(i32)]
181pub enum AutoplayPolicy {
182    /// All media is permitted to autoplay.
183    Allow = 1,
184    /// Allow autoplay when the document has received a user activation. This can be the result of
185    /// user action or [`LoadUrlParams.was_user_activated`] being set.
186    RequireUserActivation = 2,
187}
188
189impl AutoplayPolicy {
190    #[inline]
191    pub fn from_primitive(prim: i32) -> Option<Self> {
192        match prim {
193            1 => Some(Self::Allow),
194            2 => Some(Self::RequireUserActivation),
195            _ => None,
196        }
197    }
198
199    #[inline]
200    pub const fn into_primitive(self) -> i32 {
201        self as i32
202    }
203}
204
205#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
206#[repr(i32)]
207pub enum ConsoleLogLevel {
208    /// No logging.
209    None = 100,
210    /// Outputs messages from `console.debug()` and above levels.
211    Debug = -1,
212    /// Outputs messages from `console.log()`, `console.info()` and above levels.
213    Info = 0,
214    /// Outputs messages from `console.warn()` and `console.error()`.
215    Warn = 1,
216    /// Outputs messages from `console.error()`.
217    Error = 2,
218}
219
220impl ConsoleLogLevel {
221    #[inline]
222    pub fn from_primitive(prim: i32) -> Option<Self> {
223        match prim {
224            100 => Some(Self::None),
225            -1 => Some(Self::Debug),
226            0 => Some(Self::Info),
227            1 => Some(Self::Warn),
228            2 => Some(Self::Error),
229            _ => None,
230        }
231    }
232
233    #[inline]
234    pub const fn into_primitive(self) -> i32 {
235        self as i32
236    }
237}
238
239#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
240#[repr(i32)]
241pub enum ContextError {
242    /// The remote debugging service was not opened.
243    RemoteDebuggingPortNotOpened = 1,
244}
245
246impl ContextError {
247    #[inline]
248    pub fn from_primitive(prim: i32) -> Option<Self> {
249        match prim {
250            1 => Some(Self::RemoteDebuggingPortNotOpened),
251            _ => None,
252        }
253    }
254
255    #[inline]
256    pub const fn into_primitive(self) -> i32 {
257        self as i32
258    }
259}
260
261/// Indicates the reason for the error when `page_type` is set to [`PageType.ERROR`].
262#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
263pub enum ErrorDetail {
264    /// Page has failed to load. No content is rendered.
265    LoadFailed,
266    /// Tried to navigate to a site blocked by the explicit content filter. The corresponding
267    /// error page is rendered, see
268    /// [`CreateFrameParams.explicit_sites_filter_error_page`].
269    ExplicitContentBlocked,
270    /// The renderer process has crashed. No content is rendered.
271    Crash,
272    #[doc(hidden)]
273    __SourceBreaking { unknown_ordinal: u32 },
274}
275
276/// Pattern that matches an unknown `ErrorDetail` member.
277#[macro_export]
278macro_rules! ErrorDetailUnknown {
279    () => {
280        _
281    };
282}
283
284impl ErrorDetail {
285    #[inline]
286    pub fn from_primitive(prim: u32) -> Option<Self> {
287        match prim {
288            0 => Some(Self::LoadFailed),
289            1 => Some(Self::ExplicitContentBlocked),
290            2 => Some(Self::Crash),
291            _ => None,
292        }
293    }
294
295    #[inline]
296    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
297        match prim {
298            0 => Self::LoadFailed,
299            1 => Self::ExplicitContentBlocked,
300            2 => Self::Crash,
301            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
302        }
303    }
304
305    #[inline]
306    pub fn unknown() -> Self {
307        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
308    }
309
310    #[inline]
311    pub const fn into_primitive(self) -> u32 {
312        match self {
313            Self::LoadFailed => 0,
314            Self::ExplicitContentBlocked => 1,
315            Self::Crash => 2,
316            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
317        }
318    }
319
320    #[inline]
321    pub fn is_unknown(&self) -> bool {
322        match self {
323            Self::__SourceBreaking { unknown_ordinal: _ } => true,
324            _ => false,
325        }
326    }
327}
328
329/// Represents the return status of a [`Frame`] method.
330#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
331#[repr(i32)]
332pub enum FrameError {
333    /// An internal error occurred.
334    InternalError = 1,
335    /// The provided buffer is not UTF-8 encoded.
336    BufferNotUtf8 = 2,
337    /// The Frame's URL does not match any of the origins provided by the caller.
338    InvalidOrigin = 3,
339    /// The required `data` property is missing from a [`WebMessage`].
340    NoDataInMessage = 4,
341}
342
343impl FrameError {
344    #[inline]
345    pub fn from_primitive(prim: i32) -> Option<Self> {
346        match prim {
347            1 => Some(Self::InternalError),
348            2 => Some(Self::BufferNotUtf8),
349            3 => Some(Self::InvalidOrigin),
350            4 => Some(Self::NoDataInMessage),
351            _ => None,
352        }
353    }
354
355    #[inline]
356    pub const fn into_primitive(self) -> i32 {
357        self as i32
358    }
359}
360
361/// Characterizes the origin of a [`NavigationController.LoadUrl`] request.
362#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
363#[repr(u32)]
364pub enum LoadUrlReason {
365    /// Navigation was initiated by the user following a link.
366    Link = 0,
367    /// Navigation was initiated by a user-provided URL.
368    Typed = 1,
369}
370
371impl LoadUrlReason {
372    #[inline]
373    pub fn from_primitive(prim: u32) -> Option<Self> {
374        match prim {
375            0 => Some(Self::Link),
376            1 => Some(Self::Typed),
377            _ => None,
378        }
379    }
380
381    #[inline]
382    pub const fn into_primitive(self) -> u32 {
383        self as u32
384    }
385}
386
387/// Represents the return status of a [`NavigationController`] method.
388#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
389#[repr(i32)]
390pub enum NavigationControllerError {
391    /// The provided URL is invalid.
392    InvalidUrl = 1,
393    /// At least one of the provided headers was invalid.
394    InvalidHeader = 2,
395}
396
397impl NavigationControllerError {
398    #[inline]
399    pub fn from_primitive(prim: i32) -> Option<Self> {
400        match prim {
401            1 => Some(Self::InvalidUrl),
402            2 => Some(Self::InvalidHeader),
403            _ => None,
404        }
405    }
406
407    #[inline]
408    pub const fn into_primitive(self) -> i32 {
409        self as i32
410    }
411}
412
413/// Characterizes the page type in a [`NavigationState`].
414#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
415#[repr(u32)]
416pub enum PageType {
417    /// Regular web page.
418    Normal = 0,
419    /// Error page.
420    Error = 1,
421}
422
423impl PageType {
424    #[inline]
425    pub fn from_primitive(prim: u32) -> Option<Self> {
426        match prim {
427            0 => Some(Self::Normal),
428            1 => Some(Self::Error),
429            _ => None,
430        }
431    }
432
433    #[inline]
434    pub const fn into_primitive(self) -> u32 {
435        self as u32
436    }
437}
438
439/// A state for a web permission.
440#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
441#[repr(u8)]
442pub enum PermissionState {
443    /// Permission is denied.
444    Denied = 1,
445    /// Permission is granted.
446    Granted = 2,
447}
448
449impl PermissionState {
450    #[inline]
451    pub fn from_primitive(prim: u8) -> Option<Self> {
452        match prim {
453            1 => Some(Self::Denied),
454            2 => Some(Self::Granted),
455            _ => None,
456        }
457    }
458
459    #[inline]
460    pub const fn into_primitive(self) -> u8 {
461        self as u8
462    }
463}
464
465/// Identifies a type of permission that may be granted to a web origin.
466#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
467#[repr(u16)]
468pub enum PermissionType {
469    /// Permission to access microphone(s).
470    Microphone = 1,
471    /// Permission to access camera(s).
472    Camera = 2,
473    /// Permission to use device identifier(s) for EME.
474    ProtectedMediaIdentifier = 3,
475    /// Permission to use persistent storage.
476    PersistentStorage = 4,
477}
478
479impl PermissionType {
480    #[inline]
481    pub fn from_primitive(prim: u16) -> Option<Self> {
482        match prim {
483            1 => Some(Self::Microphone),
484            2 => Some(Self::Camera),
485            3 => Some(Self::ProtectedMediaIdentifier),
486            4 => Some(Self::PersistentStorage),
487            _ => None,
488        }
489    }
490
491    #[inline]
492    pub const fn into_primitive(self) -> u16 {
493        self as u16
494    }
495}
496
497/// Characterizes the type of reload.
498#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
499#[repr(u32)]
500pub enum ReloadType {
501    /// Reloads the current entry, bypassing the cache for the main resource.
502    PartialCache = 0,
503    /// Reloads the current entry, bypassing the cache entirely.
504    NoCache = 1,
505}
506
507impl ReloadType {
508    #[inline]
509    pub fn from_primitive(prim: u32) -> Option<Self> {
510        match prim {
511            0 => Some(Self::PartialCache),
512            1 => Some(Self::NoCache),
513            _ => None,
514        }
515    }
516
517    #[inline]
518    pub const fn into_primitive(self) -> u32 {
519        self as u32
520    }
521}
522
523#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
524#[repr(i32)]
525pub enum UrlRequestAction {
526    /// Allow the request to be processed.
527    Allow = 1,
528    /// Block the request.
529    Deny = 2,
530}
531
532impl UrlRequestAction {
533    #[inline]
534    pub fn from_primitive(prim: i32) -> Option<Self> {
535        match prim {
536            1 => Some(Self::Allow),
537            2 => Some(Self::Deny),
538            _ => None,
539        }
540    }
541
542    #[inline]
543    pub const fn into_primitive(self) -> i32 {
544        self as i32
545    }
546}
547
548#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
549#[repr(C)]
550pub struct ContextGetRemoteDebuggingPortResponse {
551    pub port: u16,
552}
553
554impl fidl::Persistable for ContextGetRemoteDebuggingPortResponse {}
555
556#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
557#[repr(C)]
558pub struct DevToolsPerContextListenerOnHttpPortOpenRequest {
559    pub port: u16,
560}
561
562impl fidl::Persistable for DevToolsPerContextListenerOnHttpPortOpenRequest {}
563
564#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
565pub struct FrameConfigureInputTypesRequest {
566    pub types: InputTypes,
567    pub allow: AllowInputState,
568}
569
570impl fidl::Persistable for FrameConfigureInputTypesRequest {}
571
572#[derive(Clone, Debug, PartialEq)]
573pub struct FrameForceContentDimensionsRequest {
574    pub web_dips: Option<Box<fidl_fuchsia_ui_gfx__common::Vec2>>,
575}
576
577impl fidl::Persistable for FrameForceContentDimensionsRequest {}
578
579#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
580#[repr(C)]
581pub struct FrameGetPrivateMemorySizeResponse {
582    pub size_bytes: u64,
583}
584
585impl fidl::Persistable for FrameGetPrivateMemorySizeResponse {}
586
587#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
588#[repr(C)]
589pub struct FrameRemoveBeforeLoadJavaScriptRequest {
590    pub id: u64,
591}
592
593impl fidl::Persistable for FrameRemoveBeforeLoadJavaScriptRequest {}
594
595#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
596pub struct FrameSetBlockMediaLoadingRequest {
597    pub blocked: bool,
598}
599
600impl fidl::Persistable for FrameSetBlockMediaLoadingRequest {}
601
602#[derive(Clone, Debug, PartialEq)]
603pub struct FrameSetContentAreaSettingsRequest {
604    pub settings: ContentAreaSettings,
605}
606
607impl fidl::Persistable for FrameSetContentAreaSettingsRequest {}
608
609#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
610pub struct FrameSetJavaScriptLogLevelRequest {
611    pub level: ConsoleLogLevel,
612}
613
614impl fidl::Persistable for FrameSetJavaScriptLogLevelRequest {}
615
616#[derive(Clone, Debug, PartialEq)]
617pub struct FrameSetMediaSettingsRequest {
618    pub settings: FrameMediaSettings,
619}
620
621impl fidl::Persistable for FrameSetMediaSettingsRequest {}
622
623#[derive(Clone, Debug, PartialEq)]
624pub struct FrameSetPermissionStateRequest {
625    pub permission: PermissionDescriptor,
626    pub web_origin: String,
627    pub state: PermissionState,
628}
629
630impl fidl::Persistable for FrameSetPermissionStateRequest {}
631
632#[derive(Clone, Debug, PartialEq)]
633pub struct FrameSetUrlRequestRewriteRulesRequest {
634    pub rules: Vec<UrlRequestRewriteRule>,
635}
636
637impl fidl::Persistable for FrameSetUrlRequestRewriteRulesRequest {}
638
639#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
640pub struct NavigationControllerReloadRequest {
641    pub type_: ReloadType,
642}
643
644impl fidl::Persistable for NavigationControllerReloadRequest {}
645
646#[derive(Clone, Debug, PartialEq)]
647pub struct NavigationPolicyProviderEvaluateRequestedNavigationRequest {
648    pub requested_navigation: RequestedNavigation,
649}
650
651impl fidl::Persistable for NavigationPolicyProviderEvaluateRequestedNavigationRequest {}
652
653/// Empty struct used in NavigationDecision for actions that don't hav any arguments.
654#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
655pub struct NoArgumentsAction;
656
657impl fidl::Persistable for NoArgumentsAction {}
658
659/// Settings for the web content in the Frame. Popup Frames created by the Frame will have their
660/// settings initialized to the Frame's current settings.
661#[derive(Clone, Debug, Default, PartialEq)]
662pub struct ContentAreaSettings {
663    /// Specifies whether scrollbars are hidden for the Frame. If omitted, the default is false.
664    pub hide_scrollbars: Option<bool>,
665    /// Specifies the autoplay policy for the Frame. If omitted, the default policy is
666    /// `REQUIRE_USER_ACTIVATION`.
667    pub autoplay_policy: Option<AutoplayPolicy>,
668    /// Specifies the color theme reported to web content via the `prefers-color-scheme` media
669    /// query.
670    /// Valid inputs are `LIGHT`, `DARK`, and `DEFAULT`. If omitted, the default is LIGHT theme.
671    /// Specifying `DEFAULT` means using the system settings, and requires that the [`Context`] have
672    /// the [`fuchsia.settings.Display`] service. If the service is not available, the [`Frame`]
673    /// will disconnect with `ZX_ERR_INVALID_ARGS`.
674    pub theme: Option<fidl_fuchsia_settings__common::ThemeType>,
675    /// Sets scale factor (zoom level) that should be applied to web content rendered in this
676    /// frame. Values above 1.0 make all web content (including text and images) larger, while
677    /// values below 1.0 will make it smaller. In other words, values above 1.0 are used to zoom in
678    /// and values below 1.0 zoom out. The overall ratio between physical pixel and CSS pixel is a
679    /// product of the scale set with this method and the scale provided by Scenic (see
680    /// [`fuchsia.ui.gfx.Metrics`]). That product is visible to the web content as
681    /// `window.devicePixelRatio`. If omitted, the default is 1.0.
682    ///
683    /// This setting does not have any effect on the size of the view on the screen and the
684    /// resolution at which the view is rendered. Native (non-web) UI elements, such as default
685    /// scroll bars and default mouse cursor, are not scaled. User may zoom the page further when
686    /// pinch-zoom is enabled (see [`InputTypes.GESTURE_PINCH`]).
687    pub page_scale: Option<f32>,
688    #[doc(hidden)]
689    pub __source_breaking: fidl::marker::SourceBreaking,
690}
691
692impl fidl::Persistable for ContentAreaSettings {}
693
694#[derive(Clone, Debug, Default, PartialEq)]
695pub struct CookieId {
696    /// An RFC2616 "token" chosen by the site to identify the cookie.
697    pub name: Option<String>,
698    /// The RFC1034 "subdomain" to which this cookie is scoped.
699    /// e.g. "example.com" allows access from all *.example.com sub-domains.
700    pub domain: Option<String>,
701    /// The URL "path" prefix to which this cookie is scoped.
702    /// e.g. "/" allows access from all paths.
703    pub path: Option<String>,
704    #[doc(hidden)]
705    pub __source_breaking: fidl::marker::SourceBreaking,
706}
707
708impl fidl::Persistable for CookieId {}
709
710#[derive(Clone, Debug, Default, PartialEq)]
711pub struct FrameCloseRequest {
712    /// Optional.
713    pub timeout: Option<i64>,
714    #[doc(hidden)]
715    pub __source_breaking: fidl::marker::SourceBreaking,
716}
717
718impl fidl::Persistable for FrameCloseRequest {}
719
720#[derive(Clone, Debug, Default, PartialEq)]
721pub struct FrameMediaSettings {
722    /// The [`fuchsia.media/AudioRenderUsage`] to set for every [`fuchsia.media/AudioRenderer`]
723    /// instance created by the [`Frame`]. If not set, the usage is `COMMUNICATION` for WebRTC
724    /// streams and `MEDIA` for all other streams.
725    pub renderer_usage: Option<fidl_fuchsia_media__common::AudioRenderUsage>,
726    /// When set, enables usage of [`fuchsia.media/AudioConsumer`] for audio playback. In that
727    /// case the specified value is passed to [`fuchsia.media/SessionAudioConsumerFactory`].
728    pub audio_consumer_session_id: Option<u64>,
729    /// The [`fuchsia.media/AudioRenderUsage2`] to set for every [`fuchsia.media/AudioRenderer`]
730    /// instance created by the [`Frame`]. If not set, the usage is `COMMUNICATION` for WebRTC
731    /// streams and `MEDIA` for all other streams.
732    pub renderer_usage2: Option<fidl_fuchsia_media__common::AudioRenderUsage2>,
733    #[doc(hidden)]
734    pub __source_breaking: fidl::marker::SourceBreaking,
735}
736
737impl fidl::Persistable for FrameMediaSettings {}
738
739/// Used to specify which navigation events should be delegated to [`NavigationPolicyProvider`].
740#[derive(Clone, Debug, Default, PartialEq)]
741pub struct NavigationPolicyProviderParams {
742    /// Specifies the set of navigation phases in the main frame that should be evaluated.
743    pub main_frame_phases: Option<NavigationPhase>,
744    /// Specifies the set of navigation phases in subframes that should be evaluated.
745    pub subframe_phases: Option<NavigationPhase>,
746    #[doc(hidden)]
747    pub __source_breaking: fidl::marker::SourceBreaking,
748}
749
750impl fidl::Persistable for NavigationPolicyProviderParams {}
751
752/// Describes a web permission. In the future, it may be extended with type-specific fields.
753#[derive(Clone, Debug, Default, PartialEq)]
754pub struct PermissionDescriptor {
755    pub type_: Option<PermissionType>,
756    #[doc(hidden)]
757    pub __source_breaking: fidl::marker::SourceBreaking,
758}
759
760impl fidl::Persistable for PermissionDescriptor {}
761
762#[derive(Clone, Debug, Default, PartialEq)]
763pub struct RequestedNavigation {
764    /// Unique ID of the navigation.
765    pub id: Option<u64>,
766    /// Current navigation phase. Exactly one bit will be set.
767    pub phase: Option<NavigationPhase>,
768    /// Whether the navigation is taking place in the main frame versus in a subframe.
769    pub is_main_frame: Option<bool>,
770    /// Whether the navigation happened without changing the document.
771    pub is_same_document: Option<bool>,
772    /// Whether the navigation is a POST request.
773    pub is_http_post: Option<bool>,
774    /// The current target URL of the navigation. This may change for the same navigation after
775    /// encountering a server redirect.
776    pub url: Option<String>,
777    /// Whether the navigation was initiated by a user gesture.
778    pub has_gesture: Option<bool>,
779    /// Whether the navigation has encountered a server redirect or not.
780    pub was_server_redirect: Option<bool>,
781    #[doc(hidden)]
782    pub __source_breaking: fidl::marker::SourceBreaking,
783}
784
785impl fidl::Persistable for RequestedNavigation {}
786
787/// Adds `headers` to the URL request. If a header is already present in the original URL request,
788/// it will be overwritten.
789/// - `headers` must be set.
790/// - Each [`fuchsia.net.http/Header`] in `headers` must have a valid HTTP header name and value,
791///   per [RFC 7230 section  3.2](https://tools.ietf.org/html/rfc7230#section-3.2).
792#[derive(Clone, Debug, Default, PartialEq)]
793pub struct UrlRequestRewriteAddHeaders {
794    pub headers: Option<Vec<fidl_fuchsia_net_http__common::Header>>,
795    #[doc(hidden)]
796    pub __source_breaking: fidl::marker::SourceBreaking,
797}
798
799impl fidl::Persistable for UrlRequestRewriteAddHeaders {}
800
801/// Appends `query` to the URL's query. If the URL request already has a query, `query` will be
802/// appended to it, preceded by `&`. Otherwise, the URL's query will be set to `query`.
803/// - `query` must be set.
804/// - `query` must be a valid [URL-query string](https://url.spec.whatwg.org/#url-query-string).
805#[derive(Clone, Debug, Default, PartialEq)]
806pub struct UrlRequestRewriteAppendToQuery {
807    pub query: Option<String>,
808    #[doc(hidden)]
809    pub __source_breaking: fidl::marker::SourceBreaking,
810}
811
812impl fidl::Persistable for UrlRequestRewriteAppendToQuery {}
813
814/// If `query_pattern` is in the URL's query, removes `header_name` from the list of headers. If
815/// `query_pattern` is not set, removes `header_name` from the list of headers unconditionally.
816/// - `header_name` must be set.
817/// - `header_name` must be a valid HTTP header name, per
818///   [RFC 7230 section 3.2](https://tools.ietf.org/html/rfc7230#section-3.2).
819#[derive(Clone, Debug, Default, PartialEq)]
820pub struct UrlRequestRewriteRemoveHeader {
821    pub query_pattern: Option<String>,
822    pub header_name: Option<Vec<u8>>,
823    #[doc(hidden)]
824    pub __source_breaking: fidl::marker::SourceBreaking,
825}
826
827impl fidl::Persistable for UrlRequestRewriteRemoveHeader {}
828
829/// If the URL in the URL request ends with `url_ends_with`, rewrites the URL to `new_url`.
830/// - `url_ends_with` and `new_url` must be set.
831/// - `url_ends_with` must be a valid
832///   [path-relative-URL string](https://url.spec.whatwg.org/#path-relative-url-string).
833/// - `new_url` must be a [valid URL string](https://url.spec.whatwg.org/#valid-url-string).
834#[derive(Clone, Debug, Default, PartialEq)]
835pub struct UrlRequestRewriteReplaceUrl {
836    pub url_ends_with: Option<String>,
837    pub new_url: Option<String>,
838    #[doc(hidden)]
839    pub __source_breaking: fidl::marker::SourceBreaking,
840}
841
842impl fidl::Persistable for UrlRequestRewriteReplaceUrl {}
843
844#[derive(Clone, Debug, Default, PartialEq)]
845pub struct UrlRequestRewriteRule {
846    /// Set of hosts to apply the rules to. If not set, the rule will apply to every request,
847    /// independent of host.
848    pub hosts_filter: Option<Vec<String>>,
849    /// Set of schemes to apply the rules to. If not set, the rule will apply to every request,
850    /// independent of scheme.
851    pub schemes_filter: Option<Vec<String>>,
852    /// URL request rewrites to apply.
853    pub rewrites: Option<Vec<UrlRequestRewrite>>,
854    /// Specifies the action to take for requests matching the filter criteria.
855    /// Requests are allowed by default.
856    pub action: Option<UrlRequestAction>,
857    #[doc(hidden)]
858    pub __source_breaking: fidl::marker::SourceBreaking,
859}
860
861impl fidl::Persistable for UrlRequestRewriteRule {}
862
863/// If `pattern` is found in the URL's query, replaces it with `substitution`.
864/// - `pattern` and `substitution` must be set.
865/// - `substitution` must be a valid
866///   [URL-query string](https://url.spec.whatwg.org/#url-query-string).
867#[derive(Clone, Debug, Default, PartialEq)]
868pub struct UrlRequestRewriteSubstituteQueryPattern {
869    pub pattern: Option<String>,
870    pub substitution: Option<String>,
871    #[doc(hidden)]
872    pub __source_breaking: fidl::marker::SourceBreaking,
873}
874
875impl fidl::Persistable for UrlRequestRewriteSubstituteQueryPattern {}
876
877#[derive(Clone, Debug)]
878pub enum UrlRequestRewrite {
879    /// Adds a set of headers to a URL request.
880    AddHeaders(UrlRequestRewriteAddHeaders),
881    /// Removes a header based on the presence of a pattern in the URL's query.
882    RemoveHeader(UrlRequestRewriteRemoveHeader),
883    /// Substitutes a pattern in the URL's query.
884    SubstituteQueryPattern(UrlRequestRewriteSubstituteQueryPattern),
885    /// Replaces a URL if the original URL ends with a pattern.
886    ReplaceUrl(UrlRequestRewriteReplaceUrl),
887    /// Appends to the URL's query.
888    AppendToQuery(UrlRequestRewriteAppendToQuery),
889    #[doc(hidden)]
890    __SourceBreaking { unknown_ordinal: u64 },
891}
892
893/// Pattern that matches an unknown `UrlRequestRewrite` member.
894#[macro_export]
895macro_rules! UrlRequestRewriteUnknown {
896    () => {
897        _
898    };
899}
900
901// Custom PartialEq so that unknown variants are not equal to themselves.
902impl PartialEq for UrlRequestRewrite {
903    fn eq(&self, other: &Self) -> bool {
904        match (self, other) {
905            (Self::AddHeaders(x), Self::AddHeaders(y)) => *x == *y,
906            (Self::RemoveHeader(x), Self::RemoveHeader(y)) => *x == *y,
907            (Self::SubstituteQueryPattern(x), Self::SubstituteQueryPattern(y)) => *x == *y,
908            (Self::ReplaceUrl(x), Self::ReplaceUrl(y)) => *x == *y,
909            (Self::AppendToQuery(x), Self::AppendToQuery(y)) => *x == *y,
910            _ => false,
911        }
912    }
913}
914
915impl UrlRequestRewrite {
916    #[inline]
917    pub fn ordinal(&self) -> u64 {
918        match *self {
919            Self::AddHeaders(_) => 1,
920            Self::RemoveHeader(_) => 2,
921            Self::SubstituteQueryPattern(_) => 3,
922            Self::ReplaceUrl(_) => 4,
923            Self::AppendToQuery(_) => 5,
924            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
925        }
926    }
927
928    #[inline]
929    pub fn unknown_variant_for_testing() -> Self {
930        Self::__SourceBreaking { unknown_ordinal: 0 }
931    }
932
933    #[inline]
934    pub fn is_unknown(&self) -> bool {
935        match self {
936            Self::__SourceBreaking { .. } => true,
937            _ => false,
938        }
939    }
940}
941
942impl fidl::Persistable for UrlRequestRewrite {}
943
944mod internal {
945    use super::*;
946    unsafe impl fidl::encoding::TypeMarker for ContextFeatureFlags {
947        type Owned = Self;
948
949        #[inline(always)]
950        fn inline_align(_context: fidl::encoding::Context) -> usize {
951            8
952        }
953
954        #[inline(always)]
955        fn inline_size(_context: fidl::encoding::Context) -> usize {
956            8
957        }
958    }
959
960    impl fidl::encoding::ValueTypeMarker for ContextFeatureFlags {
961        type Borrowed<'a> = Self;
962        #[inline(always)]
963        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
964            *value
965        }
966    }
967
968    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
969        for ContextFeatureFlags
970    {
971        #[inline]
972        unsafe fn encode(
973            self,
974            encoder: &mut fidl::encoding::Encoder<'_, D>,
975            offset: usize,
976            _depth: fidl::encoding::Depth,
977        ) -> fidl::Result<()> {
978            encoder.debug_check_bounds::<Self>(offset);
979            if self.bits() & Self::all().bits() != self.bits() {
980                return Err(fidl::Error::InvalidBitsValue);
981            }
982            encoder.write_num(self.bits(), offset);
983            Ok(())
984        }
985    }
986
987    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ContextFeatureFlags {
988        #[inline(always)]
989        fn new_empty() -> Self {
990            Self::empty()
991        }
992
993        #[inline]
994        unsafe fn decode(
995            &mut self,
996            decoder: &mut fidl::encoding::Decoder<'_, D>,
997            offset: usize,
998            _depth: fidl::encoding::Depth,
999        ) -> fidl::Result<()> {
1000            decoder.debug_check_bounds::<Self>(offset);
1001            let prim = decoder.read_num::<u64>(offset);
1002            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1003            Ok(())
1004        }
1005    }
1006    unsafe impl fidl::encoding::TypeMarker for InputTypes {
1007        type Owned = Self;
1008
1009        #[inline(always)]
1010        fn inline_align(_context: fidl::encoding::Context) -> usize {
1011            8
1012        }
1013
1014        #[inline(always)]
1015        fn inline_size(_context: fidl::encoding::Context) -> usize {
1016            8
1017        }
1018    }
1019
1020    impl fidl::encoding::ValueTypeMarker for InputTypes {
1021        type Borrowed<'a> = Self;
1022        #[inline(always)]
1023        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1024            *value
1025        }
1026    }
1027
1028    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for InputTypes {
1029        #[inline]
1030        unsafe fn encode(
1031            self,
1032            encoder: &mut fidl::encoding::Encoder<'_, D>,
1033            offset: usize,
1034            _depth: fidl::encoding::Depth,
1035        ) -> fidl::Result<()> {
1036            encoder.debug_check_bounds::<Self>(offset);
1037            if self.bits() & Self::all().bits() != self.bits() {
1038                return Err(fidl::Error::InvalidBitsValue);
1039            }
1040            encoder.write_num(self.bits(), offset);
1041            Ok(())
1042        }
1043    }
1044
1045    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InputTypes {
1046        #[inline(always)]
1047        fn new_empty() -> Self {
1048            Self::empty()
1049        }
1050
1051        #[inline]
1052        unsafe fn decode(
1053            &mut self,
1054            decoder: &mut fidl::encoding::Decoder<'_, D>,
1055            offset: usize,
1056            _depth: fidl::encoding::Depth,
1057        ) -> fidl::Result<()> {
1058            decoder.debug_check_bounds::<Self>(offset);
1059            let prim = decoder.read_num::<u64>(offset);
1060            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1061            Ok(())
1062        }
1063    }
1064    unsafe impl fidl::encoding::TypeMarker for NavigationEventListenerFlags {
1065        type Owned = Self;
1066
1067        #[inline(always)]
1068        fn inline_align(_context: fidl::encoding::Context) -> usize {
1069            8
1070        }
1071
1072        #[inline(always)]
1073        fn inline_size(_context: fidl::encoding::Context) -> usize {
1074            8
1075        }
1076    }
1077
1078    impl fidl::encoding::ValueTypeMarker for NavigationEventListenerFlags {
1079        type Borrowed<'a> = Self;
1080        #[inline(always)]
1081        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1082            *value
1083        }
1084    }
1085
1086    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1087        for NavigationEventListenerFlags
1088    {
1089        #[inline]
1090        unsafe fn encode(
1091            self,
1092            encoder: &mut fidl::encoding::Encoder<'_, D>,
1093            offset: usize,
1094            _depth: fidl::encoding::Depth,
1095        ) -> fidl::Result<()> {
1096            encoder.debug_check_bounds::<Self>(offset);
1097            if self.bits() & Self::all().bits() != self.bits() {
1098                return Err(fidl::Error::InvalidBitsValue);
1099            }
1100            encoder.write_num(self.bits(), offset);
1101            Ok(())
1102        }
1103    }
1104
1105    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1106        for NavigationEventListenerFlags
1107    {
1108        #[inline(always)]
1109        fn new_empty() -> Self {
1110            Self::empty()
1111        }
1112
1113        #[inline]
1114        unsafe fn decode(
1115            &mut self,
1116            decoder: &mut fidl::encoding::Decoder<'_, D>,
1117            offset: usize,
1118            _depth: fidl::encoding::Depth,
1119        ) -> fidl::Result<()> {
1120            decoder.debug_check_bounds::<Self>(offset);
1121            let prim = decoder.read_num::<u64>(offset);
1122            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1123            Ok(())
1124        }
1125    }
1126    unsafe impl fidl::encoding::TypeMarker for NavigationPhase {
1127        type Owned = Self;
1128
1129        #[inline(always)]
1130        fn inline_align(_context: fidl::encoding::Context) -> usize {
1131            4
1132        }
1133
1134        #[inline(always)]
1135        fn inline_size(_context: fidl::encoding::Context) -> usize {
1136            4
1137        }
1138    }
1139
1140    impl fidl::encoding::ValueTypeMarker for NavigationPhase {
1141        type Borrowed<'a> = Self;
1142        #[inline(always)]
1143        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1144            *value
1145        }
1146    }
1147
1148    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1149        for NavigationPhase
1150    {
1151        #[inline]
1152        unsafe fn encode(
1153            self,
1154            encoder: &mut fidl::encoding::Encoder<'_, D>,
1155            offset: usize,
1156            _depth: fidl::encoding::Depth,
1157        ) -> fidl::Result<()> {
1158            encoder.debug_check_bounds::<Self>(offset);
1159            if self.bits() & Self::all().bits() != self.bits() {
1160                return Err(fidl::Error::InvalidBitsValue);
1161            }
1162            encoder.write_num(self.bits(), offset);
1163            Ok(())
1164        }
1165    }
1166
1167    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NavigationPhase {
1168        #[inline(always)]
1169        fn new_empty() -> Self {
1170            Self::empty()
1171        }
1172
1173        #[inline]
1174        unsafe fn decode(
1175            &mut self,
1176            decoder: &mut fidl::encoding::Decoder<'_, D>,
1177            offset: usize,
1178            _depth: fidl::encoding::Depth,
1179        ) -> fidl::Result<()> {
1180            decoder.debug_check_bounds::<Self>(offset);
1181            let prim = decoder.read_num::<u32>(offset);
1182            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1183            Ok(())
1184        }
1185    }
1186    unsafe impl fidl::encoding::TypeMarker for AllowInputState {
1187        type Owned = Self;
1188
1189        #[inline(always)]
1190        fn inline_align(_context: fidl::encoding::Context) -> usize {
1191            std::mem::align_of::<i32>()
1192        }
1193
1194        #[inline(always)]
1195        fn inline_size(_context: fidl::encoding::Context) -> usize {
1196            std::mem::size_of::<i32>()
1197        }
1198
1199        #[inline(always)]
1200        fn encode_is_copy() -> bool {
1201            true
1202        }
1203
1204        #[inline(always)]
1205        fn decode_is_copy() -> bool {
1206            false
1207        }
1208    }
1209
1210    impl fidl::encoding::ValueTypeMarker for AllowInputState {
1211        type Borrowed<'a> = Self;
1212        #[inline(always)]
1213        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1214            *value
1215        }
1216    }
1217
1218    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1219        for AllowInputState
1220    {
1221        #[inline]
1222        unsafe fn encode(
1223            self,
1224            encoder: &mut fidl::encoding::Encoder<'_, D>,
1225            offset: usize,
1226            _depth: fidl::encoding::Depth,
1227        ) -> fidl::Result<()> {
1228            encoder.debug_check_bounds::<Self>(offset);
1229            encoder.write_num(self.into_primitive(), offset);
1230            Ok(())
1231        }
1232    }
1233
1234    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowInputState {
1235        #[inline(always)]
1236        fn new_empty() -> Self {
1237            Self::Allow
1238        }
1239
1240        #[inline]
1241        unsafe fn decode(
1242            &mut self,
1243            decoder: &mut fidl::encoding::Decoder<'_, D>,
1244            offset: usize,
1245            _depth: fidl::encoding::Depth,
1246        ) -> fidl::Result<()> {
1247            decoder.debug_check_bounds::<Self>(offset);
1248            let prim = decoder.read_num::<i32>(offset);
1249
1250            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1251            Ok(())
1252        }
1253    }
1254    unsafe impl fidl::encoding::TypeMarker for AutoplayPolicy {
1255        type Owned = Self;
1256
1257        #[inline(always)]
1258        fn inline_align(_context: fidl::encoding::Context) -> usize {
1259            std::mem::align_of::<i32>()
1260        }
1261
1262        #[inline(always)]
1263        fn inline_size(_context: fidl::encoding::Context) -> usize {
1264            std::mem::size_of::<i32>()
1265        }
1266
1267        #[inline(always)]
1268        fn encode_is_copy() -> bool {
1269            true
1270        }
1271
1272        #[inline(always)]
1273        fn decode_is_copy() -> bool {
1274            false
1275        }
1276    }
1277
1278    impl fidl::encoding::ValueTypeMarker for AutoplayPolicy {
1279        type Borrowed<'a> = Self;
1280        #[inline(always)]
1281        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1282            *value
1283        }
1284    }
1285
1286    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AutoplayPolicy {
1287        #[inline]
1288        unsafe fn encode(
1289            self,
1290            encoder: &mut fidl::encoding::Encoder<'_, D>,
1291            offset: usize,
1292            _depth: fidl::encoding::Depth,
1293        ) -> fidl::Result<()> {
1294            encoder.debug_check_bounds::<Self>(offset);
1295            encoder.write_num(self.into_primitive(), offset);
1296            Ok(())
1297        }
1298    }
1299
1300    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AutoplayPolicy {
1301        #[inline(always)]
1302        fn new_empty() -> Self {
1303            Self::Allow
1304        }
1305
1306        #[inline]
1307        unsafe fn decode(
1308            &mut self,
1309            decoder: &mut fidl::encoding::Decoder<'_, D>,
1310            offset: usize,
1311            _depth: fidl::encoding::Depth,
1312        ) -> fidl::Result<()> {
1313            decoder.debug_check_bounds::<Self>(offset);
1314            let prim = decoder.read_num::<i32>(offset);
1315
1316            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1317            Ok(())
1318        }
1319    }
1320    unsafe impl fidl::encoding::TypeMarker for ConsoleLogLevel {
1321        type Owned = Self;
1322
1323        #[inline(always)]
1324        fn inline_align(_context: fidl::encoding::Context) -> usize {
1325            std::mem::align_of::<i32>()
1326        }
1327
1328        #[inline(always)]
1329        fn inline_size(_context: fidl::encoding::Context) -> usize {
1330            std::mem::size_of::<i32>()
1331        }
1332
1333        #[inline(always)]
1334        fn encode_is_copy() -> bool {
1335            true
1336        }
1337
1338        #[inline(always)]
1339        fn decode_is_copy() -> bool {
1340            false
1341        }
1342    }
1343
1344    impl fidl::encoding::ValueTypeMarker for ConsoleLogLevel {
1345        type Borrowed<'a> = Self;
1346        #[inline(always)]
1347        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1348            *value
1349        }
1350    }
1351
1352    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1353        for ConsoleLogLevel
1354    {
1355        #[inline]
1356        unsafe fn encode(
1357            self,
1358            encoder: &mut fidl::encoding::Encoder<'_, D>,
1359            offset: usize,
1360            _depth: fidl::encoding::Depth,
1361        ) -> fidl::Result<()> {
1362            encoder.debug_check_bounds::<Self>(offset);
1363            encoder.write_num(self.into_primitive(), offset);
1364            Ok(())
1365        }
1366    }
1367
1368    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConsoleLogLevel {
1369        #[inline(always)]
1370        fn new_empty() -> Self {
1371            Self::Debug
1372        }
1373
1374        #[inline]
1375        unsafe fn decode(
1376            &mut self,
1377            decoder: &mut fidl::encoding::Decoder<'_, D>,
1378            offset: usize,
1379            _depth: fidl::encoding::Depth,
1380        ) -> fidl::Result<()> {
1381            decoder.debug_check_bounds::<Self>(offset);
1382            let prim = decoder.read_num::<i32>(offset);
1383
1384            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1385            Ok(())
1386        }
1387    }
1388    unsafe impl fidl::encoding::TypeMarker for ContextError {
1389        type Owned = Self;
1390
1391        #[inline(always)]
1392        fn inline_align(_context: fidl::encoding::Context) -> usize {
1393            std::mem::align_of::<i32>()
1394        }
1395
1396        #[inline(always)]
1397        fn inline_size(_context: fidl::encoding::Context) -> usize {
1398            std::mem::size_of::<i32>()
1399        }
1400
1401        #[inline(always)]
1402        fn encode_is_copy() -> bool {
1403            true
1404        }
1405
1406        #[inline(always)]
1407        fn decode_is_copy() -> bool {
1408            false
1409        }
1410    }
1411
1412    impl fidl::encoding::ValueTypeMarker for ContextError {
1413        type Borrowed<'a> = Self;
1414        #[inline(always)]
1415        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1416            *value
1417        }
1418    }
1419
1420    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ContextError {
1421        #[inline]
1422        unsafe fn encode(
1423            self,
1424            encoder: &mut fidl::encoding::Encoder<'_, D>,
1425            offset: usize,
1426            _depth: fidl::encoding::Depth,
1427        ) -> fidl::Result<()> {
1428            encoder.debug_check_bounds::<Self>(offset);
1429            encoder.write_num(self.into_primitive(), offset);
1430            Ok(())
1431        }
1432    }
1433
1434    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ContextError {
1435        #[inline(always)]
1436        fn new_empty() -> Self {
1437            Self::RemoteDebuggingPortNotOpened
1438        }
1439
1440        #[inline]
1441        unsafe fn decode(
1442            &mut self,
1443            decoder: &mut fidl::encoding::Decoder<'_, D>,
1444            offset: usize,
1445            _depth: fidl::encoding::Depth,
1446        ) -> fidl::Result<()> {
1447            decoder.debug_check_bounds::<Self>(offset);
1448            let prim = decoder.read_num::<i32>(offset);
1449
1450            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1451            Ok(())
1452        }
1453    }
1454    unsafe impl fidl::encoding::TypeMarker for ErrorDetail {
1455        type Owned = Self;
1456
1457        #[inline(always)]
1458        fn inline_align(_context: fidl::encoding::Context) -> usize {
1459            std::mem::align_of::<u32>()
1460        }
1461
1462        #[inline(always)]
1463        fn inline_size(_context: fidl::encoding::Context) -> usize {
1464            std::mem::size_of::<u32>()
1465        }
1466
1467        #[inline(always)]
1468        fn encode_is_copy() -> bool {
1469            false
1470        }
1471
1472        #[inline(always)]
1473        fn decode_is_copy() -> bool {
1474            false
1475        }
1476    }
1477
1478    impl fidl::encoding::ValueTypeMarker for ErrorDetail {
1479        type Borrowed<'a> = Self;
1480        #[inline(always)]
1481        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1482            *value
1483        }
1484    }
1485
1486    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ErrorDetail {
1487        #[inline]
1488        unsafe fn encode(
1489            self,
1490            encoder: &mut fidl::encoding::Encoder<'_, D>,
1491            offset: usize,
1492            _depth: fidl::encoding::Depth,
1493        ) -> fidl::Result<()> {
1494            encoder.debug_check_bounds::<Self>(offset);
1495            encoder.write_num(self.into_primitive(), offset);
1496            Ok(())
1497        }
1498    }
1499
1500    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ErrorDetail {
1501        #[inline(always)]
1502        fn new_empty() -> Self {
1503            Self::unknown()
1504        }
1505
1506        #[inline]
1507        unsafe fn decode(
1508            &mut self,
1509            decoder: &mut fidl::encoding::Decoder<'_, D>,
1510            offset: usize,
1511            _depth: fidl::encoding::Depth,
1512        ) -> fidl::Result<()> {
1513            decoder.debug_check_bounds::<Self>(offset);
1514            let prim = decoder.read_num::<u32>(offset);
1515
1516            *self = Self::from_primitive_allow_unknown(prim);
1517            Ok(())
1518        }
1519    }
1520    unsafe impl fidl::encoding::TypeMarker for FrameError {
1521        type Owned = Self;
1522
1523        #[inline(always)]
1524        fn inline_align(_context: fidl::encoding::Context) -> usize {
1525            std::mem::align_of::<i32>()
1526        }
1527
1528        #[inline(always)]
1529        fn inline_size(_context: fidl::encoding::Context) -> usize {
1530            std::mem::size_of::<i32>()
1531        }
1532
1533        #[inline(always)]
1534        fn encode_is_copy() -> bool {
1535            true
1536        }
1537
1538        #[inline(always)]
1539        fn decode_is_copy() -> bool {
1540            false
1541        }
1542    }
1543
1544    impl fidl::encoding::ValueTypeMarker for FrameError {
1545        type Borrowed<'a> = Self;
1546        #[inline(always)]
1547        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1548            *value
1549        }
1550    }
1551
1552    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for FrameError {
1553        #[inline]
1554        unsafe fn encode(
1555            self,
1556            encoder: &mut fidl::encoding::Encoder<'_, D>,
1557            offset: usize,
1558            _depth: fidl::encoding::Depth,
1559        ) -> fidl::Result<()> {
1560            encoder.debug_check_bounds::<Self>(offset);
1561            encoder.write_num(self.into_primitive(), offset);
1562            Ok(())
1563        }
1564    }
1565
1566    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FrameError {
1567        #[inline(always)]
1568        fn new_empty() -> Self {
1569            Self::InternalError
1570        }
1571
1572        #[inline]
1573        unsafe fn decode(
1574            &mut self,
1575            decoder: &mut fidl::encoding::Decoder<'_, D>,
1576            offset: usize,
1577            _depth: fidl::encoding::Depth,
1578        ) -> fidl::Result<()> {
1579            decoder.debug_check_bounds::<Self>(offset);
1580            let prim = decoder.read_num::<i32>(offset);
1581
1582            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1583            Ok(())
1584        }
1585    }
1586    unsafe impl fidl::encoding::TypeMarker for LoadUrlReason {
1587        type Owned = Self;
1588
1589        #[inline(always)]
1590        fn inline_align(_context: fidl::encoding::Context) -> usize {
1591            std::mem::align_of::<u32>()
1592        }
1593
1594        #[inline(always)]
1595        fn inline_size(_context: fidl::encoding::Context) -> usize {
1596            std::mem::size_of::<u32>()
1597        }
1598
1599        #[inline(always)]
1600        fn encode_is_copy() -> bool {
1601            true
1602        }
1603
1604        #[inline(always)]
1605        fn decode_is_copy() -> bool {
1606            false
1607        }
1608    }
1609
1610    impl fidl::encoding::ValueTypeMarker for LoadUrlReason {
1611        type Borrowed<'a> = Self;
1612        #[inline(always)]
1613        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1614            *value
1615        }
1616    }
1617
1618    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for LoadUrlReason {
1619        #[inline]
1620        unsafe fn encode(
1621            self,
1622            encoder: &mut fidl::encoding::Encoder<'_, D>,
1623            offset: usize,
1624            _depth: fidl::encoding::Depth,
1625        ) -> fidl::Result<()> {
1626            encoder.debug_check_bounds::<Self>(offset);
1627            encoder.write_num(self.into_primitive(), offset);
1628            Ok(())
1629        }
1630    }
1631
1632    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LoadUrlReason {
1633        #[inline(always)]
1634        fn new_empty() -> Self {
1635            Self::Link
1636        }
1637
1638        #[inline]
1639        unsafe fn decode(
1640            &mut self,
1641            decoder: &mut fidl::encoding::Decoder<'_, D>,
1642            offset: usize,
1643            _depth: fidl::encoding::Depth,
1644        ) -> fidl::Result<()> {
1645            decoder.debug_check_bounds::<Self>(offset);
1646            let prim = decoder.read_num::<u32>(offset);
1647
1648            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1649            Ok(())
1650        }
1651    }
1652    unsafe impl fidl::encoding::TypeMarker for NavigationControllerError {
1653        type Owned = Self;
1654
1655        #[inline(always)]
1656        fn inline_align(_context: fidl::encoding::Context) -> usize {
1657            std::mem::align_of::<i32>()
1658        }
1659
1660        #[inline(always)]
1661        fn inline_size(_context: fidl::encoding::Context) -> usize {
1662            std::mem::size_of::<i32>()
1663        }
1664
1665        #[inline(always)]
1666        fn encode_is_copy() -> bool {
1667            true
1668        }
1669
1670        #[inline(always)]
1671        fn decode_is_copy() -> bool {
1672            false
1673        }
1674    }
1675
1676    impl fidl::encoding::ValueTypeMarker for NavigationControllerError {
1677        type Borrowed<'a> = Self;
1678        #[inline(always)]
1679        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1680            *value
1681        }
1682    }
1683
1684    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1685        for NavigationControllerError
1686    {
1687        #[inline]
1688        unsafe fn encode(
1689            self,
1690            encoder: &mut fidl::encoding::Encoder<'_, D>,
1691            offset: usize,
1692            _depth: fidl::encoding::Depth,
1693        ) -> fidl::Result<()> {
1694            encoder.debug_check_bounds::<Self>(offset);
1695            encoder.write_num(self.into_primitive(), offset);
1696            Ok(())
1697        }
1698    }
1699
1700    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1701        for NavigationControllerError
1702    {
1703        #[inline(always)]
1704        fn new_empty() -> Self {
1705            Self::InvalidUrl
1706        }
1707
1708        #[inline]
1709        unsafe fn decode(
1710            &mut self,
1711            decoder: &mut fidl::encoding::Decoder<'_, D>,
1712            offset: usize,
1713            _depth: fidl::encoding::Depth,
1714        ) -> fidl::Result<()> {
1715            decoder.debug_check_bounds::<Self>(offset);
1716            let prim = decoder.read_num::<i32>(offset);
1717
1718            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1719            Ok(())
1720        }
1721    }
1722    unsafe impl fidl::encoding::TypeMarker for PageType {
1723        type Owned = Self;
1724
1725        #[inline(always)]
1726        fn inline_align(_context: fidl::encoding::Context) -> usize {
1727            std::mem::align_of::<u32>()
1728        }
1729
1730        #[inline(always)]
1731        fn inline_size(_context: fidl::encoding::Context) -> usize {
1732            std::mem::size_of::<u32>()
1733        }
1734
1735        #[inline(always)]
1736        fn encode_is_copy() -> bool {
1737            true
1738        }
1739
1740        #[inline(always)]
1741        fn decode_is_copy() -> bool {
1742            false
1743        }
1744    }
1745
1746    impl fidl::encoding::ValueTypeMarker for PageType {
1747        type Borrowed<'a> = Self;
1748        #[inline(always)]
1749        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1750            *value
1751        }
1752    }
1753
1754    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PageType {
1755        #[inline]
1756        unsafe fn encode(
1757            self,
1758            encoder: &mut fidl::encoding::Encoder<'_, D>,
1759            offset: usize,
1760            _depth: fidl::encoding::Depth,
1761        ) -> fidl::Result<()> {
1762            encoder.debug_check_bounds::<Self>(offset);
1763            encoder.write_num(self.into_primitive(), offset);
1764            Ok(())
1765        }
1766    }
1767
1768    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PageType {
1769        #[inline(always)]
1770        fn new_empty() -> Self {
1771            Self::Normal
1772        }
1773
1774        #[inline]
1775        unsafe fn decode(
1776            &mut self,
1777            decoder: &mut fidl::encoding::Decoder<'_, D>,
1778            offset: usize,
1779            _depth: fidl::encoding::Depth,
1780        ) -> fidl::Result<()> {
1781            decoder.debug_check_bounds::<Self>(offset);
1782            let prim = decoder.read_num::<u32>(offset);
1783
1784            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1785            Ok(())
1786        }
1787    }
1788    unsafe impl fidl::encoding::TypeMarker for PermissionState {
1789        type Owned = Self;
1790
1791        #[inline(always)]
1792        fn inline_align(_context: fidl::encoding::Context) -> usize {
1793            std::mem::align_of::<u8>()
1794        }
1795
1796        #[inline(always)]
1797        fn inline_size(_context: fidl::encoding::Context) -> usize {
1798            std::mem::size_of::<u8>()
1799        }
1800
1801        #[inline(always)]
1802        fn encode_is_copy() -> bool {
1803            true
1804        }
1805
1806        #[inline(always)]
1807        fn decode_is_copy() -> bool {
1808            false
1809        }
1810    }
1811
1812    impl fidl::encoding::ValueTypeMarker for PermissionState {
1813        type Borrowed<'a> = Self;
1814        #[inline(always)]
1815        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1816            *value
1817        }
1818    }
1819
1820    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1821        for PermissionState
1822    {
1823        #[inline]
1824        unsafe fn encode(
1825            self,
1826            encoder: &mut fidl::encoding::Encoder<'_, D>,
1827            offset: usize,
1828            _depth: fidl::encoding::Depth,
1829        ) -> fidl::Result<()> {
1830            encoder.debug_check_bounds::<Self>(offset);
1831            encoder.write_num(self.into_primitive(), offset);
1832            Ok(())
1833        }
1834    }
1835
1836    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PermissionState {
1837        #[inline(always)]
1838        fn new_empty() -> Self {
1839            Self::Denied
1840        }
1841
1842        #[inline]
1843        unsafe fn decode(
1844            &mut self,
1845            decoder: &mut fidl::encoding::Decoder<'_, D>,
1846            offset: usize,
1847            _depth: fidl::encoding::Depth,
1848        ) -> fidl::Result<()> {
1849            decoder.debug_check_bounds::<Self>(offset);
1850            let prim = decoder.read_num::<u8>(offset);
1851
1852            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1853            Ok(())
1854        }
1855    }
1856    unsafe impl fidl::encoding::TypeMarker for PermissionType {
1857        type Owned = Self;
1858
1859        #[inline(always)]
1860        fn inline_align(_context: fidl::encoding::Context) -> usize {
1861            std::mem::align_of::<u16>()
1862        }
1863
1864        #[inline(always)]
1865        fn inline_size(_context: fidl::encoding::Context) -> usize {
1866            std::mem::size_of::<u16>()
1867        }
1868
1869        #[inline(always)]
1870        fn encode_is_copy() -> bool {
1871            true
1872        }
1873
1874        #[inline(always)]
1875        fn decode_is_copy() -> bool {
1876            false
1877        }
1878    }
1879
1880    impl fidl::encoding::ValueTypeMarker for PermissionType {
1881        type Borrowed<'a> = Self;
1882        #[inline(always)]
1883        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1884            *value
1885        }
1886    }
1887
1888    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PermissionType {
1889        #[inline]
1890        unsafe fn encode(
1891            self,
1892            encoder: &mut fidl::encoding::Encoder<'_, D>,
1893            offset: usize,
1894            _depth: fidl::encoding::Depth,
1895        ) -> fidl::Result<()> {
1896            encoder.debug_check_bounds::<Self>(offset);
1897            encoder.write_num(self.into_primitive(), offset);
1898            Ok(())
1899        }
1900    }
1901
1902    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PermissionType {
1903        #[inline(always)]
1904        fn new_empty() -> Self {
1905            Self::Microphone
1906        }
1907
1908        #[inline]
1909        unsafe fn decode(
1910            &mut self,
1911            decoder: &mut fidl::encoding::Decoder<'_, D>,
1912            offset: usize,
1913            _depth: fidl::encoding::Depth,
1914        ) -> fidl::Result<()> {
1915            decoder.debug_check_bounds::<Self>(offset);
1916            let prim = decoder.read_num::<u16>(offset);
1917
1918            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1919            Ok(())
1920        }
1921    }
1922    unsafe impl fidl::encoding::TypeMarker for ReloadType {
1923        type Owned = Self;
1924
1925        #[inline(always)]
1926        fn inline_align(_context: fidl::encoding::Context) -> usize {
1927            std::mem::align_of::<u32>()
1928        }
1929
1930        #[inline(always)]
1931        fn inline_size(_context: fidl::encoding::Context) -> usize {
1932            std::mem::size_of::<u32>()
1933        }
1934
1935        #[inline(always)]
1936        fn encode_is_copy() -> bool {
1937            true
1938        }
1939
1940        #[inline(always)]
1941        fn decode_is_copy() -> bool {
1942            false
1943        }
1944    }
1945
1946    impl fidl::encoding::ValueTypeMarker for ReloadType {
1947        type Borrowed<'a> = Self;
1948        #[inline(always)]
1949        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1950            *value
1951        }
1952    }
1953
1954    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ReloadType {
1955        #[inline]
1956        unsafe fn encode(
1957            self,
1958            encoder: &mut fidl::encoding::Encoder<'_, D>,
1959            offset: usize,
1960            _depth: fidl::encoding::Depth,
1961        ) -> fidl::Result<()> {
1962            encoder.debug_check_bounds::<Self>(offset);
1963            encoder.write_num(self.into_primitive(), offset);
1964            Ok(())
1965        }
1966    }
1967
1968    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ReloadType {
1969        #[inline(always)]
1970        fn new_empty() -> Self {
1971            Self::PartialCache
1972        }
1973
1974        #[inline]
1975        unsafe fn decode(
1976            &mut self,
1977            decoder: &mut fidl::encoding::Decoder<'_, D>,
1978            offset: usize,
1979            _depth: fidl::encoding::Depth,
1980        ) -> fidl::Result<()> {
1981            decoder.debug_check_bounds::<Self>(offset);
1982            let prim = decoder.read_num::<u32>(offset);
1983
1984            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1985            Ok(())
1986        }
1987    }
1988    unsafe impl fidl::encoding::TypeMarker for UrlRequestAction {
1989        type Owned = Self;
1990
1991        #[inline(always)]
1992        fn inline_align(_context: fidl::encoding::Context) -> usize {
1993            std::mem::align_of::<i32>()
1994        }
1995
1996        #[inline(always)]
1997        fn inline_size(_context: fidl::encoding::Context) -> usize {
1998            std::mem::size_of::<i32>()
1999        }
2000
2001        #[inline(always)]
2002        fn encode_is_copy() -> bool {
2003            true
2004        }
2005
2006        #[inline(always)]
2007        fn decode_is_copy() -> bool {
2008            false
2009        }
2010    }
2011
2012    impl fidl::encoding::ValueTypeMarker for UrlRequestAction {
2013        type Borrowed<'a> = Self;
2014        #[inline(always)]
2015        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2016            *value
2017        }
2018    }
2019
2020    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2021        for UrlRequestAction
2022    {
2023        #[inline]
2024        unsafe fn encode(
2025            self,
2026            encoder: &mut fidl::encoding::Encoder<'_, D>,
2027            offset: usize,
2028            _depth: fidl::encoding::Depth,
2029        ) -> fidl::Result<()> {
2030            encoder.debug_check_bounds::<Self>(offset);
2031            encoder.write_num(self.into_primitive(), offset);
2032            Ok(())
2033        }
2034    }
2035
2036    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UrlRequestAction {
2037        #[inline(always)]
2038        fn new_empty() -> Self {
2039            Self::Allow
2040        }
2041
2042        #[inline]
2043        unsafe fn decode(
2044            &mut self,
2045            decoder: &mut fidl::encoding::Decoder<'_, D>,
2046            offset: usize,
2047            _depth: fidl::encoding::Depth,
2048        ) -> fidl::Result<()> {
2049            decoder.debug_check_bounds::<Self>(offset);
2050            let prim = decoder.read_num::<i32>(offset);
2051
2052            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2053            Ok(())
2054        }
2055    }
2056
2057    impl fidl::encoding::ValueTypeMarker for ContextGetRemoteDebuggingPortResponse {
2058        type Borrowed<'a> = &'a Self;
2059        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2060            value
2061        }
2062    }
2063
2064    unsafe impl fidl::encoding::TypeMarker for ContextGetRemoteDebuggingPortResponse {
2065        type Owned = Self;
2066
2067        #[inline(always)]
2068        fn inline_align(_context: fidl::encoding::Context) -> usize {
2069            2
2070        }
2071
2072        #[inline(always)]
2073        fn inline_size(_context: fidl::encoding::Context) -> usize {
2074            2
2075        }
2076        #[inline(always)]
2077        fn encode_is_copy() -> bool {
2078            true
2079        }
2080
2081        #[inline(always)]
2082        fn decode_is_copy() -> bool {
2083            true
2084        }
2085    }
2086
2087    unsafe impl<D: fidl::encoding::ResourceDialect>
2088        fidl::encoding::Encode<ContextGetRemoteDebuggingPortResponse, D>
2089        for &ContextGetRemoteDebuggingPortResponse
2090    {
2091        #[inline]
2092        unsafe fn encode(
2093            self,
2094            encoder: &mut fidl::encoding::Encoder<'_, D>,
2095            offset: usize,
2096            _depth: fidl::encoding::Depth,
2097        ) -> fidl::Result<()> {
2098            encoder.debug_check_bounds::<ContextGetRemoteDebuggingPortResponse>(offset);
2099            unsafe {
2100                // Copy the object into the buffer.
2101                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2102                (buf_ptr as *mut ContextGetRemoteDebuggingPortResponse)
2103                    .write_unaligned((self as *const ContextGetRemoteDebuggingPortResponse).read());
2104                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2105                // done second because the memcpy will write garbage to these bytes.
2106            }
2107            Ok(())
2108        }
2109    }
2110    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
2111        fidl::encoding::Encode<ContextGetRemoteDebuggingPortResponse, D> for (T0,)
2112    {
2113        #[inline]
2114        unsafe fn encode(
2115            self,
2116            encoder: &mut fidl::encoding::Encoder<'_, D>,
2117            offset: usize,
2118            depth: fidl::encoding::Depth,
2119        ) -> fidl::Result<()> {
2120            encoder.debug_check_bounds::<ContextGetRemoteDebuggingPortResponse>(offset);
2121            // Zero out padding regions. There's no need to apply masks
2122            // because the unmasked parts will be overwritten by fields.
2123            // Write the fields.
2124            self.0.encode(encoder, offset + 0, depth)?;
2125            Ok(())
2126        }
2127    }
2128
2129    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2130        for ContextGetRemoteDebuggingPortResponse
2131    {
2132        #[inline(always)]
2133        fn new_empty() -> Self {
2134            Self { port: fidl::new_empty!(u16, D) }
2135        }
2136
2137        #[inline]
2138        unsafe fn decode(
2139            &mut self,
2140            decoder: &mut fidl::encoding::Decoder<'_, D>,
2141            offset: usize,
2142            _depth: fidl::encoding::Depth,
2143        ) -> fidl::Result<()> {
2144            decoder.debug_check_bounds::<Self>(offset);
2145            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2146            // Verify that padding bytes are zero.
2147            // Copy from the buffer into the object.
2148            unsafe {
2149                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2150            }
2151            Ok(())
2152        }
2153    }
2154
2155    impl fidl::encoding::ValueTypeMarker for DevToolsPerContextListenerOnHttpPortOpenRequest {
2156        type Borrowed<'a> = &'a Self;
2157        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2158            value
2159        }
2160    }
2161
2162    unsafe impl fidl::encoding::TypeMarker for DevToolsPerContextListenerOnHttpPortOpenRequest {
2163        type Owned = Self;
2164
2165        #[inline(always)]
2166        fn inline_align(_context: fidl::encoding::Context) -> usize {
2167            2
2168        }
2169
2170        #[inline(always)]
2171        fn inline_size(_context: fidl::encoding::Context) -> usize {
2172            2
2173        }
2174        #[inline(always)]
2175        fn encode_is_copy() -> bool {
2176            true
2177        }
2178
2179        #[inline(always)]
2180        fn decode_is_copy() -> bool {
2181            true
2182        }
2183    }
2184
2185    unsafe impl<D: fidl::encoding::ResourceDialect>
2186        fidl::encoding::Encode<DevToolsPerContextListenerOnHttpPortOpenRequest, D>
2187        for &DevToolsPerContextListenerOnHttpPortOpenRequest
2188    {
2189        #[inline]
2190        unsafe fn encode(
2191            self,
2192            encoder: &mut fidl::encoding::Encoder<'_, D>,
2193            offset: usize,
2194            _depth: fidl::encoding::Depth,
2195        ) -> fidl::Result<()> {
2196            encoder.debug_check_bounds::<DevToolsPerContextListenerOnHttpPortOpenRequest>(offset);
2197            unsafe {
2198                // Copy the object into the buffer.
2199                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2200                (buf_ptr as *mut DevToolsPerContextListenerOnHttpPortOpenRequest).write_unaligned(
2201                    (self as *const DevToolsPerContextListenerOnHttpPortOpenRequest).read(),
2202                );
2203                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2204                // done second because the memcpy will write garbage to these bytes.
2205            }
2206            Ok(())
2207        }
2208    }
2209    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
2210        fidl::encoding::Encode<DevToolsPerContextListenerOnHttpPortOpenRequest, D> for (T0,)
2211    {
2212        #[inline]
2213        unsafe fn encode(
2214            self,
2215            encoder: &mut fidl::encoding::Encoder<'_, D>,
2216            offset: usize,
2217            depth: fidl::encoding::Depth,
2218        ) -> fidl::Result<()> {
2219            encoder.debug_check_bounds::<DevToolsPerContextListenerOnHttpPortOpenRequest>(offset);
2220            // Zero out padding regions. There's no need to apply masks
2221            // because the unmasked parts will be overwritten by fields.
2222            // Write the fields.
2223            self.0.encode(encoder, offset + 0, depth)?;
2224            Ok(())
2225        }
2226    }
2227
2228    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2229        for DevToolsPerContextListenerOnHttpPortOpenRequest
2230    {
2231        #[inline(always)]
2232        fn new_empty() -> Self {
2233            Self { port: fidl::new_empty!(u16, D) }
2234        }
2235
2236        #[inline]
2237        unsafe fn decode(
2238            &mut self,
2239            decoder: &mut fidl::encoding::Decoder<'_, D>,
2240            offset: usize,
2241            _depth: fidl::encoding::Depth,
2242        ) -> fidl::Result<()> {
2243            decoder.debug_check_bounds::<Self>(offset);
2244            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2245            // Verify that padding bytes are zero.
2246            // Copy from the buffer into the object.
2247            unsafe {
2248                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2249            }
2250            Ok(())
2251        }
2252    }
2253
2254    impl fidl::encoding::ValueTypeMarker for FrameConfigureInputTypesRequest {
2255        type Borrowed<'a> = &'a Self;
2256        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2257            value
2258        }
2259    }
2260
2261    unsafe impl fidl::encoding::TypeMarker for FrameConfigureInputTypesRequest {
2262        type Owned = Self;
2263
2264        #[inline(always)]
2265        fn inline_align(_context: fidl::encoding::Context) -> usize {
2266            8
2267        }
2268
2269        #[inline(always)]
2270        fn inline_size(_context: fidl::encoding::Context) -> usize {
2271            16
2272        }
2273    }
2274
2275    unsafe impl<D: fidl::encoding::ResourceDialect>
2276        fidl::encoding::Encode<FrameConfigureInputTypesRequest, D>
2277        for &FrameConfigureInputTypesRequest
2278    {
2279        #[inline]
2280        unsafe fn encode(
2281            self,
2282            encoder: &mut fidl::encoding::Encoder<'_, D>,
2283            offset: usize,
2284            _depth: fidl::encoding::Depth,
2285        ) -> fidl::Result<()> {
2286            encoder.debug_check_bounds::<FrameConfigureInputTypesRequest>(offset);
2287            // Delegate to tuple encoding.
2288            fidl::encoding::Encode::<FrameConfigureInputTypesRequest, D>::encode(
2289                (
2290                    <InputTypes as fidl::encoding::ValueTypeMarker>::borrow(&self.types),
2291                    <AllowInputState as fidl::encoding::ValueTypeMarker>::borrow(&self.allow),
2292                ),
2293                encoder,
2294                offset,
2295                _depth,
2296            )
2297        }
2298    }
2299    unsafe impl<
2300            D: fidl::encoding::ResourceDialect,
2301            T0: fidl::encoding::Encode<InputTypes, D>,
2302            T1: fidl::encoding::Encode<AllowInputState, D>,
2303        > fidl::encoding::Encode<FrameConfigureInputTypesRequest, D> for (T0, T1)
2304    {
2305        #[inline]
2306        unsafe fn encode(
2307            self,
2308            encoder: &mut fidl::encoding::Encoder<'_, D>,
2309            offset: usize,
2310            depth: fidl::encoding::Depth,
2311        ) -> fidl::Result<()> {
2312            encoder.debug_check_bounds::<FrameConfigureInputTypesRequest>(offset);
2313            // Zero out padding regions. There's no need to apply masks
2314            // because the unmasked parts will be overwritten by fields.
2315            unsafe {
2316                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
2317                (ptr as *mut u64).write_unaligned(0);
2318            }
2319            // Write the fields.
2320            self.0.encode(encoder, offset + 0, depth)?;
2321            self.1.encode(encoder, offset + 8, depth)?;
2322            Ok(())
2323        }
2324    }
2325
2326    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2327        for FrameConfigureInputTypesRequest
2328    {
2329        #[inline(always)]
2330        fn new_empty() -> Self {
2331            Self {
2332                types: fidl::new_empty!(InputTypes, D),
2333                allow: fidl::new_empty!(AllowInputState, D),
2334            }
2335        }
2336
2337        #[inline]
2338        unsafe fn decode(
2339            &mut self,
2340            decoder: &mut fidl::encoding::Decoder<'_, D>,
2341            offset: usize,
2342            _depth: fidl::encoding::Depth,
2343        ) -> fidl::Result<()> {
2344            decoder.debug_check_bounds::<Self>(offset);
2345            // Verify that padding bytes are zero.
2346            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
2347            let padval = unsafe { (ptr as *const u64).read_unaligned() };
2348            let mask = 0xffffffff00000000u64;
2349            let maskedval = padval & mask;
2350            if maskedval != 0 {
2351                return Err(fidl::Error::NonZeroPadding {
2352                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
2353                });
2354            }
2355            fidl::decode!(InputTypes, D, &mut self.types, decoder, offset + 0, _depth)?;
2356            fidl::decode!(AllowInputState, D, &mut self.allow, decoder, offset + 8, _depth)?;
2357            Ok(())
2358        }
2359    }
2360
2361    impl fidl::encoding::ValueTypeMarker for FrameForceContentDimensionsRequest {
2362        type Borrowed<'a> = &'a Self;
2363        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2364            value
2365        }
2366    }
2367
2368    unsafe impl fidl::encoding::TypeMarker for FrameForceContentDimensionsRequest {
2369        type Owned = Self;
2370
2371        #[inline(always)]
2372        fn inline_align(_context: fidl::encoding::Context) -> usize {
2373            8
2374        }
2375
2376        #[inline(always)]
2377        fn inline_size(_context: fidl::encoding::Context) -> usize {
2378            8
2379        }
2380    }
2381
2382    unsafe impl<D: fidl::encoding::ResourceDialect>
2383        fidl::encoding::Encode<FrameForceContentDimensionsRequest, D>
2384        for &FrameForceContentDimensionsRequest
2385    {
2386        #[inline]
2387        unsafe fn encode(
2388            self,
2389            encoder: &mut fidl::encoding::Encoder<'_, D>,
2390            offset: usize,
2391            _depth: fidl::encoding::Depth,
2392        ) -> fidl::Result<()> {
2393            encoder.debug_check_bounds::<FrameForceContentDimensionsRequest>(offset);
2394            // Delegate to tuple encoding.
2395            fidl::encoding::Encode::<FrameForceContentDimensionsRequest, D>::encode(
2396                (
2397                    <fidl::encoding::Boxed<fidl_fuchsia_ui_gfx__common::Vec2> as fidl::encoding::ValueTypeMarker>::borrow(&self.web_dips),
2398                ),
2399                encoder, offset, _depth
2400            )
2401        }
2402    }
2403    unsafe impl<
2404            D: fidl::encoding::ResourceDialect,
2405            T0: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_ui_gfx__common::Vec2>, D>,
2406        > fidl::encoding::Encode<FrameForceContentDimensionsRequest, D> for (T0,)
2407    {
2408        #[inline]
2409        unsafe fn encode(
2410            self,
2411            encoder: &mut fidl::encoding::Encoder<'_, D>,
2412            offset: usize,
2413            depth: fidl::encoding::Depth,
2414        ) -> fidl::Result<()> {
2415            encoder.debug_check_bounds::<FrameForceContentDimensionsRequest>(offset);
2416            // Zero out padding regions. There's no need to apply masks
2417            // because the unmasked parts will be overwritten by fields.
2418            // Write the fields.
2419            self.0.encode(encoder, offset + 0, depth)?;
2420            Ok(())
2421        }
2422    }
2423
2424    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2425        for FrameForceContentDimensionsRequest
2426    {
2427        #[inline(always)]
2428        fn new_empty() -> Self {
2429            Self {
2430                web_dips: fidl::new_empty!(
2431                    fidl::encoding::Boxed<fidl_fuchsia_ui_gfx__common::Vec2>,
2432                    D
2433                ),
2434            }
2435        }
2436
2437        #[inline]
2438        unsafe fn decode(
2439            &mut self,
2440            decoder: &mut fidl::encoding::Decoder<'_, D>,
2441            offset: usize,
2442            _depth: fidl::encoding::Depth,
2443        ) -> fidl::Result<()> {
2444            decoder.debug_check_bounds::<Self>(offset);
2445            // Verify that padding bytes are zero.
2446            fidl::decode!(
2447                fidl::encoding::Boxed<fidl_fuchsia_ui_gfx__common::Vec2>,
2448                D,
2449                &mut self.web_dips,
2450                decoder,
2451                offset + 0,
2452                _depth
2453            )?;
2454            Ok(())
2455        }
2456    }
2457
2458    impl fidl::encoding::ValueTypeMarker for FrameGetPrivateMemorySizeResponse {
2459        type Borrowed<'a> = &'a Self;
2460        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2461            value
2462        }
2463    }
2464
2465    unsafe impl fidl::encoding::TypeMarker for FrameGetPrivateMemorySizeResponse {
2466        type Owned = Self;
2467
2468        #[inline(always)]
2469        fn inline_align(_context: fidl::encoding::Context) -> usize {
2470            8
2471        }
2472
2473        #[inline(always)]
2474        fn inline_size(_context: fidl::encoding::Context) -> usize {
2475            8
2476        }
2477        #[inline(always)]
2478        fn encode_is_copy() -> bool {
2479            true
2480        }
2481
2482        #[inline(always)]
2483        fn decode_is_copy() -> bool {
2484            true
2485        }
2486    }
2487
2488    unsafe impl<D: fidl::encoding::ResourceDialect>
2489        fidl::encoding::Encode<FrameGetPrivateMemorySizeResponse, D>
2490        for &FrameGetPrivateMemorySizeResponse
2491    {
2492        #[inline]
2493        unsafe fn encode(
2494            self,
2495            encoder: &mut fidl::encoding::Encoder<'_, D>,
2496            offset: usize,
2497            _depth: fidl::encoding::Depth,
2498        ) -> fidl::Result<()> {
2499            encoder.debug_check_bounds::<FrameGetPrivateMemorySizeResponse>(offset);
2500            unsafe {
2501                // Copy the object into the buffer.
2502                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2503                (buf_ptr as *mut FrameGetPrivateMemorySizeResponse)
2504                    .write_unaligned((self as *const FrameGetPrivateMemorySizeResponse).read());
2505                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2506                // done second because the memcpy will write garbage to these bytes.
2507            }
2508            Ok(())
2509        }
2510    }
2511    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
2512        fidl::encoding::Encode<FrameGetPrivateMemorySizeResponse, D> for (T0,)
2513    {
2514        #[inline]
2515        unsafe fn encode(
2516            self,
2517            encoder: &mut fidl::encoding::Encoder<'_, D>,
2518            offset: usize,
2519            depth: fidl::encoding::Depth,
2520        ) -> fidl::Result<()> {
2521            encoder.debug_check_bounds::<FrameGetPrivateMemorySizeResponse>(offset);
2522            // Zero out padding regions. There's no need to apply masks
2523            // because the unmasked parts will be overwritten by fields.
2524            // Write the fields.
2525            self.0.encode(encoder, offset + 0, depth)?;
2526            Ok(())
2527        }
2528    }
2529
2530    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2531        for FrameGetPrivateMemorySizeResponse
2532    {
2533        #[inline(always)]
2534        fn new_empty() -> Self {
2535            Self { size_bytes: fidl::new_empty!(u64, D) }
2536        }
2537
2538        #[inline]
2539        unsafe fn decode(
2540            &mut self,
2541            decoder: &mut fidl::encoding::Decoder<'_, D>,
2542            offset: usize,
2543            _depth: fidl::encoding::Depth,
2544        ) -> fidl::Result<()> {
2545            decoder.debug_check_bounds::<Self>(offset);
2546            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2547            // Verify that padding bytes are zero.
2548            // Copy from the buffer into the object.
2549            unsafe {
2550                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
2551            }
2552            Ok(())
2553        }
2554    }
2555
2556    impl fidl::encoding::ValueTypeMarker for FrameRemoveBeforeLoadJavaScriptRequest {
2557        type Borrowed<'a> = &'a Self;
2558        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2559            value
2560        }
2561    }
2562
2563    unsafe impl fidl::encoding::TypeMarker for FrameRemoveBeforeLoadJavaScriptRequest {
2564        type Owned = Self;
2565
2566        #[inline(always)]
2567        fn inline_align(_context: fidl::encoding::Context) -> usize {
2568            8
2569        }
2570
2571        #[inline(always)]
2572        fn inline_size(_context: fidl::encoding::Context) -> usize {
2573            8
2574        }
2575        #[inline(always)]
2576        fn encode_is_copy() -> bool {
2577            true
2578        }
2579
2580        #[inline(always)]
2581        fn decode_is_copy() -> bool {
2582            true
2583        }
2584    }
2585
2586    unsafe impl<D: fidl::encoding::ResourceDialect>
2587        fidl::encoding::Encode<FrameRemoveBeforeLoadJavaScriptRequest, D>
2588        for &FrameRemoveBeforeLoadJavaScriptRequest
2589    {
2590        #[inline]
2591        unsafe fn encode(
2592            self,
2593            encoder: &mut fidl::encoding::Encoder<'_, D>,
2594            offset: usize,
2595            _depth: fidl::encoding::Depth,
2596        ) -> fidl::Result<()> {
2597            encoder.debug_check_bounds::<FrameRemoveBeforeLoadJavaScriptRequest>(offset);
2598            unsafe {
2599                // Copy the object into the buffer.
2600                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2601                (buf_ptr as *mut FrameRemoveBeforeLoadJavaScriptRequest).write_unaligned(
2602                    (self as *const FrameRemoveBeforeLoadJavaScriptRequest).read(),
2603                );
2604                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2605                // done second because the memcpy will write garbage to these bytes.
2606            }
2607            Ok(())
2608        }
2609    }
2610    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
2611        fidl::encoding::Encode<FrameRemoveBeforeLoadJavaScriptRequest, D> for (T0,)
2612    {
2613        #[inline]
2614        unsafe fn encode(
2615            self,
2616            encoder: &mut fidl::encoding::Encoder<'_, D>,
2617            offset: usize,
2618            depth: fidl::encoding::Depth,
2619        ) -> fidl::Result<()> {
2620            encoder.debug_check_bounds::<FrameRemoveBeforeLoadJavaScriptRequest>(offset);
2621            // Zero out padding regions. There's no need to apply masks
2622            // because the unmasked parts will be overwritten by fields.
2623            // Write the fields.
2624            self.0.encode(encoder, offset + 0, depth)?;
2625            Ok(())
2626        }
2627    }
2628
2629    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2630        for FrameRemoveBeforeLoadJavaScriptRequest
2631    {
2632        #[inline(always)]
2633        fn new_empty() -> Self {
2634            Self { id: fidl::new_empty!(u64, D) }
2635        }
2636
2637        #[inline]
2638        unsafe fn decode(
2639            &mut self,
2640            decoder: &mut fidl::encoding::Decoder<'_, D>,
2641            offset: usize,
2642            _depth: fidl::encoding::Depth,
2643        ) -> fidl::Result<()> {
2644            decoder.debug_check_bounds::<Self>(offset);
2645            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2646            // Verify that padding bytes are zero.
2647            // Copy from the buffer into the object.
2648            unsafe {
2649                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
2650            }
2651            Ok(())
2652        }
2653    }
2654
2655    impl fidl::encoding::ValueTypeMarker for FrameSetBlockMediaLoadingRequest {
2656        type Borrowed<'a> = &'a Self;
2657        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2658            value
2659        }
2660    }
2661
2662    unsafe impl fidl::encoding::TypeMarker for FrameSetBlockMediaLoadingRequest {
2663        type Owned = Self;
2664
2665        #[inline(always)]
2666        fn inline_align(_context: fidl::encoding::Context) -> usize {
2667            1
2668        }
2669
2670        #[inline(always)]
2671        fn inline_size(_context: fidl::encoding::Context) -> usize {
2672            1
2673        }
2674    }
2675
2676    unsafe impl<D: fidl::encoding::ResourceDialect>
2677        fidl::encoding::Encode<FrameSetBlockMediaLoadingRequest, D>
2678        for &FrameSetBlockMediaLoadingRequest
2679    {
2680        #[inline]
2681        unsafe fn encode(
2682            self,
2683            encoder: &mut fidl::encoding::Encoder<'_, D>,
2684            offset: usize,
2685            _depth: fidl::encoding::Depth,
2686        ) -> fidl::Result<()> {
2687            encoder.debug_check_bounds::<FrameSetBlockMediaLoadingRequest>(offset);
2688            // Delegate to tuple encoding.
2689            fidl::encoding::Encode::<FrameSetBlockMediaLoadingRequest, D>::encode(
2690                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.blocked),),
2691                encoder,
2692                offset,
2693                _depth,
2694            )
2695        }
2696    }
2697    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2698        fidl::encoding::Encode<FrameSetBlockMediaLoadingRequest, D> for (T0,)
2699    {
2700        #[inline]
2701        unsafe fn encode(
2702            self,
2703            encoder: &mut fidl::encoding::Encoder<'_, D>,
2704            offset: usize,
2705            depth: fidl::encoding::Depth,
2706        ) -> fidl::Result<()> {
2707            encoder.debug_check_bounds::<FrameSetBlockMediaLoadingRequest>(offset);
2708            // Zero out padding regions. There's no need to apply masks
2709            // because the unmasked parts will be overwritten by fields.
2710            // Write the fields.
2711            self.0.encode(encoder, offset + 0, depth)?;
2712            Ok(())
2713        }
2714    }
2715
2716    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2717        for FrameSetBlockMediaLoadingRequest
2718    {
2719        #[inline(always)]
2720        fn new_empty() -> Self {
2721            Self { blocked: fidl::new_empty!(bool, D) }
2722        }
2723
2724        #[inline]
2725        unsafe fn decode(
2726            &mut self,
2727            decoder: &mut fidl::encoding::Decoder<'_, D>,
2728            offset: usize,
2729            _depth: fidl::encoding::Depth,
2730        ) -> fidl::Result<()> {
2731            decoder.debug_check_bounds::<Self>(offset);
2732            // Verify that padding bytes are zero.
2733            fidl::decode!(bool, D, &mut self.blocked, decoder, offset + 0, _depth)?;
2734            Ok(())
2735        }
2736    }
2737
2738    impl fidl::encoding::ValueTypeMarker for FrameSetContentAreaSettingsRequest {
2739        type Borrowed<'a> = &'a Self;
2740        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2741            value
2742        }
2743    }
2744
2745    unsafe impl fidl::encoding::TypeMarker for FrameSetContentAreaSettingsRequest {
2746        type Owned = Self;
2747
2748        #[inline(always)]
2749        fn inline_align(_context: fidl::encoding::Context) -> usize {
2750            8
2751        }
2752
2753        #[inline(always)]
2754        fn inline_size(_context: fidl::encoding::Context) -> usize {
2755            16
2756        }
2757    }
2758
2759    unsafe impl<D: fidl::encoding::ResourceDialect>
2760        fidl::encoding::Encode<FrameSetContentAreaSettingsRequest, D>
2761        for &FrameSetContentAreaSettingsRequest
2762    {
2763        #[inline]
2764        unsafe fn encode(
2765            self,
2766            encoder: &mut fidl::encoding::Encoder<'_, D>,
2767            offset: usize,
2768            _depth: fidl::encoding::Depth,
2769        ) -> fidl::Result<()> {
2770            encoder.debug_check_bounds::<FrameSetContentAreaSettingsRequest>(offset);
2771            // Delegate to tuple encoding.
2772            fidl::encoding::Encode::<FrameSetContentAreaSettingsRequest, D>::encode(
2773                (<ContentAreaSettings as fidl::encoding::ValueTypeMarker>::borrow(&self.settings),),
2774                encoder,
2775                offset,
2776                _depth,
2777            )
2778        }
2779    }
2780    unsafe impl<
2781            D: fidl::encoding::ResourceDialect,
2782            T0: fidl::encoding::Encode<ContentAreaSettings, D>,
2783        > fidl::encoding::Encode<FrameSetContentAreaSettingsRequest, D> for (T0,)
2784    {
2785        #[inline]
2786        unsafe fn encode(
2787            self,
2788            encoder: &mut fidl::encoding::Encoder<'_, D>,
2789            offset: usize,
2790            depth: fidl::encoding::Depth,
2791        ) -> fidl::Result<()> {
2792            encoder.debug_check_bounds::<FrameSetContentAreaSettingsRequest>(offset);
2793            // Zero out padding regions. There's no need to apply masks
2794            // because the unmasked parts will be overwritten by fields.
2795            // Write the fields.
2796            self.0.encode(encoder, offset + 0, depth)?;
2797            Ok(())
2798        }
2799    }
2800
2801    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2802        for FrameSetContentAreaSettingsRequest
2803    {
2804        #[inline(always)]
2805        fn new_empty() -> Self {
2806            Self { settings: fidl::new_empty!(ContentAreaSettings, D) }
2807        }
2808
2809        #[inline]
2810        unsafe fn decode(
2811            &mut self,
2812            decoder: &mut fidl::encoding::Decoder<'_, D>,
2813            offset: usize,
2814            _depth: fidl::encoding::Depth,
2815        ) -> fidl::Result<()> {
2816            decoder.debug_check_bounds::<Self>(offset);
2817            // Verify that padding bytes are zero.
2818            fidl::decode!(ContentAreaSettings, D, &mut self.settings, decoder, offset + 0, _depth)?;
2819            Ok(())
2820        }
2821    }
2822
2823    impl fidl::encoding::ValueTypeMarker for FrameSetJavaScriptLogLevelRequest {
2824        type Borrowed<'a> = &'a Self;
2825        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2826            value
2827        }
2828    }
2829
2830    unsafe impl fidl::encoding::TypeMarker for FrameSetJavaScriptLogLevelRequest {
2831        type Owned = Self;
2832
2833        #[inline(always)]
2834        fn inline_align(_context: fidl::encoding::Context) -> usize {
2835            4
2836        }
2837
2838        #[inline(always)]
2839        fn inline_size(_context: fidl::encoding::Context) -> usize {
2840            4
2841        }
2842    }
2843
2844    unsafe impl<D: fidl::encoding::ResourceDialect>
2845        fidl::encoding::Encode<FrameSetJavaScriptLogLevelRequest, D>
2846        for &FrameSetJavaScriptLogLevelRequest
2847    {
2848        #[inline]
2849        unsafe fn encode(
2850            self,
2851            encoder: &mut fidl::encoding::Encoder<'_, D>,
2852            offset: usize,
2853            _depth: fidl::encoding::Depth,
2854        ) -> fidl::Result<()> {
2855            encoder.debug_check_bounds::<FrameSetJavaScriptLogLevelRequest>(offset);
2856            // Delegate to tuple encoding.
2857            fidl::encoding::Encode::<FrameSetJavaScriptLogLevelRequest, D>::encode(
2858                (<ConsoleLogLevel as fidl::encoding::ValueTypeMarker>::borrow(&self.level),),
2859                encoder,
2860                offset,
2861                _depth,
2862            )
2863        }
2864    }
2865    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ConsoleLogLevel, D>>
2866        fidl::encoding::Encode<FrameSetJavaScriptLogLevelRequest, D> for (T0,)
2867    {
2868        #[inline]
2869        unsafe fn encode(
2870            self,
2871            encoder: &mut fidl::encoding::Encoder<'_, D>,
2872            offset: usize,
2873            depth: fidl::encoding::Depth,
2874        ) -> fidl::Result<()> {
2875            encoder.debug_check_bounds::<FrameSetJavaScriptLogLevelRequest>(offset);
2876            // Zero out padding regions. There's no need to apply masks
2877            // because the unmasked parts will be overwritten by fields.
2878            // Write the fields.
2879            self.0.encode(encoder, offset + 0, depth)?;
2880            Ok(())
2881        }
2882    }
2883
2884    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2885        for FrameSetJavaScriptLogLevelRequest
2886    {
2887        #[inline(always)]
2888        fn new_empty() -> Self {
2889            Self { level: fidl::new_empty!(ConsoleLogLevel, D) }
2890        }
2891
2892        #[inline]
2893        unsafe fn decode(
2894            &mut self,
2895            decoder: &mut fidl::encoding::Decoder<'_, D>,
2896            offset: usize,
2897            _depth: fidl::encoding::Depth,
2898        ) -> fidl::Result<()> {
2899            decoder.debug_check_bounds::<Self>(offset);
2900            // Verify that padding bytes are zero.
2901            fidl::decode!(ConsoleLogLevel, D, &mut self.level, decoder, offset + 0, _depth)?;
2902            Ok(())
2903        }
2904    }
2905
2906    impl fidl::encoding::ValueTypeMarker for FrameSetMediaSettingsRequest {
2907        type Borrowed<'a> = &'a Self;
2908        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2909            value
2910        }
2911    }
2912
2913    unsafe impl fidl::encoding::TypeMarker for FrameSetMediaSettingsRequest {
2914        type Owned = Self;
2915
2916        #[inline(always)]
2917        fn inline_align(_context: fidl::encoding::Context) -> usize {
2918            8
2919        }
2920
2921        #[inline(always)]
2922        fn inline_size(_context: fidl::encoding::Context) -> usize {
2923            16
2924        }
2925    }
2926
2927    unsafe impl<D: fidl::encoding::ResourceDialect>
2928        fidl::encoding::Encode<FrameSetMediaSettingsRequest, D> for &FrameSetMediaSettingsRequest
2929    {
2930        #[inline]
2931        unsafe fn encode(
2932            self,
2933            encoder: &mut fidl::encoding::Encoder<'_, D>,
2934            offset: usize,
2935            _depth: fidl::encoding::Depth,
2936        ) -> fidl::Result<()> {
2937            encoder.debug_check_bounds::<FrameSetMediaSettingsRequest>(offset);
2938            // Delegate to tuple encoding.
2939            fidl::encoding::Encode::<FrameSetMediaSettingsRequest, D>::encode(
2940                (<FrameMediaSettings as fidl::encoding::ValueTypeMarker>::borrow(&self.settings),),
2941                encoder,
2942                offset,
2943                _depth,
2944            )
2945        }
2946    }
2947    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<FrameMediaSettings, D>>
2948        fidl::encoding::Encode<FrameSetMediaSettingsRequest, D> for (T0,)
2949    {
2950        #[inline]
2951        unsafe fn encode(
2952            self,
2953            encoder: &mut fidl::encoding::Encoder<'_, D>,
2954            offset: usize,
2955            depth: fidl::encoding::Depth,
2956        ) -> fidl::Result<()> {
2957            encoder.debug_check_bounds::<FrameSetMediaSettingsRequest>(offset);
2958            // Zero out padding regions. There's no need to apply masks
2959            // because the unmasked parts will be overwritten by fields.
2960            // Write the fields.
2961            self.0.encode(encoder, offset + 0, depth)?;
2962            Ok(())
2963        }
2964    }
2965
2966    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2967        for FrameSetMediaSettingsRequest
2968    {
2969        #[inline(always)]
2970        fn new_empty() -> Self {
2971            Self { settings: fidl::new_empty!(FrameMediaSettings, D) }
2972        }
2973
2974        #[inline]
2975        unsafe fn decode(
2976            &mut self,
2977            decoder: &mut fidl::encoding::Decoder<'_, D>,
2978            offset: usize,
2979            _depth: fidl::encoding::Depth,
2980        ) -> fidl::Result<()> {
2981            decoder.debug_check_bounds::<Self>(offset);
2982            // Verify that padding bytes are zero.
2983            fidl::decode!(FrameMediaSettings, D, &mut self.settings, decoder, offset + 0, _depth)?;
2984            Ok(())
2985        }
2986    }
2987
2988    impl fidl::encoding::ValueTypeMarker for FrameSetPermissionStateRequest {
2989        type Borrowed<'a> = &'a Self;
2990        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2991            value
2992        }
2993    }
2994
2995    unsafe impl fidl::encoding::TypeMarker for FrameSetPermissionStateRequest {
2996        type Owned = Self;
2997
2998        #[inline(always)]
2999        fn inline_align(_context: fidl::encoding::Context) -> usize {
3000            8
3001        }
3002
3003        #[inline(always)]
3004        fn inline_size(_context: fidl::encoding::Context) -> usize {
3005            40
3006        }
3007    }
3008
3009    unsafe impl<D: fidl::encoding::ResourceDialect>
3010        fidl::encoding::Encode<FrameSetPermissionStateRequest, D>
3011        for &FrameSetPermissionStateRequest
3012    {
3013        #[inline]
3014        unsafe fn encode(
3015            self,
3016            encoder: &mut fidl::encoding::Encoder<'_, D>,
3017            offset: usize,
3018            _depth: fidl::encoding::Depth,
3019        ) -> fidl::Result<()> {
3020            encoder.debug_check_bounds::<FrameSetPermissionStateRequest>(offset);
3021            // Delegate to tuple encoding.
3022            fidl::encoding::Encode::<FrameSetPermissionStateRequest, D>::encode(
3023                (
3024                    <PermissionDescriptor as fidl::encoding::ValueTypeMarker>::borrow(&self.permission),
3025                    <fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow(&self.web_origin),
3026                    <PermissionState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
3027                ),
3028                encoder, offset, _depth
3029            )
3030        }
3031    }
3032    unsafe impl<
3033            D: fidl::encoding::ResourceDialect,
3034            T0: fidl::encoding::Encode<PermissionDescriptor, D>,
3035            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<65536>, D>,
3036            T2: fidl::encoding::Encode<PermissionState, D>,
3037        > fidl::encoding::Encode<FrameSetPermissionStateRequest, D> for (T0, T1, T2)
3038    {
3039        #[inline]
3040        unsafe fn encode(
3041            self,
3042            encoder: &mut fidl::encoding::Encoder<'_, D>,
3043            offset: usize,
3044            depth: fidl::encoding::Depth,
3045        ) -> fidl::Result<()> {
3046            encoder.debug_check_bounds::<FrameSetPermissionStateRequest>(offset);
3047            // Zero out padding regions. There's no need to apply masks
3048            // because the unmasked parts will be overwritten by fields.
3049            unsafe {
3050                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
3051                (ptr as *mut u64).write_unaligned(0);
3052            }
3053            // Write the fields.
3054            self.0.encode(encoder, offset + 0, depth)?;
3055            self.1.encode(encoder, offset + 16, depth)?;
3056            self.2.encode(encoder, offset + 32, depth)?;
3057            Ok(())
3058        }
3059    }
3060
3061    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3062        for FrameSetPermissionStateRequest
3063    {
3064        #[inline(always)]
3065        fn new_empty() -> Self {
3066            Self {
3067                permission: fidl::new_empty!(PermissionDescriptor, D),
3068                web_origin: fidl::new_empty!(fidl::encoding::BoundedString<65536>, D),
3069                state: fidl::new_empty!(PermissionState, D),
3070            }
3071        }
3072
3073        #[inline]
3074        unsafe fn decode(
3075            &mut self,
3076            decoder: &mut fidl::encoding::Decoder<'_, D>,
3077            offset: usize,
3078            _depth: fidl::encoding::Depth,
3079        ) -> fidl::Result<()> {
3080            decoder.debug_check_bounds::<Self>(offset);
3081            // Verify that padding bytes are zero.
3082            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
3083            let padval = unsafe { (ptr as *const u64).read_unaligned() };
3084            let mask = 0xffffffffffffff00u64;
3085            let maskedval = padval & mask;
3086            if maskedval != 0 {
3087                return Err(fidl::Error::NonZeroPadding {
3088                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
3089                });
3090            }
3091            fidl::decode!(
3092                PermissionDescriptor,
3093                D,
3094                &mut self.permission,
3095                decoder,
3096                offset + 0,
3097                _depth
3098            )?;
3099            fidl::decode!(
3100                fidl::encoding::BoundedString<65536>,
3101                D,
3102                &mut self.web_origin,
3103                decoder,
3104                offset + 16,
3105                _depth
3106            )?;
3107            fidl::decode!(PermissionState, D, &mut self.state, decoder, offset + 32, _depth)?;
3108            Ok(())
3109        }
3110    }
3111
3112    impl fidl::encoding::ValueTypeMarker for FrameSetUrlRequestRewriteRulesRequest {
3113        type Borrowed<'a> = &'a Self;
3114        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3115            value
3116        }
3117    }
3118
3119    unsafe impl fidl::encoding::TypeMarker for FrameSetUrlRequestRewriteRulesRequest {
3120        type Owned = Self;
3121
3122        #[inline(always)]
3123        fn inline_align(_context: fidl::encoding::Context) -> usize {
3124            8
3125        }
3126
3127        #[inline(always)]
3128        fn inline_size(_context: fidl::encoding::Context) -> usize {
3129            16
3130        }
3131    }
3132
3133    unsafe impl<D: fidl::encoding::ResourceDialect>
3134        fidl::encoding::Encode<FrameSetUrlRequestRewriteRulesRequest, D>
3135        for &FrameSetUrlRequestRewriteRulesRequest
3136    {
3137        #[inline]
3138        unsafe fn encode(
3139            self,
3140            encoder: &mut fidl::encoding::Encoder<'_, D>,
3141            offset: usize,
3142            _depth: fidl::encoding::Depth,
3143        ) -> fidl::Result<()> {
3144            encoder.debug_check_bounds::<FrameSetUrlRequestRewriteRulesRequest>(offset);
3145            // Delegate to tuple encoding.
3146            fidl::encoding::Encode::<FrameSetUrlRequestRewriteRulesRequest, D>::encode(
3147                (
3148                    <fidl::encoding::Vector<UrlRequestRewriteRule, 4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.rules),
3149                ),
3150                encoder, offset, _depth
3151            )
3152        }
3153    }
3154    unsafe impl<
3155            D: fidl::encoding::ResourceDialect,
3156            T0: fidl::encoding::Encode<fidl::encoding::Vector<UrlRequestRewriteRule, 4096>, D>,
3157        > fidl::encoding::Encode<FrameSetUrlRequestRewriteRulesRequest, D> for (T0,)
3158    {
3159        #[inline]
3160        unsafe fn encode(
3161            self,
3162            encoder: &mut fidl::encoding::Encoder<'_, D>,
3163            offset: usize,
3164            depth: fidl::encoding::Depth,
3165        ) -> fidl::Result<()> {
3166            encoder.debug_check_bounds::<FrameSetUrlRequestRewriteRulesRequest>(offset);
3167            // Zero out padding regions. There's no need to apply masks
3168            // because the unmasked parts will be overwritten by fields.
3169            // Write the fields.
3170            self.0.encode(encoder, offset + 0, depth)?;
3171            Ok(())
3172        }
3173    }
3174
3175    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3176        for FrameSetUrlRequestRewriteRulesRequest
3177    {
3178        #[inline(always)]
3179        fn new_empty() -> Self {
3180            Self { rules: fidl::new_empty!(fidl::encoding::Vector<UrlRequestRewriteRule, 4096>, D) }
3181        }
3182
3183        #[inline]
3184        unsafe fn decode(
3185            &mut self,
3186            decoder: &mut fidl::encoding::Decoder<'_, D>,
3187            offset: usize,
3188            _depth: fidl::encoding::Depth,
3189        ) -> fidl::Result<()> {
3190            decoder.debug_check_bounds::<Self>(offset);
3191            // Verify that padding bytes are zero.
3192            fidl::decode!(fidl::encoding::Vector<UrlRequestRewriteRule, 4096>, D, &mut self.rules, decoder, offset + 0, _depth)?;
3193            Ok(())
3194        }
3195    }
3196
3197    impl fidl::encoding::ValueTypeMarker for NavigationControllerReloadRequest {
3198        type Borrowed<'a> = &'a Self;
3199        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3200            value
3201        }
3202    }
3203
3204    unsafe impl fidl::encoding::TypeMarker for NavigationControllerReloadRequest {
3205        type Owned = Self;
3206
3207        #[inline(always)]
3208        fn inline_align(_context: fidl::encoding::Context) -> usize {
3209            4
3210        }
3211
3212        #[inline(always)]
3213        fn inline_size(_context: fidl::encoding::Context) -> usize {
3214            4
3215        }
3216    }
3217
3218    unsafe impl<D: fidl::encoding::ResourceDialect>
3219        fidl::encoding::Encode<NavigationControllerReloadRequest, D>
3220        for &NavigationControllerReloadRequest
3221    {
3222        #[inline]
3223        unsafe fn encode(
3224            self,
3225            encoder: &mut fidl::encoding::Encoder<'_, D>,
3226            offset: usize,
3227            _depth: fidl::encoding::Depth,
3228        ) -> fidl::Result<()> {
3229            encoder.debug_check_bounds::<NavigationControllerReloadRequest>(offset);
3230            // Delegate to tuple encoding.
3231            fidl::encoding::Encode::<NavigationControllerReloadRequest, D>::encode(
3232                (<ReloadType as fidl::encoding::ValueTypeMarker>::borrow(&self.type_),),
3233                encoder,
3234                offset,
3235                _depth,
3236            )
3237        }
3238    }
3239    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ReloadType, D>>
3240        fidl::encoding::Encode<NavigationControllerReloadRequest, D> for (T0,)
3241    {
3242        #[inline]
3243        unsafe fn encode(
3244            self,
3245            encoder: &mut fidl::encoding::Encoder<'_, D>,
3246            offset: usize,
3247            depth: fidl::encoding::Depth,
3248        ) -> fidl::Result<()> {
3249            encoder.debug_check_bounds::<NavigationControllerReloadRequest>(offset);
3250            // Zero out padding regions. There's no need to apply masks
3251            // because the unmasked parts will be overwritten by fields.
3252            // Write the fields.
3253            self.0.encode(encoder, offset + 0, depth)?;
3254            Ok(())
3255        }
3256    }
3257
3258    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3259        for NavigationControllerReloadRequest
3260    {
3261        #[inline(always)]
3262        fn new_empty() -> Self {
3263            Self { type_: fidl::new_empty!(ReloadType, D) }
3264        }
3265
3266        #[inline]
3267        unsafe fn decode(
3268            &mut self,
3269            decoder: &mut fidl::encoding::Decoder<'_, D>,
3270            offset: usize,
3271            _depth: fidl::encoding::Depth,
3272        ) -> fidl::Result<()> {
3273            decoder.debug_check_bounds::<Self>(offset);
3274            // Verify that padding bytes are zero.
3275            fidl::decode!(ReloadType, D, &mut self.type_, decoder, offset + 0, _depth)?;
3276            Ok(())
3277        }
3278    }
3279
3280    impl fidl::encoding::ValueTypeMarker
3281        for NavigationPolicyProviderEvaluateRequestedNavigationRequest
3282    {
3283        type Borrowed<'a> = &'a Self;
3284        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3285            value
3286        }
3287    }
3288
3289    unsafe impl fidl::encoding::TypeMarker
3290        for NavigationPolicyProviderEvaluateRequestedNavigationRequest
3291    {
3292        type Owned = Self;
3293
3294        #[inline(always)]
3295        fn inline_align(_context: fidl::encoding::Context) -> usize {
3296            8
3297        }
3298
3299        #[inline(always)]
3300        fn inline_size(_context: fidl::encoding::Context) -> usize {
3301            16
3302        }
3303    }
3304
3305    unsafe impl<D: fidl::encoding::ResourceDialect>
3306        fidl::encoding::Encode<NavigationPolicyProviderEvaluateRequestedNavigationRequest, D>
3307        for &NavigationPolicyProviderEvaluateRequestedNavigationRequest
3308    {
3309        #[inline]
3310        unsafe fn encode(
3311            self,
3312            encoder: &mut fidl::encoding::Encoder<'_, D>,
3313            offset: usize,
3314            _depth: fidl::encoding::Depth,
3315        ) -> fidl::Result<()> {
3316            encoder
3317                .debug_check_bounds::<NavigationPolicyProviderEvaluateRequestedNavigationRequest>(
3318                    offset,
3319                );
3320            // Delegate to tuple encoding.
3321            fidl::encoding::Encode::<NavigationPolicyProviderEvaluateRequestedNavigationRequest, D>::encode(
3322                (
3323                    <RequestedNavigation as fidl::encoding::ValueTypeMarker>::borrow(&self.requested_navigation),
3324                ),
3325                encoder, offset, _depth
3326            )
3327        }
3328    }
3329    unsafe impl<
3330            D: fidl::encoding::ResourceDialect,
3331            T0: fidl::encoding::Encode<RequestedNavigation, D>,
3332        > fidl::encoding::Encode<NavigationPolicyProviderEvaluateRequestedNavigationRequest, D>
3333        for (T0,)
3334    {
3335        #[inline]
3336        unsafe fn encode(
3337            self,
3338            encoder: &mut fidl::encoding::Encoder<'_, D>,
3339            offset: usize,
3340            depth: fidl::encoding::Depth,
3341        ) -> fidl::Result<()> {
3342            encoder
3343                .debug_check_bounds::<NavigationPolicyProviderEvaluateRequestedNavigationRequest>(
3344                    offset,
3345                );
3346            // Zero out padding regions. There's no need to apply masks
3347            // because the unmasked parts will be overwritten by fields.
3348            // Write the fields.
3349            self.0.encode(encoder, offset + 0, depth)?;
3350            Ok(())
3351        }
3352    }
3353
3354    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3355        for NavigationPolicyProviderEvaluateRequestedNavigationRequest
3356    {
3357        #[inline(always)]
3358        fn new_empty() -> Self {
3359            Self { requested_navigation: fidl::new_empty!(RequestedNavigation, D) }
3360        }
3361
3362        #[inline]
3363        unsafe fn decode(
3364            &mut self,
3365            decoder: &mut fidl::encoding::Decoder<'_, D>,
3366            offset: usize,
3367            _depth: fidl::encoding::Depth,
3368        ) -> fidl::Result<()> {
3369            decoder.debug_check_bounds::<Self>(offset);
3370            // Verify that padding bytes are zero.
3371            fidl::decode!(
3372                RequestedNavigation,
3373                D,
3374                &mut self.requested_navigation,
3375                decoder,
3376                offset + 0,
3377                _depth
3378            )?;
3379            Ok(())
3380        }
3381    }
3382
3383    impl fidl::encoding::ValueTypeMarker for NoArgumentsAction {
3384        type Borrowed<'a> = &'a Self;
3385        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3386            value
3387        }
3388    }
3389
3390    unsafe impl fidl::encoding::TypeMarker for NoArgumentsAction {
3391        type Owned = Self;
3392
3393        #[inline(always)]
3394        fn inline_align(_context: fidl::encoding::Context) -> usize {
3395            1
3396        }
3397
3398        #[inline(always)]
3399        fn inline_size(_context: fidl::encoding::Context) -> usize {
3400            1
3401        }
3402    }
3403
3404    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NoArgumentsAction, D>
3405        for &NoArgumentsAction
3406    {
3407        #[inline]
3408        unsafe fn encode(
3409            self,
3410            encoder: &mut fidl::encoding::Encoder<'_, D>,
3411            offset: usize,
3412            _depth: fidl::encoding::Depth,
3413        ) -> fidl::Result<()> {
3414            encoder.debug_check_bounds::<NoArgumentsAction>(offset);
3415            encoder.write_num(0u8, offset);
3416            Ok(())
3417        }
3418    }
3419
3420    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NoArgumentsAction {
3421        #[inline(always)]
3422        fn new_empty() -> Self {
3423            Self
3424        }
3425
3426        #[inline]
3427        unsafe fn decode(
3428            &mut self,
3429            decoder: &mut fidl::encoding::Decoder<'_, D>,
3430            offset: usize,
3431            _depth: fidl::encoding::Depth,
3432        ) -> fidl::Result<()> {
3433            decoder.debug_check_bounds::<Self>(offset);
3434            match decoder.read_num::<u8>(offset) {
3435                0 => Ok(()),
3436                _ => Err(fidl::Error::Invalid),
3437            }
3438        }
3439    }
3440
3441    impl ContentAreaSettings {
3442        #[inline(always)]
3443        fn max_ordinal_present(&self) -> u64 {
3444            if let Some(_) = self.page_scale {
3445                return 4;
3446            }
3447            if let Some(_) = self.theme {
3448                return 3;
3449            }
3450            if let Some(_) = self.autoplay_policy {
3451                return 2;
3452            }
3453            if let Some(_) = self.hide_scrollbars {
3454                return 1;
3455            }
3456            0
3457        }
3458    }
3459
3460    impl fidl::encoding::ValueTypeMarker for ContentAreaSettings {
3461        type Borrowed<'a> = &'a Self;
3462        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3463            value
3464        }
3465    }
3466
3467    unsafe impl fidl::encoding::TypeMarker for ContentAreaSettings {
3468        type Owned = Self;
3469
3470        #[inline(always)]
3471        fn inline_align(_context: fidl::encoding::Context) -> usize {
3472            8
3473        }
3474
3475        #[inline(always)]
3476        fn inline_size(_context: fidl::encoding::Context) -> usize {
3477            16
3478        }
3479    }
3480
3481    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ContentAreaSettings, D>
3482        for &ContentAreaSettings
3483    {
3484        unsafe fn encode(
3485            self,
3486            encoder: &mut fidl::encoding::Encoder<'_, D>,
3487            offset: usize,
3488            mut depth: fidl::encoding::Depth,
3489        ) -> fidl::Result<()> {
3490            encoder.debug_check_bounds::<ContentAreaSettings>(offset);
3491            // Vector header
3492            let max_ordinal: u64 = self.max_ordinal_present();
3493            encoder.write_num(max_ordinal, offset);
3494            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3495            // Calling encoder.out_of_line_offset(0) is not allowed.
3496            if max_ordinal == 0 {
3497                return Ok(());
3498            }
3499            depth.increment()?;
3500            let envelope_size = 8;
3501            let bytes_len = max_ordinal as usize * envelope_size;
3502            #[allow(unused_variables)]
3503            let offset = encoder.out_of_line_offset(bytes_len);
3504            let mut _prev_end_offset: usize = 0;
3505            if 1 > max_ordinal {
3506                return Ok(());
3507            }
3508
3509            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3510            // are envelope_size bytes.
3511            let cur_offset: usize = (1 - 1) * envelope_size;
3512
3513            // Zero reserved fields.
3514            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3515
3516            // Safety:
3517            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3518            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3519            //   envelope_size bytes, there is always sufficient room.
3520            fidl::encoding::encode_in_envelope_optional::<bool, D>(
3521                self.hide_scrollbars
3522                    .as_ref()
3523                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3524                encoder,
3525                offset + cur_offset,
3526                depth,
3527            )?;
3528
3529            _prev_end_offset = cur_offset + envelope_size;
3530            if 2 > max_ordinal {
3531                return Ok(());
3532            }
3533
3534            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3535            // are envelope_size bytes.
3536            let cur_offset: usize = (2 - 1) * envelope_size;
3537
3538            // Zero reserved fields.
3539            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3540
3541            // Safety:
3542            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3543            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3544            //   envelope_size bytes, there is always sufficient room.
3545            fidl::encoding::encode_in_envelope_optional::<AutoplayPolicy, D>(
3546                self.autoplay_policy
3547                    .as_ref()
3548                    .map(<AutoplayPolicy as fidl::encoding::ValueTypeMarker>::borrow),
3549                encoder,
3550                offset + cur_offset,
3551                depth,
3552            )?;
3553
3554            _prev_end_offset = cur_offset + envelope_size;
3555            if 3 > max_ordinal {
3556                return Ok(());
3557            }
3558
3559            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3560            // are envelope_size bytes.
3561            let cur_offset: usize = (3 - 1) * envelope_size;
3562
3563            // Zero reserved fields.
3564            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3565
3566            // Safety:
3567            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3568            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3569            //   envelope_size bytes, there is always sufficient room.
3570            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_settings__common::ThemeType, D>(
3571            self.theme.as_ref().map(<fidl_fuchsia_settings__common::ThemeType as fidl::encoding::ValueTypeMarker>::borrow),
3572            encoder, offset + cur_offset, depth
3573        )?;
3574
3575            _prev_end_offset = cur_offset + envelope_size;
3576            if 4 > max_ordinal {
3577                return Ok(());
3578            }
3579
3580            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3581            // are envelope_size bytes.
3582            let cur_offset: usize = (4 - 1) * envelope_size;
3583
3584            // Zero reserved fields.
3585            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3586
3587            // Safety:
3588            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3589            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3590            //   envelope_size bytes, there is always sufficient room.
3591            fidl::encoding::encode_in_envelope_optional::<f32, D>(
3592                self.page_scale.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
3593                encoder,
3594                offset + cur_offset,
3595                depth,
3596            )?;
3597
3598            _prev_end_offset = cur_offset + envelope_size;
3599
3600            Ok(())
3601        }
3602    }
3603
3604    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ContentAreaSettings {
3605        #[inline(always)]
3606        fn new_empty() -> Self {
3607            Self::default()
3608        }
3609
3610        unsafe fn decode(
3611            &mut self,
3612            decoder: &mut fidl::encoding::Decoder<'_, D>,
3613            offset: usize,
3614            mut depth: fidl::encoding::Depth,
3615        ) -> fidl::Result<()> {
3616            decoder.debug_check_bounds::<Self>(offset);
3617            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3618                None => return Err(fidl::Error::NotNullable),
3619                Some(len) => len,
3620            };
3621            // Calling decoder.out_of_line_offset(0) is not allowed.
3622            if len == 0 {
3623                return Ok(());
3624            };
3625            depth.increment()?;
3626            let envelope_size = 8;
3627            let bytes_len = len * envelope_size;
3628            let offset = decoder.out_of_line_offset(bytes_len)?;
3629            // Decode the envelope for each type.
3630            let mut _next_ordinal_to_read = 0;
3631            let mut next_offset = offset;
3632            let end_offset = offset + bytes_len;
3633            _next_ordinal_to_read += 1;
3634            if next_offset >= end_offset {
3635                return Ok(());
3636            }
3637
3638            // Decode unknown envelopes for gaps in ordinals.
3639            while _next_ordinal_to_read < 1 {
3640                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3641                _next_ordinal_to_read += 1;
3642                next_offset += envelope_size;
3643            }
3644
3645            let next_out_of_line = decoder.next_out_of_line();
3646            let handles_before = decoder.remaining_handles();
3647            if let Some((inlined, num_bytes, num_handles)) =
3648                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3649            {
3650                let member_inline_size =
3651                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3652                if inlined != (member_inline_size <= 4) {
3653                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3654                }
3655                let inner_offset;
3656                let mut inner_depth = depth.clone();
3657                if inlined {
3658                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3659                    inner_offset = next_offset;
3660                } else {
3661                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3662                    inner_depth.increment()?;
3663                }
3664                let val_ref = self.hide_scrollbars.get_or_insert_with(|| fidl::new_empty!(bool, D));
3665                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3666                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3667                {
3668                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3669                }
3670                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3671                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3672                }
3673            }
3674
3675            next_offset += envelope_size;
3676            _next_ordinal_to_read += 1;
3677            if next_offset >= end_offset {
3678                return Ok(());
3679            }
3680
3681            // Decode unknown envelopes for gaps in ordinals.
3682            while _next_ordinal_to_read < 2 {
3683                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3684                _next_ordinal_to_read += 1;
3685                next_offset += envelope_size;
3686            }
3687
3688            let next_out_of_line = decoder.next_out_of_line();
3689            let handles_before = decoder.remaining_handles();
3690            if let Some((inlined, num_bytes, num_handles)) =
3691                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3692            {
3693                let member_inline_size =
3694                    <AutoplayPolicy as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3695                if inlined != (member_inline_size <= 4) {
3696                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3697                }
3698                let inner_offset;
3699                let mut inner_depth = depth.clone();
3700                if inlined {
3701                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3702                    inner_offset = next_offset;
3703                } else {
3704                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3705                    inner_depth.increment()?;
3706                }
3707                let val_ref =
3708                    self.autoplay_policy.get_or_insert_with(|| fidl::new_empty!(AutoplayPolicy, D));
3709                fidl::decode!(AutoplayPolicy, D, val_ref, decoder, inner_offset, inner_depth)?;
3710                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3711                {
3712                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3713                }
3714                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3715                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3716                }
3717            }
3718
3719            next_offset += envelope_size;
3720            _next_ordinal_to_read += 1;
3721            if next_offset >= end_offset {
3722                return Ok(());
3723            }
3724
3725            // Decode unknown envelopes for gaps in ordinals.
3726            while _next_ordinal_to_read < 3 {
3727                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3728                _next_ordinal_to_read += 1;
3729                next_offset += envelope_size;
3730            }
3731
3732            let next_out_of_line = decoder.next_out_of_line();
3733            let handles_before = decoder.remaining_handles();
3734            if let Some((inlined, num_bytes, num_handles)) =
3735                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3736            {
3737                let member_inline_size = <fidl_fuchsia_settings__common::ThemeType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3738                if inlined != (member_inline_size <= 4) {
3739                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3740                }
3741                let inner_offset;
3742                let mut inner_depth = depth.clone();
3743                if inlined {
3744                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3745                    inner_offset = next_offset;
3746                } else {
3747                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3748                    inner_depth.increment()?;
3749                }
3750                let val_ref = self.theme.get_or_insert_with(|| {
3751                    fidl::new_empty!(fidl_fuchsia_settings__common::ThemeType, D)
3752                });
3753                fidl::decode!(
3754                    fidl_fuchsia_settings__common::ThemeType,
3755                    D,
3756                    val_ref,
3757                    decoder,
3758                    inner_offset,
3759                    inner_depth
3760                )?;
3761                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3762                {
3763                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3764                }
3765                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3766                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3767                }
3768            }
3769
3770            next_offset += envelope_size;
3771            _next_ordinal_to_read += 1;
3772            if next_offset >= end_offset {
3773                return Ok(());
3774            }
3775
3776            // Decode unknown envelopes for gaps in ordinals.
3777            while _next_ordinal_to_read < 4 {
3778                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3779                _next_ordinal_to_read += 1;
3780                next_offset += envelope_size;
3781            }
3782
3783            let next_out_of_line = decoder.next_out_of_line();
3784            let handles_before = decoder.remaining_handles();
3785            if let Some((inlined, num_bytes, num_handles)) =
3786                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3787            {
3788                let member_inline_size =
3789                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3790                if inlined != (member_inline_size <= 4) {
3791                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3792                }
3793                let inner_offset;
3794                let mut inner_depth = depth.clone();
3795                if inlined {
3796                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3797                    inner_offset = next_offset;
3798                } else {
3799                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3800                    inner_depth.increment()?;
3801                }
3802                let val_ref = self.page_scale.get_or_insert_with(|| fidl::new_empty!(f32, D));
3803                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
3804                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3805                {
3806                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3807                }
3808                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3809                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3810                }
3811            }
3812
3813            next_offset += envelope_size;
3814
3815            // Decode the remaining unknown envelopes.
3816            while next_offset < end_offset {
3817                _next_ordinal_to_read += 1;
3818                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3819                next_offset += envelope_size;
3820            }
3821
3822            Ok(())
3823        }
3824    }
3825
3826    impl CookieId {
3827        #[inline(always)]
3828        fn max_ordinal_present(&self) -> u64 {
3829            if let Some(_) = self.path {
3830                return 3;
3831            }
3832            if let Some(_) = self.domain {
3833                return 2;
3834            }
3835            if let Some(_) = self.name {
3836                return 1;
3837            }
3838            0
3839        }
3840    }
3841
3842    impl fidl::encoding::ValueTypeMarker for CookieId {
3843        type Borrowed<'a> = &'a Self;
3844        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3845            value
3846        }
3847    }
3848
3849    unsafe impl fidl::encoding::TypeMarker for CookieId {
3850        type Owned = Self;
3851
3852        #[inline(always)]
3853        fn inline_align(_context: fidl::encoding::Context) -> usize {
3854            8
3855        }
3856
3857        #[inline(always)]
3858        fn inline_size(_context: fidl::encoding::Context) -> usize {
3859            16
3860        }
3861    }
3862
3863    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CookieId, D> for &CookieId {
3864        unsafe fn encode(
3865            self,
3866            encoder: &mut fidl::encoding::Encoder<'_, D>,
3867            offset: usize,
3868            mut depth: fidl::encoding::Depth,
3869        ) -> fidl::Result<()> {
3870            encoder.debug_check_bounds::<CookieId>(offset);
3871            // Vector header
3872            let max_ordinal: u64 = self.max_ordinal_present();
3873            encoder.write_num(max_ordinal, offset);
3874            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3875            // Calling encoder.out_of_line_offset(0) is not allowed.
3876            if max_ordinal == 0 {
3877                return Ok(());
3878            }
3879            depth.increment()?;
3880            let envelope_size = 8;
3881            let bytes_len = max_ordinal as usize * envelope_size;
3882            #[allow(unused_variables)]
3883            let offset = encoder.out_of_line_offset(bytes_len);
3884            let mut _prev_end_offset: usize = 0;
3885            if 1 > max_ordinal {
3886                return Ok(());
3887            }
3888
3889            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3890            // are envelope_size bytes.
3891            let cur_offset: usize = (1 - 1) * envelope_size;
3892
3893            // Zero reserved fields.
3894            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3895
3896            // Safety:
3897            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3898            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3899            //   envelope_size bytes, there is always sufficient room.
3900            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
3901                self.name.as_ref().map(
3902                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
3903                ),
3904                encoder,
3905                offset + cur_offset,
3906                depth,
3907            )?;
3908
3909            _prev_end_offset = cur_offset + envelope_size;
3910            if 2 > max_ordinal {
3911                return Ok(());
3912            }
3913
3914            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3915            // are envelope_size bytes.
3916            let cur_offset: usize = (2 - 1) * envelope_size;
3917
3918            // Zero reserved fields.
3919            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3920
3921            // Safety:
3922            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3923            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3924            //   envelope_size bytes, there is always sufficient room.
3925            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
3926                self.domain.as_ref().map(
3927                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
3928                ),
3929                encoder,
3930                offset + cur_offset,
3931                depth,
3932            )?;
3933
3934            _prev_end_offset = cur_offset + envelope_size;
3935            if 3 > max_ordinal {
3936                return Ok(());
3937            }
3938
3939            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3940            // are envelope_size bytes.
3941            let cur_offset: usize = (3 - 1) * envelope_size;
3942
3943            // Zero reserved fields.
3944            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3945
3946            // Safety:
3947            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3948            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3949            //   envelope_size bytes, there is always sufficient room.
3950            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
3951            self.path.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
3952            encoder, offset + cur_offset, depth
3953        )?;
3954
3955            _prev_end_offset = cur_offset + envelope_size;
3956
3957            Ok(())
3958        }
3959    }
3960
3961    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CookieId {
3962        #[inline(always)]
3963        fn new_empty() -> Self {
3964            Self::default()
3965        }
3966
3967        unsafe fn decode(
3968            &mut self,
3969            decoder: &mut fidl::encoding::Decoder<'_, D>,
3970            offset: usize,
3971            mut depth: fidl::encoding::Depth,
3972        ) -> fidl::Result<()> {
3973            decoder.debug_check_bounds::<Self>(offset);
3974            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3975                None => return Err(fidl::Error::NotNullable),
3976                Some(len) => len,
3977            };
3978            // Calling decoder.out_of_line_offset(0) is not allowed.
3979            if len == 0 {
3980                return Ok(());
3981            };
3982            depth.increment()?;
3983            let envelope_size = 8;
3984            let bytes_len = len * envelope_size;
3985            let offset = decoder.out_of_line_offset(bytes_len)?;
3986            // Decode the envelope for each type.
3987            let mut _next_ordinal_to_read = 0;
3988            let mut next_offset = offset;
3989            let end_offset = offset + bytes_len;
3990            _next_ordinal_to_read += 1;
3991            if next_offset >= end_offset {
3992                return Ok(());
3993            }
3994
3995            // Decode unknown envelopes for gaps in ordinals.
3996            while _next_ordinal_to_read < 1 {
3997                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3998                _next_ordinal_to_read += 1;
3999                next_offset += envelope_size;
4000            }
4001
4002            let next_out_of_line = decoder.next_out_of_line();
4003            let handles_before = decoder.remaining_handles();
4004            if let Some((inlined, num_bytes, num_handles)) =
4005                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4006            {
4007                let member_inline_size =
4008                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4009                        decoder.context,
4010                    );
4011                if inlined != (member_inline_size <= 4) {
4012                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4013                }
4014                let inner_offset;
4015                let mut inner_depth = depth.clone();
4016                if inlined {
4017                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4018                    inner_offset = next_offset;
4019                } else {
4020                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4021                    inner_depth.increment()?;
4022                }
4023                let val_ref = self
4024                    .name
4025                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4026                fidl::decode!(
4027                    fidl::encoding::UnboundedString,
4028                    D,
4029                    val_ref,
4030                    decoder,
4031                    inner_offset,
4032                    inner_depth
4033                )?;
4034                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4035                {
4036                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4037                }
4038                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4039                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4040                }
4041            }
4042
4043            next_offset += envelope_size;
4044            _next_ordinal_to_read += 1;
4045            if next_offset >= end_offset {
4046                return Ok(());
4047            }
4048
4049            // Decode unknown envelopes for gaps in ordinals.
4050            while _next_ordinal_to_read < 2 {
4051                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4052                _next_ordinal_to_read += 1;
4053                next_offset += envelope_size;
4054            }
4055
4056            let next_out_of_line = decoder.next_out_of_line();
4057            let handles_before = decoder.remaining_handles();
4058            if let Some((inlined, num_bytes, num_handles)) =
4059                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4060            {
4061                let member_inline_size =
4062                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
4063                        decoder.context,
4064                    );
4065                if inlined != (member_inline_size <= 4) {
4066                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4067                }
4068                let inner_offset;
4069                let mut inner_depth = depth.clone();
4070                if inlined {
4071                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4072                    inner_offset = next_offset;
4073                } else {
4074                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4075                    inner_depth.increment()?;
4076                }
4077                let val_ref = self
4078                    .domain
4079                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
4080                fidl::decode!(
4081                    fidl::encoding::BoundedString<255>,
4082                    D,
4083                    val_ref,
4084                    decoder,
4085                    inner_offset,
4086                    inner_depth
4087                )?;
4088                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4089                {
4090                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4091                }
4092                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4093                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4094                }
4095            }
4096
4097            next_offset += envelope_size;
4098            _next_ordinal_to_read += 1;
4099            if next_offset >= end_offset {
4100                return Ok(());
4101            }
4102
4103            // Decode unknown envelopes for gaps in ordinals.
4104            while _next_ordinal_to_read < 3 {
4105                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4106                _next_ordinal_to_read += 1;
4107                next_offset += envelope_size;
4108            }
4109
4110            let next_out_of_line = decoder.next_out_of_line();
4111            let handles_before = decoder.remaining_handles();
4112            if let Some((inlined, num_bytes, num_handles)) =
4113                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4114            {
4115                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4116                if inlined != (member_inline_size <= 4) {
4117                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4118                }
4119                let inner_offset;
4120                let mut inner_depth = depth.clone();
4121                if inlined {
4122                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4123                    inner_offset = next_offset;
4124                } else {
4125                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4126                    inner_depth.increment()?;
4127                }
4128                let val_ref = self.path.get_or_insert_with(|| {
4129                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
4130                });
4131                fidl::decode!(
4132                    fidl::encoding::BoundedString<65536>,
4133                    D,
4134                    val_ref,
4135                    decoder,
4136                    inner_offset,
4137                    inner_depth
4138                )?;
4139                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4140                {
4141                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4142                }
4143                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4144                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4145                }
4146            }
4147
4148            next_offset += envelope_size;
4149
4150            // Decode the remaining unknown envelopes.
4151            while next_offset < end_offset {
4152                _next_ordinal_to_read += 1;
4153                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4154                next_offset += envelope_size;
4155            }
4156
4157            Ok(())
4158        }
4159    }
4160
4161    impl FrameCloseRequest {
4162        #[inline(always)]
4163        fn max_ordinal_present(&self) -> u64 {
4164            if let Some(_) = self.timeout {
4165                return 1;
4166            }
4167            0
4168        }
4169    }
4170
4171    impl fidl::encoding::ValueTypeMarker for FrameCloseRequest {
4172        type Borrowed<'a> = &'a Self;
4173        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4174            value
4175        }
4176    }
4177
4178    unsafe impl fidl::encoding::TypeMarker for FrameCloseRequest {
4179        type Owned = Self;
4180
4181        #[inline(always)]
4182        fn inline_align(_context: fidl::encoding::Context) -> usize {
4183            8
4184        }
4185
4186        #[inline(always)]
4187        fn inline_size(_context: fidl::encoding::Context) -> usize {
4188            16
4189        }
4190    }
4191
4192    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FrameCloseRequest, D>
4193        for &FrameCloseRequest
4194    {
4195        unsafe fn encode(
4196            self,
4197            encoder: &mut fidl::encoding::Encoder<'_, D>,
4198            offset: usize,
4199            mut depth: fidl::encoding::Depth,
4200        ) -> fidl::Result<()> {
4201            encoder.debug_check_bounds::<FrameCloseRequest>(offset);
4202            // Vector header
4203            let max_ordinal: u64 = self.max_ordinal_present();
4204            encoder.write_num(max_ordinal, offset);
4205            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4206            // Calling encoder.out_of_line_offset(0) is not allowed.
4207            if max_ordinal == 0 {
4208                return Ok(());
4209            }
4210            depth.increment()?;
4211            let envelope_size = 8;
4212            let bytes_len = max_ordinal as usize * envelope_size;
4213            #[allow(unused_variables)]
4214            let offset = encoder.out_of_line_offset(bytes_len);
4215            let mut _prev_end_offset: usize = 0;
4216            if 1 > max_ordinal {
4217                return Ok(());
4218            }
4219
4220            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4221            // are envelope_size bytes.
4222            let cur_offset: usize = (1 - 1) * envelope_size;
4223
4224            // Zero reserved fields.
4225            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4226
4227            // Safety:
4228            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4229            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4230            //   envelope_size bytes, there is always sufficient room.
4231            fidl::encoding::encode_in_envelope_optional::<i64, D>(
4232                self.timeout.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4233                encoder,
4234                offset + cur_offset,
4235                depth,
4236            )?;
4237
4238            _prev_end_offset = cur_offset + envelope_size;
4239
4240            Ok(())
4241        }
4242    }
4243
4244    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FrameCloseRequest {
4245        #[inline(always)]
4246        fn new_empty() -> Self {
4247            Self::default()
4248        }
4249
4250        unsafe fn decode(
4251            &mut self,
4252            decoder: &mut fidl::encoding::Decoder<'_, D>,
4253            offset: usize,
4254            mut depth: fidl::encoding::Depth,
4255        ) -> fidl::Result<()> {
4256            decoder.debug_check_bounds::<Self>(offset);
4257            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4258                None => return Err(fidl::Error::NotNullable),
4259                Some(len) => len,
4260            };
4261            // Calling decoder.out_of_line_offset(0) is not allowed.
4262            if len == 0 {
4263                return Ok(());
4264            };
4265            depth.increment()?;
4266            let envelope_size = 8;
4267            let bytes_len = len * envelope_size;
4268            let offset = decoder.out_of_line_offset(bytes_len)?;
4269            // Decode the envelope for each type.
4270            let mut _next_ordinal_to_read = 0;
4271            let mut next_offset = offset;
4272            let end_offset = offset + bytes_len;
4273            _next_ordinal_to_read += 1;
4274            if next_offset >= end_offset {
4275                return Ok(());
4276            }
4277
4278            // Decode unknown envelopes for gaps in ordinals.
4279            while _next_ordinal_to_read < 1 {
4280                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4281                _next_ordinal_to_read += 1;
4282                next_offset += envelope_size;
4283            }
4284
4285            let next_out_of_line = decoder.next_out_of_line();
4286            let handles_before = decoder.remaining_handles();
4287            if let Some((inlined, num_bytes, num_handles)) =
4288                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4289            {
4290                let member_inline_size =
4291                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4292                if inlined != (member_inline_size <= 4) {
4293                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4294                }
4295                let inner_offset;
4296                let mut inner_depth = depth.clone();
4297                if inlined {
4298                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4299                    inner_offset = next_offset;
4300                } else {
4301                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4302                    inner_depth.increment()?;
4303                }
4304                let val_ref = self.timeout.get_or_insert_with(|| fidl::new_empty!(i64, D));
4305                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4306                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4307                {
4308                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4309                }
4310                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4311                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4312                }
4313            }
4314
4315            next_offset += envelope_size;
4316
4317            // Decode the remaining unknown envelopes.
4318            while next_offset < end_offset {
4319                _next_ordinal_to_read += 1;
4320                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4321                next_offset += envelope_size;
4322            }
4323
4324            Ok(())
4325        }
4326    }
4327
4328    impl FrameMediaSettings {
4329        #[inline(always)]
4330        fn max_ordinal_present(&self) -> u64 {
4331            if let Some(_) = self.renderer_usage2 {
4332                return 3;
4333            }
4334            if let Some(_) = self.audio_consumer_session_id {
4335                return 2;
4336            }
4337            if let Some(_) = self.renderer_usage {
4338                return 1;
4339            }
4340            0
4341        }
4342    }
4343
4344    impl fidl::encoding::ValueTypeMarker for FrameMediaSettings {
4345        type Borrowed<'a> = &'a Self;
4346        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4347            value
4348        }
4349    }
4350
4351    unsafe impl fidl::encoding::TypeMarker for FrameMediaSettings {
4352        type Owned = Self;
4353
4354        #[inline(always)]
4355        fn inline_align(_context: fidl::encoding::Context) -> usize {
4356            8
4357        }
4358
4359        #[inline(always)]
4360        fn inline_size(_context: fidl::encoding::Context) -> usize {
4361            16
4362        }
4363    }
4364
4365    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FrameMediaSettings, D>
4366        for &FrameMediaSettings
4367    {
4368        unsafe fn encode(
4369            self,
4370            encoder: &mut fidl::encoding::Encoder<'_, D>,
4371            offset: usize,
4372            mut depth: fidl::encoding::Depth,
4373        ) -> fidl::Result<()> {
4374            encoder.debug_check_bounds::<FrameMediaSettings>(offset);
4375            // Vector header
4376            let max_ordinal: u64 = self.max_ordinal_present();
4377            encoder.write_num(max_ordinal, offset);
4378            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4379            // Calling encoder.out_of_line_offset(0) is not allowed.
4380            if max_ordinal == 0 {
4381                return Ok(());
4382            }
4383            depth.increment()?;
4384            let envelope_size = 8;
4385            let bytes_len = max_ordinal as usize * envelope_size;
4386            #[allow(unused_variables)]
4387            let offset = encoder.out_of_line_offset(bytes_len);
4388            let mut _prev_end_offset: usize = 0;
4389            if 1 > max_ordinal {
4390                return Ok(());
4391            }
4392
4393            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4394            // are envelope_size bytes.
4395            let cur_offset: usize = (1 - 1) * envelope_size;
4396
4397            // Zero reserved fields.
4398            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4399
4400            // Safety:
4401            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4402            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4403            //   envelope_size bytes, there is always sufficient room.
4404            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_media__common::AudioRenderUsage, D>(
4405            self.renderer_usage.as_ref().map(<fidl_fuchsia_media__common::AudioRenderUsage as fidl::encoding::ValueTypeMarker>::borrow),
4406            encoder, offset + cur_offset, depth
4407        )?;
4408
4409            _prev_end_offset = cur_offset + envelope_size;
4410            if 2 > max_ordinal {
4411                return Ok(());
4412            }
4413
4414            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4415            // are envelope_size bytes.
4416            let cur_offset: usize = (2 - 1) * envelope_size;
4417
4418            // Zero reserved fields.
4419            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4420
4421            // Safety:
4422            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4423            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4424            //   envelope_size bytes, there is always sufficient room.
4425            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4426                self.audio_consumer_session_id
4427                    .as_ref()
4428                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4429                encoder,
4430                offset + cur_offset,
4431                depth,
4432            )?;
4433
4434            _prev_end_offset = cur_offset + envelope_size;
4435            if 3 > max_ordinal {
4436                return Ok(());
4437            }
4438
4439            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4440            // are envelope_size bytes.
4441            let cur_offset: usize = (3 - 1) * envelope_size;
4442
4443            // Zero reserved fields.
4444            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4445
4446            // Safety:
4447            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4448            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4449            //   envelope_size bytes, there is always sufficient room.
4450            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_media__common::AudioRenderUsage2, D>(
4451            self.renderer_usage2.as_ref().map(<fidl_fuchsia_media__common::AudioRenderUsage2 as fidl::encoding::ValueTypeMarker>::borrow),
4452            encoder, offset + cur_offset, depth
4453        )?;
4454
4455            _prev_end_offset = cur_offset + envelope_size;
4456
4457            Ok(())
4458        }
4459    }
4460
4461    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FrameMediaSettings {
4462        #[inline(always)]
4463        fn new_empty() -> Self {
4464            Self::default()
4465        }
4466
4467        unsafe fn decode(
4468            &mut self,
4469            decoder: &mut fidl::encoding::Decoder<'_, D>,
4470            offset: usize,
4471            mut depth: fidl::encoding::Depth,
4472        ) -> fidl::Result<()> {
4473            decoder.debug_check_bounds::<Self>(offset);
4474            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4475                None => return Err(fidl::Error::NotNullable),
4476                Some(len) => len,
4477            };
4478            // Calling decoder.out_of_line_offset(0) is not allowed.
4479            if len == 0 {
4480                return Ok(());
4481            };
4482            depth.increment()?;
4483            let envelope_size = 8;
4484            let bytes_len = len * envelope_size;
4485            let offset = decoder.out_of_line_offset(bytes_len)?;
4486            // Decode the envelope for each type.
4487            let mut _next_ordinal_to_read = 0;
4488            let mut next_offset = offset;
4489            let end_offset = offset + bytes_len;
4490            _next_ordinal_to_read += 1;
4491            if next_offset >= end_offset {
4492                return Ok(());
4493            }
4494
4495            // Decode unknown envelopes for gaps in ordinals.
4496            while _next_ordinal_to_read < 1 {
4497                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4498                _next_ordinal_to_read += 1;
4499                next_offset += envelope_size;
4500            }
4501
4502            let next_out_of_line = decoder.next_out_of_line();
4503            let handles_before = decoder.remaining_handles();
4504            if let Some((inlined, num_bytes, num_handles)) =
4505                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4506            {
4507                let member_inline_size = <fidl_fuchsia_media__common::AudioRenderUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4508                if inlined != (member_inline_size <= 4) {
4509                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4510                }
4511                let inner_offset;
4512                let mut inner_depth = depth.clone();
4513                if inlined {
4514                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4515                    inner_offset = next_offset;
4516                } else {
4517                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4518                    inner_depth.increment()?;
4519                }
4520                let val_ref = self.renderer_usage.get_or_insert_with(|| {
4521                    fidl::new_empty!(fidl_fuchsia_media__common::AudioRenderUsage, D)
4522                });
4523                fidl::decode!(
4524                    fidl_fuchsia_media__common::AudioRenderUsage,
4525                    D,
4526                    val_ref,
4527                    decoder,
4528                    inner_offset,
4529                    inner_depth
4530                )?;
4531                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4532                {
4533                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4534                }
4535                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4536                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4537                }
4538            }
4539
4540            next_offset += envelope_size;
4541            _next_ordinal_to_read += 1;
4542            if next_offset >= end_offset {
4543                return Ok(());
4544            }
4545
4546            // Decode unknown envelopes for gaps in ordinals.
4547            while _next_ordinal_to_read < 2 {
4548                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4549                _next_ordinal_to_read += 1;
4550                next_offset += envelope_size;
4551            }
4552
4553            let next_out_of_line = decoder.next_out_of_line();
4554            let handles_before = decoder.remaining_handles();
4555            if let Some((inlined, num_bytes, num_handles)) =
4556                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4557            {
4558                let member_inline_size =
4559                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4560                if inlined != (member_inline_size <= 4) {
4561                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4562                }
4563                let inner_offset;
4564                let mut inner_depth = depth.clone();
4565                if inlined {
4566                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4567                    inner_offset = next_offset;
4568                } else {
4569                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4570                    inner_depth.increment()?;
4571                }
4572                let val_ref =
4573                    self.audio_consumer_session_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
4574                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4575                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4576                {
4577                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4578                }
4579                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4580                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4581                }
4582            }
4583
4584            next_offset += envelope_size;
4585            _next_ordinal_to_read += 1;
4586            if next_offset >= end_offset {
4587                return Ok(());
4588            }
4589
4590            // Decode unknown envelopes for gaps in ordinals.
4591            while _next_ordinal_to_read < 3 {
4592                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4593                _next_ordinal_to_read += 1;
4594                next_offset += envelope_size;
4595            }
4596
4597            let next_out_of_line = decoder.next_out_of_line();
4598            let handles_before = decoder.remaining_handles();
4599            if let Some((inlined, num_bytes, num_handles)) =
4600                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4601            {
4602                let member_inline_size = <fidl_fuchsia_media__common::AudioRenderUsage2 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4603                if inlined != (member_inline_size <= 4) {
4604                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4605                }
4606                let inner_offset;
4607                let mut inner_depth = depth.clone();
4608                if inlined {
4609                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4610                    inner_offset = next_offset;
4611                } else {
4612                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4613                    inner_depth.increment()?;
4614                }
4615                let val_ref = self.renderer_usage2.get_or_insert_with(|| {
4616                    fidl::new_empty!(fidl_fuchsia_media__common::AudioRenderUsage2, D)
4617                });
4618                fidl::decode!(
4619                    fidl_fuchsia_media__common::AudioRenderUsage2,
4620                    D,
4621                    val_ref,
4622                    decoder,
4623                    inner_offset,
4624                    inner_depth
4625                )?;
4626                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4627                {
4628                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4629                }
4630                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4631                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4632                }
4633            }
4634
4635            next_offset += envelope_size;
4636
4637            // Decode the remaining unknown envelopes.
4638            while next_offset < end_offset {
4639                _next_ordinal_to_read += 1;
4640                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4641                next_offset += envelope_size;
4642            }
4643
4644            Ok(())
4645        }
4646    }
4647
4648    impl NavigationPolicyProviderParams {
4649        #[inline(always)]
4650        fn max_ordinal_present(&self) -> u64 {
4651            if let Some(_) = self.subframe_phases {
4652                return 2;
4653            }
4654            if let Some(_) = self.main_frame_phases {
4655                return 1;
4656            }
4657            0
4658        }
4659    }
4660
4661    impl fidl::encoding::ValueTypeMarker for NavigationPolicyProviderParams {
4662        type Borrowed<'a> = &'a Self;
4663        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4664            value
4665        }
4666    }
4667
4668    unsafe impl fidl::encoding::TypeMarker for NavigationPolicyProviderParams {
4669        type Owned = Self;
4670
4671        #[inline(always)]
4672        fn inline_align(_context: fidl::encoding::Context) -> usize {
4673            8
4674        }
4675
4676        #[inline(always)]
4677        fn inline_size(_context: fidl::encoding::Context) -> usize {
4678            16
4679        }
4680    }
4681
4682    unsafe impl<D: fidl::encoding::ResourceDialect>
4683        fidl::encoding::Encode<NavigationPolicyProviderParams, D>
4684        for &NavigationPolicyProviderParams
4685    {
4686        unsafe fn encode(
4687            self,
4688            encoder: &mut fidl::encoding::Encoder<'_, D>,
4689            offset: usize,
4690            mut depth: fidl::encoding::Depth,
4691        ) -> fidl::Result<()> {
4692            encoder.debug_check_bounds::<NavigationPolicyProviderParams>(offset);
4693            // Vector header
4694            let max_ordinal: u64 = self.max_ordinal_present();
4695            encoder.write_num(max_ordinal, offset);
4696            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4697            // Calling encoder.out_of_line_offset(0) is not allowed.
4698            if max_ordinal == 0 {
4699                return Ok(());
4700            }
4701            depth.increment()?;
4702            let envelope_size = 8;
4703            let bytes_len = max_ordinal as usize * envelope_size;
4704            #[allow(unused_variables)]
4705            let offset = encoder.out_of_line_offset(bytes_len);
4706            let mut _prev_end_offset: usize = 0;
4707            if 1 > max_ordinal {
4708                return Ok(());
4709            }
4710
4711            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4712            // are envelope_size bytes.
4713            let cur_offset: usize = (1 - 1) * envelope_size;
4714
4715            // Zero reserved fields.
4716            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4717
4718            // Safety:
4719            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4720            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4721            //   envelope_size bytes, there is always sufficient room.
4722            fidl::encoding::encode_in_envelope_optional::<NavigationPhase, D>(
4723                self.main_frame_phases
4724                    .as_ref()
4725                    .map(<NavigationPhase as fidl::encoding::ValueTypeMarker>::borrow),
4726                encoder,
4727                offset + cur_offset,
4728                depth,
4729            )?;
4730
4731            _prev_end_offset = cur_offset + envelope_size;
4732            if 2 > max_ordinal {
4733                return Ok(());
4734            }
4735
4736            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4737            // are envelope_size bytes.
4738            let cur_offset: usize = (2 - 1) * envelope_size;
4739
4740            // Zero reserved fields.
4741            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4742
4743            // Safety:
4744            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4745            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4746            //   envelope_size bytes, there is always sufficient room.
4747            fidl::encoding::encode_in_envelope_optional::<NavigationPhase, D>(
4748                self.subframe_phases
4749                    .as_ref()
4750                    .map(<NavigationPhase as fidl::encoding::ValueTypeMarker>::borrow),
4751                encoder,
4752                offset + cur_offset,
4753                depth,
4754            )?;
4755
4756            _prev_end_offset = cur_offset + envelope_size;
4757
4758            Ok(())
4759        }
4760    }
4761
4762    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4763        for NavigationPolicyProviderParams
4764    {
4765        #[inline(always)]
4766        fn new_empty() -> Self {
4767            Self::default()
4768        }
4769
4770        unsafe fn decode(
4771            &mut self,
4772            decoder: &mut fidl::encoding::Decoder<'_, D>,
4773            offset: usize,
4774            mut depth: fidl::encoding::Depth,
4775        ) -> fidl::Result<()> {
4776            decoder.debug_check_bounds::<Self>(offset);
4777            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4778                None => return Err(fidl::Error::NotNullable),
4779                Some(len) => len,
4780            };
4781            // Calling decoder.out_of_line_offset(0) is not allowed.
4782            if len == 0 {
4783                return Ok(());
4784            };
4785            depth.increment()?;
4786            let envelope_size = 8;
4787            let bytes_len = len * envelope_size;
4788            let offset = decoder.out_of_line_offset(bytes_len)?;
4789            // Decode the envelope for each type.
4790            let mut _next_ordinal_to_read = 0;
4791            let mut next_offset = offset;
4792            let end_offset = offset + bytes_len;
4793            _next_ordinal_to_read += 1;
4794            if next_offset >= end_offset {
4795                return Ok(());
4796            }
4797
4798            // Decode unknown envelopes for gaps in ordinals.
4799            while _next_ordinal_to_read < 1 {
4800                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4801                _next_ordinal_to_read += 1;
4802                next_offset += envelope_size;
4803            }
4804
4805            let next_out_of_line = decoder.next_out_of_line();
4806            let handles_before = decoder.remaining_handles();
4807            if let Some((inlined, num_bytes, num_handles)) =
4808                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4809            {
4810                let member_inline_size =
4811                    <NavigationPhase as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4812                if inlined != (member_inline_size <= 4) {
4813                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4814                }
4815                let inner_offset;
4816                let mut inner_depth = depth.clone();
4817                if inlined {
4818                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4819                    inner_offset = next_offset;
4820                } else {
4821                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4822                    inner_depth.increment()?;
4823                }
4824                let val_ref = self
4825                    .main_frame_phases
4826                    .get_or_insert_with(|| fidl::new_empty!(NavigationPhase, D));
4827                fidl::decode!(NavigationPhase, D, val_ref, decoder, inner_offset, inner_depth)?;
4828                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4829                {
4830                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4831                }
4832                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4833                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4834                }
4835            }
4836
4837            next_offset += envelope_size;
4838            _next_ordinal_to_read += 1;
4839            if next_offset >= end_offset {
4840                return Ok(());
4841            }
4842
4843            // Decode unknown envelopes for gaps in ordinals.
4844            while _next_ordinal_to_read < 2 {
4845                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4846                _next_ordinal_to_read += 1;
4847                next_offset += envelope_size;
4848            }
4849
4850            let next_out_of_line = decoder.next_out_of_line();
4851            let handles_before = decoder.remaining_handles();
4852            if let Some((inlined, num_bytes, num_handles)) =
4853                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4854            {
4855                let member_inline_size =
4856                    <NavigationPhase as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4857                if inlined != (member_inline_size <= 4) {
4858                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4859                }
4860                let inner_offset;
4861                let mut inner_depth = depth.clone();
4862                if inlined {
4863                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4864                    inner_offset = next_offset;
4865                } else {
4866                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4867                    inner_depth.increment()?;
4868                }
4869                let val_ref = self
4870                    .subframe_phases
4871                    .get_or_insert_with(|| fidl::new_empty!(NavigationPhase, D));
4872                fidl::decode!(NavigationPhase, D, val_ref, decoder, inner_offset, inner_depth)?;
4873                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4874                {
4875                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4876                }
4877                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4878                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4879                }
4880            }
4881
4882            next_offset += envelope_size;
4883
4884            // Decode the remaining unknown envelopes.
4885            while next_offset < end_offset {
4886                _next_ordinal_to_read += 1;
4887                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4888                next_offset += envelope_size;
4889            }
4890
4891            Ok(())
4892        }
4893    }
4894
4895    impl PermissionDescriptor {
4896        #[inline(always)]
4897        fn max_ordinal_present(&self) -> u64 {
4898            if let Some(_) = self.type_ {
4899                return 1;
4900            }
4901            0
4902        }
4903    }
4904
4905    impl fidl::encoding::ValueTypeMarker for PermissionDescriptor {
4906        type Borrowed<'a> = &'a Self;
4907        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4908            value
4909        }
4910    }
4911
4912    unsafe impl fidl::encoding::TypeMarker for PermissionDescriptor {
4913        type Owned = Self;
4914
4915        #[inline(always)]
4916        fn inline_align(_context: fidl::encoding::Context) -> usize {
4917            8
4918        }
4919
4920        #[inline(always)]
4921        fn inline_size(_context: fidl::encoding::Context) -> usize {
4922            16
4923        }
4924    }
4925
4926    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PermissionDescriptor, D>
4927        for &PermissionDescriptor
4928    {
4929        unsafe fn encode(
4930            self,
4931            encoder: &mut fidl::encoding::Encoder<'_, D>,
4932            offset: usize,
4933            mut depth: fidl::encoding::Depth,
4934        ) -> fidl::Result<()> {
4935            encoder.debug_check_bounds::<PermissionDescriptor>(offset);
4936            // Vector header
4937            let max_ordinal: u64 = self.max_ordinal_present();
4938            encoder.write_num(max_ordinal, offset);
4939            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4940            // Calling encoder.out_of_line_offset(0) is not allowed.
4941            if max_ordinal == 0 {
4942                return Ok(());
4943            }
4944            depth.increment()?;
4945            let envelope_size = 8;
4946            let bytes_len = max_ordinal as usize * envelope_size;
4947            #[allow(unused_variables)]
4948            let offset = encoder.out_of_line_offset(bytes_len);
4949            let mut _prev_end_offset: usize = 0;
4950            if 1 > max_ordinal {
4951                return Ok(());
4952            }
4953
4954            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4955            // are envelope_size bytes.
4956            let cur_offset: usize = (1 - 1) * envelope_size;
4957
4958            // Zero reserved fields.
4959            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4960
4961            // Safety:
4962            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4963            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4964            //   envelope_size bytes, there is always sufficient room.
4965            fidl::encoding::encode_in_envelope_optional::<PermissionType, D>(
4966                self.type_
4967                    .as_ref()
4968                    .map(<PermissionType as fidl::encoding::ValueTypeMarker>::borrow),
4969                encoder,
4970                offset + cur_offset,
4971                depth,
4972            )?;
4973
4974            _prev_end_offset = cur_offset + envelope_size;
4975
4976            Ok(())
4977        }
4978    }
4979
4980    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PermissionDescriptor {
4981        #[inline(always)]
4982        fn new_empty() -> Self {
4983            Self::default()
4984        }
4985
4986        unsafe fn decode(
4987            &mut self,
4988            decoder: &mut fidl::encoding::Decoder<'_, D>,
4989            offset: usize,
4990            mut depth: fidl::encoding::Depth,
4991        ) -> fidl::Result<()> {
4992            decoder.debug_check_bounds::<Self>(offset);
4993            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4994                None => return Err(fidl::Error::NotNullable),
4995                Some(len) => len,
4996            };
4997            // Calling decoder.out_of_line_offset(0) is not allowed.
4998            if len == 0 {
4999                return Ok(());
5000            };
5001            depth.increment()?;
5002            let envelope_size = 8;
5003            let bytes_len = len * envelope_size;
5004            let offset = decoder.out_of_line_offset(bytes_len)?;
5005            // Decode the envelope for each type.
5006            let mut _next_ordinal_to_read = 0;
5007            let mut next_offset = offset;
5008            let end_offset = offset + bytes_len;
5009            _next_ordinal_to_read += 1;
5010            if next_offset >= end_offset {
5011                return Ok(());
5012            }
5013
5014            // Decode unknown envelopes for gaps in ordinals.
5015            while _next_ordinal_to_read < 1 {
5016                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5017                _next_ordinal_to_read += 1;
5018                next_offset += envelope_size;
5019            }
5020
5021            let next_out_of_line = decoder.next_out_of_line();
5022            let handles_before = decoder.remaining_handles();
5023            if let Some((inlined, num_bytes, num_handles)) =
5024                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5025            {
5026                let member_inline_size =
5027                    <PermissionType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5028                if inlined != (member_inline_size <= 4) {
5029                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5030                }
5031                let inner_offset;
5032                let mut inner_depth = depth.clone();
5033                if inlined {
5034                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5035                    inner_offset = next_offset;
5036                } else {
5037                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5038                    inner_depth.increment()?;
5039                }
5040                let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(PermissionType, D));
5041                fidl::decode!(PermissionType, D, val_ref, decoder, inner_offset, inner_depth)?;
5042                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5043                {
5044                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5045                }
5046                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5047                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5048                }
5049            }
5050
5051            next_offset += envelope_size;
5052
5053            // Decode the remaining unknown envelopes.
5054            while next_offset < end_offset {
5055                _next_ordinal_to_read += 1;
5056                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5057                next_offset += envelope_size;
5058            }
5059
5060            Ok(())
5061        }
5062    }
5063
5064    impl RequestedNavigation {
5065        #[inline(always)]
5066        fn max_ordinal_present(&self) -> u64 {
5067            if let Some(_) = self.was_server_redirect {
5068                return 8;
5069            }
5070            if let Some(_) = self.has_gesture {
5071                return 7;
5072            }
5073            if let Some(_) = self.url {
5074                return 6;
5075            }
5076            if let Some(_) = self.is_http_post {
5077                return 5;
5078            }
5079            if let Some(_) = self.is_same_document {
5080                return 4;
5081            }
5082            if let Some(_) = self.is_main_frame {
5083                return 3;
5084            }
5085            if let Some(_) = self.phase {
5086                return 2;
5087            }
5088            if let Some(_) = self.id {
5089                return 1;
5090            }
5091            0
5092        }
5093    }
5094
5095    impl fidl::encoding::ValueTypeMarker for RequestedNavigation {
5096        type Borrowed<'a> = &'a Self;
5097        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5098            value
5099        }
5100    }
5101
5102    unsafe impl fidl::encoding::TypeMarker for RequestedNavigation {
5103        type Owned = Self;
5104
5105        #[inline(always)]
5106        fn inline_align(_context: fidl::encoding::Context) -> usize {
5107            8
5108        }
5109
5110        #[inline(always)]
5111        fn inline_size(_context: fidl::encoding::Context) -> usize {
5112            16
5113        }
5114    }
5115
5116    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RequestedNavigation, D>
5117        for &RequestedNavigation
5118    {
5119        unsafe fn encode(
5120            self,
5121            encoder: &mut fidl::encoding::Encoder<'_, D>,
5122            offset: usize,
5123            mut depth: fidl::encoding::Depth,
5124        ) -> fidl::Result<()> {
5125            encoder.debug_check_bounds::<RequestedNavigation>(offset);
5126            // Vector header
5127            let max_ordinal: u64 = self.max_ordinal_present();
5128            encoder.write_num(max_ordinal, offset);
5129            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5130            // Calling encoder.out_of_line_offset(0) is not allowed.
5131            if max_ordinal == 0 {
5132                return Ok(());
5133            }
5134            depth.increment()?;
5135            let envelope_size = 8;
5136            let bytes_len = max_ordinal as usize * envelope_size;
5137            #[allow(unused_variables)]
5138            let offset = encoder.out_of_line_offset(bytes_len);
5139            let mut _prev_end_offset: usize = 0;
5140            if 1 > max_ordinal {
5141                return Ok(());
5142            }
5143
5144            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5145            // are envelope_size bytes.
5146            let cur_offset: usize = (1 - 1) * envelope_size;
5147
5148            // Zero reserved fields.
5149            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5150
5151            // Safety:
5152            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5153            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5154            //   envelope_size bytes, there is always sufficient room.
5155            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5156                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5157                encoder,
5158                offset + cur_offset,
5159                depth,
5160            )?;
5161
5162            _prev_end_offset = cur_offset + envelope_size;
5163            if 2 > max_ordinal {
5164                return Ok(());
5165            }
5166
5167            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5168            // are envelope_size bytes.
5169            let cur_offset: usize = (2 - 1) * envelope_size;
5170
5171            // Zero reserved fields.
5172            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5173
5174            // Safety:
5175            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5176            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5177            //   envelope_size bytes, there is always sufficient room.
5178            fidl::encoding::encode_in_envelope_optional::<NavigationPhase, D>(
5179                self.phase
5180                    .as_ref()
5181                    .map(<NavigationPhase as fidl::encoding::ValueTypeMarker>::borrow),
5182                encoder,
5183                offset + cur_offset,
5184                depth,
5185            )?;
5186
5187            _prev_end_offset = cur_offset + envelope_size;
5188            if 3 > max_ordinal {
5189                return Ok(());
5190            }
5191
5192            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5193            // are envelope_size bytes.
5194            let cur_offset: usize = (3 - 1) * envelope_size;
5195
5196            // Zero reserved fields.
5197            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5198
5199            // Safety:
5200            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5201            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5202            //   envelope_size bytes, there is always sufficient room.
5203            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5204                self.is_main_frame.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5205                encoder,
5206                offset + cur_offset,
5207                depth,
5208            )?;
5209
5210            _prev_end_offset = cur_offset + envelope_size;
5211            if 4 > max_ordinal {
5212                return Ok(());
5213            }
5214
5215            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5216            // are envelope_size bytes.
5217            let cur_offset: usize = (4 - 1) * envelope_size;
5218
5219            // Zero reserved fields.
5220            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5221
5222            // Safety:
5223            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5224            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5225            //   envelope_size bytes, there is always sufficient room.
5226            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5227                self.is_same_document
5228                    .as_ref()
5229                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5230                encoder,
5231                offset + cur_offset,
5232                depth,
5233            )?;
5234
5235            _prev_end_offset = cur_offset + envelope_size;
5236            if 5 > max_ordinal {
5237                return Ok(());
5238            }
5239
5240            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5241            // are envelope_size bytes.
5242            let cur_offset: usize = (5 - 1) * envelope_size;
5243
5244            // Zero reserved fields.
5245            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5246
5247            // Safety:
5248            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5249            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5250            //   envelope_size bytes, there is always sufficient room.
5251            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5252                self.is_http_post.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5253                encoder,
5254                offset + cur_offset,
5255                depth,
5256            )?;
5257
5258            _prev_end_offset = cur_offset + envelope_size;
5259            if 6 > max_ordinal {
5260                return Ok(());
5261            }
5262
5263            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5264            // are envelope_size bytes.
5265            let cur_offset: usize = (6 - 1) * envelope_size;
5266
5267            // Zero reserved fields.
5268            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5269
5270            // Safety:
5271            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5272            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5273            //   envelope_size bytes, there is always sufficient room.
5274            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
5275            self.url.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
5276            encoder, offset + cur_offset, depth
5277        )?;
5278
5279            _prev_end_offset = cur_offset + envelope_size;
5280            if 7 > max_ordinal {
5281                return Ok(());
5282            }
5283
5284            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5285            // are envelope_size bytes.
5286            let cur_offset: usize = (7 - 1) * envelope_size;
5287
5288            // Zero reserved fields.
5289            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5290
5291            // Safety:
5292            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5293            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5294            //   envelope_size bytes, there is always sufficient room.
5295            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5296                self.has_gesture.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5297                encoder,
5298                offset + cur_offset,
5299                depth,
5300            )?;
5301
5302            _prev_end_offset = cur_offset + envelope_size;
5303            if 8 > max_ordinal {
5304                return Ok(());
5305            }
5306
5307            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5308            // are envelope_size bytes.
5309            let cur_offset: usize = (8 - 1) * envelope_size;
5310
5311            // Zero reserved fields.
5312            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5313
5314            // Safety:
5315            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5316            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5317            //   envelope_size bytes, there is always sufficient room.
5318            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5319                self.was_server_redirect
5320                    .as_ref()
5321                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5322                encoder,
5323                offset + cur_offset,
5324                depth,
5325            )?;
5326
5327            _prev_end_offset = cur_offset + envelope_size;
5328
5329            Ok(())
5330        }
5331    }
5332
5333    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RequestedNavigation {
5334        #[inline(always)]
5335        fn new_empty() -> Self {
5336            Self::default()
5337        }
5338
5339        unsafe fn decode(
5340            &mut self,
5341            decoder: &mut fidl::encoding::Decoder<'_, D>,
5342            offset: usize,
5343            mut depth: fidl::encoding::Depth,
5344        ) -> fidl::Result<()> {
5345            decoder.debug_check_bounds::<Self>(offset);
5346            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5347                None => return Err(fidl::Error::NotNullable),
5348                Some(len) => len,
5349            };
5350            // Calling decoder.out_of_line_offset(0) is not allowed.
5351            if len == 0 {
5352                return Ok(());
5353            };
5354            depth.increment()?;
5355            let envelope_size = 8;
5356            let bytes_len = len * envelope_size;
5357            let offset = decoder.out_of_line_offset(bytes_len)?;
5358            // Decode the envelope for each type.
5359            let mut _next_ordinal_to_read = 0;
5360            let mut next_offset = offset;
5361            let end_offset = offset + bytes_len;
5362            _next_ordinal_to_read += 1;
5363            if next_offset >= end_offset {
5364                return Ok(());
5365            }
5366
5367            // Decode unknown envelopes for gaps in ordinals.
5368            while _next_ordinal_to_read < 1 {
5369                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5370                _next_ordinal_to_read += 1;
5371                next_offset += envelope_size;
5372            }
5373
5374            let next_out_of_line = decoder.next_out_of_line();
5375            let handles_before = decoder.remaining_handles();
5376            if let Some((inlined, num_bytes, num_handles)) =
5377                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5378            {
5379                let member_inline_size =
5380                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5381                if inlined != (member_inline_size <= 4) {
5382                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5383                }
5384                let inner_offset;
5385                let mut inner_depth = depth.clone();
5386                if inlined {
5387                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5388                    inner_offset = next_offset;
5389                } else {
5390                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5391                    inner_depth.increment()?;
5392                }
5393                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5394                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5395                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5396                {
5397                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5398                }
5399                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5400                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5401                }
5402            }
5403
5404            next_offset += envelope_size;
5405            _next_ordinal_to_read += 1;
5406            if next_offset >= end_offset {
5407                return Ok(());
5408            }
5409
5410            // Decode unknown envelopes for gaps in ordinals.
5411            while _next_ordinal_to_read < 2 {
5412                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5413                _next_ordinal_to_read += 1;
5414                next_offset += envelope_size;
5415            }
5416
5417            let next_out_of_line = decoder.next_out_of_line();
5418            let handles_before = decoder.remaining_handles();
5419            if let Some((inlined, num_bytes, num_handles)) =
5420                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5421            {
5422                let member_inline_size =
5423                    <NavigationPhase as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5424                if inlined != (member_inline_size <= 4) {
5425                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5426                }
5427                let inner_offset;
5428                let mut inner_depth = depth.clone();
5429                if inlined {
5430                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5431                    inner_offset = next_offset;
5432                } else {
5433                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5434                    inner_depth.increment()?;
5435                }
5436                let val_ref =
5437                    self.phase.get_or_insert_with(|| fidl::new_empty!(NavigationPhase, D));
5438                fidl::decode!(NavigationPhase, D, val_ref, decoder, inner_offset, inner_depth)?;
5439                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5440                {
5441                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5442                }
5443                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5444                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5445                }
5446            }
5447
5448            next_offset += envelope_size;
5449            _next_ordinal_to_read += 1;
5450            if next_offset >= end_offset {
5451                return Ok(());
5452            }
5453
5454            // Decode unknown envelopes for gaps in ordinals.
5455            while _next_ordinal_to_read < 3 {
5456                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5457                _next_ordinal_to_read += 1;
5458                next_offset += envelope_size;
5459            }
5460
5461            let next_out_of_line = decoder.next_out_of_line();
5462            let handles_before = decoder.remaining_handles();
5463            if let Some((inlined, num_bytes, num_handles)) =
5464                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5465            {
5466                let member_inline_size =
5467                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5468                if inlined != (member_inline_size <= 4) {
5469                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5470                }
5471                let inner_offset;
5472                let mut inner_depth = depth.clone();
5473                if inlined {
5474                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5475                    inner_offset = next_offset;
5476                } else {
5477                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5478                    inner_depth.increment()?;
5479                }
5480                let val_ref = self.is_main_frame.get_or_insert_with(|| fidl::new_empty!(bool, D));
5481                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5482                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5483                {
5484                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5485                }
5486                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5487                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5488                }
5489            }
5490
5491            next_offset += envelope_size;
5492            _next_ordinal_to_read += 1;
5493            if next_offset >= end_offset {
5494                return Ok(());
5495            }
5496
5497            // Decode unknown envelopes for gaps in ordinals.
5498            while _next_ordinal_to_read < 4 {
5499                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5500                _next_ordinal_to_read += 1;
5501                next_offset += envelope_size;
5502            }
5503
5504            let next_out_of_line = decoder.next_out_of_line();
5505            let handles_before = decoder.remaining_handles();
5506            if let Some((inlined, num_bytes, num_handles)) =
5507                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5508            {
5509                let member_inline_size =
5510                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5511                if inlined != (member_inline_size <= 4) {
5512                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5513                }
5514                let inner_offset;
5515                let mut inner_depth = depth.clone();
5516                if inlined {
5517                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5518                    inner_offset = next_offset;
5519                } else {
5520                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5521                    inner_depth.increment()?;
5522                }
5523                let val_ref =
5524                    self.is_same_document.get_or_insert_with(|| fidl::new_empty!(bool, D));
5525                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5526                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5527                {
5528                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5529                }
5530                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5531                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5532                }
5533            }
5534
5535            next_offset += envelope_size;
5536            _next_ordinal_to_read += 1;
5537            if next_offset >= end_offset {
5538                return Ok(());
5539            }
5540
5541            // Decode unknown envelopes for gaps in ordinals.
5542            while _next_ordinal_to_read < 5 {
5543                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5544                _next_ordinal_to_read += 1;
5545                next_offset += envelope_size;
5546            }
5547
5548            let next_out_of_line = decoder.next_out_of_line();
5549            let handles_before = decoder.remaining_handles();
5550            if let Some((inlined, num_bytes, num_handles)) =
5551                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5552            {
5553                let member_inline_size =
5554                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5555                if inlined != (member_inline_size <= 4) {
5556                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5557                }
5558                let inner_offset;
5559                let mut inner_depth = depth.clone();
5560                if inlined {
5561                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5562                    inner_offset = next_offset;
5563                } else {
5564                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5565                    inner_depth.increment()?;
5566                }
5567                let val_ref = self.is_http_post.get_or_insert_with(|| fidl::new_empty!(bool, D));
5568                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5569                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5570                {
5571                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5572                }
5573                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5574                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5575                }
5576            }
5577
5578            next_offset += envelope_size;
5579            _next_ordinal_to_read += 1;
5580            if next_offset >= end_offset {
5581                return Ok(());
5582            }
5583
5584            // Decode unknown envelopes for gaps in ordinals.
5585            while _next_ordinal_to_read < 6 {
5586                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5587                _next_ordinal_to_read += 1;
5588                next_offset += envelope_size;
5589            }
5590
5591            let next_out_of_line = decoder.next_out_of_line();
5592            let handles_before = decoder.remaining_handles();
5593            if let Some((inlined, num_bytes, num_handles)) =
5594                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5595            {
5596                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5597                if inlined != (member_inline_size <= 4) {
5598                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5599                }
5600                let inner_offset;
5601                let mut inner_depth = depth.clone();
5602                if inlined {
5603                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5604                    inner_offset = next_offset;
5605                } else {
5606                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5607                    inner_depth.increment()?;
5608                }
5609                let val_ref = self.url.get_or_insert_with(|| {
5610                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
5611                });
5612                fidl::decode!(
5613                    fidl::encoding::BoundedString<65536>,
5614                    D,
5615                    val_ref,
5616                    decoder,
5617                    inner_offset,
5618                    inner_depth
5619                )?;
5620                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5621                {
5622                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5623                }
5624                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5625                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5626                }
5627            }
5628
5629            next_offset += envelope_size;
5630            _next_ordinal_to_read += 1;
5631            if next_offset >= end_offset {
5632                return Ok(());
5633            }
5634
5635            // Decode unknown envelopes for gaps in ordinals.
5636            while _next_ordinal_to_read < 7 {
5637                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5638                _next_ordinal_to_read += 1;
5639                next_offset += envelope_size;
5640            }
5641
5642            let next_out_of_line = decoder.next_out_of_line();
5643            let handles_before = decoder.remaining_handles();
5644            if let Some((inlined, num_bytes, num_handles)) =
5645                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5646            {
5647                let member_inline_size =
5648                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5649                if inlined != (member_inline_size <= 4) {
5650                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5651                }
5652                let inner_offset;
5653                let mut inner_depth = depth.clone();
5654                if inlined {
5655                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5656                    inner_offset = next_offset;
5657                } else {
5658                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5659                    inner_depth.increment()?;
5660                }
5661                let val_ref = self.has_gesture.get_or_insert_with(|| fidl::new_empty!(bool, D));
5662                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5663                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5664                {
5665                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5666                }
5667                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5668                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5669                }
5670            }
5671
5672            next_offset += envelope_size;
5673            _next_ordinal_to_read += 1;
5674            if next_offset >= end_offset {
5675                return Ok(());
5676            }
5677
5678            // Decode unknown envelopes for gaps in ordinals.
5679            while _next_ordinal_to_read < 8 {
5680                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5681                _next_ordinal_to_read += 1;
5682                next_offset += envelope_size;
5683            }
5684
5685            let next_out_of_line = decoder.next_out_of_line();
5686            let handles_before = decoder.remaining_handles();
5687            if let Some((inlined, num_bytes, num_handles)) =
5688                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5689            {
5690                let member_inline_size =
5691                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5692                if inlined != (member_inline_size <= 4) {
5693                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5694                }
5695                let inner_offset;
5696                let mut inner_depth = depth.clone();
5697                if inlined {
5698                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5699                    inner_offset = next_offset;
5700                } else {
5701                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5702                    inner_depth.increment()?;
5703                }
5704                let val_ref =
5705                    self.was_server_redirect.get_or_insert_with(|| fidl::new_empty!(bool, D));
5706                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5707                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5708                {
5709                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5710                }
5711                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5712                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5713                }
5714            }
5715
5716            next_offset += envelope_size;
5717
5718            // Decode the remaining unknown envelopes.
5719            while next_offset < end_offset {
5720                _next_ordinal_to_read += 1;
5721                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5722                next_offset += envelope_size;
5723            }
5724
5725            Ok(())
5726        }
5727    }
5728
5729    impl UrlRequestRewriteAddHeaders {
5730        #[inline(always)]
5731        fn max_ordinal_present(&self) -> u64 {
5732            if let Some(_) = self.headers {
5733                return 1;
5734            }
5735            0
5736        }
5737    }
5738
5739    impl fidl::encoding::ValueTypeMarker for UrlRequestRewriteAddHeaders {
5740        type Borrowed<'a> = &'a Self;
5741        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5742            value
5743        }
5744    }
5745
5746    unsafe impl fidl::encoding::TypeMarker for UrlRequestRewriteAddHeaders {
5747        type Owned = Self;
5748
5749        #[inline(always)]
5750        fn inline_align(_context: fidl::encoding::Context) -> usize {
5751            8
5752        }
5753
5754        #[inline(always)]
5755        fn inline_size(_context: fidl::encoding::Context) -> usize {
5756            16
5757        }
5758    }
5759
5760    unsafe impl<D: fidl::encoding::ResourceDialect>
5761        fidl::encoding::Encode<UrlRequestRewriteAddHeaders, D> for &UrlRequestRewriteAddHeaders
5762    {
5763        unsafe fn encode(
5764            self,
5765            encoder: &mut fidl::encoding::Encoder<'_, D>,
5766            offset: usize,
5767            mut depth: fidl::encoding::Depth,
5768        ) -> fidl::Result<()> {
5769            encoder.debug_check_bounds::<UrlRequestRewriteAddHeaders>(offset);
5770            // Vector header
5771            let max_ordinal: u64 = self.max_ordinal_present();
5772            encoder.write_num(max_ordinal, offset);
5773            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5774            // Calling encoder.out_of_line_offset(0) is not allowed.
5775            if max_ordinal == 0 {
5776                return Ok(());
5777            }
5778            depth.increment()?;
5779            let envelope_size = 8;
5780            let bytes_len = max_ordinal as usize * envelope_size;
5781            #[allow(unused_variables)]
5782            let offset = encoder.out_of_line_offset(bytes_len);
5783            let mut _prev_end_offset: usize = 0;
5784            if 1 > max_ordinal {
5785                return Ok(());
5786            }
5787
5788            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5789            // are envelope_size bytes.
5790            let cur_offset: usize = (1 - 1) * envelope_size;
5791
5792            // Zero reserved fields.
5793            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5794
5795            // Safety:
5796            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5797            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5798            //   envelope_size bytes, there is always sufficient room.
5799            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_net_http__common::Header, 4096>, D>(
5800            self.headers.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_net_http__common::Header, 4096> as fidl::encoding::ValueTypeMarker>::borrow),
5801            encoder, offset + cur_offset, depth
5802        )?;
5803
5804            _prev_end_offset = cur_offset + envelope_size;
5805
5806            Ok(())
5807        }
5808    }
5809
5810    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5811        for UrlRequestRewriteAddHeaders
5812    {
5813        #[inline(always)]
5814        fn new_empty() -> Self {
5815            Self::default()
5816        }
5817
5818        unsafe fn decode(
5819            &mut self,
5820            decoder: &mut fidl::encoding::Decoder<'_, D>,
5821            offset: usize,
5822            mut depth: fidl::encoding::Depth,
5823        ) -> fidl::Result<()> {
5824            decoder.debug_check_bounds::<Self>(offset);
5825            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5826                None => return Err(fidl::Error::NotNullable),
5827                Some(len) => len,
5828            };
5829            // Calling decoder.out_of_line_offset(0) is not allowed.
5830            if len == 0 {
5831                return Ok(());
5832            };
5833            depth.increment()?;
5834            let envelope_size = 8;
5835            let bytes_len = len * envelope_size;
5836            let offset = decoder.out_of_line_offset(bytes_len)?;
5837            // Decode the envelope for each type.
5838            let mut _next_ordinal_to_read = 0;
5839            let mut next_offset = offset;
5840            let end_offset = offset + bytes_len;
5841            _next_ordinal_to_read += 1;
5842            if next_offset >= end_offset {
5843                return Ok(());
5844            }
5845
5846            // Decode unknown envelopes for gaps in ordinals.
5847            while _next_ordinal_to_read < 1 {
5848                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5849                _next_ordinal_to_read += 1;
5850                next_offset += envelope_size;
5851            }
5852
5853            let next_out_of_line = decoder.next_out_of_line();
5854            let handles_before = decoder.remaining_handles();
5855            if let Some((inlined, num_bytes, num_handles)) =
5856                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5857            {
5858                let member_inline_size = <fidl::encoding::Vector<
5859                    fidl_fuchsia_net_http__common::Header,
5860                    4096,
5861                > as fidl::encoding::TypeMarker>::inline_size(
5862                    decoder.context
5863                );
5864                if inlined != (member_inline_size <= 4) {
5865                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5866                }
5867                let inner_offset;
5868                let mut inner_depth = depth.clone();
5869                if inlined {
5870                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5871                    inner_offset = next_offset;
5872                } else {
5873                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5874                    inner_depth.increment()?;
5875                }
5876                let val_ref =
5877                self.headers.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net_http__common::Header, 4096>, D));
5878                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net_http__common::Header, 4096>, D, val_ref, decoder, inner_offset, inner_depth)?;
5879                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5880                {
5881                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5882                }
5883                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5884                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5885                }
5886            }
5887
5888            next_offset += envelope_size;
5889
5890            // Decode the remaining unknown envelopes.
5891            while next_offset < end_offset {
5892                _next_ordinal_to_read += 1;
5893                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5894                next_offset += envelope_size;
5895            }
5896
5897            Ok(())
5898        }
5899    }
5900
5901    impl UrlRequestRewriteAppendToQuery {
5902        #[inline(always)]
5903        fn max_ordinal_present(&self) -> u64 {
5904            if let Some(_) = self.query {
5905                return 1;
5906            }
5907            0
5908        }
5909    }
5910
5911    impl fidl::encoding::ValueTypeMarker for UrlRequestRewriteAppendToQuery {
5912        type Borrowed<'a> = &'a Self;
5913        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5914            value
5915        }
5916    }
5917
5918    unsafe impl fidl::encoding::TypeMarker for UrlRequestRewriteAppendToQuery {
5919        type Owned = Self;
5920
5921        #[inline(always)]
5922        fn inline_align(_context: fidl::encoding::Context) -> usize {
5923            8
5924        }
5925
5926        #[inline(always)]
5927        fn inline_size(_context: fidl::encoding::Context) -> usize {
5928            16
5929        }
5930    }
5931
5932    unsafe impl<D: fidl::encoding::ResourceDialect>
5933        fidl::encoding::Encode<UrlRequestRewriteAppendToQuery, D>
5934        for &UrlRequestRewriteAppendToQuery
5935    {
5936        unsafe fn encode(
5937            self,
5938            encoder: &mut fidl::encoding::Encoder<'_, D>,
5939            offset: usize,
5940            mut depth: fidl::encoding::Depth,
5941        ) -> fidl::Result<()> {
5942            encoder.debug_check_bounds::<UrlRequestRewriteAppendToQuery>(offset);
5943            // Vector header
5944            let max_ordinal: u64 = self.max_ordinal_present();
5945            encoder.write_num(max_ordinal, offset);
5946            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5947            // Calling encoder.out_of_line_offset(0) is not allowed.
5948            if max_ordinal == 0 {
5949                return Ok(());
5950            }
5951            depth.increment()?;
5952            let envelope_size = 8;
5953            let bytes_len = max_ordinal as usize * envelope_size;
5954            #[allow(unused_variables)]
5955            let offset = encoder.out_of_line_offset(bytes_len);
5956            let mut _prev_end_offset: usize = 0;
5957            if 1 > max_ordinal {
5958                return Ok(());
5959            }
5960
5961            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5962            // are envelope_size bytes.
5963            let cur_offset: usize = (1 - 1) * envelope_size;
5964
5965            // Zero reserved fields.
5966            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5967
5968            // Safety:
5969            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5970            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5971            //   envelope_size bytes, there is always sufficient room.
5972            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
5973            self.query.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
5974            encoder, offset + cur_offset, depth
5975        )?;
5976
5977            _prev_end_offset = cur_offset + envelope_size;
5978
5979            Ok(())
5980        }
5981    }
5982
5983    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5984        for UrlRequestRewriteAppendToQuery
5985    {
5986        #[inline(always)]
5987        fn new_empty() -> Self {
5988            Self::default()
5989        }
5990
5991        unsafe fn decode(
5992            &mut self,
5993            decoder: &mut fidl::encoding::Decoder<'_, D>,
5994            offset: usize,
5995            mut depth: fidl::encoding::Depth,
5996        ) -> fidl::Result<()> {
5997            decoder.debug_check_bounds::<Self>(offset);
5998            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5999                None => return Err(fidl::Error::NotNullable),
6000                Some(len) => len,
6001            };
6002            // Calling decoder.out_of_line_offset(0) is not allowed.
6003            if len == 0 {
6004                return Ok(());
6005            };
6006            depth.increment()?;
6007            let envelope_size = 8;
6008            let bytes_len = len * envelope_size;
6009            let offset = decoder.out_of_line_offset(bytes_len)?;
6010            // Decode the envelope for each type.
6011            let mut _next_ordinal_to_read = 0;
6012            let mut next_offset = offset;
6013            let end_offset = offset + bytes_len;
6014            _next_ordinal_to_read += 1;
6015            if next_offset >= end_offset {
6016                return Ok(());
6017            }
6018
6019            // Decode unknown envelopes for gaps in ordinals.
6020            while _next_ordinal_to_read < 1 {
6021                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6022                _next_ordinal_to_read += 1;
6023                next_offset += envelope_size;
6024            }
6025
6026            let next_out_of_line = decoder.next_out_of_line();
6027            let handles_before = decoder.remaining_handles();
6028            if let Some((inlined, num_bytes, num_handles)) =
6029                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6030            {
6031                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6032                if inlined != (member_inline_size <= 4) {
6033                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6034                }
6035                let inner_offset;
6036                let mut inner_depth = depth.clone();
6037                if inlined {
6038                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6039                    inner_offset = next_offset;
6040                } else {
6041                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6042                    inner_depth.increment()?;
6043                }
6044                let val_ref = self.query.get_or_insert_with(|| {
6045                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
6046                });
6047                fidl::decode!(
6048                    fidl::encoding::BoundedString<65536>,
6049                    D,
6050                    val_ref,
6051                    decoder,
6052                    inner_offset,
6053                    inner_depth
6054                )?;
6055                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6056                {
6057                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6058                }
6059                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6060                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6061                }
6062            }
6063
6064            next_offset += envelope_size;
6065
6066            // Decode the remaining unknown envelopes.
6067            while next_offset < end_offset {
6068                _next_ordinal_to_read += 1;
6069                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6070                next_offset += envelope_size;
6071            }
6072
6073            Ok(())
6074        }
6075    }
6076
6077    impl UrlRequestRewriteRemoveHeader {
6078        #[inline(always)]
6079        fn max_ordinal_present(&self) -> u64 {
6080            if let Some(_) = self.header_name {
6081                return 2;
6082            }
6083            if let Some(_) = self.query_pattern {
6084                return 1;
6085            }
6086            0
6087        }
6088    }
6089
6090    impl fidl::encoding::ValueTypeMarker for UrlRequestRewriteRemoveHeader {
6091        type Borrowed<'a> = &'a Self;
6092        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6093            value
6094        }
6095    }
6096
6097    unsafe impl fidl::encoding::TypeMarker for UrlRequestRewriteRemoveHeader {
6098        type Owned = Self;
6099
6100        #[inline(always)]
6101        fn inline_align(_context: fidl::encoding::Context) -> usize {
6102            8
6103        }
6104
6105        #[inline(always)]
6106        fn inline_size(_context: fidl::encoding::Context) -> usize {
6107            16
6108        }
6109    }
6110
6111    unsafe impl<D: fidl::encoding::ResourceDialect>
6112        fidl::encoding::Encode<UrlRequestRewriteRemoveHeader, D>
6113        for &UrlRequestRewriteRemoveHeader
6114    {
6115        unsafe fn encode(
6116            self,
6117            encoder: &mut fidl::encoding::Encoder<'_, D>,
6118            offset: usize,
6119            mut depth: fidl::encoding::Depth,
6120        ) -> fidl::Result<()> {
6121            encoder.debug_check_bounds::<UrlRequestRewriteRemoveHeader>(offset);
6122            // Vector header
6123            let max_ordinal: u64 = self.max_ordinal_present();
6124            encoder.write_num(max_ordinal, offset);
6125            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6126            // Calling encoder.out_of_line_offset(0) is not allowed.
6127            if max_ordinal == 0 {
6128                return Ok(());
6129            }
6130            depth.increment()?;
6131            let envelope_size = 8;
6132            let bytes_len = max_ordinal as usize * envelope_size;
6133            #[allow(unused_variables)]
6134            let offset = encoder.out_of_line_offset(bytes_len);
6135            let mut _prev_end_offset: usize = 0;
6136            if 1 > max_ordinal {
6137                return Ok(());
6138            }
6139
6140            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6141            // are envelope_size bytes.
6142            let cur_offset: usize = (1 - 1) * envelope_size;
6143
6144            // Zero reserved fields.
6145            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6146
6147            // Safety:
6148            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6149            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6150            //   envelope_size bytes, there is always sufficient room.
6151            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
6152            self.query_pattern.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
6153            encoder, offset + cur_offset, depth
6154        )?;
6155
6156            _prev_end_offset = cur_offset + envelope_size;
6157            if 2 > max_ordinal {
6158                return Ok(());
6159            }
6160
6161            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6162            // are envelope_size bytes.
6163            let cur_offset: usize = (2 - 1) * envelope_size;
6164
6165            // Zero reserved fields.
6166            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6167
6168            // Safety:
6169            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6170            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6171            //   envelope_size bytes, there is always sufficient room.
6172            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
6173            self.header_name.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
6174            encoder, offset + cur_offset, depth
6175        )?;
6176
6177            _prev_end_offset = cur_offset + envelope_size;
6178
6179            Ok(())
6180        }
6181    }
6182
6183    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6184        for UrlRequestRewriteRemoveHeader
6185    {
6186        #[inline(always)]
6187        fn new_empty() -> Self {
6188            Self::default()
6189        }
6190
6191        unsafe fn decode(
6192            &mut self,
6193            decoder: &mut fidl::encoding::Decoder<'_, D>,
6194            offset: usize,
6195            mut depth: fidl::encoding::Depth,
6196        ) -> fidl::Result<()> {
6197            decoder.debug_check_bounds::<Self>(offset);
6198            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6199                None => return Err(fidl::Error::NotNullable),
6200                Some(len) => len,
6201            };
6202            // Calling decoder.out_of_line_offset(0) is not allowed.
6203            if len == 0 {
6204                return Ok(());
6205            };
6206            depth.increment()?;
6207            let envelope_size = 8;
6208            let bytes_len = len * envelope_size;
6209            let offset = decoder.out_of_line_offset(bytes_len)?;
6210            // Decode the envelope for each type.
6211            let mut _next_ordinal_to_read = 0;
6212            let mut next_offset = offset;
6213            let end_offset = offset + bytes_len;
6214            _next_ordinal_to_read += 1;
6215            if next_offset >= end_offset {
6216                return Ok(());
6217            }
6218
6219            // Decode unknown envelopes for gaps in ordinals.
6220            while _next_ordinal_to_read < 1 {
6221                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6222                _next_ordinal_to_read += 1;
6223                next_offset += envelope_size;
6224            }
6225
6226            let next_out_of_line = decoder.next_out_of_line();
6227            let handles_before = decoder.remaining_handles();
6228            if let Some((inlined, num_bytes, num_handles)) =
6229                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6230            {
6231                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6232                if inlined != (member_inline_size <= 4) {
6233                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6234                }
6235                let inner_offset;
6236                let mut inner_depth = depth.clone();
6237                if inlined {
6238                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6239                    inner_offset = next_offset;
6240                } else {
6241                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6242                    inner_depth.increment()?;
6243                }
6244                let val_ref = self.query_pattern.get_or_insert_with(|| {
6245                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
6246                });
6247                fidl::decode!(
6248                    fidl::encoding::BoundedString<65536>,
6249                    D,
6250                    val_ref,
6251                    decoder,
6252                    inner_offset,
6253                    inner_depth
6254                )?;
6255                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6256                {
6257                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6258                }
6259                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6260                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6261                }
6262            }
6263
6264            next_offset += envelope_size;
6265            _next_ordinal_to_read += 1;
6266            if next_offset >= end_offset {
6267                return Ok(());
6268            }
6269
6270            // Decode unknown envelopes for gaps in ordinals.
6271            while _next_ordinal_to_read < 2 {
6272                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6273                _next_ordinal_to_read += 1;
6274                next_offset += envelope_size;
6275            }
6276
6277            let next_out_of_line = decoder.next_out_of_line();
6278            let handles_before = decoder.remaining_handles();
6279            if let Some((inlined, num_bytes, num_handles)) =
6280                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6281            {
6282                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6283                if inlined != (member_inline_size <= 4) {
6284                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6285                }
6286                let inner_offset;
6287                let mut inner_depth = depth.clone();
6288                if inlined {
6289                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6290                    inner_offset = next_offset;
6291                } else {
6292                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6293                    inner_depth.increment()?;
6294                }
6295                let val_ref = self.header_name.get_or_insert_with(|| {
6296                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
6297                });
6298                fidl::decode!(
6299                    fidl::encoding::UnboundedVector<u8>,
6300                    D,
6301                    val_ref,
6302                    decoder,
6303                    inner_offset,
6304                    inner_depth
6305                )?;
6306                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6307                {
6308                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6309                }
6310                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6311                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6312                }
6313            }
6314
6315            next_offset += envelope_size;
6316
6317            // Decode the remaining unknown envelopes.
6318            while next_offset < end_offset {
6319                _next_ordinal_to_read += 1;
6320                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6321                next_offset += envelope_size;
6322            }
6323
6324            Ok(())
6325        }
6326    }
6327
6328    impl UrlRequestRewriteReplaceUrl {
6329        #[inline(always)]
6330        fn max_ordinal_present(&self) -> u64 {
6331            if let Some(_) = self.new_url {
6332                return 2;
6333            }
6334            if let Some(_) = self.url_ends_with {
6335                return 1;
6336            }
6337            0
6338        }
6339    }
6340
6341    impl fidl::encoding::ValueTypeMarker for UrlRequestRewriteReplaceUrl {
6342        type Borrowed<'a> = &'a Self;
6343        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6344            value
6345        }
6346    }
6347
6348    unsafe impl fidl::encoding::TypeMarker for UrlRequestRewriteReplaceUrl {
6349        type Owned = Self;
6350
6351        #[inline(always)]
6352        fn inline_align(_context: fidl::encoding::Context) -> usize {
6353            8
6354        }
6355
6356        #[inline(always)]
6357        fn inline_size(_context: fidl::encoding::Context) -> usize {
6358            16
6359        }
6360    }
6361
6362    unsafe impl<D: fidl::encoding::ResourceDialect>
6363        fidl::encoding::Encode<UrlRequestRewriteReplaceUrl, D> for &UrlRequestRewriteReplaceUrl
6364    {
6365        unsafe fn encode(
6366            self,
6367            encoder: &mut fidl::encoding::Encoder<'_, D>,
6368            offset: usize,
6369            mut depth: fidl::encoding::Depth,
6370        ) -> fidl::Result<()> {
6371            encoder.debug_check_bounds::<UrlRequestRewriteReplaceUrl>(offset);
6372            // Vector header
6373            let max_ordinal: u64 = self.max_ordinal_present();
6374            encoder.write_num(max_ordinal, offset);
6375            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6376            // Calling encoder.out_of_line_offset(0) is not allowed.
6377            if max_ordinal == 0 {
6378                return Ok(());
6379            }
6380            depth.increment()?;
6381            let envelope_size = 8;
6382            let bytes_len = max_ordinal as usize * envelope_size;
6383            #[allow(unused_variables)]
6384            let offset = encoder.out_of_line_offset(bytes_len);
6385            let mut _prev_end_offset: usize = 0;
6386            if 1 > max_ordinal {
6387                return Ok(());
6388            }
6389
6390            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6391            // are envelope_size bytes.
6392            let cur_offset: usize = (1 - 1) * envelope_size;
6393
6394            // Zero reserved fields.
6395            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6396
6397            // Safety:
6398            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6399            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6400            //   envelope_size bytes, there is always sufficient room.
6401            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
6402            self.url_ends_with.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
6403            encoder, offset + cur_offset, depth
6404        )?;
6405
6406            _prev_end_offset = cur_offset + envelope_size;
6407            if 2 > max_ordinal {
6408                return Ok(());
6409            }
6410
6411            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6412            // are envelope_size bytes.
6413            let cur_offset: usize = (2 - 1) * envelope_size;
6414
6415            // Zero reserved fields.
6416            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6417
6418            // Safety:
6419            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6420            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6421            //   envelope_size bytes, there is always sufficient room.
6422            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
6423            self.new_url.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
6424            encoder, offset + cur_offset, depth
6425        )?;
6426
6427            _prev_end_offset = cur_offset + envelope_size;
6428
6429            Ok(())
6430        }
6431    }
6432
6433    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6434        for UrlRequestRewriteReplaceUrl
6435    {
6436        #[inline(always)]
6437        fn new_empty() -> Self {
6438            Self::default()
6439        }
6440
6441        unsafe fn decode(
6442            &mut self,
6443            decoder: &mut fidl::encoding::Decoder<'_, D>,
6444            offset: usize,
6445            mut depth: fidl::encoding::Depth,
6446        ) -> fidl::Result<()> {
6447            decoder.debug_check_bounds::<Self>(offset);
6448            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6449                None => return Err(fidl::Error::NotNullable),
6450                Some(len) => len,
6451            };
6452            // Calling decoder.out_of_line_offset(0) is not allowed.
6453            if len == 0 {
6454                return Ok(());
6455            };
6456            depth.increment()?;
6457            let envelope_size = 8;
6458            let bytes_len = len * envelope_size;
6459            let offset = decoder.out_of_line_offset(bytes_len)?;
6460            // Decode the envelope for each type.
6461            let mut _next_ordinal_to_read = 0;
6462            let mut next_offset = offset;
6463            let end_offset = offset + bytes_len;
6464            _next_ordinal_to_read += 1;
6465            if next_offset >= end_offset {
6466                return Ok(());
6467            }
6468
6469            // Decode unknown envelopes for gaps in ordinals.
6470            while _next_ordinal_to_read < 1 {
6471                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6472                _next_ordinal_to_read += 1;
6473                next_offset += envelope_size;
6474            }
6475
6476            let next_out_of_line = decoder.next_out_of_line();
6477            let handles_before = decoder.remaining_handles();
6478            if let Some((inlined, num_bytes, num_handles)) =
6479                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6480            {
6481                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6482                if inlined != (member_inline_size <= 4) {
6483                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6484                }
6485                let inner_offset;
6486                let mut inner_depth = depth.clone();
6487                if inlined {
6488                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6489                    inner_offset = next_offset;
6490                } else {
6491                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6492                    inner_depth.increment()?;
6493                }
6494                let val_ref = self.url_ends_with.get_or_insert_with(|| {
6495                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
6496                });
6497                fidl::decode!(
6498                    fidl::encoding::BoundedString<65536>,
6499                    D,
6500                    val_ref,
6501                    decoder,
6502                    inner_offset,
6503                    inner_depth
6504                )?;
6505                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6506                {
6507                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6508                }
6509                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6510                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6511                }
6512            }
6513
6514            next_offset += envelope_size;
6515            _next_ordinal_to_read += 1;
6516            if next_offset >= end_offset {
6517                return Ok(());
6518            }
6519
6520            // Decode unknown envelopes for gaps in ordinals.
6521            while _next_ordinal_to_read < 2 {
6522                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6523                _next_ordinal_to_read += 1;
6524                next_offset += envelope_size;
6525            }
6526
6527            let next_out_of_line = decoder.next_out_of_line();
6528            let handles_before = decoder.remaining_handles();
6529            if let Some((inlined, num_bytes, num_handles)) =
6530                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6531            {
6532                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6533                if inlined != (member_inline_size <= 4) {
6534                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6535                }
6536                let inner_offset;
6537                let mut inner_depth = depth.clone();
6538                if inlined {
6539                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6540                    inner_offset = next_offset;
6541                } else {
6542                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6543                    inner_depth.increment()?;
6544                }
6545                let val_ref = self.new_url.get_or_insert_with(|| {
6546                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
6547                });
6548                fidl::decode!(
6549                    fidl::encoding::BoundedString<65536>,
6550                    D,
6551                    val_ref,
6552                    decoder,
6553                    inner_offset,
6554                    inner_depth
6555                )?;
6556                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6557                {
6558                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6559                }
6560                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6561                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6562                }
6563            }
6564
6565            next_offset += envelope_size;
6566
6567            // Decode the remaining unknown envelopes.
6568            while next_offset < end_offset {
6569                _next_ordinal_to_read += 1;
6570                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6571                next_offset += envelope_size;
6572            }
6573
6574            Ok(())
6575        }
6576    }
6577
6578    impl UrlRequestRewriteRule {
6579        #[inline(always)]
6580        fn max_ordinal_present(&self) -> u64 {
6581            if let Some(_) = self.action {
6582                return 4;
6583            }
6584            if let Some(_) = self.rewrites {
6585                return 3;
6586            }
6587            if let Some(_) = self.schemes_filter {
6588                return 2;
6589            }
6590            if let Some(_) = self.hosts_filter {
6591                return 1;
6592            }
6593            0
6594        }
6595    }
6596
6597    impl fidl::encoding::ValueTypeMarker for UrlRequestRewriteRule {
6598        type Borrowed<'a> = &'a Self;
6599        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6600            value
6601        }
6602    }
6603
6604    unsafe impl fidl::encoding::TypeMarker for UrlRequestRewriteRule {
6605        type Owned = Self;
6606
6607        #[inline(always)]
6608        fn inline_align(_context: fidl::encoding::Context) -> usize {
6609            8
6610        }
6611
6612        #[inline(always)]
6613        fn inline_size(_context: fidl::encoding::Context) -> usize {
6614            16
6615        }
6616    }
6617
6618    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UrlRequestRewriteRule, D>
6619        for &UrlRequestRewriteRule
6620    {
6621        unsafe fn encode(
6622            self,
6623            encoder: &mut fidl::encoding::Encoder<'_, D>,
6624            offset: usize,
6625            mut depth: fidl::encoding::Depth,
6626        ) -> fidl::Result<()> {
6627            encoder.debug_check_bounds::<UrlRequestRewriteRule>(offset);
6628            // Vector header
6629            let max_ordinal: u64 = self.max_ordinal_present();
6630            encoder.write_num(max_ordinal, offset);
6631            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6632            // Calling encoder.out_of_line_offset(0) is not allowed.
6633            if max_ordinal == 0 {
6634                return Ok(());
6635            }
6636            depth.increment()?;
6637            let envelope_size = 8;
6638            let bytes_len = max_ordinal as usize * envelope_size;
6639            #[allow(unused_variables)]
6640            let offset = encoder.out_of_line_offset(bytes_len);
6641            let mut _prev_end_offset: usize = 0;
6642            if 1 > max_ordinal {
6643                return Ok(());
6644            }
6645
6646            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6647            // are envelope_size bytes.
6648            let cur_offset: usize = (1 - 1) * envelope_size;
6649
6650            // Zero reserved fields.
6651            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6652
6653            // Safety:
6654            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6655            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6656            //   envelope_size bytes, there is always sufficient room.
6657            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096>, D>(
6658            self.hosts_filter.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096> as fidl::encoding::ValueTypeMarker>::borrow),
6659            encoder, offset + cur_offset, depth
6660        )?;
6661
6662            _prev_end_offset = cur_offset + envelope_size;
6663            if 2 > max_ordinal {
6664                return Ok(());
6665            }
6666
6667            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6668            // are envelope_size bytes.
6669            let cur_offset: usize = (2 - 1) * envelope_size;
6670
6671            // Zero reserved fields.
6672            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6673
6674            // Safety:
6675            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6676            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6677            //   envelope_size bytes, there is always sufficient room.
6678            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096>, D>(
6679            self.schemes_filter.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096> as fidl::encoding::ValueTypeMarker>::borrow),
6680            encoder, offset + cur_offset, depth
6681        )?;
6682
6683            _prev_end_offset = cur_offset + envelope_size;
6684            if 3 > max_ordinal {
6685                return Ok(());
6686            }
6687
6688            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6689            // are envelope_size bytes.
6690            let cur_offset: usize = (3 - 1) * envelope_size;
6691
6692            // Zero reserved fields.
6693            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6694
6695            // Safety:
6696            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6697            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6698            //   envelope_size bytes, there is always sufficient room.
6699            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<UrlRequestRewrite, 4096>, D>(
6700            self.rewrites.as_ref().map(<fidl::encoding::Vector<UrlRequestRewrite, 4096> as fidl::encoding::ValueTypeMarker>::borrow),
6701            encoder, offset + cur_offset, depth
6702        )?;
6703
6704            _prev_end_offset = cur_offset + envelope_size;
6705            if 4 > max_ordinal {
6706                return Ok(());
6707            }
6708
6709            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6710            // are envelope_size bytes.
6711            let cur_offset: usize = (4 - 1) * envelope_size;
6712
6713            // Zero reserved fields.
6714            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6715
6716            // Safety:
6717            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6718            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6719            //   envelope_size bytes, there is always sufficient room.
6720            fidl::encoding::encode_in_envelope_optional::<UrlRequestAction, D>(
6721                self.action
6722                    .as_ref()
6723                    .map(<UrlRequestAction as fidl::encoding::ValueTypeMarker>::borrow),
6724                encoder,
6725                offset + cur_offset,
6726                depth,
6727            )?;
6728
6729            _prev_end_offset = cur_offset + envelope_size;
6730
6731            Ok(())
6732        }
6733    }
6734
6735    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UrlRequestRewriteRule {
6736        #[inline(always)]
6737        fn new_empty() -> Self {
6738            Self::default()
6739        }
6740
6741        unsafe fn decode(
6742            &mut self,
6743            decoder: &mut fidl::encoding::Decoder<'_, D>,
6744            offset: usize,
6745            mut depth: fidl::encoding::Depth,
6746        ) -> fidl::Result<()> {
6747            decoder.debug_check_bounds::<Self>(offset);
6748            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6749                None => return Err(fidl::Error::NotNullable),
6750                Some(len) => len,
6751            };
6752            // Calling decoder.out_of_line_offset(0) is not allowed.
6753            if len == 0 {
6754                return Ok(());
6755            };
6756            depth.increment()?;
6757            let envelope_size = 8;
6758            let bytes_len = len * envelope_size;
6759            let offset = decoder.out_of_line_offset(bytes_len)?;
6760            // Decode the envelope for each type.
6761            let mut _next_ordinal_to_read = 0;
6762            let mut next_offset = offset;
6763            let end_offset = offset + bytes_len;
6764            _next_ordinal_to_read += 1;
6765            if next_offset >= end_offset {
6766                return Ok(());
6767            }
6768
6769            // Decode unknown envelopes for gaps in ordinals.
6770            while _next_ordinal_to_read < 1 {
6771                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6772                _next_ordinal_to_read += 1;
6773                next_offset += envelope_size;
6774            }
6775
6776            let next_out_of_line = decoder.next_out_of_line();
6777            let handles_before = decoder.remaining_handles();
6778            if let Some((inlined, num_bytes, num_handles)) =
6779                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6780            {
6781                let member_inline_size = <fidl::encoding::Vector<
6782                    fidl::encoding::BoundedString<255>,
6783                    4096,
6784                > as fidl::encoding::TypeMarker>::inline_size(
6785                    decoder.context
6786                );
6787                if inlined != (member_inline_size <= 4) {
6788                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6789                }
6790                let inner_offset;
6791                let mut inner_depth = depth.clone();
6792                if inlined {
6793                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6794                    inner_offset = next_offset;
6795                } else {
6796                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6797                    inner_depth.increment()?;
6798                }
6799                let val_ref = self.hosts_filter.get_or_insert_with(|| {
6800                    fidl::new_empty!(
6801                        fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096>,
6802                        D
6803                    )
6804                });
6805                fidl::decode!(
6806                    fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096>,
6807                    D,
6808                    val_ref,
6809                    decoder,
6810                    inner_offset,
6811                    inner_depth
6812                )?;
6813                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6814                {
6815                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6816                }
6817                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6818                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6819                }
6820            }
6821
6822            next_offset += envelope_size;
6823            _next_ordinal_to_read += 1;
6824            if next_offset >= end_offset {
6825                return Ok(());
6826            }
6827
6828            // Decode unknown envelopes for gaps in ordinals.
6829            while _next_ordinal_to_read < 2 {
6830                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6831                _next_ordinal_to_read += 1;
6832                next_offset += envelope_size;
6833            }
6834
6835            let next_out_of_line = decoder.next_out_of_line();
6836            let handles_before = decoder.remaining_handles();
6837            if let Some((inlined, num_bytes, num_handles)) =
6838                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6839            {
6840                let member_inline_size = <fidl::encoding::Vector<
6841                    fidl::encoding::BoundedString<255>,
6842                    4096,
6843                > as fidl::encoding::TypeMarker>::inline_size(
6844                    decoder.context
6845                );
6846                if inlined != (member_inline_size <= 4) {
6847                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6848                }
6849                let inner_offset;
6850                let mut inner_depth = depth.clone();
6851                if inlined {
6852                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6853                    inner_offset = next_offset;
6854                } else {
6855                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6856                    inner_depth.increment()?;
6857                }
6858                let val_ref = self.schemes_filter.get_or_insert_with(|| {
6859                    fidl::new_empty!(
6860                        fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096>,
6861                        D
6862                    )
6863                });
6864                fidl::decode!(
6865                    fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096>,
6866                    D,
6867                    val_ref,
6868                    decoder,
6869                    inner_offset,
6870                    inner_depth
6871                )?;
6872                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6873                {
6874                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6875                }
6876                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6877                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6878                }
6879            }
6880
6881            next_offset += envelope_size;
6882            _next_ordinal_to_read += 1;
6883            if next_offset >= end_offset {
6884                return Ok(());
6885            }
6886
6887            // Decode unknown envelopes for gaps in ordinals.
6888            while _next_ordinal_to_read < 3 {
6889                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6890                _next_ordinal_to_read += 1;
6891                next_offset += envelope_size;
6892            }
6893
6894            let next_out_of_line = decoder.next_out_of_line();
6895            let handles_before = decoder.remaining_handles();
6896            if let Some((inlined, num_bytes, num_handles)) =
6897                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6898            {
6899                let member_inline_size = <fidl::encoding::Vector<UrlRequestRewrite, 4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6900                if inlined != (member_inline_size <= 4) {
6901                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6902                }
6903                let inner_offset;
6904                let mut inner_depth = depth.clone();
6905                if inlined {
6906                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6907                    inner_offset = next_offset;
6908                } else {
6909                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6910                    inner_depth.increment()?;
6911                }
6912                let val_ref = self.rewrites.get_or_insert_with(
6913                    || fidl::new_empty!(fidl::encoding::Vector<UrlRequestRewrite, 4096>, D),
6914                );
6915                fidl::decode!(fidl::encoding::Vector<UrlRequestRewrite, 4096>, D, val_ref, decoder, inner_offset, inner_depth)?;
6916                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6917                {
6918                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6919                }
6920                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6921                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6922                }
6923            }
6924
6925            next_offset += envelope_size;
6926            _next_ordinal_to_read += 1;
6927            if next_offset >= end_offset {
6928                return Ok(());
6929            }
6930
6931            // Decode unknown envelopes for gaps in ordinals.
6932            while _next_ordinal_to_read < 4 {
6933                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6934                _next_ordinal_to_read += 1;
6935                next_offset += envelope_size;
6936            }
6937
6938            let next_out_of_line = decoder.next_out_of_line();
6939            let handles_before = decoder.remaining_handles();
6940            if let Some((inlined, num_bytes, num_handles)) =
6941                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6942            {
6943                let member_inline_size =
6944                    <UrlRequestAction as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6945                if inlined != (member_inline_size <= 4) {
6946                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6947                }
6948                let inner_offset;
6949                let mut inner_depth = depth.clone();
6950                if inlined {
6951                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6952                    inner_offset = next_offset;
6953                } else {
6954                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6955                    inner_depth.increment()?;
6956                }
6957                let val_ref =
6958                    self.action.get_or_insert_with(|| fidl::new_empty!(UrlRequestAction, D));
6959                fidl::decode!(UrlRequestAction, D, val_ref, decoder, inner_offset, inner_depth)?;
6960                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6961                {
6962                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6963                }
6964                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6965                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6966                }
6967            }
6968
6969            next_offset += envelope_size;
6970
6971            // Decode the remaining unknown envelopes.
6972            while next_offset < end_offset {
6973                _next_ordinal_to_read += 1;
6974                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6975                next_offset += envelope_size;
6976            }
6977
6978            Ok(())
6979        }
6980    }
6981
6982    impl UrlRequestRewriteSubstituteQueryPattern {
6983        #[inline(always)]
6984        fn max_ordinal_present(&self) -> u64 {
6985            if let Some(_) = self.substitution {
6986                return 2;
6987            }
6988            if let Some(_) = self.pattern {
6989                return 1;
6990            }
6991            0
6992        }
6993    }
6994
6995    impl fidl::encoding::ValueTypeMarker for UrlRequestRewriteSubstituteQueryPattern {
6996        type Borrowed<'a> = &'a Self;
6997        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6998            value
6999        }
7000    }
7001
7002    unsafe impl fidl::encoding::TypeMarker for UrlRequestRewriteSubstituteQueryPattern {
7003        type Owned = Self;
7004
7005        #[inline(always)]
7006        fn inline_align(_context: fidl::encoding::Context) -> usize {
7007            8
7008        }
7009
7010        #[inline(always)]
7011        fn inline_size(_context: fidl::encoding::Context) -> usize {
7012            16
7013        }
7014    }
7015
7016    unsafe impl<D: fidl::encoding::ResourceDialect>
7017        fidl::encoding::Encode<UrlRequestRewriteSubstituteQueryPattern, D>
7018        for &UrlRequestRewriteSubstituteQueryPattern
7019    {
7020        unsafe fn encode(
7021            self,
7022            encoder: &mut fidl::encoding::Encoder<'_, D>,
7023            offset: usize,
7024            mut depth: fidl::encoding::Depth,
7025        ) -> fidl::Result<()> {
7026            encoder.debug_check_bounds::<UrlRequestRewriteSubstituteQueryPattern>(offset);
7027            // Vector header
7028            let max_ordinal: u64 = self.max_ordinal_present();
7029            encoder.write_num(max_ordinal, offset);
7030            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7031            // Calling encoder.out_of_line_offset(0) is not allowed.
7032            if max_ordinal == 0 {
7033                return Ok(());
7034            }
7035            depth.increment()?;
7036            let envelope_size = 8;
7037            let bytes_len = max_ordinal as usize * envelope_size;
7038            #[allow(unused_variables)]
7039            let offset = encoder.out_of_line_offset(bytes_len);
7040            let mut _prev_end_offset: usize = 0;
7041            if 1 > max_ordinal {
7042                return Ok(());
7043            }
7044
7045            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7046            // are envelope_size bytes.
7047            let cur_offset: usize = (1 - 1) * envelope_size;
7048
7049            // Zero reserved fields.
7050            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7051
7052            // Safety:
7053            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7054            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7055            //   envelope_size bytes, there is always sufficient room.
7056            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
7057            self.pattern.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
7058            encoder, offset + cur_offset, depth
7059        )?;
7060
7061            _prev_end_offset = cur_offset + envelope_size;
7062            if 2 > max_ordinal {
7063                return Ok(());
7064            }
7065
7066            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7067            // are envelope_size bytes.
7068            let cur_offset: usize = (2 - 1) * envelope_size;
7069
7070            // Zero reserved fields.
7071            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7072
7073            // Safety:
7074            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7075            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7076            //   envelope_size bytes, there is always sufficient room.
7077            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
7078            self.substitution.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
7079            encoder, offset + cur_offset, depth
7080        )?;
7081
7082            _prev_end_offset = cur_offset + envelope_size;
7083
7084            Ok(())
7085        }
7086    }
7087
7088    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7089        for UrlRequestRewriteSubstituteQueryPattern
7090    {
7091        #[inline(always)]
7092        fn new_empty() -> Self {
7093            Self::default()
7094        }
7095
7096        unsafe fn decode(
7097            &mut self,
7098            decoder: &mut fidl::encoding::Decoder<'_, D>,
7099            offset: usize,
7100            mut depth: fidl::encoding::Depth,
7101        ) -> fidl::Result<()> {
7102            decoder.debug_check_bounds::<Self>(offset);
7103            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7104                None => return Err(fidl::Error::NotNullable),
7105                Some(len) => len,
7106            };
7107            // Calling decoder.out_of_line_offset(0) is not allowed.
7108            if len == 0 {
7109                return Ok(());
7110            };
7111            depth.increment()?;
7112            let envelope_size = 8;
7113            let bytes_len = len * envelope_size;
7114            let offset = decoder.out_of_line_offset(bytes_len)?;
7115            // Decode the envelope for each type.
7116            let mut _next_ordinal_to_read = 0;
7117            let mut next_offset = offset;
7118            let end_offset = offset + bytes_len;
7119            _next_ordinal_to_read += 1;
7120            if next_offset >= end_offset {
7121                return Ok(());
7122            }
7123
7124            // Decode unknown envelopes for gaps in ordinals.
7125            while _next_ordinal_to_read < 1 {
7126                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7127                _next_ordinal_to_read += 1;
7128                next_offset += envelope_size;
7129            }
7130
7131            let next_out_of_line = decoder.next_out_of_line();
7132            let handles_before = decoder.remaining_handles();
7133            if let Some((inlined, num_bytes, num_handles)) =
7134                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7135            {
7136                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7137                if inlined != (member_inline_size <= 4) {
7138                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7139                }
7140                let inner_offset;
7141                let mut inner_depth = depth.clone();
7142                if inlined {
7143                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7144                    inner_offset = next_offset;
7145                } else {
7146                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7147                    inner_depth.increment()?;
7148                }
7149                let val_ref = self.pattern.get_or_insert_with(|| {
7150                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
7151                });
7152                fidl::decode!(
7153                    fidl::encoding::BoundedString<65536>,
7154                    D,
7155                    val_ref,
7156                    decoder,
7157                    inner_offset,
7158                    inner_depth
7159                )?;
7160                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7161                {
7162                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7163                }
7164                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7165                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7166                }
7167            }
7168
7169            next_offset += envelope_size;
7170            _next_ordinal_to_read += 1;
7171            if next_offset >= end_offset {
7172                return Ok(());
7173            }
7174
7175            // Decode unknown envelopes for gaps in ordinals.
7176            while _next_ordinal_to_read < 2 {
7177                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7178                _next_ordinal_to_read += 1;
7179                next_offset += envelope_size;
7180            }
7181
7182            let next_out_of_line = decoder.next_out_of_line();
7183            let handles_before = decoder.remaining_handles();
7184            if let Some((inlined, num_bytes, num_handles)) =
7185                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7186            {
7187                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7188                if inlined != (member_inline_size <= 4) {
7189                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7190                }
7191                let inner_offset;
7192                let mut inner_depth = depth.clone();
7193                if inlined {
7194                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7195                    inner_offset = next_offset;
7196                } else {
7197                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7198                    inner_depth.increment()?;
7199                }
7200                let val_ref = self.substitution.get_or_insert_with(|| {
7201                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
7202                });
7203                fidl::decode!(
7204                    fidl::encoding::BoundedString<65536>,
7205                    D,
7206                    val_ref,
7207                    decoder,
7208                    inner_offset,
7209                    inner_depth
7210                )?;
7211                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7212                {
7213                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7214                }
7215                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7216                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7217                }
7218            }
7219
7220            next_offset += envelope_size;
7221
7222            // Decode the remaining unknown envelopes.
7223            while next_offset < end_offset {
7224                _next_ordinal_to_read += 1;
7225                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7226                next_offset += envelope_size;
7227            }
7228
7229            Ok(())
7230        }
7231    }
7232
7233    impl fidl::encoding::ValueTypeMarker for UrlRequestRewrite {
7234        type Borrowed<'a> = &'a Self;
7235        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7236            value
7237        }
7238    }
7239
7240    unsafe impl fidl::encoding::TypeMarker for UrlRequestRewrite {
7241        type Owned = Self;
7242
7243        #[inline(always)]
7244        fn inline_align(_context: fidl::encoding::Context) -> usize {
7245            8
7246        }
7247
7248        #[inline(always)]
7249        fn inline_size(_context: fidl::encoding::Context) -> usize {
7250            16
7251        }
7252    }
7253
7254    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UrlRequestRewrite, D>
7255        for &UrlRequestRewrite
7256    {
7257        #[inline]
7258        unsafe fn encode(
7259            self,
7260            encoder: &mut fidl::encoding::Encoder<'_, D>,
7261            offset: usize,
7262            _depth: fidl::encoding::Depth,
7263        ) -> fidl::Result<()> {
7264            encoder.debug_check_bounds::<UrlRequestRewrite>(offset);
7265            encoder.write_num::<u64>(self.ordinal(), offset);
7266            match self {
7267            UrlRequestRewrite::AddHeaders(ref val) => {
7268                fidl::encoding::encode_in_envelope::<UrlRequestRewriteAddHeaders, D>(
7269                    <UrlRequestRewriteAddHeaders as fidl::encoding::ValueTypeMarker>::borrow(val),
7270                    encoder, offset + 8, _depth
7271                )
7272            }
7273            UrlRequestRewrite::RemoveHeader(ref val) => {
7274                fidl::encoding::encode_in_envelope::<UrlRequestRewriteRemoveHeader, D>(
7275                    <UrlRequestRewriteRemoveHeader as fidl::encoding::ValueTypeMarker>::borrow(val),
7276                    encoder, offset + 8, _depth
7277                )
7278            }
7279            UrlRequestRewrite::SubstituteQueryPattern(ref val) => {
7280                fidl::encoding::encode_in_envelope::<UrlRequestRewriteSubstituteQueryPattern, D>(
7281                    <UrlRequestRewriteSubstituteQueryPattern as fidl::encoding::ValueTypeMarker>::borrow(val),
7282                    encoder, offset + 8, _depth
7283                )
7284            }
7285            UrlRequestRewrite::ReplaceUrl(ref val) => {
7286                fidl::encoding::encode_in_envelope::<UrlRequestRewriteReplaceUrl, D>(
7287                    <UrlRequestRewriteReplaceUrl as fidl::encoding::ValueTypeMarker>::borrow(val),
7288                    encoder, offset + 8, _depth
7289                )
7290            }
7291            UrlRequestRewrite::AppendToQuery(ref val) => {
7292                fidl::encoding::encode_in_envelope::<UrlRequestRewriteAppendToQuery, D>(
7293                    <UrlRequestRewriteAppendToQuery as fidl::encoding::ValueTypeMarker>::borrow(val),
7294                    encoder, offset + 8, _depth
7295                )
7296            }
7297            UrlRequestRewrite::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
7298        }
7299        }
7300    }
7301
7302    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UrlRequestRewrite {
7303        #[inline(always)]
7304        fn new_empty() -> Self {
7305            Self::__SourceBreaking { unknown_ordinal: 0 }
7306        }
7307
7308        #[inline]
7309        unsafe fn decode(
7310            &mut self,
7311            decoder: &mut fidl::encoding::Decoder<'_, D>,
7312            offset: usize,
7313            mut depth: fidl::encoding::Depth,
7314        ) -> fidl::Result<()> {
7315            decoder.debug_check_bounds::<Self>(offset);
7316            #[allow(unused_variables)]
7317            let next_out_of_line = decoder.next_out_of_line();
7318            let handles_before = decoder.remaining_handles();
7319            let (ordinal, inlined, num_bytes, num_handles) =
7320                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
7321
7322            let member_inline_size = match ordinal {
7323            1 => <UrlRequestRewriteAddHeaders as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7324            2 => <UrlRequestRewriteRemoveHeader as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7325            3 => <UrlRequestRewriteSubstituteQueryPattern as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7326            4 => <UrlRequestRewriteReplaceUrl as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7327            5 => <UrlRequestRewriteAppendToQuery as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7328            0 => return Err(fidl::Error::UnknownUnionTag),
7329            _ => num_bytes as usize,
7330        };
7331
7332            if inlined != (member_inline_size <= 4) {
7333                return Err(fidl::Error::InvalidInlineBitInEnvelope);
7334            }
7335            let _inner_offset;
7336            if inlined {
7337                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
7338                _inner_offset = offset + 8;
7339            } else {
7340                depth.increment()?;
7341                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7342            }
7343            match ordinal {
7344                1 => {
7345                    #[allow(irrefutable_let_patterns)]
7346                    if let UrlRequestRewrite::AddHeaders(_) = self {
7347                        // Do nothing, read the value into the object
7348                    } else {
7349                        // Initialize `self` to the right variant
7350                        *self = UrlRequestRewrite::AddHeaders(fidl::new_empty!(
7351                            UrlRequestRewriteAddHeaders,
7352                            D
7353                        ));
7354                    }
7355                    #[allow(irrefutable_let_patterns)]
7356                    if let UrlRequestRewrite::AddHeaders(ref mut val) = self {
7357                        fidl::decode!(
7358                            UrlRequestRewriteAddHeaders,
7359                            D,
7360                            val,
7361                            decoder,
7362                            _inner_offset,
7363                            depth
7364                        )?;
7365                    } else {
7366                        unreachable!()
7367                    }
7368                }
7369                2 => {
7370                    #[allow(irrefutable_let_patterns)]
7371                    if let UrlRequestRewrite::RemoveHeader(_) = self {
7372                        // Do nothing, read the value into the object
7373                    } else {
7374                        // Initialize `self` to the right variant
7375                        *self = UrlRequestRewrite::RemoveHeader(fidl::new_empty!(
7376                            UrlRequestRewriteRemoveHeader,
7377                            D
7378                        ));
7379                    }
7380                    #[allow(irrefutable_let_patterns)]
7381                    if let UrlRequestRewrite::RemoveHeader(ref mut val) = self {
7382                        fidl::decode!(
7383                            UrlRequestRewriteRemoveHeader,
7384                            D,
7385                            val,
7386                            decoder,
7387                            _inner_offset,
7388                            depth
7389                        )?;
7390                    } else {
7391                        unreachable!()
7392                    }
7393                }
7394                3 => {
7395                    #[allow(irrefutable_let_patterns)]
7396                    if let UrlRequestRewrite::SubstituteQueryPattern(_) = self {
7397                        // Do nothing, read the value into the object
7398                    } else {
7399                        // Initialize `self` to the right variant
7400                        *self = UrlRequestRewrite::SubstituteQueryPattern(fidl::new_empty!(
7401                            UrlRequestRewriteSubstituteQueryPattern,
7402                            D
7403                        ));
7404                    }
7405                    #[allow(irrefutable_let_patterns)]
7406                    if let UrlRequestRewrite::SubstituteQueryPattern(ref mut val) = self {
7407                        fidl::decode!(
7408                            UrlRequestRewriteSubstituteQueryPattern,
7409                            D,
7410                            val,
7411                            decoder,
7412                            _inner_offset,
7413                            depth
7414                        )?;
7415                    } else {
7416                        unreachable!()
7417                    }
7418                }
7419                4 => {
7420                    #[allow(irrefutable_let_patterns)]
7421                    if let UrlRequestRewrite::ReplaceUrl(_) = self {
7422                        // Do nothing, read the value into the object
7423                    } else {
7424                        // Initialize `self` to the right variant
7425                        *self = UrlRequestRewrite::ReplaceUrl(fidl::new_empty!(
7426                            UrlRequestRewriteReplaceUrl,
7427                            D
7428                        ));
7429                    }
7430                    #[allow(irrefutable_let_patterns)]
7431                    if let UrlRequestRewrite::ReplaceUrl(ref mut val) = self {
7432                        fidl::decode!(
7433                            UrlRequestRewriteReplaceUrl,
7434                            D,
7435                            val,
7436                            decoder,
7437                            _inner_offset,
7438                            depth
7439                        )?;
7440                    } else {
7441                        unreachable!()
7442                    }
7443                }
7444                5 => {
7445                    #[allow(irrefutable_let_patterns)]
7446                    if let UrlRequestRewrite::AppendToQuery(_) = self {
7447                        // Do nothing, read the value into the object
7448                    } else {
7449                        // Initialize `self` to the right variant
7450                        *self = UrlRequestRewrite::AppendToQuery(fidl::new_empty!(
7451                            UrlRequestRewriteAppendToQuery,
7452                            D
7453                        ));
7454                    }
7455                    #[allow(irrefutable_let_patterns)]
7456                    if let UrlRequestRewrite::AppendToQuery(ref mut val) = self {
7457                        fidl::decode!(
7458                            UrlRequestRewriteAppendToQuery,
7459                            D,
7460                            val,
7461                            decoder,
7462                            _inner_offset,
7463                            depth
7464                        )?;
7465                    } else {
7466                        unreachable!()
7467                    }
7468                }
7469                #[allow(deprecated)]
7470                ordinal => {
7471                    for _ in 0..num_handles {
7472                        decoder.drop_next_handle()?;
7473                    }
7474                    *self = UrlRequestRewrite::__SourceBreaking { unknown_ordinal: ordinal };
7475                }
7476            }
7477            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
7478                return Err(fidl::Error::InvalidNumBytesInEnvelope);
7479            }
7480            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7481                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7482            }
7483            Ok(())
7484        }
7485    }
7486}