Rust: Polish off communication across Mojom interfaces

mojo/public/rust/tests/util/mojom_validation.rs

 //! This file was auto-generated by the Rust bindings generator.
 #![allow(bad_style)]
 #![allow(unused_imports)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
 
 use mojo::bindings::decoding;
 use mojo::bindings::decoding::{Decoder, ValidationError};
 use mojo::bindings::encoding;
 use mojo::bindings::encoding::{Context, DataHeaderValue, DATA_HEADER_SIZE, Encoder};
@@ skipping 875 matching lines @@
 // Interfaces:
 // --- InterfaceA ---
 
 pub mod InterfaceA {
     pub const SERVICE_NAME: &'static str = "";
     pub const VERSION: u32 = 0;
 }
 
 pub struct InterfaceAClient {
     pipe: message_pipe::MessageEndpoint,
+    version: u32,
 }
 
 impl InterfaceAClient {
     pub fn new(pipe: message_pipe::MessageEndpoint) -> InterfaceAClient {
-        InterfaceAClient { pipe: pipe }
+        InterfaceAClient {
+            pipe: pipe,
+            version: InterfaceA::VERSION,
+        }
     }
-}
-
-impl CastHandle for InterfaceAClient {
-    unsafe fn from_untyped(handle: system::UntypedHandle) -> InterfaceAClient {
-        InterfaceAClient { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
+    pub fn with_version(pipe: message_pipe::MessageEndpoint, version: u32) -> InterfaceAClient {
+        InterfaceAClient {
+            pipe: pipe,
+            version: version,
+        }
     }
-    fn as_untyped(self) -> system::UntypedHandle {
-        self.pipe.as_untyped()
-    }
-}
-
-impl MojomEncodable for InterfaceAClient {
-    impl_encodable_for_interface!();
 }
 
 impl MojomInterface for InterfaceAClient {
     fn service_name() -> &'static str {
         InterfaceA::SERVICE_NAME
     }
-    fn version() -> u32 {
-        InterfaceA::VERSION
+    fn version(&self) -> u32 {
+        self.version
     }
     fn pipe(&self) -> &message_pipe::MessageEndpoint {
         &self.pipe
     }
     fn unwrap(self) -> message_pipe::MessageEndpoint {
         self.pipe
     }
 }
 
+impl CastHandle for InterfaceAClient {
+    unsafe fn from_untyped(handle: system::UntypedHandle) -> InterfaceAClient {
+        InterfaceAClient {
+            pipe: message_pipe::MessageEndpoint::from_untyped(handle),
+            version: 0, // Since we have no other information, assume its the base
+        }
+    }
+    fn as_untyped(self) -> system::UntypedHandle {
+        self.pipe.as_untyped()
+    }
+}
+
+impl MojomEncodable for InterfaceAClient {
+    impl_encodable_for_interface!();
+}
+
 impl<R: InterfaceARequest> MojomInterfaceSend<R> for InterfaceAClient {}
 impl MojomInterfaceRecv for InterfaceAClient {
     type Container = InterfaceAResponseOption;
 }
 
 pub struct InterfaceAServer {
     pipe: message_pipe::MessageEndpoint,
+    version: u32,
 }
 
 impl InterfaceAServer {
     pub fn new(pipe: message_pipe::MessageEndpoint) -> InterfaceAServer {
-        InterfaceAServer { pipe: pipe }
+        InterfaceAServer {
+            pipe: pipe,
+            version: InterfaceA::VERSION,
+        }
     }
-}
-
-impl CastHandle for InterfaceAServer {
-    unsafe fn from_untyped(handle: system::UntypedHandle) -> InterfaceAServer {
-        InterfaceAServer { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
+    pub fn with_version(pipe: message_pipe::MessageEndpoint, version: u32) -> InterfaceAServer {
+        InterfaceAServer {
+            pipe: pipe,
+            version: version,
+        }
     }
-    fn as_untyped(self) -> system::UntypedHandle {
-        self.pipe.as_untyped()
-    }
-}
-
-impl MojomEncodable for InterfaceAServer {
-    impl_encodable_for_interface!();
 }
 
 impl MojomInterface for InterfaceAServer {
     fn service_name() -> &'static str {
         InterfaceA::SERVICE_NAME
     }
-    fn version() -> u32 {
-        InterfaceA::VERSION
+    fn version(&self) -> u32 {
+        self.version
     }
     fn pipe(&self) -> &message_pipe::MessageEndpoint {
         &self.pipe
     }
     fn unwrap(self) -> message_pipe::MessageEndpoint {
         self.pipe
     }
 }
 
+impl CastHandle for InterfaceAServer {
+    unsafe fn from_untyped(handle: system::UntypedHandle) -> InterfaceAServer {
+        InterfaceAServer {
+            pipe: message_pipe::MessageEndpoint::from_untyped(handle),
+            version: 0, // Since we have no other information, assume its the base
+        }
+    }
+    fn as_untyped(self) -> system::UntypedHandle {
+        self.pipe.as_untyped()
+    }
+}
+
+impl MojomEncodable for InterfaceAServer {
+    impl_encodable_for_interface!();
+}
+
 impl<R: InterfaceAResponse> MojomInterfaceSend<R> for InterfaceAServer {}
 impl MojomInterfaceRecv for InterfaceAServer {
     type Container = InterfaceARequestOption;
 }
 
 // Enums
 
 
 // Constants
 
@@ skipping 37 matching lines @@
 
 // --- BoundsCheckTestInterface ---
 
 pub mod BoundsCheckTestInterface {
     pub const SERVICE_NAME: &'static str = "this.is.the.service.name.for.BoundsCheckTestInterface";
     pub const VERSION: u32 = 0;
 }
 
 pub struct BoundsCheckTestInterfaceClient {
     pipe: message_pipe::MessageEndpoint,
+    version: u32,
 }
 
 impl BoundsCheckTestInterfaceClient {
     pub fn new(pipe: message_pipe::MessageEndpoint) -> BoundsCheckTestInterfaceClient {
-        BoundsCheckTestInterfaceClient { pipe: pipe }
+        BoundsCheckTestInterfaceClient {
+            pipe: pipe,
+            version: BoundsCheckTestInterface::VERSION,
+        }
     }
-}
-
-impl CastHandle for BoundsCheckTestInterfaceClient {
-    unsafe fn from_untyped(handle: system::UntypedHandle) -> BoundsCheckTestInterfaceClient {
-        BoundsCheckTestInterfaceClient { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
+    pub fn with_version(pipe: message_pipe::MessageEndpoint,
+                        version: u32)
+                        -> BoundsCheckTestInterfaceClient {
+        BoundsCheckTestInterfaceClient {
+            pipe: pipe,
+            version: version,
+        }
     }
-    fn as_untyped(self) -> system::UntypedHandle {
-        self.pipe.as_untyped()
-    }
-}
-
-impl MojomEncodable for BoundsCheckTestInterfaceClient {
-    impl_encodable_for_interface!();
 }
 
 impl MojomInterface for BoundsCheckTestInterfaceClient {
     fn service_name() -> &'static str {
         BoundsCheckTestInterface::SERVICE_NAME
     }
-    fn version() -> u32 {
-        BoundsCheckTestInterface::VERSION
+    fn version(&self) -> u32 {
+        self.version
     }
     fn pipe(&self) -> &message_pipe::MessageEndpoint {
         &self.pipe
     }
     fn unwrap(self) -> message_pipe::MessageEndpoint {
         self.pipe
     }
 }
 
+impl CastHandle for BoundsCheckTestInterfaceClient {
+    unsafe fn from_untyped(handle: system::UntypedHandle) -> BoundsCheckTestInterfaceClient {
+        BoundsCheckTestInterfaceClient {
+            pipe: message_pipe::MessageEndpoint::from_untyped(handle),
+            version: 0, // Since we have no other information, assume its the base
+        }
+    }
+    fn as_untyped(self) -> system::UntypedHandle {
+        self.pipe.as_untyped()
+    }
+}
+
+impl MojomEncodable for BoundsCheckTestInterfaceClient {
+    impl_encodable_for_interface!();
+}
+
 impl<R: BoundsCheckTestInterfaceRequest> MojomInterfaceSend<R> for BoundsCheckTestInterfaceClient {}
 impl MojomInterfaceRecv for BoundsCheckTestInterfaceClient {
     type Container = BoundsCheckTestInterfaceResponseOption;
 }
 
 pub struct BoundsCheckTestInterfaceServer {
     pipe: message_pipe::MessageEndpoint,
+    version: u32,
 }
 
 impl BoundsCheckTestInterfaceServer {
     pub fn new(pipe: message_pipe::MessageEndpoint) -> BoundsCheckTestInterfaceServer {
-        BoundsCheckTestInterfaceServer { pipe: pipe }
+        BoundsCheckTestInterfaceServer {
+            pipe: pipe,
+            version: BoundsCheckTestInterface::VERSION,
+        }
     }
-}
-
-impl CastHandle for BoundsCheckTestInterfaceServer {
-    unsafe fn from_untyped(handle: system::UntypedHandle) -> BoundsCheckTestInterfaceServer {
-        BoundsCheckTestInterfaceServer { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
+    pub fn with_version(pipe: message_pipe::MessageEndpoint,
+                        version: u32)
+                        -> BoundsCheckTestInterfaceServer {
+        BoundsCheckTestInterfaceServer {
+            pipe: pipe,
+            version: version,
+        }
     }
-    fn as_untyped(self) -> system::UntypedHandle {
-        self.pipe.as_untyped()
-    }
-}
-
-impl MojomEncodable for BoundsCheckTestInterfaceServer {
-    impl_encodable_for_interface!();
 }
 
 impl MojomInterface for BoundsCheckTestInterfaceServer {
     fn service_name() -> &'static str {
         BoundsCheckTestInterface::SERVICE_NAME
     }
-    fn version() -> u32 {
-        BoundsCheckTestInterface::VERSION
+    fn version(&self) -> u32 {
+        self.version
     }
     fn pipe(&self) -> &message_pipe::MessageEndpoint {
         &self.pipe
     }
     fn unwrap(self) -> message_pipe::MessageEndpoint {
         self.pipe
     }
 }
 
+impl CastHandle for BoundsCheckTestInterfaceServer {
+    unsafe fn from_untyped(handle: system::UntypedHandle) -> BoundsCheckTestInterfaceServer {
+        BoundsCheckTestInterfaceServer {
+            pipe: message_pipe::MessageEndpoint::from_untyped(handle),
+            version: 0, // Since we have no other information, assume its the base
+        }
+    }
+    fn as_untyped(self) -> system::UntypedHandle {
+        self.pipe.as_untyped()
+    }
+}
+
+impl MojomEncodable for BoundsCheckTestInterfaceServer {
+    impl_encodable_for_interface!();
+}
+
 impl<R: BoundsCheckTestInterfaceResponse> MojomInterfaceSend<R> for BoundsCheckTestInterfaceServer {}
 impl MojomInterfaceRecv for BoundsCheckTestInterfaceServer {
     type Container = BoundsCheckTestInterfaceRequestOption;
 }
 
 // Enums
 
 
 // Constants
 
@@ skipping 106 matching lines @@
 impl MojomEncodable for BoundsCheckTestInterfaceMethod0Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone())
     }
 }
 
 impl MojomStruct for BoundsCheckTestInterfaceMethod0Request {}
 impl MojomMessage for BoundsCheckTestInterfaceMethod0Request {
+    fn min_version() -> u32 {
+        BoundsCheckTestInterfaceMethod0::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(BoundsCheckTestInterface::VERSION,
+        MessageHeader::new(1,
                            BoundsCheckTestInterfaceMethod0::ORDINAL,
                            message::MESSAGE_HEADER_EXPECT_RESPONSE)
 
     }
 }
 impl BoundsCheckTestInterfaceRequest for BoundsCheckTestInterfaceMethod0Request {}
 
 // -- BoundsCheckTestInterfaceMethod0Response --
 
 // Constants
@@ skipping 37 matching lines @@
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone())
     }
 }
 
 impl MojomStruct for BoundsCheckTestInterfaceMethod0Response {}
 
 impl MojomMessage for BoundsCheckTestInterfaceMethod0Response {
+    fn min_version() -> u32 {
+        BoundsCheckTestInterfaceMethod0::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(BoundsCheckTestInterface::VERSION,
+        MessageHeader::new(1,
                            BoundsCheckTestInterfaceMethod0::ORDINAL,
                            message::MESSAGE_HEADER_IS_RESPONSE)
     }
 }
-impl BoundsCheckTestInterfaceResponse for BoundsCheckTestInterfaceMethod0Request {}
+impl BoundsCheckTestInterfaceResponse for BoundsCheckTestInterfaceMethod0Response {}
 /// Message: BoundsCheckTestInterfaceMethod1
 pub mod BoundsCheckTestInterfaceMethod1 {
     pub const ORDINAL: u32 = 1;
     pub const MIN_VERSION: u32 = 0;
 }
 // -- BoundsCheckTestInterfaceMethod1Request --
 
 // Constants
 // Enums
 // Struct version information
@@ skipping 34 matching lines @@
 impl MojomEncodable for BoundsCheckTestInterfaceMethod1Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone())
     }
 }
 
 impl MojomStruct for BoundsCheckTestInterfaceMethod1Request {}
 impl MojomMessage for BoundsCheckTestInterfaceMethod1Request {
+    fn min_version() -> u32 {
+        BoundsCheckTestInterfaceMethod1::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(BoundsCheckTestInterface::VERSION,
+        MessageHeader::new(0,
                            BoundsCheckTestInterfaceMethod1::ORDINAL,
                            message::MESSAGE_HEADER_NO_FLAG)
 
     }
 }
 impl BoundsCheckTestInterfaceRequest for BoundsCheckTestInterfaceMethod1Request {}
 
 
 // --- ConformanceTestInterface ---
 
 pub mod ConformanceTestInterface {
     pub const SERVICE_NAME: &'static str = "";
     pub const VERSION: u32 = 0;
 }
 
 pub struct ConformanceTestInterfaceClient {
     pipe: message_pipe::MessageEndpoint,
+    version: u32,
 }
 
 impl ConformanceTestInterfaceClient {
     pub fn new(pipe: message_pipe::MessageEndpoint) -> ConformanceTestInterfaceClient {
-        ConformanceTestInterfaceClient { pipe: pipe }
+        ConformanceTestInterfaceClient {
+            pipe: pipe,
+            version: ConformanceTestInterface::VERSION,
+        }
     }
-}
-
-impl CastHandle for ConformanceTestInterfaceClient {
-    unsafe fn from_untyped(handle: system::UntypedHandle) -> ConformanceTestInterfaceClient {
-        ConformanceTestInterfaceClient { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
+    pub fn with_version(pipe: message_pipe::MessageEndpoint,
+                        version: u32)
+                        -> ConformanceTestInterfaceClient {
+        ConformanceTestInterfaceClient {
+            pipe: pipe,
+            version: version,
+        }
     }
-    fn as_untyped(self) -> system::UntypedHandle {
-        self.pipe.as_untyped()
-    }
-}
-
-impl MojomEncodable for ConformanceTestInterfaceClient {
-    impl_encodable_for_interface!();
 }
 
 impl MojomInterface for ConformanceTestInterfaceClient {
     fn service_name() -> &'static str {
         ConformanceTestInterface::SERVICE_NAME
     }
-    fn version() -> u32 {
-        ConformanceTestInterface::VERSION
+    fn version(&self) -> u32 {
+        self.version
     }
     fn pipe(&self) -> &message_pipe::MessageEndpoint {
         &self.pipe
     }
     fn unwrap(self) -> message_pipe::MessageEndpoint {
         self.pipe
     }
 }
 
+impl CastHandle for ConformanceTestInterfaceClient {
+    unsafe fn from_untyped(handle: system::UntypedHandle) -> ConformanceTestInterfaceClient {
+        ConformanceTestInterfaceClient {
+            pipe: message_pipe::MessageEndpoint::from_untyped(handle),
+            version: 0, // Since we have no other information, assume its the base
+        }
+    }
+    fn as_untyped(self) -> system::UntypedHandle {
+        self.pipe.as_untyped()
+    }
+}
+
+impl MojomEncodable for ConformanceTestInterfaceClient {
+    impl_encodable_for_interface!();
+}
+
 impl<R: ConformanceTestInterfaceRequest> MojomInterfaceSend<R> for ConformanceTestInterfaceClient {}
 impl MojomInterfaceRecv for ConformanceTestInterfaceClient {
     type Container = ConformanceTestInterfaceResponseOption;
 }
 
 pub struct ConformanceTestInterfaceServer {
     pipe: message_pipe::MessageEndpoint,
+    version: u32,
 }
 
 impl ConformanceTestInterfaceServer {
     pub fn new(pipe: message_pipe::MessageEndpoint) -> ConformanceTestInterfaceServer {
-        ConformanceTestInterfaceServer { pipe: pipe }
+        ConformanceTestInterfaceServer {
+            pipe: pipe,
+            version: ConformanceTestInterface::VERSION,
+        }
     }
-}
-
-impl CastHandle for ConformanceTestInterfaceServer {
-    unsafe fn from_untyped(handle: system::UntypedHandle) -> ConformanceTestInterfaceServer {
-        ConformanceTestInterfaceServer { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
+    pub fn with_version(pipe: message_pipe::MessageEndpoint,
+                        version: u32)
+                        -> ConformanceTestInterfaceServer {
+        ConformanceTestInterfaceServer {
+            pipe: pipe,
+            version: version,
+        }
     }
-    fn as_untyped(self) -> system::UntypedHandle {
-        self.pipe.as_untyped()
-    }
-}
-
-impl MojomEncodable for ConformanceTestInterfaceServer {
-    impl_encodable_for_interface!();
 }
 
 impl MojomInterface for ConformanceTestInterfaceServer {
     fn service_name() -> &'static str {
         ConformanceTestInterface::SERVICE_NAME
     }
-    fn version() -> u32 {
-        ConformanceTestInterface::VERSION
+    fn version(&self) -> u32 {
+        self.version
     }
     fn pipe(&self) -> &message_pipe::MessageEndpoint {
         &self.pipe
     }
     fn unwrap(self) -> message_pipe::MessageEndpoint {
         self.pipe
     }
 }
 
+impl CastHandle for ConformanceTestInterfaceServer {
+    unsafe fn from_untyped(handle: system::UntypedHandle) -> ConformanceTestInterfaceServer {
+        ConformanceTestInterfaceServer {
+            pipe: message_pipe::MessageEndpoint::from_untyped(handle),
+            version: 0, // Since we have no other information, assume its the base
+        }
+    }
+    fn as_untyped(self) -> system::UntypedHandle {
+        self.pipe.as_untyped()
+    }
+}
+
+impl MojomEncodable for ConformanceTestInterfaceServer {
+    impl_encodable_for_interface!();
+}
+
 impl<R: ConformanceTestInterfaceResponse> MojomInterfaceSend<R> for ConformanceTestInterfaceServer {}
 impl MojomInterfaceRecv for ConformanceTestInterfaceServer {
     type Container = ConformanceTestInterfaceRequestOption;
 }
 
 // Enums
 
 
 // Constants
 
 
 pub trait ConformanceTestInterfaceRequest: MojomMessage {}
 pub trait ConformanceTestInterfaceResponse: MojomMessage {}
 
 pub enum ConformanceTestInterfaceRequestOption {
-    ConformanceTestInterfaceMethod2(ConformanceTestInterfaceMethod2Request),
     ConformanceTestInterfaceMethod3(ConformanceTestInterfaceMethod3Request),
     ConformanceTestInterfaceMethod4(ConformanceTestInterfaceMethod4Request),
     ConformanceTestInterfaceMethod5(ConformanceTestInterfaceMethod5Request),
-    ConformanceTestInterfaceMethod10(ConformanceTestInterfaceMethod10Request),
-    ConformanceTestInterfaceMethod6(ConformanceTestInterfaceMethod6Request),
     ConformanceTestInterfaceMethod7(ConformanceTestInterfaceMethod7Request),
-    ConformanceTestInterfaceMethod8(ConformanceTestInterfaceMethod8Request),
-    ConformanceTestInterfaceMethod9(ConformanceTestInterfaceMethod9Request),
-    ConformanceTestInterfaceMethod11(ConformanceTestInterfaceMethod11Request),
     ConformanceTestInterfaceMethod12(ConformanceTestInterfaceMethod12Request),
     ConformanceTestInterfaceMethod14(ConformanceTestInterfaceMethod14Request),
+    ConformanceTestInterfaceMethod15(ConformanceTestInterfaceMethod15Request),
+    ConformanceTestInterfaceMethod1(ConformanceTestInterfaceMethod1Request),
+    ConformanceTestInterfaceMethod2(ConformanceTestInterfaceMethod2Request),
+    ConformanceTestInterfaceMethod6(ConformanceTestInterfaceMethod6Request),
+    ConformanceTestInterfaceMethod8(ConformanceTestInterfaceMethod8Request),
+    ConformanceTestInterfaceMethod10(ConformanceTestInterfaceMethod10Request),
+    ConformanceTestInterfaceMethod11(ConformanceTestInterfaceMethod11Request),
     ConformanceTestInterfaceMethod0(ConformanceTestInterfaceMethod0Request),
-    ConformanceTestInterfaceMethod1(ConformanceTestInterfaceMethod1Request),
+    ConformanceTestInterfaceMethod9(ConformanceTestInterfaceMethod9Request),
     ConformanceTestInterfaceMethod13(ConformanceTestInterfaceMethod13Request),
-    ConformanceTestInterfaceMethod15(ConformanceTestInterfaceMethod15Request),
 }
 
 impl MojomMessageOption for ConformanceTestInterfaceRequestOption {
     fn decode_payload(header: MessageHeader,
                       buffer: &[u8],
                       handles: Vec<UntypedHandle>)
                       -> Result<Self, ValidationError> {
         match header.name {
-            ConformanceTestInterfaceMethod2::ORDINAL => {
-                if header.flags != message::MESSAGE_HEADER_NO_FLAG {
-                    return Err(ValidationError::MessageHeaderInvalidFlags);
-                }
-                match ConformanceTestInterfaceMethod2Request::deserialize(buffer, handles) {
-                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod2(value)),
-                    Err(err) => return Err(err),
-                }
-            }
             ConformanceTestInterfaceMethod3::ORDINAL => {
                 if header.flags != message::MESSAGE_HEADER_NO_FLAG {
                     return Err(ValidationError::MessageHeaderInvalidFlags);
                 }
                 match ConformanceTestInterfaceMethod3Request::deserialize(buffer, handles) {
                     Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod3(value)),
                     Err(err) => return Err(err),
                 }
             }
             ConformanceTestInterfaceMethod4::ORDINAL => {
                 if header.flags != message::MESSAGE_HEADER_NO_FLAG {
                     return Err(ValidationError::MessageHeaderInvalidFlags);
                 }
                 match ConformanceTestInterfaceMethod4Request::deserialize(buffer, handles) {
                     Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod4(value)),
                     Err(err) => return Err(err),
                 }
             }
             ConformanceTestInterfaceMethod5::ORDINAL => {
                 if header.flags != message::MESSAGE_HEADER_NO_FLAG {
                     return Err(ValidationError::MessageHeaderInvalidFlags);
                 }
                 match ConformanceTestInterfaceMethod5Request::deserialize(buffer, handles) {
                     Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod5(value)),
                     Err(err) => return Err(err),
                 }
             }
-            ConformanceTestInterfaceMethod10::ORDINAL => {
-                if header.flags != message::MESSAGE_HEADER_NO_FLAG {
-                    return Err(ValidationError::MessageHeaderInvalidFlags);
-                }
-                match ConformanceTestInterfaceMethod10Request::deserialize(buffer, handles) {
-                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod10(value)),
-                    Err(err) => return Err(err),
-                }
-            }
-            ConformanceTestInterfaceMethod6::ORDINAL => {
-                if header.flags != message::MESSAGE_HEADER_NO_FLAG {
-                    return Err(ValidationError::MessageHeaderInvalidFlags);
-                }
-                match ConformanceTestInterfaceMethod6Request::deserialize(buffer, handles) {
-                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod6(value)),
-                    Err(err) => return Err(err),
-                }
-            }
             ConformanceTestInterfaceMethod7::ORDINAL => {
                 if header.flags != message::MESSAGE_HEADER_NO_FLAG {
                     return Err(ValidationError::MessageHeaderInvalidFlags);
                 }
                 match ConformanceTestInterfaceMethod7Request::deserialize(buffer, handles) {
                     Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod7(value)),
                     Err(err) => return Err(err),
                 }
             }
-            ConformanceTestInterfaceMethod8::ORDINAL => {
-                if header.flags != message::MESSAGE_HEADER_NO_FLAG {
-                    return Err(ValidationError::MessageHeaderInvalidFlags);
-                }
-                match ConformanceTestInterfaceMethod8Request::deserialize(buffer, handles) {
-                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod8(value)),
-                    Err(err) => return Err(err),
-                }
-            }
-            ConformanceTestInterfaceMethod9::ORDINAL => {
-                if header.flags != message::MESSAGE_HEADER_NO_FLAG {
-                    return Err(ValidationError::MessageHeaderInvalidFlags);
-                }
-                match ConformanceTestInterfaceMethod9Request::deserialize(buffer, handles) {
-                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod9(value)),
-                    Err(err) => return Err(err),
-                }
-            }
-            ConformanceTestInterfaceMethod11::ORDINAL => {
-                if header.flags != message::MESSAGE_HEADER_NO_FLAG {
-                    return Err(ValidationError::MessageHeaderInvalidFlags);
-                }
-                match ConformanceTestInterfaceMethod11Request::deserialize(buffer, handles) {
-                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod11(value)),
-                    Err(err) => return Err(err),
-                }
-            }
             ConformanceTestInterfaceMethod12::ORDINAL => {
                 if header.flags != message::MESSAGE_HEADER_EXPECT_RESPONSE {
                     return Err(ValidationError::MessageHeaderInvalidFlags);
                 }
                 match ConformanceTestInterfaceMethod12Request::deserialize(buffer, handles) {
                     Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod12(value)),
                     Err(err) => return Err(err),
                 }
             }
             ConformanceTestInterfaceMethod14::ORDINAL => {
                 if header.flags != message::MESSAGE_HEADER_NO_FLAG {
                     return Err(ValidationError::MessageHeaderInvalidFlags);
                 }
                 match ConformanceTestInterfaceMethod14Request::deserialize(buffer, handles) {
                     Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod14(value)),
                     Err(err) => return Err(err),
                 }
             }
