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