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