| OLD | NEW |
| (Empty) |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 use bindings::decoding::{Decoder, ValidationError}; | |
| 6 use bindings::encoding; | |
| 7 use bindings::encoding::{Context, DATA_HEADER_SIZE, DataHeaderValue, Encoder}; | |
| 8 use bindings::mojom::{MojomEncodable, MojomPointer, MojomStruct}; | |
| 9 | |
| 10 /// A flag for the message header indicating that no flag has been set. | |
| 11 pub const MESSAGE_HEADER_NO_FLAG: u32 = 0; | |
| 12 | |
| 13 /// A flag for the message header indicating that this message expects | |
| 14 /// a response. | |
| 15 pub const MESSAGE_HEADER_EXPECT_RESPONSE: u32 = 1; | |
| 16 | |
| 17 /// A flag for the message header indicating that this message is | |
| 18 /// a response. | |
| 19 pub const MESSAGE_HEADER_IS_RESPONSE: u32 = 2; | |
| 20 | |
| 21 const MESSAGE_HEADER_VERSIONS: [(u32, u32); 2] = [(0, 16), (1, 24)]; | |
| 22 | |
| 23 /// A message header object implemented as a Mojom struct. | |
| 24 pub struct MessageHeader { | |
| 25 pub version: u32, | |
| 26 pub name: u32, | |
| 27 pub flags: u32, | |
| 28 pub request_id: u64, | |
| 29 } | |
| 30 | |
| 31 impl MessageHeader { | |
| 32 /// Create a new MessageHeader. | |
| 33 pub fn new(version: u32, name: u32, flags: u32) -> MessageHeader { | |
| 34 MessageHeader { | |
| 35 version: version, | |
| 36 name: name, | |
| 37 flags: flags, | |
| 38 request_id: 0, | |
| 39 } | |
| 40 } | |
| 41 } | |
| 42 | |
| 43 impl MojomPointer for MessageHeader { | |
| 44 fn header_data(&self) -> DataHeaderValue { | |
| 45 DataHeaderValue::Version(self.version) | |
| 46 } | |
| 47 | |
| 48 /// Get the serialized size. | |
| 49 /// | |
| 50 /// This value differs based on whether or not | |
| 51 /// a request_id is necessary. | |
| 52 fn serialized_size(&self, _context: &Context) -> usize { | |
| 53 let mut size = DATA_HEADER_SIZE + 8; | |
| 54 if self.flags != MESSAGE_HEADER_NO_FLAG { | |
| 55 size += 8; | |
| 56 } | |
| 57 encoding::align_default(size) | |
| 58 } | |
| 59 | |
| 60 fn encode_value(self, encoder: &mut Encoder, context: Context) { | |
| 61 MojomEncodable::encode(self.name, encoder, context.clone()); | |
| 62 MojomEncodable::encode(self.flags, encoder, context.clone()); | |
| 63 if self.version > 0 { | |
| 64 MojomEncodable::encode(self.request_id, encoder, context.clone()); | |
| 65 } | |
| 66 } | |
| 67 | |
| 68 fn decode_value(decoder: &mut Decoder, context: Context) -> Result<Self, Val
idationError> { | |
| 69 let mut state = decoder.get_mut(&context); | |
| 70 let version = match state.decode_struct_header(&MESSAGE_HEADER_VERSIONS)
{ | |
| 71 Ok(header) => header.data(), | |
| 72 Err(err) => return Err(err), | |
| 73 }; | |
| 74 let name = state.decode::<u32>(); | |
| 75 let flags = state.decode::<u32>(); | |
| 76 if flags > MESSAGE_HEADER_IS_RESPONSE { | |
| 77 return Err(ValidationError::MessageHeaderInvalidFlags); | |
| 78 } | |
| 79 if version == 0 { | |
| 80 if flags == MESSAGE_HEADER_IS_RESPONSE || flags == MESSAGE_HEADER_EX
PECT_RESPONSE { | |
| 81 return Err(ValidationError::MessageHeaderMissingRequestId); | |
| 82 } | |
| 83 Ok(MessageHeader { | |
| 84 version: version, | |
| 85 name: name, | |
| 86 flags: flags, | |
| 87 request_id: 0, | |
| 88 }) | |
| 89 } else if version == 1 { | |
| 90 Ok(MessageHeader { | |
| 91 version: version, | |
| 92 name: name, | |
| 93 flags: flags, | |
| 94 request_id: state.decode::<u64>(), | |
| 95 }) | |
| 96 } else { | |
| 97 return Err(ValidationError::UnexpectedStructHeader); | |
| 98 } | |
| 99 } | |
| 100 } | |
| 101 | |
| 102 impl MojomEncodable for MessageHeader { | |
| 103 impl_encodable_for_pointer!(); | |
| 104 fn compute_size(&self, context: Context) -> usize { | |
| 105 self.serialized_size(&context) | |
| 106 } | |
| 107 } | |
| 108 | |
| 109 impl MojomStruct for MessageHeader {} | |
| 110 | |
| OLD | NEW |