| Index: mojo/public/rust/tests/util/mojom_validation.rs
|
| diff --git a/mojo/public/rust/tests/util/mojom_validation.rs b/mojo/public/rust/tests/util/mojom_validation.rs
|
| index 07c9bfa04519154c4143456b9b0d775081f48f57..9eda8c5b0a0e96f5828f94b1df6f29ea4dd1b5f6 100644
|
| --- a/mojo/public/rust/tests/util/mojom_validation.rs
|
| +++ b/mojo/public/rust/tests/util/mojom_validation.rs
|
| @@ -893,33 +893,30 @@ pub mod InterfaceA {
|
|
|
| pub struct InterfaceAClient {
|
| pipe: message_pipe::MessageEndpoint,
|
| + version: u32,
|
| }
|
|
|
| impl InterfaceAClient {
|
| pub fn new(pipe: message_pipe::MessageEndpoint) -> InterfaceAClient {
|
| - InterfaceAClient { pipe: pipe }
|
| - }
|
| -}
|
| -
|
| -impl CastHandle for InterfaceAClient {
|
| - unsafe fn from_untyped(handle: system::UntypedHandle) -> InterfaceAClient {
|
| - InterfaceAClient { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
|
| + InterfaceAClient {
|
| + pipe: pipe,
|
| + version: InterfaceA::VERSION,
|
| + }
|
| }
|
| - fn as_untyped(self) -> system::UntypedHandle {
|
| - self.pipe.as_untyped()
|
| + pub fn with_version(pipe: message_pipe::MessageEndpoint, version: u32) -> InterfaceAClient {
|
| + InterfaceAClient {
|
| + pipe: pipe,
|
| + version: version,
|
| + }
|
| }
|
| }
|
|
|
| -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
|
| @@ -929,6 +926,22 @@ impl MojomInterface for InterfaceAClient {
|
| }
|
| }
|
|
|
| +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;
|
| @@ -936,33 +949,30 @@ impl MojomInterfaceRecv for InterfaceAClient {
|
|
|
| pub struct InterfaceAServer {
|
| pipe: message_pipe::MessageEndpoint,
|
| + version: u32,
|
| }
|
|
|
| impl InterfaceAServer {
|
| pub fn new(pipe: message_pipe::MessageEndpoint) -> InterfaceAServer {
|
| - InterfaceAServer { pipe: pipe }
|
| - }
|
| -}
|
| -
|
| -impl CastHandle for InterfaceAServer {
|
| - unsafe fn from_untyped(handle: system::UntypedHandle) -> InterfaceAServer {
|
| - InterfaceAServer { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
|
| + InterfaceAServer {
|
| + pipe: pipe,
|
| + version: InterfaceA::VERSION,
|
| + }
|
| }
|
| - fn as_untyped(self) -> system::UntypedHandle {
|
| - self.pipe.as_untyped()
|
| + pub fn with_version(pipe: message_pipe::MessageEndpoint, version: u32) -> InterfaceAServer {
|
| + InterfaceAServer {
|
| + pipe: pipe,
|
| + version: version,
|
| + }
|
| }
|
| }
|
|
|
| -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
|
| @@ -972,6 +982,22 @@ impl MojomInterface for InterfaceAServer {
|
| }
|
| }
|
|
|
| +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;
|
| @@ -1029,33 +1055,32 @@ pub mod BoundsCheckTestInterface {
|
|
|
| pub struct BoundsCheckTestInterfaceClient {
|
| pipe: message_pipe::MessageEndpoint,
|
| + version: u32,
|
| }
|
|
|
| impl BoundsCheckTestInterfaceClient {
|
| pub fn new(pipe: message_pipe::MessageEndpoint) -> BoundsCheckTestInterfaceClient {
|
| - BoundsCheckTestInterfaceClient { pipe: pipe }
|
| - }
|
| -}
|
| -
|
| -impl CastHandle for BoundsCheckTestInterfaceClient {
|
| - unsafe fn from_untyped(handle: system::UntypedHandle) -> BoundsCheckTestInterfaceClient {
|
| - BoundsCheckTestInterfaceClient { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
|
| + BoundsCheckTestInterfaceClient {
|
| + pipe: pipe,
|
| + version: BoundsCheckTestInterface::VERSION,
|
| + }
|
| }
|
| - fn as_untyped(self) -> system::UntypedHandle {
|
| - self.pipe.as_untyped()
|
| + pub fn with_version(pipe: message_pipe::MessageEndpoint,
|
| + version: u32)
|
| + -> BoundsCheckTestInterfaceClient {
|
| + BoundsCheckTestInterfaceClient {
|
| + pipe: pipe,
|
| + version: version,
|
| + }
|
| }
|
| }
|
|
|
| -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
|
| @@ -1065,6 +1090,22 @@ impl MojomInterface for BoundsCheckTestInterfaceClient {
|
| }
|
| }
|
|
|
| +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;
|
| @@ -1072,33 +1113,32 @@ impl MojomInterfaceRecv for BoundsCheckTestInterfaceClient {
|
|
|
| pub struct BoundsCheckTestInterfaceServer {
|
| pipe: message_pipe::MessageEndpoint,
|
| + version: u32,
|
| }
|
|
|
| impl BoundsCheckTestInterfaceServer {
|
| pub fn new(pipe: message_pipe::MessageEndpoint) -> BoundsCheckTestInterfaceServer {
|
| - BoundsCheckTestInterfaceServer { pipe: pipe }
|
| - }
|
| -}
|
| -
|
| -impl CastHandle for BoundsCheckTestInterfaceServer {
|
| - unsafe fn from_untyped(handle: system::UntypedHandle) -> BoundsCheckTestInterfaceServer {
|
| - BoundsCheckTestInterfaceServer { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
|
| + BoundsCheckTestInterfaceServer {
|
| + pipe: pipe,
|
| + version: BoundsCheckTestInterface::VERSION,
|
| + }
|
| }
|
| - fn as_untyped(self) -> system::UntypedHandle {
|
| - self.pipe.as_untyped()
|
| + pub fn with_version(pipe: message_pipe::MessageEndpoint,
|
| + version: u32)
|
| + -> BoundsCheckTestInterfaceServer {
|
| + BoundsCheckTestInterfaceServer {
|
| + pipe: pipe,
|
| + version: version,
|
| + }
|
| }
|
| }
|
|
|
| -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
|
| @@ -1108,6 +1148,22 @@ impl MojomInterface for BoundsCheckTestInterfaceServer {
|
| }
|
| }
|
|
|
| +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;
|
| @@ -1234,8 +1290,11 @@ impl MojomEncodable for BoundsCheckTestInterfaceMethod0Request {
|
|
|
| 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)
|
|
|
| @@ -1293,13 +1352,16 @@ impl MojomEncodable for BoundsCheckTestInterfaceMethod0Response {
|
| 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;
|
| @@ -1354,8 +1416,11 @@ impl MojomEncodable for BoundsCheckTestInterfaceMethod1Request {
|
|
|
| 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)
|
|
|
| @@ -1373,33 +1438,32 @@ pub mod ConformanceTestInterface {
|
|
|
| pub struct ConformanceTestInterfaceClient {
|
| pipe: message_pipe::MessageEndpoint,
|
| + version: u32,
|
| }
|
|
|
| impl ConformanceTestInterfaceClient {
|
| pub fn new(pipe: message_pipe::MessageEndpoint) -> ConformanceTestInterfaceClient {
|
| - ConformanceTestInterfaceClient { pipe: pipe }
|
| - }
|
| -}
|
| -
|
| -impl CastHandle for ConformanceTestInterfaceClient {
|
| - unsafe fn from_untyped(handle: system::UntypedHandle) -> ConformanceTestInterfaceClient {
|
| - ConformanceTestInterfaceClient { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
|
| + ConformanceTestInterfaceClient {
|
| + pipe: pipe,
|
| + version: ConformanceTestInterface::VERSION,
|
| + }
|
| }
|
| - fn as_untyped(self) -> system::UntypedHandle {
|
| - self.pipe.as_untyped()
|
| + pub fn with_version(pipe: message_pipe::MessageEndpoint,
|
| + version: u32)
|
| + -> ConformanceTestInterfaceClient {
|
| + ConformanceTestInterfaceClient {
|
| + pipe: pipe,
|
| + version: version,
|
| + }
|
| }
|
| }
|
|
|
| -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
|
| @@ -1409,6 +1473,22 @@ impl MojomInterface for ConformanceTestInterfaceClient {
|
| }
|
| }
|
|
|
| +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;
|
| @@ -1416,33 +1496,32 @@ impl MojomInterfaceRecv for ConformanceTestInterfaceClient {
|
|
|
| pub struct ConformanceTestInterfaceServer {
|
| pipe: message_pipe::MessageEndpoint,
|
| + version: u32,
|
| }
|
|
|
| impl ConformanceTestInterfaceServer {
|
| pub fn new(pipe: message_pipe::MessageEndpoint) -> ConformanceTestInterfaceServer {
|
| - ConformanceTestInterfaceServer { pipe: pipe }
|
| - }
|
| -}
|
| -
|
| -impl CastHandle for ConformanceTestInterfaceServer {
|
| - unsafe fn from_untyped(handle: system::UntypedHandle) -> ConformanceTestInterfaceServer {
|
| - ConformanceTestInterfaceServer { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
|
| + ConformanceTestInterfaceServer {
|
| + pipe: pipe,
|
| + version: ConformanceTestInterface::VERSION,
|
| + }
|
| }
|
| - fn as_untyped(self) -> system::UntypedHandle {
|
| - self.pipe.as_untyped()
|
| + pub fn with_version(pipe: message_pipe::MessageEndpoint,
|
| + version: u32)
|
| + -> ConformanceTestInterfaceServer {
|
| + ConformanceTestInterfaceServer {
|
| + pipe: pipe,
|
| + version: version,
|
| + }
|
| }
|
| }
|
|
|
| -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
|
| @@ -1452,6 +1531,22 @@ impl MojomInterface for ConformanceTestInterfaceServer {
|
| }
|
| }
|
|
|
| +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;
|
| @@ -1467,22 +1562,22 @@ 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),
|
| - ConformanceTestInterfaceMethod0(ConformanceTestInterfaceMethod0Request),
|
| + ConformanceTestInterfaceMethod15(ConformanceTestInterfaceMethod15Request),
|
| ConformanceTestInterfaceMethod1(ConformanceTestInterfaceMethod1Request),
|
| + ConformanceTestInterfaceMethod2(ConformanceTestInterfaceMethod2Request),
|
| + ConformanceTestInterfaceMethod6(ConformanceTestInterfaceMethod6Request),
|
| + ConformanceTestInterfaceMethod8(ConformanceTestInterfaceMethod8Request),
|
| + ConformanceTestInterfaceMethod10(ConformanceTestInterfaceMethod10Request),
|
| + ConformanceTestInterfaceMethod11(ConformanceTestInterfaceMethod11Request),
|
| + ConformanceTestInterfaceMethod0(ConformanceTestInterfaceMethod0Request),
|
| + ConformanceTestInterfaceMethod9(ConformanceTestInterfaceMethod9Request),
|
| ConformanceTestInterfaceMethod13(ConformanceTestInterfaceMethod13Request),
|
| - ConformanceTestInterfaceMethod15(ConformanceTestInterfaceMethod15Request),
|
| }
|
|
|
| impl MojomMessageOption for ConformanceTestInterfaceRequestOption {
|
| @@ -1491,15 +1586,6 @@ impl MojomMessageOption for ConformanceTestInterfaceRequestOption {
|
| 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);
|
| @@ -1527,111 +1613,120 @@ impl MojomMessageOption for ConformanceTestInterfaceRequestOption {
|
| Err(err) => return Err(err),
|
| }
|
| }
|
| - ConformanceTestInterfaceMethod10::ORDINAL => {
|
| + ConformanceTestInterfaceMethod7::ORDINAL => {
|
| if header.flags != message::MESSAGE_HEADER_NO_FLAG {
|
| return Err(ValidationError::MessageHeaderInvalidFlags);
|
| }
|
| - match ConformanceTestInterfaceMethod10Request::deserialize(buffer, handles) {
|
| - Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod10(value)),
|
| + match ConformanceTestInterfaceMethod7Request::deserialize(buffer, handles) {
|
| + Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod7(value)),
|
| Err(err) => return Err(err),
|
| }
|
| }
|
| - ConformanceTestInterfaceMethod6::ORDINAL => {
|
| - if header.flags != message::MESSAGE_HEADER_NO_FLAG {
|
| + ConformanceTestInterfaceMethod12::ORDINAL => {
|
| + if header.flags != message::MESSAGE_HEADER_EXPECT_RESPONSE {
|
| return Err(ValidationError::MessageHeaderInvalidFlags);
|
| }
|
| - match ConformanceTestInterfaceMethod6Request::deserialize(buffer, handles) {
|
| - Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod6(value)),
|
| + match ConformanceTestInterfaceMethod12Request::deserialize(buffer, handles) {
|
| + Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod12(value)),
|
| Err(err) => return Err(err),
|
| }
|
| }
|
| - ConformanceTestInterfaceMethod7::ORDINAL => {
|
| + ConformanceTestInterfaceMethod14::ORDINAL => {
|
| if header.flags != message::MESSAGE_HEADER_NO_FLAG {
|
| return Err(ValidationError::MessageHeaderInvalidFlags);
|
| }
|
| - match ConformanceTestInterfaceMethod7Request::deserialize(buffer, handles) {
|
| - Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod7(value)),
|
| + match ConformanceTestInterfaceMethod14Request::deserialize(buffer, handles) {
|
| + Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod14(value)),
|
| Err(err) => return Err(err),
|
| }
|
| }
|
| - ConformanceTestInterfaceMethod8::ORDINAL => {
|
| + ConformanceTestInterfaceMethod15::ORDINAL => {
|
| if header.flags != message::MESSAGE_HEADER_NO_FLAG {
|
| return Err(ValidationError::MessageHeaderInvalidFlags);
|
| }
|
| - match ConformanceTestInterfaceMethod8Request::deserialize(buffer, handles) {
|
| - Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod8(value)),
|
| + match ConformanceTestInterfaceMethod15Request::deserialize(buffer, handles) {
|
| + Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod15(value)),
|
| Err(err) => return Err(err),
|
| }
|
| }
|
| - ConformanceTestInterfaceMethod9::ORDINAL => {
|
| + ConformanceTestInterfaceMethod1::ORDINAL => {
|
| if header.flags != message::MESSAGE_HEADER_NO_FLAG {
|
| return Err(ValidationError::MessageHeaderInvalidFlags);
|
| }
|
| - match ConformanceTestInterfaceMethod9Request::deserialize(buffer, handles) {
|
| - Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod9(value)),
|
| + match ConformanceTestInterfaceMethod1Request::deserialize(buffer, handles) {
|
| + Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod1(value)),
|
| Err(err) => return Err(err),
|
| }
|
| }
|
| - ConformanceTestInterfaceMethod11::ORDINAL => {
|
| + ConformanceTestInterfaceMethod2::ORDINAL => {
|
| if header.flags != message::MESSAGE_HEADER_NO_FLAG {
|
| return Err(ValidationError::MessageHeaderInvalidFlags);
|
| }
|
| - match ConformanceTestInterfaceMethod11Request::deserialize(buffer, handles) {
|
| - Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod11(value)),
|
| + match ConformanceTestInterfaceMethod2Request::deserialize(buffer, handles) {
|
| + Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod2(value)),
|
| Err(err) => return Err(err),
|
| }
|
| }
|
| - ConformanceTestInterfaceMethod12::ORDINAL => {
|
| - if header.flags != message::MESSAGE_HEADER_EXPECT_RESPONSE {
|
| + ConformanceTestInterfaceMethod6::ORDINAL => {
|
| + if header.flags != message::MESSAGE_HEADER_NO_FLAG {
|
| return Err(ValidationError::MessageHeaderInvalidFlags);
|
| }
|
| - match ConformanceTestInterfaceMethod12Request::deserialize(buffer, handles) {
|
| - Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod12(value)),
|
| + match ConformanceTestInterfaceMethod6Request::deserialize(buffer, handles) {
|
| + Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod6(value)),
|
| Err(err) => return Err(err),
|
| }
|
| }
|
| - ConformanceTestInterfaceMethod14::ORDINAL => {
|
| + ConformanceTestInterfaceMethod8::ORDINAL => {
|
| if header.flags != message::MESSAGE_HEADER_NO_FLAG {
|
| return Err(ValidationError::MessageHeaderInvalidFlags);
|
| }
|
| - match ConformanceTestInterfaceMethod14Request::deserialize(buffer, handles) {
|
| - Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod14(value)),
|
| + match ConformanceTestInterfaceMethod8Request::deserialize(buffer, handles) {
|
| + Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod8(value)),
|
| Err(err) => return Err(err),
|
| }
|
| }
|
| - ConformanceTestInterfaceMethod0::ORDINAL => {
|
| + ConformanceTestInterfaceMethod10::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 ConformanceTestInterfaceMethod10Request::deserialize(buffer, handles) {
|
| + Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod10(value)),
|
| Err(err) => return Err(err),
|
| }
|
| }
|
| - ConformanceTestInterfaceMethod1::ORDINAL => {
|
| + ConformanceTestInterfaceMethod11::ORDINAL => {
|
| if header.flags != message::MESSAGE_HEADER_NO_FLAG {
|
| return Err(ValidationError::MessageHeaderInvalidFlags);
|
| }
|
| - match ConformanceTestInterfaceMethod1Request::deserialize(buffer, handles) {
|
| - Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod1(value)),
|
| + match ConformanceTestInterfaceMethod11Request::deserialize(buffer, handles) {
|
| + Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod11(value)),
|
| Err(err) => return Err(err),
|
| }
|
| }
|
| - ConformanceTestInterfaceMethod13::ORDINAL => {
|
| + ConformanceTestInterfaceMethod0::ORDINAL => {
|
| if header.flags != message::MESSAGE_HEADER_NO_FLAG {
|
| return Err(ValidationError::MessageHeaderInvalidFlags);
|
| }
|
| - match ConformanceTestInterfaceMethod13Request::deserialize(buffer, handles) {
|
| - Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod13(value)),
|
| + match ConformanceTestInterfaceMethod0Request::deserialize(buffer, handles) {
|
| + Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod0(value)),
|
| Err(err) => return Err(err),
|
| }
|
| }
|
| - ConformanceTestInterfaceMethod15::ORDINAL => {
|
| + ConformanceTestInterfaceMethod9::ORDINAL => {
|
| if header.flags != message::MESSAGE_HEADER_NO_FLAG {
|
| return Err(ValidationError::MessageHeaderInvalidFlags);
|
| }
|
| - match ConformanceTestInterfaceMethod15Request::deserialize(buffer, handles) {
|
| - Ok(value) => Ok(ConformanceTestInterfaceRequestOption::ConformanceTestInterfaceMethod15(value)),
|
| + 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),
|
| }
|
| }
|
| @@ -1664,79 +1759,6 @@ impl MojomMessageOption for ConformanceTestInterfaceResponseOption {
|
| }
|
| }
|
|
|
| -/// 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;
|
| @@ -1791,8 +1813,11 @@ impl MojomEncodable for ConformanceTestInterfaceMethod3Request {
|
|
|
| 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)
|
|
|
| @@ -1864,8 +1889,11 @@ impl MojomEncodable for ConformanceTestInterfaceMethod4Request {
|
|
|
| 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)
|
|
|
| @@ -1938,8 +1966,11 @@ impl MojomEncodable for ConformanceTestInterfaceMethod5Request {
|
|
|
| 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)
|
|
|
| @@ -1947,87 +1978,100 @@ impl MojomMessage for ConformanceTestInterfaceMethod5Request {
|
| }
|
| 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)
|
| }
|
| @@ -2041,20 +2085,20 @@ impl MojomPointer for ConformanceTestInterfaceMethod6Request {
|
| 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)) +
|
| @@ -2062,36 +2106,98 @@ impl MojomEncodable for ConformanceTestInterfaceMethod6Request {
|
| }
|
| }
|
|
|
| -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;
|
| +// -- ConformanceTestInterfaceMethod12Response --
|
| +
|
| +// Constants
|
| +// Enums
|
| +// Struct version information
|
| +const ConformanceTestInterfaceMethod12ResponseVersions: [(u32, u32); 1] = [(0, 16)];
|
| +
|
| +// Struct definition
|
| +pub struct ConformanceTestInterfaceMethod12Response {
|
| + pub param0: f32,
|
| +}
|
| +
|
| +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;
|
| }
|
| -// -- ConformanceTestInterfaceMethod7Request --
|
| +// -- ConformanceTestInterfaceMethod14Request --
|
|
|
| // Constants
|
| // Enums
|
| // Struct version information
|
| -const ConformanceTestInterfaceMethod7RequestVersions: [(u32, u32); 1] = [(0, 24)];
|
| +const ConformanceTestInterfaceMethod14RequestVersions: [(u32, u32); 1] = [(0, 24)];
|
|
|
| // Struct definition
|
| -pub struct ConformanceTestInterfaceMethod7Request {
|
| - pub param0: StructF,
|
| - pub param1: [Option<[u8; 3]>; 2],
|
| +pub struct ConformanceTestInterfaceMethod14Request {
|
| + pub param0: UnionA,
|
| }
|
|
|
| -impl MojomPointer for ConformanceTestInterfaceMethod7Request {
|
| +impl MojomPointer for ConformanceTestInterfaceMethod14Request {
|
| fn header_data(&self) -> DataHeaderValue {
|
| DataHeaderValue::Version(0)
|
| }
|
| @@ -2100,70 +2206,130 @@ impl MojomPointer for ConformanceTestInterfaceMethod7Request {
|
| }
|
| 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(ConformanceTestInterfaceMethod14Request { param0: param0 })
|
| + }
|
| +}
|
| +
|
| +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())
|
| + }
|
| +}
|
| +
|
| +impl MojomStruct for ConformanceTestInterfaceMethod14Request {}
|
| +impl MojomMessage for ConformanceTestInterfaceMethod14Request {
|
| + fn min_version() -> u32 {
|
| + ConformanceTestInterfaceMethod14::MIN_VERSION
|
| + }
|
| + fn create_header() -> MessageHeader {
|
| + MessageHeader::new(0,
|
| + ConformanceTestInterfaceMethod14::ORDINAL,
|
| + message::MESSAGE_HEADER_NO_FLAG)
|
| +
|
| + }
|
| +}
|
| +impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod14Request {}
|
| +
|
| +/// 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(ConformanceTestInterfaceMethod7Request {
|
| - param0: param0,
|
| - param1: param1,
|
| - })
|
| + Ok(ConformanceTestInterfaceMethod15Request { param0: param0 })
|
| }
|
| }
|
|
|
| -impl MojomEncodable for ConformanceTestInterfaceMethod7Request {
|
| +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()) +
|
| - self.param1.compute_size(context.clone())
|
| + self.param0.compute_size(context.clone())
|
| }
|
| }
|
|
|
| -impl MojomStruct for ConformanceTestInterfaceMethod7Request {}
|
| -impl MojomMessage for ConformanceTestInterfaceMethod7Request {
|
| +impl MojomStruct for ConformanceTestInterfaceMethod15Request {}
|
| +impl MojomMessage for ConformanceTestInterfaceMethod15Request {
|
| + fn min_version() -> u32 {
|
| + ConformanceTestInterfaceMethod15::MIN_VERSION
|
| + }
|
| fn create_header() -> MessageHeader {
|
| - MessageHeader::new(ConformanceTestInterface::VERSION,
|
| - ConformanceTestInterfaceMethod7::ORDINAL,
|
| + MessageHeader::new(0,
|
| + ConformanceTestInterfaceMethod15::ORDINAL,
|
| message::MESSAGE_HEADER_NO_FLAG)
|
|
|
| }
|
| }
|
| -impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod7Request {}
|
| +impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod15Request {}
|
|
|
| -/// Message: ConformanceTestInterfaceMethod8
|
| -pub mod ConformanceTestInterfaceMethod8 {
|
| - pub const ORDINAL: u32 = 8;
|
| +/// Message: ConformanceTestInterfaceMethod1
|
| +pub mod ConformanceTestInterfaceMethod1 {
|
| + pub const ORDINAL: u32 = 1;
|
| pub const MIN_VERSION: u32 = 0;
|
| }
|
| -// -- ConformanceTestInterfaceMethod8Request --
|
| +// -- ConformanceTestInterfaceMethod1Request --
|
|
|
| // Constants
|
| // Enums
|
| // Struct version information
|
| -const ConformanceTestInterfaceMethod8RequestVersions: [(u32, u32); 1] = [(0, 16)];
|
| +const ConformanceTestInterfaceMethod1RequestVersions: [(u32, u32); 1] = [(0, 16)];
|
|
|
| // Struct definition
|
| -pub struct ConformanceTestInterfaceMethod8Request {
|
| - pub param0: Vec<Option<Vec<String>>>,
|
| +pub struct ConformanceTestInterfaceMethod1Request {
|
| + pub param0: StructA,
|
| }
|
|
|
| -impl MojomPointer for ConformanceTestInterfaceMethod8Request {
|
| +impl MojomPointer for ConformanceTestInterfaceMethod1Request {
|
| fn header_data(&self) -> DataHeaderValue {
|
| DataHeaderValue::Version(0)
|
| }
|
| @@ -2177,20 +2343,20 @@ impl MojomPointer for ConformanceTestInterfaceMethod8Request {
|
| 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)) +
|
| @@ -2198,98 +2364,114 @@ impl MojomEncodable for ConformanceTestInterfaceMethod8Request {
|
| }
|
| }
|
|
|
| -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)
|
| }
|
| @@ -2303,20 +2485,20 @@ impl MojomPointer for ConformanceTestInterfaceMethod11Request {
|
| 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)) +
|
| @@ -2324,35 +2506,38 @@ impl MojomEncodable for ConformanceTestInterfaceMethod11Request {
|
| }
|
| }
|
|
|
| -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 {}
|
| -
|
| -/// Message: ConformanceTestInterfaceMethod12
|
| -pub mod ConformanceTestInterfaceMethod12 {
|
| - pub const ORDINAL: u32 = 12;
|
| +impl ConformanceTestInterfaceRequest for ConformanceTestInterfaceMethod6Request {}
|
| +
|
| +/// 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)
|
| }
|
| @@ -2366,20 +2551,20 @@ impl MojomPointer for ConformanceTestInterfaceMethod12Request {
|
| 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)) +
|
| @@ -2387,30 +2572,38 @@ impl MojomEncodable for ConformanceTestInterfaceMethod12Request {
|
| }
|
| }
|
|
|
| -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)
|
| }
|
| @@ -2424,20 +2617,20 @@ impl MojomPointer for ConformanceTestInterfaceMethod12Response {
|
| 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)) +
|
| @@ -2445,39 +2638,43 @@ impl MojomEncodable for ConformanceTestInterfaceMethod12Response {
|
| }
|
| }
|
|
|
| -impl MojomStruct for ConformanceTestInterfaceMethod12Response {}
|
| -
|
| -impl MojomMessage for ConformanceTestInterfaceMethod12Response {
|
| +impl MojomStruct for ConformanceTestInterfaceMethod10Request {}
|
| +impl MojomMessage for ConformanceTestInterfaceMethod10Request {
|
| + fn min_version() -> u32 {
|
| + ConformanceTestInterfaceMethod10::MIN_VERSION
|
| + }
|
| fn create_header() -> MessageHeader {
|
| - MessageHeader::new(ConformanceTestInterface::VERSION,
|
| - ConformanceTestInterfaceMethod12::ORDINAL,
|
| - message::MESSAGE_HEADER_IS_RESPONSE)
|
| + MessageHeader::new(0,
|
| + ConformanceTestInterfaceMethod10::ORDINAL,
|
| + message::MESSAGE_HEADER_NO_FLAG)
|
| +
|
| }
|
| }
|
| -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());
|
| @@ -2486,20 +2683,20 @@ impl MojomPointer for ConformanceTestInterfaceMethod14Request {
|
| 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)) +
|
| @@ -2507,16 +2704,19 @@ impl MojomEncodable for ConformanceTestInterfaceMethod14Request {
|
| }
|
| }
|
|
|
| -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 {
|
| @@ -2572,8 +2772,11 @@ impl MojomEncodable for ConformanceTestInterfaceMethod0Request {
|
|
|
| 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)
|
|
|
| @@ -2581,24 +2784,24 @@ impl MojomMessage for ConformanceTestInterfaceMethod0Request {
|
| }
|
| 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)
|
| }
|
| @@ -2612,20 +2815,20 @@ impl MojomPointer for ConformanceTestInterfaceMethod1Request {
|
| 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)) +
|
| @@ -2633,16 +2836,19 @@ impl MojomEncodable for ConformanceTestInterfaceMethod1Request {
|
| }
|
| }
|
|
|
| -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 {
|
| @@ -2716,8 +2922,11 @@ impl MojomEncodable for ConformanceTestInterfaceMethod13Request {
|
|
|
| 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)
|
|
|
| @@ -2725,69 +2934,6 @@ impl MojomMessage for ConformanceTestInterfaceMethod13Request {
|
| }
|
| 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 ---
|
|
|
| @@ -2798,33 +2944,32 @@ pub mod IntegrationTestInterface {
|
|
|
| pub struct IntegrationTestInterfaceClient {
|
| pipe: message_pipe::MessageEndpoint,
|
| + version: u32,
|
| }
|
|
|
| impl IntegrationTestInterfaceClient {
|
| pub fn new(pipe: message_pipe::MessageEndpoint) -> IntegrationTestInterfaceClient {
|
| - IntegrationTestInterfaceClient { pipe: pipe }
|
| - }
|
| -}
|
| -
|
| -impl CastHandle for IntegrationTestInterfaceClient {
|
| - unsafe fn from_untyped(handle: system::UntypedHandle) -> IntegrationTestInterfaceClient {
|
| - IntegrationTestInterfaceClient { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
|
| + IntegrationTestInterfaceClient {
|
| + pipe: pipe,
|
| + version: IntegrationTestInterface::VERSION,
|
| + }
|
| }
|
| - fn as_untyped(self) -> system::UntypedHandle {
|
| - self.pipe.as_untyped()
|
| + pub fn with_version(pipe: message_pipe::MessageEndpoint,
|
| + version: u32)
|
| + -> IntegrationTestInterfaceClient {
|
| + IntegrationTestInterfaceClient {
|
| + pipe: pipe,
|
| + version: version,
|
| + }
|
| }
|
| }
|
|
|
| -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
|
| @@ -2834,6 +2979,22 @@ impl MojomInterface for IntegrationTestInterfaceClient {
|
| }
|
| }
|
|
|
| +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;
|
| @@ -2841,33 +3002,32 @@ impl MojomInterfaceRecv for IntegrationTestInterfaceClient {
|
|
|
| pub struct IntegrationTestInterfaceServer {
|
| pipe: message_pipe::MessageEndpoint,
|
| + version: u32,
|
| }
|
|
|
| impl IntegrationTestInterfaceServer {
|
| pub fn new(pipe: message_pipe::MessageEndpoint) -> IntegrationTestInterfaceServer {
|
| - IntegrationTestInterfaceServer { pipe: pipe }
|
| - }
|
| -}
|
| -
|
| -impl CastHandle for IntegrationTestInterfaceServer {
|
| - unsafe fn from_untyped(handle: system::UntypedHandle) -> IntegrationTestInterfaceServer {
|
| - IntegrationTestInterfaceServer { pipe: message_pipe::MessageEndpoint::from_untyped(handle) }
|
| + IntegrationTestInterfaceServer {
|
| + pipe: pipe,
|
| + version: IntegrationTestInterface::VERSION,
|
| + }
|
| }
|
| - fn as_untyped(self) -> system::UntypedHandle {
|
| - self.pipe.as_untyped()
|
| + pub fn with_version(pipe: message_pipe::MessageEndpoint,
|
| + version: u32)
|
| + -> IntegrationTestInterfaceServer {
|
| + IntegrationTestInterfaceServer {
|
| + pipe: pipe,
|
| + version: version,
|
| + }
|
| }
|
| }
|
|
|
| -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
|
| @@ -2877,6 +3037,22 @@ impl MojomInterface for IntegrationTestInterfaceServer {
|
| }
|
| }
|
|
|
| +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;
|
| @@ -2993,8 +3169,11 @@ impl MojomEncodable for IntegrationTestInterfaceMethod0Request {
|
|
|
| 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)
|
|
|
| @@ -3052,10 +3231,13 @@ impl MojomEncodable for IntegrationTestInterfaceMethod0Response {
|
| 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 {}
|
|
|
Chromium Code Reviews
Issue 2240003002:
Rust: Polish off communication across Mojom interfaces (Closed)
Base URL: git@github.com:domokit/mojo.git@master