Skip to content

Commit bb9d481

Browse files
bnjbvrbnjbvr
committed
refactor(widget): get rid of the null MatrixDriverRequestHandle
1 parent 3df336a commit bb9d481

File tree

2 files changed

+99
-78
lines changed

2 files changed

+99
-78
lines changed

‎crates/matrix-sdk/src/widget/machine/driver_req.rs‎

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -70,10 +70,6 @@ where
7070
Self { request_meta: Some(request_meta), _phantom: PhantomData }
7171
}
7272

73-
pub(crate) fn null() -> Self {
74-
Self { request_meta: None, _phantom: PhantomData }
75-
}
76-
7773
/// Setup a callback function that will be called once the matrix driver has
7874
/// processed the request.
7975
pub(crate) fn then(

‎crates/matrix-sdk/src/widget/machine/mod.rs‎

Lines changed: 99 additions & 74 deletions
Original file line numberDiff line numberDiff line change
@@ -247,19 +247,27 @@ impl WidgetMachine {
247247
.unwrap_or_default(),
248248

249249
FromWidgetRequest::GetOpenId {} => {
250-
let (request, request_action) = self.send_matrix_driver_request(RequestOpenId);
251-
request.then(|res, machine| {
252-
let response = match res {
253-
Ok(res) => OpenIdResponse::Allowed(OpenIdState::new(request_id, res)),
254-
Err(msg) => {
255-
info!("OpenID request failed: {msg}");
256-
OpenIdResponse::Blocked { original_request_id: request_id }
257-
}
258-
};
259-
260-
let action = machine.send_to_widget_request(NotifyOpenIdChanged(response)).1;
261-
action.map(|a| vec![a]).unwrap_or_default()
262-
});
250+
let request_action = self.send_matrix_driver_request(RequestOpenId).map(
251+
|(request, request_action)| {
252+
request.then(|res, machine| {
253+
let response = match res {
254+
Ok(res) => {
255+
OpenIdResponse::Allowed(OpenIdState::new(request_id, res))
256+
}
257+
Err(msg) => {
258+
info!("OpenID request failed: {msg}");
259+
OpenIdResponse::Blocked { original_request_id: request_id }
260+
}
261+
};
262+
263+
let action =
264+
machine.send_to_widget_request(NotifyOpenIdChanged(response)).1;
265+
action.map(|a| vec![a]).unwrap_or_default()
266+
});
267+
268+
request_action
269+
},
270+
);
263271

264272
let response =
265273
Self::send_from_widget_response(raw_request, Ok(OpenIdResponse::Pending));
@@ -281,23 +289,26 @@ impl WidgetMachine {
281289
)];
282290
}
283291

284-
let (request, request_action) =
285-
self.send_matrix_driver_request(UpdateDelayedEventRequest {
286-
action: req.action,
287-
delay_id: req.delay_id,
292+
self.send_matrix_driver_request(UpdateDelayedEventRequest {
293+
action: req.action,
294+
delay_id: req.delay_id,
295+
})
296+
.map(|(request, request_action)| {
297+
request.then(|result, _machine| {
298+
vec![Self::send_from_widget_response(
299+
raw_request,
300+
// This is mapped to another type because the
301+
// update_delay_event::Response
302+
// does not impl Serialize
303+
result
304+
.map(Into::<UpdateDelayedEventResponse>::into)
305+
.map_err(FromWidgetErrorResponse::from_error),
306+
)]
288307
});
289-
request.then(|result, _machine| {
290-
vec![Self::send_from_widget_response(
291-
raw_request,
292-
// This is mapped to another type because the update_delay_event::Response
293-
// does not impl Serialize
294-
result
295-
.map(Into::<UpdateDelayedEventResponse>::into)
296-
.map_err(FromWidgetErrorResponse::from_error),
297-
)]
298-
});
299308

300-
request_action.map(|a| vec![a]).unwrap_or_default()
309+
vec![request_action]
310+
})
311+
.unwrap_or_default()
301312
}
302313
}
303314
}
@@ -328,10 +339,9 @@ impl WidgetMachine {
328339
let limit = limit.unwrap_or(DEFAULT_EVENT_LIMIT);
329340
let request = ReadMessageLikeEventRequest { event_type, limit };
330341

331-
let (request, action) = self.send_matrix_driver_request(request);
332-
333-
request.then(|result, machine| {
334-
let response = match &machine.capabilities {
342+
self.send_matrix_driver_request(request).map(|(request, action)| {
343+
request.then(|result, machine| {
344+
let response = match &machine.capabilities {
335345
CapabilitiesState::Unset => Err(FromWidgetErrorResponse::from_string(
336346
"Received read event request before capabilities negotiation",
337347
)),
@@ -348,10 +358,11 @@ impl WidgetMachine {
348358
.map_err(FromWidgetErrorResponse::from_error),
349359
};
350360

351-
vec![Self::send_from_widget_response(raw_request, response)]
352-
});
361+
vec![Self::send_from_widget_response(raw_request, response)]
362+
});
353363

354-
action
364+
action
365+
})
355366
}
356367

357368
ReadEventRequest::ReadStateEvent { event_type, state_key } => {
@@ -375,14 +386,15 @@ impl WidgetMachine {
375386

376387
if allowed {
377388
let request = ReadStateEventRequest { event_type, state_key };
378-
let (request, action) = self.send_matrix_driver_request(request);
379-
request.then(|result, _machine| {
380-
let response = result
381-
.map(|events| ReadEventResponse { events })
382-
.map_err(FromWidgetErrorResponse::from_error);
383-
vec![Self::send_from_widget_response(raw_request, response)]
384-
});
385-
action
389+
self.send_matrix_driver_request(request).map(|(request, action)| {
390+
request.then(|result, _machine| {
391+
let response = result
392+
.map(|events| ReadEventResponse { events })
393+
.map_err(FromWidgetErrorResponse::from_error);
394+
vec![Self::send_from_widget_response(raw_request, response)]
395+
});
396+
action
397+
})
386398
} else {
387399
Some(Self::send_from_widget_error_string_response(
388400
raw_request,
@@ -428,19 +440,19 @@ impl WidgetMachine {
428440
));
429441
}
430442

431-
let (request, action) = self.send_matrix_driver_request(request);
432-
433-
request.then(|mut result, machine| {
434-
if let Ok(r) = result.as_mut() {
435-
r.set_room_id(machine.room_id.clone());
436-
}
437-
vec![Self::send_from_widget_response(
438-
raw_request,
439-
result.map_err(FromWidgetErrorResponse::from_error),
440-
)]
441-
});
443+
self.send_matrix_driver_request(request).map(|(request, action)| {
444+
request.then(|mut result, machine| {
445+
if let Ok(r) = result.as_mut() {
446+
r.set_room_id(machine.room_id.clone());
447+
}
448+
vec![Self::send_from_widget_response(
449+
raw_request,
450+
result.map_err(FromWidgetErrorResponse::from_error),
451+
)]
452+
});
442453

443-
action
454+
action
455+
})
444456
}
445457

446458
#[instrument(skip_all, fields(?request_id))]
@@ -582,17 +594,20 @@ impl WidgetMachine {
582594
fn send_matrix_driver_request<T: MatrixDriverRequest>(
583595
&mut self,
584596
request: T,
585-
) -> (MatrixDriverRequestHandle<'_, T::Response>, Option<Action>) {
597+
) -> Option<(MatrixDriverRequestHandle<'_, T::Response>, Action)> {
586598
let request_id = Uuid::new_v4();
587599
let request_meta = MatrixDriverRequestMeta::new();
600+
588601
let Some(meta) = self.pending_matrix_driver_requests.insert(request_id, request_meta)
589602
else {
590603
warn!("Reached limits of pending requests for matrix driver requests");
591-
return (MatrixDriverRequestHandle::null(), None);
604+
return None;
592605
};
593606

594-
let action = Action::MatrixDriverRequest { request_id, data: request.into() };
595-
(MatrixDriverRequestHandle::new(meta), Some(action))
607+
Some((
608+
MatrixDriverRequestHandle::new(meta),
609+
Action::MatrixDriverRequest { request_id, data: request.into() },
610+
))
596611
}
597612

598613
fn negotiate_capabilities(&mut self) -> Vec<Action> {
@@ -601,28 +616,38 @@ impl WidgetMachine {
601616
self.capabilities = CapabilitiesState::Negotiating;
602617

603618
let (request, action) = self.send_to_widget_request(RequestCapabilities {});
619+
604620
request.then(|response, machine| {
605621
let requested = response.capabilities;
606-
let (request, action) = machine.send_matrix_driver_request(AcquireCapabilities {
607-
desired_capabilities: requested.clone(),
608-
});
609622

610-
request.then(|result, machine| {
611-
let approved = result.unwrap_or_else(|e| {
612-
error!("Acquiring capabilities failed: {e}");
613-
Capabilities::default()
614-
});
623+
if let Some((request, action)) =
624+
machine.send_matrix_driver_request(AcquireCapabilities {
625+
desired_capabilities: requested.clone(),
626+
})
627+
{
628+
request.then(|result, machine| {
629+
let approved = result.unwrap_or_else(|e| {
630+
error!("Acquiring capabilities failed: {e}");
631+
Capabilities::default()
632+
});
615633

616-
let subscribe_required = !approved.read.is_empty();
617-
machine.capabilities = CapabilitiesState::Negotiated(approved.clone());
634+
let subscribe_required = !approved.read.is_empty();
635+
machine.capabilities = CapabilitiesState::Negotiated(approved.clone());
618636

619-
let update = NotifyCapabilitiesChanged { approved, requested };
620-
let (_request, action) = machine.send_to_widget_request(update);
637+
let update = NotifyCapabilitiesChanged { approved, requested };
638+
let (_request, action) = machine.send_to_widget_request(update);
621639

622-
subscribe_required.then_some(Action::Subscribe).into_iter().chain(action).collect()
623-
});
640+
subscribe_required
641+
.then_some(Action::Subscribe)
642+
.into_iter()
643+
.chain(action)
644+
.collect()
645+
});
624646

625-
action.map(|a| vec![a]).unwrap_or_default()
647+
vec![action]
648+
} else {
649+
Vec::new()
650+
}
626651
});
627652

628653
unsubscribe_required.then_some(Action::Unsubscribe).into_iter().chain(action).collect()

0 commit comments

Comments
 (0)