-            ConformanceTestInterfaceMethod0::ORDINAL => {
+            ConformanceTestInterfaceMethod15::ORDINAL => {
                 if header.flags != message::MESSAGE_HEADER_NO_FLAG {
                     return Err(ValidationError::MessageHeaderInvalidFlags);
                 }
-                match ConformanceTestInterfaceMethod0Request::deserialize(buffer, handles) {
-                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod0(value)),
+                match ConformanceTestInterfaceMethod15Request::deserialize(buffer, handles) {
+                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod15(value)),
                     Err(err) => return Err(err),
                 }
             }
             ConformanceTestInterfaceMethod1::ORDINAL => {
                 if header.flags != message::MESSAGE_HEADER_NO_FLAG {
                     return Err(ValidationError::MessageHeaderInvalidFlags);
                 }
                 match ConformanceTestInterfaceMethod1Request::deserialize(buffer, handles) {
                     Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod1(value)),
                     Err(err) => return Err(err),
                 }
             }
+            ConformanceTestInterfaceMethod2::ORDINAL => {
+                if header.flags != message::MESSAGE_HEADER_NO_FLAG {
+                    return Err(ValidationError::MessageHeaderInvalidFlags);
+                }
+                match ConformanceTestInterfaceMethod2Request::deserialize(buffer, handles) {
+                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod2(value)),
+                    Err(err) => return Err(err),
+                }
+            }
+            ConformanceTestInterfaceMethod6::ORDINAL => {
+                if header.flags != message::MESSAGE_HEADER_NO_FLAG {
+                    return Err(ValidationError::MessageHeaderInvalidFlags);
+                }
+                match ConformanceTestInterfaceMethod6Request::deserialize(buffer, handles) {
+                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod6(value)),
+                    Err(err) => return Err(err),
+                }
+            }
+            ConformanceTestInterfaceMethod8::ORDINAL => {
+                if header.flags != message::MESSAGE_HEADER_NO_FLAG {
+                    return Err(ValidationError::MessageHeaderInvalidFlags);
+                }
+                match ConformanceTestInterfaceMethod8Request::deserialize(buffer, handles) {
+                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod8(value)),
+                    Err(err) => return Err(err),
+                }
+            }
+            ConformanceTestInterfaceMethod10::ORDINAL => {
+                if header.flags != message::MESSAGE_HEADER_NO_FLAG {
+                    return Err(ValidationError::MessageHeaderInvalidFlags);
+                }
+                match ConformanceTestInterfaceMethod10Request::deserialize(buffer, handles) {
+                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod10(value)),
+                    Err(err) => return Err(err),
+                }
+            }
+            ConformanceTestInterfaceMethod11::ORDINAL => {
+                if header.flags != message::MESSAGE_HEADER_NO_FLAG {
+                    return Err(ValidationError::MessageHeaderInvalidFlags);
+                }
+                match ConformanceTestInterfaceMethod11Request::deserialize(buffer, handles) {
+                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod11(value)),
+                    Err(err) => return Err(err),
+                }
+            }
+            ConformanceTestInterfaceMethod0::ORDINAL => {
+                if header.flags != message::MESSAGE_HEADER_NO_FLAG {
+                    return Err(ValidationError::MessageHeaderInvalidFlags);
+                }
+                match ConformanceTestInterfaceMethod0Request::deserialize(buffer, handles) {
+                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod0(value)),
+                    Err(err) => return Err(err),
+                }
+            }
+            ConformanceTestInterfaceMethod9::ORDINAL => {
+                if header.flags != message::MESSAGE_HEADER_NO_FLAG {
+                    return Err(ValidationError::MessageHeaderInvalidFlags);
+                }
+                match ConformanceTestInterfaceMethod9Request::deserialize(buffer, handles) {
+                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod9(value)),
+                    Err(err) => return Err(err),
+                }
+            }
             ConformanceTestInterfaceMethod13::ORDINAL => {
                 if header.flags != message::MESSAGE_HEADER_NO_FLAG {
                     return Err(ValidationError::MessageHeaderInvalidFlags);
                 }
                 match ConformanceTestInterfaceMethod13Request::deserialize(buffer, handles) {
                     Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod13(value)),
                     Err(err) => return Err(err),
                 }
             }
