Google Git
Sign in
chromium / chromium / src / lkgr / . / mojo / core / ports / event.cc
blob: d19b9fa57d0a46929b8e084675ef4ca8168f4242 [file] [log] [blame]
Avi Drissmand387f0922022-09-14 20:51:31[diff] [blame]1// Copyright 2016 The Chromium Authors
rockot26ffc142016-02-10 05:53:07[diff] [blame]2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
Arthur Sonzognid4ee5452024-07-18 21:51:54[diff] [blame]5#ifdef UNSAFE_BUFFERS_BUILD
6// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
7#pragma allow_unsafe_buffers
8#endif
9
Ken Rockotdba46db2018-07-04 18:41:04[diff] [blame]10#include "mojo/core/ports/event.h"
rockot26ffc142016-02-10 05:53:07[diff] [blame]11
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]12#include <stdint.h>
rockot26ffc142016-02-10 05:53:07[diff] [blame]13#include <string.h>
14
Florian Jacky40b7d280b2025-09-09 08:39:31[diff] [blame]15#include "base/containers/span.h"
Hans Wennborg7c2ea37d2020-04-21 20:22:33[diff] [blame]16#include "base/logging.h"
David Sanders27d32052022-04-04 18:08:19[diff] [blame]17#include "base/memory/ptr_util.h"
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]18#include "base/numerics/safe_math.h"
Ken Rockotdba46db2018-07-04 18:41:04[diff] [blame]19#include "mojo/core/ports/user_message.h"
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]20
rockot26ffc142016-02-10 05:53:07[diff] [blame]21namespace mojo {
Ken Rockotdba46db2018-07-04 18:41:04[diff] [blame]22namespace core {
rockot26ffc142016-02-10 05:53:07[diff] [blame]23namespace ports {
24
25namespace {
26
27const size_t kPortsMessageAlignment = 8;
28
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]29#pragma pack(push, 1)
30
31struct SerializedHeader {
32 Event::Type type;
33 uint32_t padding;
34 PortName port_name;
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]35#ifndef MOJO_BACKWARDS_COMPAT
36 PortName from_port;
37 uint64_t control_sequence_num;
38#endif
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]39};
40
41struct UserMessageEventData {
42 uint64_t sequence_num;
43 uint32_t num_ports;
Ken Rockot3e0b3d022019-04-17 17:51:03[diff] [blame]44 uint32_t padding;
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]45};
46
47struct ObserveProxyEventData {
48 NodeName proxy_node_name;
49 PortName proxy_port_name;
50 NodeName proxy_target_node_name;
51 PortName proxy_target_port_name;
52};
53
54struct ObserveProxyAckEventData {
55 uint64_t last_sequence_num;
56};
57
58struct ObserveClosureEventData {
59 uint64_t last_sequence_num;
60};
61
62struct MergePortEventData {
63 PortName new_port_name;
64 Event::PortDescriptor new_port_descriptor;
65};
66
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]67struct UserMessageReadAckRequestEventData {
68 uint64_t sequence_num_to_acknowledge;
69};
70
71struct UserMessageReadAckEventData {
72 uint64_t sequence_num_acknowledged;
73};
74
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]75struct UpdatePreviousPeerEventData {
76 NodeName new_node_name;
77 PortName new_port_name;
78};
79
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]80#pragma pack(pop)
81
82static_assert(sizeof(Event::PortDescriptor) % kPortsMessageAlignment == 0,
rockot26ffc142016-02-10 05:53:07[diff] [blame]83 "Invalid PortDescriptor size.");
84
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]85static_assert(sizeof(SerializedHeader) % kPortsMessageAlignment == 0,
86 "Invalid SerializedHeader size.");
rockot26ffc142016-02-10 05:53:07[diff] [blame]87
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]88static_assert(sizeof(UserMessageEventData) % kPortsMessageAlignment == 0,
rockot26ffc142016-02-10 05:53:07[diff] [blame]89 "Invalid UserEventData size.");
90
91static_assert(sizeof(ObserveProxyEventData) % kPortsMessageAlignment == 0,
92 "Invalid ObserveProxyEventData size.");
93
94static_assert(sizeof(ObserveProxyAckEventData) % kPortsMessageAlignment == 0,
95 "Invalid ObserveProxyAckEventData size.");
96
97static_assert(sizeof(ObserveClosureEventData) % kPortsMessageAlignment == 0,
98 "Invalid ObserveClosureEventData size.");
99
100static_assert(sizeof(MergePortEventData) % kPortsMessageAlignment == 0,
101 "Invalid MergePortEventData size.");
102
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]103static_assert(sizeof(UserMessageReadAckRequestEventData) %
104 kPortsMessageAlignment ==
105 0,
106 "Invalid UserMessageReadAckRequestEventData size.");
107
108static_assert(sizeof(UserMessageReadAckEventData) % kPortsMessageAlignment == 0,
109 "Invalid UserMessageReadAckEventData size.");
110
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]111static_assert(sizeof(UpdatePreviousPeerEventData) % kPortsMessageAlignment == 0,
112 "Invalid UpdatePreviousPeerEventData size.");
113
rockot26ffc142016-02-10 05:53:07[diff] [blame]114} // namespace
115
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]116Event::PortDescriptor::PortDescriptor() {
rockot26ffc142016-02-10 05:53:07[diff] [blame]117 memset(padding, 0, sizeof(padding));
118}
119
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]120Event::~Event() = default;
121
122// static
123ScopedEvent Event::Deserialize(const void* buffer, size_t num_bytes) {
124 if (num_bytes < sizeof(SerializedHeader))
125 return nullptr;
126
127 const auto* header = static_cast<const SerializedHeader*>(buffer);
128 const PortName& port_name = header->port_name;
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]129#ifndef MOJO_BACKWARDS_COMPAT
130 const PortName& from_port = header->from_port;
131 const uint64_t control_sequence_num = header->control_sequence_num;
132#else
133 const PortName& from_port = kInvalidPortName;
134 const uint64_t control_sequence_num = std::numeric_limits<uint64_t>::max();
135#endif
Ken Rockot5f3e8cf2017-12-18 21:08:02[diff] [blame]136 const size_t data_size = num_bytes - sizeof(*header);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]137 switch (header->type) {
138 case Type::kUserMessage:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]139 return UserMessageEvent::Deserialize(
140 port_name, from_port, control_sequence_num, header + 1, data_size);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]141 case Type::kPortAccepted:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]142 return PortAcceptedEvent::Deserialize(
143 port_name, from_port, control_sequence_num, header + 1, data_size);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]144 case Type::kObserveProxy:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]145 return ObserveProxyEvent::Deserialize(
146 port_name, from_port, control_sequence_num, header + 1, data_size);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]147 case Type::kObserveProxyAck:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]148 return ObserveProxyAckEvent::Deserialize(
149 port_name, from_port, control_sequence_num, header + 1, data_size);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]150 case Type::kObserveClosure:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]151 return ObserveClosureEvent::Deserialize(
152 port_name, from_port, control_sequence_num, header + 1, data_size);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]153 case Type::kMergePort:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]154 return MergePortEvent::Deserialize(
155 port_name, from_port, control_sequence_num, header + 1, data_size);
Sigurdur Asgeirsson86c1eb32020-01-28 22:51:56[diff] [blame]156 case Type::kUserMessageReadAckRequest:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]157 return UserMessageReadAckRequestEvent::Deserialize(
158 port_name, from_port, control_sequence_num, header + 1, data_size);
Sigurdur Asgeirsson86c1eb32020-01-28 22:51:56[diff] [blame]159 case Type::kUserMessageReadAck:
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]160 return UserMessageReadAckEvent::Deserialize(
161 port_name, from_port, control_sequence_num, header + 1, data_size);
162 case Type::kUpdatePreviousPeer:
163 return UpdatePreviousPeerEvent::Deserialize(
164 port_name, from_port, control_sequence_num, header + 1, data_size);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]165 default:
166 DVLOG(2) << "Ingoring unknown port event type: "
167 << static_cast<uint32_t>(header->type);
168 return nullptr;
169 }
170}
171
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]172Event::Event(Type type,
173 const PortName& port_name,
174 const PortName& from_port,
175 uint64_t control_sequence_num)
176 : type_(type),
177 port_name_(port_name),
178 from_port_(from_port),
179 control_sequence_num_(control_sequence_num) {}
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]180
181size_t Event::GetSerializedSize() const {
182 return sizeof(SerializedHeader) + GetSerializedDataSize();
183}
184
185void Event::Serialize(void* buffer) const {
186 auto* header = static_cast<SerializedHeader*>(buffer);
187 header->type = type_;
188 header->padding = 0;
189 header->port_name = port_name_;
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]190#ifndef MOJO_BACKWARDS_COMPAT
191 header->from_port = from_port_;
192 header->control_sequence_num = control_sequence_num_;
193#endif
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]194 SerializeData(header + 1);
195}
196
Stephen Roettger4b6f8c5c2021-12-20 18:46:48[diff] [blame]197ScopedEvent Event::CloneForBroadcast() const {
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]198 return nullptr;
199}
200
201UserMessageEvent::~UserMessageEvent() = default;
202
203UserMessageEvent::UserMessageEvent(size_t num_ports)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]204 : Event(Type::kUserMessage, kInvalidPortName, kInvalidPortName, -1) {
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]205 ReservePorts(num_ports);
206}
207
208void UserMessageEvent::AttachMessage(std::unique_ptr<UserMessage> message) {
209 DCHECK(!message_);
210 message_ = std::move(message);
211}
212
213void UserMessageEvent::ReservePorts(size_t num_ports) {
214 port_descriptors_.resize(num_ports);
215 ports_.resize(num_ports);
216}
217
Ken Rockot15b2b0b2017-06-12 20:36:05[diff] [blame]218bool UserMessageEvent::NotifyWillBeRoutedExternally() {
219 DCHECK(message_);
Ken Rockotfdf158da2017-06-12 20:45:29[diff] [blame]220 return message_->WillBeRoutedExternally();
Ken Rockot15b2b0b2017-06-12 20:36:05[diff] [blame]221}
222
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]223// static
224ScopedEvent UserMessageEvent::Deserialize(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]225 const PortName& from_port,
226 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]227 const void* buffer,
228 size_t num_bytes) {
229 if (num_bytes < sizeof(UserMessageEventData))
230 return nullptr;
231
232 const auto* data = static_cast<const UserMessageEventData*>(buffer);
233 base::CheckedNumeric<size_t> port_data_size = data->num_ports;
234 port_data_size *= sizeof(PortDescriptor) + sizeof(PortName);
235 if (!port_data_size.IsValid())
236 return nullptr;
237
238 base::CheckedNumeric<size_t> total_size = port_data_size.ValueOrDie();
239 total_size += sizeof(UserMessageEventData);
240 if (!total_size.IsValid() || num_bytes < total_size.ValueOrDie())
241 return nullptr;
242
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]243 auto event = base::WrapUnique(new UserMessageEvent(
244 port_name, from_port, control_sequence_num, data->sequence_num));
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]245 event->ReservePorts(data->num_ports);
246 const auto* in_descriptors =
247 reinterpret_cast<const PortDescriptor*>(data + 1);
Florian Jacky40b7d280b2025-09-09 08:39:31[diff] [blame]248 base::span(event->port_descriptors())
249 .copy_from(base::span(in_descriptors, data->num_ports));
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]250
251 const auto* in_names =
252 reinterpret_cast<const PortName*>(in_descriptors + data->num_ports);
Florian Jacky40b7d280b2025-09-09 08:39:31[diff] [blame]253 base::span(event->ports()).copy_from(base::span(in_names, data->num_ports));
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]254 return std::move(event);
255}
256
257UserMessageEvent::UserMessageEvent(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]258 const PortName& from_port,
259 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]260 uint64_t sequence_num)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]261 : Event(Type::kUserMessage, port_name, from_port, control_sequence_num),
262 sequence_num_(sequence_num) {}
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]263
Ken Rockot0db0bcf2018-07-12 22:01:12[diff] [blame]264size_t UserMessageEvent::GetSizeIfSerialized() const {
265 if (!message_)
266 return 0;
267 return message_->GetSizeIfSerialized();
268}
269
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]270size_t UserMessageEvent::GetSerializedDataSize() const {
271 DCHECK_EQ(ports_.size(), port_descriptors_.size());
272 base::CheckedNumeric<size_t> size = sizeof(UserMessageEventData);
273 base::CheckedNumeric<size_t> ports_size =
274 sizeof(PortDescriptor) + sizeof(PortName);
275 ports_size *= ports_.size();
276 return (size + ports_size.ValueOrDie()).ValueOrDie();
277}
278
279void UserMessageEvent::SerializeData(void* buffer) const {
280 DCHECK_EQ(ports_.size(), port_descriptors_.size());
281 auto* data = static_cast<UserMessageEventData*>(buffer);
282 data->sequence_num = sequence_num_;
283 DCHECK(base::IsValueInRangeForNumericType<uint32_t>(ports_.size()));
284 data->num_ports = static_cast<uint32_t>(ports_.size());
Ken Rockot3e0b3d022019-04-17 17:51:03[diff] [blame]285 data->padding = 0;
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]286
287 auto* ports_data = reinterpret_cast<PortDescriptor*>(data + 1);
Peter Kasting1ed31f52025-01-27 22:15:35[diff] [blame]288 std::ranges::copy(port_descriptors_, ports_data);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]289
290 auto* port_names_data =
291 reinterpret_cast<PortName*>(ports_data + ports_.size());
Peter Kasting1ed31f52025-01-27 22:15:35[diff] [blame]292 std::ranges::copy(ports_, port_names_data);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]293}
294
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]295PortAcceptedEvent::PortAcceptedEvent(const PortName& port_name,
296 const PortName& from_port,
297 uint64_t control_sequence_num)
298 : Event(Type::kPortAccepted, port_name, from_port, control_sequence_num) {}
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]299
300PortAcceptedEvent::~PortAcceptedEvent() = default;
301
302// static
303ScopedEvent PortAcceptedEvent::Deserialize(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]304 const PortName& from_port,
305 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]306 const void* buffer,
307 size_t num_bytes) {
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]308 return std::make_unique<PortAcceptedEvent>(port_name, from_port,
309 control_sequence_num);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]310}
311
312size_t PortAcceptedEvent::GetSerializedDataSize() const {
313 return 0;
314}
315
316void PortAcceptedEvent::SerializeData(void* buffer) const {}
317
318ObserveProxyEvent::ObserveProxyEvent(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]319 const PortName& from_port,
320 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]321 const NodeName& proxy_node_name,
322 const PortName& proxy_port_name,
323 const NodeName& proxy_target_node_name,
324 const PortName& proxy_target_port_name)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]325 : Event(Type::kObserveProxy, port_name, from_port, control_sequence_num),
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]326 proxy_node_name_(proxy_node_name),
327 proxy_port_name_(proxy_port_name),
328 proxy_target_node_name_(proxy_target_node_name),
329 proxy_target_port_name_(proxy_target_port_name) {}
330
331ObserveProxyEvent::~ObserveProxyEvent() = default;
332
333// static
334ScopedEvent ObserveProxyEvent::Deserialize(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]335 const PortName& from_port,
336 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]337 const void* buffer,
338 size_t num_bytes) {
339 if (num_bytes < sizeof(ObserveProxyEventData))
340 return nullptr;
341
342 const auto* data = static_cast<const ObserveProxyEventData*>(buffer);
Jeremy Romancf9ae2f2017-08-24 17:06:37[diff] [blame]343 return std::make_unique<ObserveProxyEvent>(
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]344 port_name, from_port, control_sequence_num, data->proxy_node_name,
345 data->proxy_port_name, data->proxy_target_node_name,
346 data->proxy_target_port_name);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]347}
348
349size_t ObserveProxyEvent::GetSerializedDataSize() const {
350 return sizeof(ObserveProxyEventData);
351}
352
353void ObserveProxyEvent::SerializeData(void* buffer) const {
354 auto* data = static_cast<ObserveProxyEventData*>(buffer);
355 data->proxy_node_name = proxy_node_name_;
356 data->proxy_port_name = proxy_port_name_;
357 data->proxy_target_node_name = proxy_target_node_name_;
358 data->proxy_target_port_name = proxy_target_port_name_;
359}
360
Stephen Roettger4b6f8c5c2021-12-20 18:46:48[diff] [blame]361ScopedEvent ObserveProxyEvent::CloneForBroadcast() const {
362 // Don't broadcast events targeted at specific ports. Otherwise a malicioius
363 // node can use this to bypass sender verification.
364 if (port_name() != kInvalidPortName) {
365 return nullptr;
366 }
Jeremy Romancf9ae2f2017-08-24 17:06:37[diff] [blame]367 return std::make_unique<ObserveProxyEvent>(
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]368 port_name(), from_port(), control_sequence_num(), proxy_node_name_,
369 proxy_port_name_, proxy_target_node_name_, proxy_target_port_name_);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]370}
371
372ObserveProxyAckEvent::ObserveProxyAckEvent(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]373 const PortName& from_port,
374 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]375 uint64_t last_sequence_num)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]376 : Event(Type::kObserveProxyAck, port_name, from_port, control_sequence_num),
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]377 last_sequence_num_(last_sequence_num) {}
378
379ObserveProxyAckEvent::~ObserveProxyAckEvent() = default;
380
381// static
382ScopedEvent ObserveProxyAckEvent::Deserialize(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]383 const PortName& from_port,
384 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]385 const void* buffer,
386 size_t num_bytes) {
387 if (num_bytes < sizeof(ObserveProxyAckEventData))
388 return nullptr;
389
390 const auto* data = static_cast<const ObserveProxyAckEventData*>(buffer);
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]391 return std::make_unique<ObserveProxyAckEvent>(
392 port_name, from_port, control_sequence_num, data->last_sequence_num);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]393}
394
395size_t ObserveProxyAckEvent::GetSerializedDataSize() const {
396 return sizeof(ObserveProxyAckEventData);
397}
398
399void ObserveProxyAckEvent::SerializeData(void* buffer) const {
400 auto* data = static_cast<ObserveProxyAckEventData*>(buffer);
401 data->last_sequence_num = last_sequence_num_;
402}
403
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]404ObserveClosureEvent::ObserveClosureEvent(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]405 const PortName& from_port,
406 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]407 uint64_t last_sequence_num)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]408 : Event(Type::kObserveClosure, port_name, from_port, control_sequence_num),
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]409 last_sequence_num_(last_sequence_num) {}
410
411ObserveClosureEvent::~ObserveClosureEvent() = default;
412
413// static
414ScopedEvent ObserveClosureEvent::Deserialize(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]415 const PortName& from_port,
416 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]417 const void* buffer,
418 size_t num_bytes) {
419 if (num_bytes < sizeof(ObserveClosureEventData))
420 return nullptr;
421
422 const auto* data = static_cast<const ObserveClosureEventData*>(buffer);
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]423 return std::make_unique<ObserveClosureEvent>(
424 port_name, from_port, control_sequence_num, data->last_sequence_num);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]425}
426
427size_t ObserveClosureEvent::GetSerializedDataSize() const {
428 return sizeof(ObserveClosureEventData);
429}
430
431void ObserveClosureEvent::SerializeData(void* buffer) const {
432 auto* data = static_cast<ObserveClosureEventData*>(buffer);
433 data->last_sequence_num = last_sequence_num_;
434}
435
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]436MergePortEvent::MergePortEvent(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]437 const PortName& from_port,
438 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]439 const PortName& new_port_name,
440 const PortDescriptor& new_port_descriptor)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]441 : Event(Type::kMergePort, port_name, from_port, control_sequence_num),
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]442 new_port_name_(new_port_name),
443 new_port_descriptor_(new_port_descriptor) {}
444
445MergePortEvent::~MergePortEvent() = default;
446
447// static
448ScopedEvent MergePortEvent::Deserialize(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]449 const PortName& from_port,
450 uint64_t control_sequence_num,
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]451 const void* buffer,
452 size_t num_bytes) {
453 if (num_bytes < sizeof(MergePortEventData))
454 return nullptr;
455
456 const auto* data = static_cast<const MergePortEventData*>(buffer);
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]457 return std::make_unique<MergePortEvent>(
458 port_name, from_port, control_sequence_num, data->new_port_name,
459 data->new_port_descriptor);
Ken Rockot5d983722017-05-31 04:46:57[diff] [blame]460}
461
462size_t MergePortEvent::GetSerializedDataSize() const {
463 return sizeof(MergePortEventData);
464}
465
466void MergePortEvent::SerializeData(void* buffer) const {
467 auto* data = static_cast<MergePortEventData*>(buffer);
468 data->new_port_name = new_port_name_;
469 data->new_port_descriptor = new_port_descriptor_;
470}
471
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]472UserMessageReadAckRequestEvent::UserMessageReadAckRequestEvent(
473 const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]474 const PortName& from_port,
475 uint64_t control_sequence_num,
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]476 uint64_t sequence_num_to_acknowledge)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]477 : Event(Type::kUserMessageReadAckRequest,
478 port_name,
479 from_port,
480 control_sequence_num),
481 sequence_num_to_acknowledge_(sequence_num_to_acknowledge) {}
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]482
483UserMessageReadAckRequestEvent::~UserMessageReadAckRequestEvent() = default;
484
485// static
486ScopedEvent UserMessageReadAckRequestEvent::Deserialize(
487 const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]488 const PortName& from_port,
489 uint64_t control_sequence_num,
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]490 const void* buffer,
491 size_t num_bytes) {
492 if (num_bytes < sizeof(UserMessageReadAckRequestEventData))
493 return nullptr;
494
495 const auto* data =
496 static_cast<const UserMessageReadAckRequestEventData*>(buffer);
497 return std::make_unique<UserMessageReadAckRequestEvent>(
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]498 port_name, from_port, control_sequence_num,
499 data->sequence_num_to_acknowledge);
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]500}
501
502size_t UserMessageReadAckRequestEvent::GetSerializedDataSize() const {
503 return sizeof(UserMessageReadAckRequestEventData);
504}
505
506void UserMessageReadAckRequestEvent::SerializeData(void* buffer) const {
507 auto* data = static_cast<UserMessageReadAckRequestEventData*>(buffer);
508 data->sequence_num_to_acknowledge = sequence_num_to_acknowledge_;
509}
510
511UserMessageReadAckEvent::UserMessageReadAckEvent(
512 const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]513 const PortName& from_port,
514 uint64_t control_sequence_num,
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]515 uint64_t sequence_num_acknowledged)
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]516 : Event(Type::kUserMessageReadAck,
517 port_name,
518 from_port,
519 control_sequence_num),
520 sequence_num_acknowledged_(sequence_num_acknowledged) {}
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]521
522UserMessageReadAckEvent::~UserMessageReadAckEvent() = default;
523
524// static
525ScopedEvent UserMessageReadAckEvent::Deserialize(const PortName& port_name,
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]526 const PortName& from_port,
527 uint64_t control_sequence_num,
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]528 const void* buffer,
529 size_t num_bytes) {
530 if (num_bytes < sizeof(UserMessageReadAckEventData))
531 return nullptr;
532
533 const auto* data = static_cast<const UserMessageReadAckEventData*>(buffer);
534 return std::make_unique<UserMessageReadAckEvent>(
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]535 port_name, from_port, control_sequence_num,
536 data->sequence_num_acknowledged);
Sigurdur Asgeirsson96f358c2019-07-03 17:23:19[diff] [blame]537}
538
539size_t UserMessageReadAckEvent::GetSerializedDataSize() const {
540 return sizeof(UserMessageReadAckEventData);
541}
542
543void UserMessageReadAckEvent::SerializeData(void* buffer) const {
544 auto* data = static_cast<UserMessageReadAckEventData*>(buffer);
545 data->sequence_num_acknowledged = sequence_num_acknowledged_;
546}
547
Stephen Roettger96bcaf1a2021-12-21 13:46:40[diff] [blame]548UpdatePreviousPeerEvent::UpdatePreviousPeerEvent(const PortName& port_name,
549 const PortName& from_port,
550 uint64_t control_sequence_num,
551 const NodeName& new_node_name,
552 const PortName& new_port_name)
553 : Event(Type::kUpdatePreviousPeer,
554 port_name,
555 from_port,
556 control_sequence_num),
557 new_node_name_(new_node_name),
558 new_port_name_(new_port_name) {}
559
560UpdatePreviousPeerEvent::~UpdatePreviousPeerEvent() = default;
561
562// static
563ScopedEvent UpdatePreviousPeerEvent::Deserialize(const PortName& port_name,
564 const PortName& from_port,
565 uint64_t control_sequence_num,
566 const void* buffer,
567 size_t num_bytes) {
568 if (num_bytes < sizeof(UpdatePreviousPeerEventData))
569 return nullptr;
570
571 const auto* data = static_cast<const UpdatePreviousPeerEventData*>(buffer);
572 return std::make_unique<UpdatePreviousPeerEvent>(
573 port_name, from_port, control_sequence_num, data->new_node_name,
574 data->new_port_name);
575}
576
577size_t UpdatePreviousPeerEvent::GetSerializedDataSize() const {
578 return sizeof(UpdatePreviousPeerEventData);
579}
580
581void UpdatePreviousPeerEvent::SerializeData(void* buffer) const {
582 auto* data = static_cast<UpdatePreviousPeerEventData*>(buffer);
583 data->new_node_name = new_node_name_;
584 data->new_port_name = new_port_name_;
585}
586
rockot26ffc142016-02-10 05:53:07[diff] [blame]587} // namespace ports
Ken Rockotdba46db2018-07-04 18:41:04[diff] [blame]588} // namespace core
rockot26ffc142016-02-10 05:53:07[diff] [blame]589} // namespace mojo