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