-            ConformanceTestInterfaceMethod15::ORDINAL => {
-                if header.flags != message::MESSAGE_HEADER_NO_FLAG {
-                    return Err(ValidationError::MessageHeaderInvalidFlags);
-                }
-                match ConformanceTestInterfaceMethod15Request::deserialize(buffer, handles) {
-                    Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod15(value)),
-                    Err(err) => return Err(err),
-                }
-            }
             _ => Err(ValidationError::MessageHeaderUnknownMethod),
         }
     }
 }
 
 pub enum ConformanceTestInterfaceResponseOption {
     ConformanceTestInterfaceMethod12(ConformanceTestInterfaceMethod12Response),
 }
 
 impl MojomMessageOption for ConformanceTestInterfaceResponseOption {
     fn decode_payload(header: MessageHeader,
                       buffer: &[u8],
                       handles: Vec<UntypedHandle>)
                       -> Result<Self, ValidationError> {
         if header.flags != message::MESSAGE_HEADER_IS_RESPONSE {
             return Err(ValidationError::MessageHeaderInvalidFlags);
         }
         match header.name {
             ConformanceTestInterfaceMethod12::ORDINAL => {
                 match ConformanceTestInterfaceMethod12Response::deserialize(buffer, handles) {
                     Ok(value) => Ok(ConformanceTestInterfaceResponseOption::ConformanceTestInterfaceMethod12(value)),
                     Err(err) => return Err(err),
                 }
             }
             _ => Err(ValidationError::MessageHeaderUnknownMethod),
         }
     }
 }
 
-/// Message: ConformanceTestInterfaceMethod2
-pub mod ConformanceTestInterfaceMethod2 {
-    pub const ORDINAL: u32 = 2;
-    pub const MIN_VERSION: u32 = 0;
-}
-// -- ConformanceTestInterfaceMethod2Request --
-
-// Constants
-// Enums
-// Struct version information
-const ConformanceTestInterfaceMethod2RequestVersions: [(u32, u32); 1] = [(0, 24)];
-
-// Struct definition
-pub struct ConformanceTestInterfaceMethod2Request {
-    pub param0: StructB,
-    pub param1: StructA,
-}
-
-impl MojomPointer for ConformanceTestInterfaceMethod2Request {
-    fn header_data(&self) -> DataHeaderValue {
-        DataHeaderValue::Version(0)
-    }
-    fn serialized_size(&self, _context: &Context) -> usize {
-        24
-    }
-    fn encode_value(self, encoder: &mut Encoder, context: Context) {
-        MojomEncodable::encode(self.param0, encoder, context.clone());
-        MojomEncodable::encode(self.param1, encoder, context.clone());
-
-    }
-    fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, ValidationError> {
-        let version = {
-            let mut state = decoder.get_mut(&context);
-            match state.decode_struct_header(&ConformanceTestInterfaceMethod2RequestVersions) {
-                Ok(header) => header.data(),
-                Err(err) => return Err(err),
-            }
-        };
-        let param0 = match <StructB>::decode(decoder, context.clone()) {
-            Ok(value) => value,
-            Err(err) => return Err(err),
-        };
-        let param1 = match <StructA>::decode(decoder, context.clone()) {
-            Ok(value) => value,
-            Err(err) => return Err(err),
-        };
-        Ok(ConformanceTestInterfaceMethod2Request {
-            param0: param0,
-            param1: param1,
-        })
-    }
-}
-
-impl MojomEncodable for ConformanceTestInterfaceMethod2Request {
-    impl_encodable_for_pointer!();
-    fn compute_size(&self, context: Context) -> usize {
-        encoding::align_default(self.serialized_size(&context)) +
-        self.param0.compute_size(context.clone()) +
-        self.param1.compute_size(context.clone())
-    }
-}
-
-impl MojomStruct for ConformanceTestInterfaceMethod2Request {}
-impl MojomMessage for ConformanceTestInterfaceMethod2Request {
-    fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
-                           ConformanceTestInterfaceMethod2::ORDINAL,
-                           message::MESSAGE_HEADER_NO_FLAG)
-
-    }
-}
-impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod2Request {}
-
 /// Message: ConformanceTestInterfaceMethod3
 pub mod ConformanceTestInterfaceMethod3 {
     pub const ORDINAL: u32 = 3;
     pub const MIN_VERSION: u32 = 0;
 }
 // -- ConformanceTestInterfaceMethod3Request --
 
 // Constants
 // Enums
 // Struct version information
@@ skipping 34 matching lines @@
 impl MojomEncodable for ConformanceTestInterfaceMethod3Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone())
     }
 }
 
 impl MojomStruct for ConformanceTestInterfaceMethod3Request {}
 impl MojomMessage for ConformanceTestInterfaceMethod3Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod3::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
+        MessageHeader::new(0,
                            ConformanceTestInterfaceMethod3::ORDINAL,
                            message::MESSAGE_HEADER_NO_FLAG)
 
     }
 }
 impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod3Request {}
 
 /// Message: ConformanceTestInterfaceMethod4
 pub mod ConformanceTestInterfaceMethod4 {
     pub const ORDINAL: u32 = 4;
@@ skipping 51 matching lines @@
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone()) +
         self.param1.compute_size(context.clone())
     }
 }
 
 impl MojomStruct for ConformanceTestInterfaceMethod4Request {}
 impl MojomMessage for ConformanceTestInterfaceMethod4Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod4::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
+        MessageHeader::new(0,
                            ConformanceTestInterfaceMethod4::ORDINAL,
                            message::MESSAGE_HEADER_NO_FLAG)
 
     }
 }
 impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod4Request {}
 
 /// Message: ConformanceTestInterfaceMethod5
 pub mod ConformanceTestInterfaceMethod5 {
     pub const ORDINAL: u32 = 5;
@@ skipping 52 matching lines @@
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone()) +
         self.param1.compute_size(context.clone())
     }
 }
 
 impl MojomStruct for ConformanceTestInterfaceMethod5Request {}
 impl MojomMessage for ConformanceTestInterfaceMethod5Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod5::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
+        MessageHeader::new(0,
                            ConformanceTestInterfaceMethod5::ORDINAL,
                            message::MESSAGE_HEADER_NO_FLAG)
 
     }
 }
 impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod5Request {}
 
-/// Message: ConformanceTestInterfaceMethod10
-pub mod ConformanceTestInterfaceMethod10 {
-    pub const ORDINAL: u32 = 10;
+/// Message: ConformanceTestInterfaceMethod7
+pub mod ConformanceTestInterfaceMethod7 {
+    pub const ORDINAL: u32 = 7;
     pub const MIN_VERSION: u32 = 0;
 }
-// -- ConformanceTestInterfaceMethod10Request --
+// -- ConformanceTestInterfaceMethod7Request --
 
 // Constants
 // Enums
 // Struct version information
-const ConformanceTestInterfaceMethod10RequestVersions: [(u32, u32); 1] = [(0, 16)];
+const ConformanceTestInterfaceMethod7RequestVersions: [(u32, u32); 1] = [(0, 24)];
 
 // Struct definition
-pub struct ConformanceTestInterfaceMethod10Request {
-    pub param0: HashMap<String, u8>,
+pub struct ConformanceTestInterfaceMethod7Request {
+    pub param0: StructF,
+    pub param1: [Option<[u8; 3]>; 2],
 }
 
-impl MojomPointer for ConformanceTestInterfaceMethod10Request {
+impl MojomPointer for ConformanceTestInterfaceMethod7Request {
     fn header_data(&self) -> DataHeaderValue {
         DataHeaderValue::Version(0)
     }
     fn serialized_size(&self, _context: &Context) -> usize {
-        16
+        24
     }
     fn encode_value(self, encoder: &mut Encoder, context: Context) {
         MojomEncodable::encode(self.param0, encoder, context.clone());
+        MojomEncodable::encode(self.param1, encoder, context.clone());
 
     }
     fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, ValidationError> {
         let version = {
             let mut state = decoder.get_mut(&context);
-            match state.decode_struct_header(&ConformanceTestInterfaceMethod10RequestVersions) {
+            match state.decode_struct_header(&ConformanceTestInterfaceMethod7RequestVersions) {
                 Ok(header) => header.data(),
                 Err(err) => return Err(err),
             }
         };
-        let param0 = match <HashMap<String, u8>>::decode(decoder, context.clone()) {
+        let param0 = match <StructF>::decode(decoder, context.clone()) {
             Ok(value) => value,
             Err(err) => return Err(err),
         };
-        Ok(ConformanceTestInterfaceMethod10Request { param0: param0 })
+        let param1 = match <[Option<[u8; 3]>; 2]>::decode(decoder, context.clone()) {
+            Ok(value) => value,
+            Err(err) => return Err(err),
+        };
+        Ok(ConformanceTestInterfaceMethod7Request {
+            param0: param0,
+            param1: param1,
+        })
     }
 }
 
-impl MojomEncodable for ConformanceTestInterfaceMethod10Request {
+impl MojomEncodable for ConformanceTestInterfaceMethod7Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
-        self.param0.compute_size(context.clone())
+        self.param0.compute_size(context.clone()) +
+        self.param1.compute_size(context.clone())
     }
 }
 
-impl MojomStruct for ConformanceTestInterfaceMethod10Request {}
-impl MojomMessage for ConformanceTestInterfaceMethod10Request {
+impl MojomStruct for ConformanceTestInterfaceMethod7Request {}
+impl MojomMessage for ConformanceTestInterfaceMethod7Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod7::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
-                           ConformanceTestInterfaceMethod10::ORDINAL,
+        MessageHeader::new(0,
+                           ConformanceTestInterfaceMethod7::ORDINAL,
                            message::MESSAGE_HEADER_NO_FLAG)
 
     }
 }
-impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod10Request {}
+impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod7Request {}
 
-/// Message: ConformanceTestInterfaceMethod6
-pub mod ConformanceTestInterfaceMethod6 {
-    pub const ORDINAL: u32 = 6;
+/// Message: ConformanceTestInterfaceMethod12
+pub mod ConformanceTestInterfaceMethod12 {
+    pub const ORDINAL: u32 = 12;
     pub const MIN_VERSION: u32 = 0;
 }
-// -- ConformanceTestInterfaceMethod6Request --
+// -- ConformanceTestInterfaceMethod12Request --
 
 // Constants
 // Enums
 // Struct version information
-const ConformanceTestInterfaceMethod6RequestVersions: [(u32, u32); 1] = [(0, 16)];
+const ConformanceTestInterfaceMethod12RequestVersions: [(u32, u32); 1] = [(0, 16)];
 
 // Struct definition
-pub struct ConformanceTestInterfaceMethod6Request {
-    pub param0: Vec<Vec<u8>>,
+pub struct ConformanceTestInterfaceMethod12Request {
+    pub param0: f32,
 }
 
-impl MojomPointer for ConformanceTestInterfaceMethod6Request {
+impl MojomPointer for ConformanceTestInterfaceMethod12Request {
     fn header_data(&self) -> DataHeaderValue {
         DataHeaderValue::Version(0)
     }
     fn serialized_size(&self, _context: &Context) -> usize {
         16
     }
     fn encode_value(self, encoder: &mut Encoder, context: Context) {
         MojomEncodable::encode(self.param0, encoder, context.clone());
 
     }
     fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, ValidationError> {
         let version = {
             let mut state = decoder.get_mut(&context);
-            match state.decode_struct_header(&ConformanceTestInterfaceMethod6RequestVersions) {
+            match state.decode_struct_header(&ConformanceTestInterfaceMethod12RequestVersions) {
                 Ok(header) => header.data(),
                 Err(err) => return Err(err),
             }
         };
-        let param0 = match <Vec<Vec<u8>>>::decode(decoder, context.clone()) {
+        let param0 = match <f32>::decode(decoder, context.clone()) {
             Ok(value) => value,
             Err(err) => return Err(err),
         };
-        Ok(ConformanceTestInterfaceMethod6Request { param0: param0 })
+        Ok(ConformanceTestInterfaceMethod12Request { param0: param0 })
     }
 }
 
-impl MojomEncodable for ConformanceTestInterfaceMethod6Request {
+impl MojomEncodable for ConformanceTestInterfaceMethod12Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone())
     }
 }
 
-impl MojomStruct for ConformanceTestInterfaceMethod6Request {}
-impl MojomMessage for ConformanceTestInterfaceMethod6Request {
+impl MojomStruct for ConformanceTestInterfaceMethod12Request {}
+impl MojomMessage for ConformanceTestInterfaceMethod12Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod12::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
-                           ConformanceTestInterfaceMethod6::ORDINAL,
-                           message::MESSAGE_HEADER_NO_FLAG)
+        MessageHeader::new(1,
+                           ConformanceTestInterfaceMethod12::ORDINAL,
+                           message::MESSAGE_HEADER_EXPECT_RESPONSE)
 
     }
 }
-impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod6Request {}
+impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod12Request {}
 
-/// Message: ConformanceTestInterfaceMethod7
-pub mod ConformanceTestInterfaceMethod7 {
-    pub const ORDINAL: u32 = 7;
-    pub const MIN_VERSION: u32 = 0;
-}
-// -- ConformanceTestInterfaceMethod7Request --
+// -- ConformanceTestInterfaceMethod12Response --
 
 // Constants
 // Enums
 // Struct version information
-const ConformanceTestInterfaceMethod7RequestVersions: [(u32, u32); 1] = [(0, 24)];
+const ConformanceTestInterfaceMethod12ResponseVersions: [(u32, u32); 1] = [(0, 16)];
 
 // Struct definition
-pub struct ConformanceTestInterfaceMethod7Request {
-    pub param0: StructF,
-    pub param1: [Option<[u8; 3]>; 2],
+pub struct ConformanceTestInterfaceMethod12Response {
+    pub param0: f32,
 }
 
-impl MojomPointer for ConformanceTestInterfaceMethod7Request {
+impl MojomPointer for ConformanceTestInterfaceMethod12Response {
     fn header_data(&self) -> DataHeaderValue {
         DataHeaderValue::Version(0)
     }
+    fn serialized_size(&self, _context: &Context) -> usize {
+        16
+    }
+    fn encode_value(self, encoder: &mut Encoder, context: Context) {
+        MojomEncodable::encode(self.param0, encoder, context.clone());
+
+    }
+    fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, ValidationError> {
+        let version = {
+            let mut state = decoder.get_mut(&context);
+            match state.decode_struct_header(&ConformanceTestInterfaceMethod12ResponseVersions) {
+                Ok(header) => header.data(),
+                Err(err) => return Err(err),
+            }
+        };
+        let param0 = match <f32>::decode(decoder, context.clone()) {
+            Ok(value) => value,
+            Err(err) => return Err(err),
+        };
+        Ok(ConformanceTestInterfaceMethod12Response { param0: param0 })
+    }
+}
+
+impl MojomEncodable for ConformanceTestInterfaceMethod12Response {
+    impl_encodable_for_pointer!();
+    fn compute_size(&self, context: Context) -> usize {
+        encoding::align_default(self.serialized_size(&context)) +
+        self.param0.compute_size(context.clone())
+    }
+}
+
+impl MojomStruct for ConformanceTestInterfaceMethod12Response {}
+
+impl MojomMessage for ConformanceTestInterfaceMethod12Response {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod12::MIN_VERSION
+    }
+    fn create_header() -> MessageHeader {
+        MessageHeader::new(1,
+                           ConformanceTestInterfaceMethod12::ORDINAL,
+                           message::MESSAGE_HEADER_IS_RESPONSE)
+    }
+}
+impl ConformanceTestInterfaceResponse for ConformanceTestInterfaceMethod12Response {}
+/// Message: ConformanceTestInterfaceMethod14
+pub mod ConformanceTestInterfaceMethod14 {
+    pub const ORDINAL: u32 = 14;
+    pub const MIN_VERSION: u32 = 0;
+}
+// -- ConformanceTestInterfaceMethod14Request --
+
+// Constants
+// Enums
+// Struct version information
+const ConformanceTestInterfaceMethod14RequestVersions: [(u32, u32); 1] = [(0, 24)];
+
+// Struct definition
+pub struct ConformanceTestInterfaceMethod14Request {
+    pub param0: UnionA,
+}
+
+impl MojomPointer for ConformanceTestInterfaceMethod14Request {
+    fn header_data(&self) -> DataHeaderValue {
+        DataHeaderValue::Version(0)
+    }
     fn serialized_size(&self, _context: &Context) -> usize {
         24
     }
     fn encode_value(self, encoder: &mut Encoder, context: Context) {
         MojomEncodable::encode(self.param0, encoder, context.clone());
-        MojomEncodable::encode(self.param1, encoder, context.clone());
 
     }
     fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, ValidationError> {
         let version = {
             let mut state = decoder.get_mut(&context);
-            match state.decode_struct_header(&ConformanceTestInterfaceMethod7RequestVersions) {
+            match state.decode_struct_header(&ConformanceTestInterfaceMethod14RequestVersions) {
                 Ok(header) => header.data(),
                 Err(err) => return Err(err),
             }
         };
-        let param0 = match <StructF>::decode(decoder, context.clone()) {
+        let param0 = match <UnionA>::decode(decoder, context.clone()) {
             Ok(value) => value,
             Err(err) => return Err(err),
         };
-        let param1 = match <[Option<[u8; 3]>; 2]>::decode(decoder, context.clone()) {
-            Ok(value) => value,
-            Err(err) => return Err(err),
-        };
-        Ok(ConformanceTestInterfaceMethod7Request {
-            param0: param0,
-            param1: param1,
-        })
+        Ok(ConformanceTestInterfaceMethod14Request { param0: param0 })
     }
 }
 
-impl MojomEncodable for ConformanceTestInterfaceMethod7Request {
+impl MojomEncodable for ConformanceTestInterfaceMethod14Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
-        self.param0.compute_size(context.clone()) +
-        self.param1.compute_size(context.clone())
+        self.param0.compute_size(context.clone())
     }
 }
 
-impl MojomStruct for ConformanceTestInterfaceMethod7Request {}
-impl MojomMessage for ConformanceTestInterfaceMethod7Request {
+impl MojomStruct for ConformanceTestInterfaceMethod14Request {}
+impl MojomMessage for ConformanceTestInterfaceMethod14Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod14::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
-                           ConformanceTestInterfaceMethod7::ORDINAL,
+        MessageHeader::new(0,
+                           ConformanceTestInterfaceMethod14::ORDINAL,
                            message::MESSAGE_HEADER_NO_FLAG)
 
     }
 }
-impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod7Request {}
+impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod14Request {}
 
-/// Message: ConformanceTestInterfaceMethod8
-pub mod ConformanceTestInterfaceMethod8 {
-    pub const ORDINAL: u32 = 8;
+/// Message: ConformanceTestInterfaceMethod15
+pub mod ConformanceTestInterfaceMethod15 {
+    pub const ORDINAL: u32 = 15;
     pub const MIN_VERSION: u32 = 0;
 }
-// -- ConformanceTestInterfaceMethod8Request --
+// -- ConformanceTestInterfaceMethod15Request --
 
 // Constants
 // Enums
 // Struct version information
-const ConformanceTestInterfaceMethod8RequestVersions: [(u32, u32); 1] = [(0, 16)];
+const ConformanceTestInterfaceMethod15RequestVersions: [(u32, u32); 1] = [(0, 16)];
 
 // Struct definition
-pub struct ConformanceTestInterfaceMethod8Request {
-    pub param0: Vec<Option<Vec<String>>>,
+pub struct ConformanceTestInterfaceMethod15Request {
+    pub param0: StructH,
 }
 
-impl MojomPointer for ConformanceTestInterfaceMethod8Request {
+impl MojomPointer for ConformanceTestInterfaceMethod15Request {
     fn header_data(&self) -> DataHeaderValue {
         DataHeaderValue::Version(0)
     }
+    fn serialized_size(&self, _context: &Context) -> usize {
+        16
+    }
+    fn encode_value(self, encoder: &mut Encoder, context: Context) {
+        MojomEncodable::encode(self.param0, encoder, context.clone());
+
+    }
+    fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, ValidationError> {
+        let version = {
+            let mut state = decoder.get_mut(&context);
+            match state.decode_struct_header(&ConformanceTestInterfaceMethod15RequestVersions) {
+                Ok(header) => header.data(),
+                Err(err) => return Err(err),
+            }
+        };
+        let param0 = match <StructH>::decode(decoder, context.clone()) {
+            Ok(value) => value,
+            Err(err) => return Err(err),
+        };
+        Ok(ConformanceTestInterfaceMethod15Request { param0: param0 })
+    }
+}
+
+impl MojomEncodable for ConformanceTestInterfaceMethod15Request {
+    impl_encodable_for_pointer!();
+    fn compute_size(&self, context: Context) -> usize {
+        encoding::align_default(self.serialized_size(&context)) +
+        self.param0.compute_size(context.clone())
+    }
+}
+
+impl MojomStruct for ConformanceTestInterfaceMethod15Request {}
+impl MojomMessage for ConformanceTestInterfaceMethod15Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod15::MIN_VERSION
+    }
+    fn create_header() -> MessageHeader {
+        MessageHeader::new(0,
+                           ConformanceTestInterfaceMethod15::ORDINAL,
+                           message::MESSAGE_HEADER_NO_FLAG)
+
+    }
+}
+impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod15Request {}
+
+/// Message: ConformanceTestInterfaceMethod1
+pub mod ConformanceTestInterfaceMethod1 {
+    pub const ORDINAL: u32 = 1;
+    pub const MIN_VERSION: u32 = 0;
+}
+// -- ConformanceTestInterfaceMethod1Request --
+
+// Constants
+// Enums
+// Struct version information
+const ConformanceTestInterfaceMethod1RequestVersions: [(u32, u32); 1] = [(0, 16)];
+
+// Struct definition
+pub struct ConformanceTestInterfaceMethod1Request {
+    pub param0: StructA,
+}
+
+impl MojomPointer for ConformanceTestInterfaceMethod1Request {
+    fn header_data(&self) -> DataHeaderValue {
+        DataHeaderValue::Version(0)
+    }
     fn serialized_size(&self, _context: &Context) -> usize {
         16
     }
     fn encode_value(self, encoder: &mut Encoder, context: Context) {
         MojomEncodable::encode(self.param0, encoder, context.clone());
 
     }
     fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, ValidationError> {
         let version = {
             let mut state = decoder.get_mut(&context);
-            match state.decode_struct_header(&ConformanceTestInterfaceMethod8RequestVersions) {
+            match state.decode_struct_header(&ConformanceTestInterfaceMethod1RequestVersions) {
                 Ok(header) => header.data(),
                 Err(err) => return Err(err),
             }
         };
-        let param0 = match <Vec<Option<Vec<String>>>>::decode(decoder, context.clone()) {
+        let param0 = match <StructA>::decode(decoder, context.clone()) {
             Ok(value) => value,
             Err(err) => return Err(err),
         };
-        Ok(ConformanceTestInterfaceMethod8Request { param0: param0 })
+        Ok(ConformanceTestInterfaceMethod1Request { param0: param0 })
     }
 }
 
-impl MojomEncodable for ConformanceTestInterfaceMethod8Request {
+impl MojomEncodable for ConformanceTestInterfaceMethod1Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone())
     }
 }
 
-impl MojomStruct for ConformanceTestInterfaceMethod8Request {}
-impl MojomMessage for ConformanceTestInterfaceMethod8Request {
+impl MojomStruct for ConformanceTestInterfaceMethod1Request {}
+impl MojomMessage for ConformanceTestInterfaceMethod1Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod1::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
-                           ConformanceTestInterfaceMethod8::ORDINAL,
+        MessageHeader::new(0,
+                           ConformanceTestInterfaceMethod1::ORDINAL,
                            message::MESSAGE_HEADER_NO_FLAG)
 
     }
 }
-impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod8Request {}
+impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod1Request {}
 
-/// Message: ConformanceTestInterfaceMethod9
-pub mod ConformanceTestInterfaceMethod9 {
-    pub const ORDINAL: u32 = 9;
+/// Message: ConformanceTestInterfaceMethod2
+pub mod ConformanceTestInterfaceMethod2 {
+    pub const ORDINAL: u32 = 2;
     pub const MIN_VERSION: u32 = 0;
 }
-// -- ConformanceTestInterfaceMethod9Request --
+// -- ConformanceTestInterfaceMethod2Request --
 
 // Constants
 // Enums
 // Struct version information
-const ConformanceTestInterfaceMethod9RequestVersions: [(u32, u32); 1] = [(0, 16)];
+const ConformanceTestInterfaceMethod2RequestVersions: [(u32, u32); 1] = [(0, 24)];
 
 // Struct definition
-pub struct ConformanceTestInterfaceMethod9Request {
-    pub param0: Option<Vec<Vec<Option<system::UntypedHandle>>>>,
+pub struct ConformanceTestInterfaceMethod2Request {
+    pub param0: StructB,
+    pub param1: StructA,
 }
 
-impl MojomPointer for ConformanceTestInterfaceMethod9Request {
+impl MojomPointer for ConformanceTestInterfaceMethod2Request {
     fn header_data(&self) -> DataHeaderValue {
         DataHeaderValue::Version(0)
     }
     fn serialized_size(&self, _context: &Context) -> usize {
-        16
+        24
     }
     fn encode_value(self, encoder: &mut Encoder, context: Context) {
         MojomEncodable::encode(self.param0, encoder, context.clone());
+        MojomEncodable::encode(self.param1, encoder, context.clone());
 
     }
     fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, ValidationError> {
         let version = {
             let mut state = decoder.get_mut(&context);
-            match state.decode_struct_header(&ConformanceTestInterfaceMethod9RequestVersions) {
+            match state.decode_struct_header(&ConformanceTestInterfaceMethod2RequestVersions) {
                 Ok(header) => header.data(),
                 Err(err) => return Err(err),
             }
         };
-        let param0 = match <Option<Vec<Vec<Option<system::UntypedHandle>>>>>::decode(decoder, context.clone()) {
+        let param0 = match <StructB>::decode(decoder, context.clone()) {
             Ok(value) => value,
             Err(err) => return Err(err),
         };
-        Ok(ConformanceTestInterfaceMethod9Request { param0: param0 })
+        let param1 = match <StructA>::decode(decoder, context.clone()) {
+            Ok(value) => value,
+            Err(err) => return Err(err),
+        };
+        Ok(ConformanceTestInterfaceMethod2Request {
+            param0: param0,
+            param1: param1,
+        })
     }
 }
 
-impl MojomEncodable for ConformanceTestInterfaceMethod9Request {
+impl MojomEncodable for ConformanceTestInterfaceMethod2Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
-        self.param0.compute_size(context.clone())
+        self.param0.compute_size(context.clone()) +
+        self.param1.compute_size(context.clone())
     }
 }
 
-impl MojomStruct for ConformanceTestInterfaceMethod9Request {}
-impl MojomMessage for ConformanceTestInterfaceMethod9Request {
+impl MojomStruct for ConformanceTestInterfaceMethod2Request {}
+impl MojomMessage for ConformanceTestInterfaceMethod2Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod2::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
-                           ConformanceTestInterfaceMethod9::ORDINAL,
+        MessageHeader::new(0,
+                           ConformanceTestInterfaceMethod2::ORDINAL,
                            message::MESSAGE_HEADER_NO_FLAG)
 
     }
 }
-impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod9Request {}
+impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod2Request {}
 
-/// Message: ConformanceTestInterfaceMethod11
-pub mod ConformanceTestInterfaceMethod11 {
-    pub const ORDINAL: u32 = 11;
+/// Message: ConformanceTestInterfaceMethod6
+pub mod ConformanceTestInterfaceMethod6 {
+    pub const ORDINAL: u32 = 6;
     pub const MIN_VERSION: u32 = 0;
 }
-// -- ConformanceTestInterfaceMethod11Request --
+// -- ConformanceTestInterfaceMethod6Request --
 
 // Constants
 // Enums
 // Struct version information
-const ConformanceTestInterfaceMethod11RequestVersions: [(u32, u32); 1] = [(0, 16)];
+const ConformanceTestInterfaceMethod6RequestVersions: [(u32, u32); 1] = [(0, 16)];
 
 // Struct definition
-pub struct ConformanceTestInterfaceMethod11Request {
-    pub param0: StructG,
+pub struct ConformanceTestInterfaceMethod6Request {
+    pub param0: Vec<Vec<u8>>,
 }
 
-impl MojomPointer for ConformanceTestInterfaceMethod11Request {
+impl MojomPointer for ConformanceTestInterfaceMethod6Request {
     fn header_data(&self) -> DataHeaderValue {
         DataHeaderValue::Version(0)
     }
     fn serialized_size(&self, _context: &Context) -> usize {
         16
     }
     fn encode_value(self, encoder: &mut Encoder, context: Context) {
         MojomEncodable::encode(self.param0, encoder, context.clone());
 
     }
     fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, ValidationError> {
         let version = {
             let mut state = decoder.get_mut(&context);
-            match state.decode_struct_header(&ConformanceTestInterfaceMethod11RequestVersions) {
+            match state.decode_struct_header(&ConformanceTestInterfaceMethod6RequestVersions) {
                 Ok(header) => header.data(),
                 Err(err) => return Err(err),
             }
         };
-        let param0 = match <StructG>::decode(decoder, context.clone()) {
+        let param0 = match <Vec<Vec<u8>>>::decode(decoder, context.clone()) {
             Ok(value) => value,
             Err(err) => return Err(err),
         };
-        Ok(ConformanceTestInterfaceMethod11Request { param0: param0 })
+        Ok(ConformanceTestInterfaceMethod6Request { param0: param0 })
     }
 }
 
-impl MojomEncodable for ConformanceTestInterfaceMethod11Request {
+impl MojomEncodable for ConformanceTestInterfaceMethod6Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone())
     }
 }
 
-impl MojomStruct for ConformanceTestInterfaceMethod11Request {}
-impl MojomMessage for ConformanceTestInterfaceMethod11Request {
+impl MojomStruct for ConformanceTestInterfaceMethod6Request {}
+impl MojomMessage for ConformanceTestInterfaceMethod6Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod6::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
-                           ConformanceTestInterfaceMethod11::ORDINAL,
+        MessageHeader::new(0,
+                           ConformanceTestInterfaceMethod6::ORDINAL,
                            message::MESSAGE_HEADER_NO_FLAG)
 
     }
 }
-impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod11Request {}
+impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod6Request {}
 
-/// Message: ConformanceTestInterfaceMethod12
-pub mod ConformanceTestInterfaceMethod12 {
-    pub const ORDINAL: u32 = 12;
+/// Message: ConformanceTestInterfaceMethod8
+pub mod ConformanceTestInterfaceMethod8 {
+    pub const ORDINAL: u32 = 8;
     pub const MIN_VERSION: u32 = 0;
 }
-// -- ConformanceTestInterfaceMethod12Request --
+// -- ConformanceTestInterfaceMethod8Request --
 
 // Constants
 // Enums
 // Struct version information
-const ConformanceTestInterfaceMethod12RequestVersions: [(u32, u32); 1] = [(0, 16)];
+const ConformanceTestInterfaceMethod8RequestVersions: [(u32, u32); 1] = [(0, 16)];
 
 // Struct definition
-pub struct ConformanceTestInterfaceMethod12Request {
-    pub param0: f32,
+pub struct ConformanceTestInterfaceMethod8Request {
+    pub param0: Vec<Option<Vec<String>>>,
 }
 
-impl MojomPointer for ConformanceTestInterfaceMethod12Request {
+impl MojomPointer for ConformanceTestInterfaceMethod8Request {
     fn header_data(&self) -> DataHeaderValue {
         DataHeaderValue::Version(0)
     }
     fn serialized_size(&self, _context: &Context) -> usize {
         16
     }
     fn encode_value(self, encoder: &mut Encoder, context: Context) {
         MojomEncodable::encode(self.param0, encoder, context.clone());
 
     }
     fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, ValidationError> {
         let version = {
             let mut state = decoder.get_mut(&context);
-            match state.decode_struct_header(&ConformanceTestInterfaceMethod12RequestVersions) {
+            match state.decode_struct_header(&ConformanceTestInterfaceMethod8RequestVersions) {
                 Ok(header) => header.data(),
                 Err(err) => return Err(err),
             }
         };
-        let param0 = match <f32>::decode(decoder, context.clone()) {
+        let param0 = match <Vec<Option<Vec<String>>>>::decode(decoder, context.clone()) {
             Ok(value) => value,
             Err(err) => return Err(err),
         };
-        Ok(ConformanceTestInterfaceMethod12Request { param0: param0 })
+        Ok(ConformanceTestInterfaceMethod8Request { param0: param0 })
     }
 }
 
-impl MojomEncodable for ConformanceTestInterfaceMethod12Request {
+impl MojomEncodable for ConformanceTestInterfaceMethod8Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone())
     }
 }
 
-impl MojomStruct for ConformanceTestInterfaceMethod12Request {}
-impl MojomMessage for ConformanceTestInterfaceMethod12Request {
+impl MojomStruct for ConformanceTestInterfaceMethod8Request {}
+impl MojomMessage for ConformanceTestInterfaceMethod8Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod8::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
-                           ConformanceTestInterfaceMethod12::ORDINAL,
-                           message::MESSAGE_HEADER_EXPECT_RESPONSE)
+        MessageHeader::new(0,
+                           ConformanceTestInterfaceMethod8::ORDINAL,
+                           message::MESSAGE_HEADER_NO_FLAG)
 
     }
 }
-impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod12Request {}
+impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod8Request {}
 
-// -- ConformanceTestInterfaceMethod12Response --
+/// Message: ConformanceTestInterfaceMethod10
+pub mod ConformanceTestInterfaceMethod10 {
+    pub const ORDINAL: u32 = 10;
+    pub const MIN_VERSION: u32 = 0;
+}
+// -- ConformanceTestInterfaceMethod10Request --
 
 // Constants
 // Enums
 // Struct version information
-const ConformanceTestInterfaceMethod12ResponseVersions: [(u32, u32); 1] = [(0, 16)];
+const ConformanceTestInterfaceMethod10RequestVersions: [(u32, u32); 1] = [(0, 16)];
 
 // Struct definition
-pub struct ConformanceTestInterfaceMethod12Response {
-    pub param0: f32,
+pub struct ConformanceTestInterfaceMethod10Request {
+    pub param0: HashMap<String, u8>,
 }
 
-impl MojomPointer for ConformanceTestInterfaceMethod12Response {
+impl MojomPointer for ConformanceTestInterfaceMethod10Request {
     fn header_data(&self) -> DataHeaderValue {
         DataHeaderValue::Version(0)
     }
     fn serialized_size(&self, _context: &Context) -> usize {
         16
     }
     fn encode_value(self, encoder: &mut Encoder, context: Context) {
         MojomEncodable::encode(self.param0, encoder, context.clone());
 
     }
     fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, ValidationError> {
         let version = {
             let mut state = decoder.get_mut(&context);
-            match state.decode_struct_header(&ConformanceTestInterfaceMethod12ResponseVersions) {
+            match state.decode_struct_header(&ConformanceTestInterfaceMethod10RequestVersions) {
                 Ok(header) => header.data(),
                 Err(err) => return Err(err),
             }
         };
-        let param0 = match <f32>::decode(decoder, context.clone()) {
+        let param0 = match <HashMap<String, u8>>::decode(decoder, context.clone()) {
             Ok(value) => value,
             Err(err) => return Err(err),
         };
-        Ok(ConformanceTestInterfaceMethod12Response { param0: param0 })
+        Ok(ConformanceTestInterfaceMethod10Request { param0: param0 })
     }
 }
 
-impl MojomEncodable for ConformanceTestInterfaceMethod12Response {
+impl MojomEncodable for ConformanceTestInterfaceMethod10Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone())
     }
 }
 
-impl MojomStruct for ConformanceTestInterfaceMethod12Response {}
+impl MojomStruct for ConformanceTestInterfaceMethod10Request {}
+impl MojomMessage for ConformanceTestInterfaceMethod10Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod10::MIN_VERSION
+    }
+    fn create_header() -> MessageHeader {
+        MessageHeader::new(0,
+                           ConformanceTestInterfaceMethod10::ORDINAL,
+                           message::MESSAGE_HEADER_NO_FLAG)
 
-impl MojomMessage for ConformanceTestInterfaceMethod12Response {
-    fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
-                           ConformanceTestInterfaceMethod12::ORDINAL,
-                           message::MESSAGE_HEADER_IS_RESPONSE)
     }
 }
-impl ConformanceTestInterfaceResponse for ConformanceTestInterfaceMethod12Request {}
-/// Message: ConformanceTestInterfaceMethod14
-pub mod ConformanceTestInterfaceMethod14 {
-    pub const ORDINAL: u32 = 14;
+impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod10Request {}
+
+/// Message: ConformanceTestInterfaceMethod11
+pub mod ConformanceTestInterfaceMethod11 {
+    pub const ORDINAL: u32 = 11;
     pub const MIN_VERSION: u32 = 0;
 }
-// -- ConformanceTestInterfaceMethod14Request --
+// -- ConformanceTestInterfaceMethod11Request --
 
 // Constants
 // Enums
 // Struct version information
-const ConformanceTestInterfaceMethod14RequestVersions: [(u32, u32); 1] = [(0, 24)];
+const ConformanceTestInterfaceMethod11RequestVersions: [(u32, u32); 1] = [(0, 16)];
 
 // Struct definition
-pub struct ConformanceTestInterfaceMethod14Request {
-    pub param0: UnionA,
+pub struct ConformanceTestInterfaceMethod11Request {
+    pub param0: StructG,
 }
 
-impl MojomPointer for ConformanceTestInterfaceMethod14Request {
+impl MojomPointer for ConformanceTestInterfaceMethod11Request {
     fn header_data(&self) -> DataHeaderValue {
         DataHeaderValue::Version(0)
     }
     fn serialized_size(&self, _context: &Context) -> usize {
-        24
+        16
     }
     fn encode_value(self, encoder: &mut Encoder, context: Context) {
         MojomEncodable::encode(self.param0, encoder, context.clone());
 
     }
     fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, ValidationError> {
         let version = {
             let mut state = decoder.get_mut(&context);
-            match state.decode_struct_header(&ConformanceTestInterfaceMethod14RequestVersions) {
+            match state.decode_struct_header(&ConformanceTestInterfaceMethod11RequestVersions) {
                 Ok(header) => header.data(),
                 Err(err) => return Err(err),
             }
         };
-        let param0 = match <UnionA>::decode(decoder, context.clone()) {
+        let param0 = match <StructG>::decode(decoder, context.clone()) {
             Ok(value) => value,
             Err(err) => return Err(err),
         };
-        Ok(ConformanceTestInterfaceMethod14Request { param0: param0 })
+        Ok(ConformanceTestInterfaceMethod11Request { param0: param0 })
     }
 }
 
-impl MojomEncodable for ConformanceTestInterfaceMethod14Request {
+impl MojomEncodable for ConformanceTestInterfaceMethod11Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone())
     }
 }
 
-impl MojomStruct for ConformanceTestInterfaceMethod14Request {}
-impl MojomMessage for ConformanceTestInterfaceMethod14Request {
+impl MojomStruct for ConformanceTestInterfaceMethod11Request {}
+impl MojomMessage for ConformanceTestInterfaceMethod11Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod11::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
-                           ConformanceTestInterfaceMethod14::ORDINAL,
+        MessageHeader::new(0,
+                           ConformanceTestInterfaceMethod11::ORDINAL,
                            message::MESSAGE_HEADER_NO_FLAG)
 
     }
 }
-impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod14Request {}
+impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod11Request {}
 
 /// Message: ConformanceTestInterfaceMethod0
 pub mod ConformanceTestInterfaceMethod0 {
     pub const ORDINAL: u32 = 0;
     pub const MIN_VERSION: u32 = 0;
 }
 // -- ConformanceTestInterfaceMethod0Request --
 
 // Constants
 // Enums
@@ skipping 35 matching lines @@
 impl MojomEncodable for ConformanceTestInterfaceMethod0Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone())
     }
 }
 
 impl MojomStruct for ConformanceTestInterfaceMethod0Request {}
 impl MojomMessage for ConformanceTestInterfaceMethod0Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod0::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
+        MessageHeader::new(0,
                            ConformanceTestInterfaceMethod0::ORDINAL,
                            message::MESSAGE_HEADER_NO_FLAG)
 
     }
 }
 impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod0Request {}
 
-/// Message: ConformanceTestInterfaceMethod1
-pub mod ConformanceTestInterfaceMethod1 {
-    pub const ORDINAL: u32 = 1;
+/// Message: ConformanceTestInterfaceMethod9
+pub mod ConformanceTestInterfaceMethod9 {
+    pub const ORDINAL: u32 = 9;
     pub const MIN_VERSION: u32 = 0;
 }
-// -- ConformanceTestInterfaceMethod1Request --
+// -- ConformanceTestInterfaceMethod9Request --
 
 // Constants
 // Enums
 // Struct version information
-const ConformanceTestInterfaceMethod1RequestVersions: [(u32, u32); 1] = [(0, 16)];
+const ConformanceTestInterfaceMethod9RequestVersions: [(u32, u32); 1] = [(0, 16)];
 
 // Struct definition
-pub struct ConformanceTestInterfaceMethod1Request {
-    pub param0: StructA,
+pub struct ConformanceTestInterfaceMethod9Request {
+    pub param0: Option<Vec<Vec<Option<system::UntypedHandle>>>>,
 }
 
-impl MojomPointer for ConformanceTestInterfaceMethod1Request {
+impl MojomPointer for ConformanceTestInterfaceMethod9Request {
     fn header_data(&self) -> DataHeaderValue {
         DataHeaderValue::Version(0)
     }
     fn serialized_size(&self, _context: &Context) -> usize {
         16
     }
     fn encode_value(self, encoder: &mut Encoder, context: Context) {
         MojomEncodable::encode(self.param0, encoder, context.clone());
 
     }
     fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, ValidationError> {
         let version = {
             let mut state = decoder.get_mut(&context);
-            match state.decode_struct_header(&ConformanceTestInterfaceMethod1RequestVersions) {
+            match state.decode_struct_header(&ConformanceTestInterfaceMethod9RequestVersions) {
                 Ok(header) => header.data(),
                 Err(err) => return Err(err),
             }
         };
-        let param0 = match <StructA>::decode(decoder, context.clone()) {
+        let param0 = match <Option<Vec<Vec<Option<system::UntypedHandle>>>>>::decode(decoder, context.clone()) {
             Ok(value) => value,
             Err(err) => return Err(err),
         };
-        Ok(ConformanceTestInterfaceMethod1Request { param0: param0 })
+        Ok(ConformanceTestInterfaceMethod9Request { param0: param0 })
     }
 }
 
-impl MojomEncodable for ConformanceTestInterfaceMethod1Request {
+impl MojomEncodable for ConformanceTestInterfaceMethod9Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone())
     }
 }
 
-impl MojomStruct for ConformanceTestInterfaceMethod1Request {}
-impl MojomMessage for ConformanceTestInterfaceMethod1Request {
+impl MojomStruct for ConformanceTestInterfaceMethod9Request {}
+impl MojomMessage for ConformanceTestInterfaceMethod9Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod9::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
-                           ConformanceTestInterfaceMethod1::ORDINAL,
+        MessageHeader::new(0,
+                           ConformanceTestInterfaceMethod9::ORDINAL,
                            message::MESSAGE_HEADER_NO_FLAG)
 
     }
 }
-impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod1Request {}
+impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod9Request {}
 
 /// Message: ConformanceTestInterfaceMethod13
 pub mod ConformanceTestInterfaceMethod13 {
     pub const ORDINAL: u32 = 13;
     pub const MIN_VERSION: u32 = 0;
 }
 // -- ConformanceTestInterfaceMethod13Request --
 
 // Constants
 // Enums
@@ skipping 53 matching lines @@
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone()) +
         self.param1.compute_size(context.clone()) +
         self.param2.compute_size(context.clone())
     }
 }
 
 impl MojomStruct for ConformanceTestInterfaceMethod13Request {}
 impl MojomMessage for ConformanceTestInterfaceMethod13Request {
+    fn min_version() -> u32 {
+        ConformanceTestInterfaceMethod13::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
+        MessageHeader::new(0,
                            ConformanceTestInterfaceMethod13::ORDINAL,
                            message::MESSAGE_HEADER_NO_FLAG)
 
     }
 }
 impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod13Request {}
 
-/// Message: ConformanceTestInterfaceMethod15
-pub mod ConformanceTestInterfaceMethod15 {
-    pub const ORDINAL: u32 = 15;
-    pub const MIN_VERSION: u32 = 0;
-}
-// -- ConformanceTestInterfaceMethod15Request --
-
-// Constants
-// Enums
-// Struct version information
-const ConformanceTestInterfaceMethod15RequestVersions: [(u32, u32); 1] = [(0, 16)];
-
-// Struct definition
-pub struct ConformanceTestInterfaceMethod15Request {
-    pub param0: StructH,
-}
-
-impl MojomPointer for ConformanceTestInterfaceMethod15Request {
-    fn header_data(&self) -> DataHeaderValue {
-        DataHeaderValue::Version(0)
-    }
-    fn serialized_size(&self, _context: &Context) -> usize {
-        16
-    }
-    fn encode_value(self, encoder: &mut Encoder, context: Context) {
-        MojomEncodable::encode(self.param0, encoder, context.clone());
-
-    }
-    fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, ValidationError> {
-        let version = {
-            let mut state = decoder.get_mut(&context);
-            match state.decode_struct_header(&ConformanceTestInterfaceMethod15RequestVersions) {
-                Ok(header) => header.data(),
-                Err(err) => return Err(err),
-            }
-        };
-        let param0 = match <StructH>::decode(decoder, context.clone()) {
-            Ok(value) => value,
-            Err(err) => return Err(err),
-        };
-        Ok(ConformanceTestInterfaceMethod15Request { param0: param0 })
-    }
-}
-
-impl MojomEncodable for ConformanceTestInterfaceMethod15Request {
-    impl_encodable_for_pointer!();
-    fn compute_size(&self, context: Context) -> usize {
-        encoding::align_default(self.serialized_size(&context)) +
-        self.param0.compute_size(context.clone())
-    }
-}
-
-impl MojomStruct for ConformanceTestInterfaceMethod15Request {}
-impl MojomMessage for ConformanceTestInterfaceMethod15Request {
-    fn create_header() -> MessageHeader {
-        MessageHeader::new(ConformanceTestInterface::VERSION,
-                           ConformanceTestInterfaceMethod15::ORDINAL,
-                           message::MESSAGE_HEADER_NO_FLAG)
-
-    }
-}
-impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod15Request {}
-
 
 // --- IntegrationTestInterface ---
 
 pub mod IntegrationTestInterface {
     pub const SERVICE_NAME: &'static str = "";
     pub const VERSION: u32 = 0;
 }
 
 pub struct IntegrationTestInterfaceClient {
     pipe: message_pipe::MessageEndpoint,
+    version: u32,
 }
 
 impl IntegrationTestInterfaceClient {
     pub fn new(pipe: message_pipe::MessageEndpoint) -> IntegrationTestInterfaceClient {
-        IntegrationTestInterfaceClient { pipe: pipe }
+        IntegrationTestInterfaceClient {
+            pipe: pipe,
+            version: IntegrationTestInterface::VERSION,
+        }
     }
-}
-
-impl CastHandle for IntegrationTestInterfaceClient {
-    unsafe fn from_untyped(handle: system::UntypedHandle) -> IntegrationTestInterfaceClient {
-        IntegrationTestInterfaceClient { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
+    pub fn with_version(pipe: message_pipe::MessageEndpoint,
+                        version: u32)
+                        -> IntegrationTestInterfaceClient {
+        IntegrationTestInterfaceClient {
+            pipe: pipe,
+            version: version,
+        }
     }
-    fn as_untyped(self) -> system::UntypedHandle {
-        self.pipe.as_untyped()
-    }
-}
-
-impl MojomEncodable for IntegrationTestInterfaceClient {
-    impl_encodable_for_interface!();
 }
 
 impl MojomInterface for IntegrationTestInterfaceClient {
     fn service_name() -> &'static str {
         IntegrationTestInterface::SERVICE_NAME
     }
-    fn version() -> u32 {
-        IntegrationTestInterface::VERSION
+    fn version(&self) -> u32 {
+        self.version
     }
     fn pipe(&self) -> &message_pipe::MessageEndpoint {
         &self.pipe
     }
     fn unwrap(self) -> message_pipe::MessageEndpoint {
         self.pipe
     }
 }
 
+impl CastHandle for IntegrationTestInterfaceClient {
+    unsafe fn from_untyped(handle: system::UntypedHandle) -> IntegrationTestInterfaceClient {
+        IntegrationTestInterfaceClient {
+            pipe: message_pipe::MessageEndpoint::from_untyped(handle),
+            version: 0, // Since we have no other information, assume its the base
+        }
+    }
+    fn as_untyped(self) -> system::UntypedHandle {
+        self.pipe.as_untyped()
+    }
+}
+
+impl MojomEncodable for IntegrationTestInterfaceClient {
+    impl_encodable_for_interface!();
+}
+
 impl<R: IntegrationTestInterfaceRequest> MojomInterfaceSend<R> for IntegrationTestInterfaceClient {}
 impl MojomInterfaceRecv for IntegrationTestInterfaceClient {
     type Container = IntegrationTestInterfaceResponseOption;
 }
 
 pub struct IntegrationTestInterfaceServer {
     pipe: message_pipe::MessageEndpoint,
+    version: u32,
 }
 
 impl IntegrationTestInterfaceServer {
     pub fn new(pipe: message_pipe::MessageEndpoint) -> IntegrationTestInterfaceServer {
-        IntegrationTestInterfaceServer { pipe: pipe }
+        IntegrationTestInterfaceServer {
+            pipe: pipe,
+            version: IntegrationTestInterface::VERSION,
+        }
     }
-}
-
-impl CastHandle for IntegrationTestInterfaceServer {
-    unsafe fn from_untyped(handle: system::UntypedHandle) -> IntegrationTestInterfaceServer {
-        IntegrationTestInterfaceServer { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
+    pub fn with_version(pipe: message_pipe::MessageEndpoint,
+                        version: u32)
+                        -> IntegrationTestInterfaceServer {
+        IntegrationTestInterfaceServer {
+            pipe: pipe,
+            version: version,
+        }
     }
-    fn as_untyped(self) -> system::UntypedHandle {
-        self.pipe.as_untyped()
-    }
-}
-
-impl MojomEncodable for IntegrationTestInterfaceServer {
-    impl_encodable_for_interface!();
 }
 
 impl MojomInterface for IntegrationTestInterfaceServer {
     fn service_name() -> &'static str {
         IntegrationTestInterface::SERVICE_NAME
     }
-    fn version() -> u32 {
-        IntegrationTestInterface::VERSION
+    fn version(&self) -> u32 {
+        self.version
     }
     fn pipe(&self) -> &message_pipe::MessageEndpoint {
         &self.pipe
     }
     fn unwrap(self) -> message_pipe::MessageEndpoint {
         self.pipe
     }
 }
 
+impl CastHandle for IntegrationTestInterfaceServer {
+    unsafe fn from_untyped(handle: system::UntypedHandle) -> IntegrationTestInterfaceServer {
+        IntegrationTestInterfaceServer {
+            pipe: message_pipe::MessageEndpoint::from_untyped(handle),
+            version: 0, // Since we have no other information, assume its the base
+        }
+    }
+    fn as_untyped(self) -> system::UntypedHandle {
+        self.pipe.as_untyped()
+    }
+}
+
+impl MojomEncodable for IntegrationTestInterfaceServer {
+    impl_encodable_for_interface!();
+}
+
 impl<R: IntegrationTestInterfaceResponse> MojomInterfaceSend<R> for IntegrationTestInterfaceServer {}
 impl MojomInterfaceRecv for IntegrationTestInterfaceServer {
     type Container = IntegrationTestInterfaceRequestOption;
 }
 
 // Enums
 
 
 // Constants
 
@@ skipping 96 matching lines @@
 impl MojomEncodable for IntegrationTestInterfaceMethod0Request {
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone())
     }
 }
 
 impl MojomStruct for IntegrationTestInterfaceMethod0Request {}
 impl MojomMessage for IntegrationTestInterfaceMethod0Request {
+    fn min_version() -> u32 {
+        IntegrationTestInterfaceMethod0::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(IntegrationTestInterface::VERSION,
+        MessageHeader::new(1,
                            IntegrationTestInterfaceMethod0::ORDINAL,
                            message::MESSAGE_HEADER_EXPECT_RESPONSE)
 
     }
 }
 impl IntegrationTestInterfaceRequest for IntegrationTestInterfaceMethod0Request {}
 
 // -- IntegrationTestInterfaceMethod0Response --
 
 // Constants
@@ skipping 37 matching lines @@
     impl_encodable_for_pointer!();
     fn compute_size(&self, context: Context) -> usize {
         encoding::align_default(self.serialized_size(&context)) +
         self.param0.compute_size(context.clone())
     }
 }
 
 impl MojomStruct for IntegrationTestInterfaceMethod0Response {}
 
 impl MojomMessage for IntegrationTestInterfaceMethod0Response {
+    fn min_version() -> u32 {
+        IntegrationTestInterfaceMethod0::MIN_VERSION
+    }
     fn create_header() -> MessageHeader {
-        MessageHeader::new(IntegrationTestInterface::VERSION,
+        MessageHeader::new(1,
                            IntegrationTestInterfaceMethod0::ORDINAL,
                            message::MESSAGE_HEADER_IS_RESPONSE)
     }
 }
-impl IntegrationTestInterfaceResponse for IntegrationTestInterfaceMethod0Request {}
+impl IntegrationTestInterfaceResponse for IntegrationTestInterfaceMethod0Response {}