Introduce function to restore thread timer to avoid logic duplication

presage/src/manager/registered.rs

@@ -817,28 +817,10 @@ impl<S: Store> Manager<S, Registered> {
         // Issue <https://github.com/whisperfish/presage/issues/252>
         let include_pni_signature = false;
         let recipient = recipient_addr.into();
+        let thread = Thread::Contact(recipient.uuid);
         let mut content_body: ContentBody = message.into();
 
-        let store_expire_timer = self
-            .store
-            .expire_timer(&Thread::Contact(recipient.uuid))
-            .unwrap_or_default();
-
-        match content_body {
-            ContentBody::DataMessage(DataMessage {
-                expire_timer: ref mut timer,
-                expire_timer_version: ref mut version,
-                ..
-            }) => {
-                if timer.is_none() {
-                    *timer = store_expire_timer.map(|(t, _)| t);
-                    *version = Some(store_expire_timer.map(|(_, v)| v).unwrap_or_default());
-                } else {
-                    *version = Some(store_expire_timer.map(|(_, v)| v).unwrap_or_default() + 1);
-                }
-            }
-            _ => {}
-        }
+        self.restore_thread_timer(&thread, &mut content_body);
 
         let sender_certificate = self.sender_certificate().await?;
         let unidentified_access =
@@ -883,13 +865,7 @@ impl<S: Store> Manager<S, Registered> {
         };
 
         let mut push_service = self.identified_push_service();
-        save_message(
-            &mut self.store,
-            &mut push_service,
-            content,
-            Some(Thread::Contact(recipient.uuid)),
-        )
-        .await?;
+        save_message(&mut self.store, &mut push_service, content, Some(thread)).await?;
 
         Ok(())
     }
@@ -924,23 +900,10 @@ impl<S: Store> Manager<S, Registered> {
         let master_key_bytes = master_key_bytes
             .try_into()
             .expect("Master key bytes to be of size 32.");
+        let thread = Thread::Group(master_key_bytes);
+
+        self.restore_thread_timer(&thread, &mut content_body);
 
-        // Only update the expiration timer if it is not set.
-        match content_body {
-            ContentBody::DataMessage(DataMessage {
-                expire_timer: ref mut timer,
-                ..
-            }) if timer.is_none() => {
-                // Set the expire timer to None for errors.
-                let store_expire_timer = self
-                    .store
-                    .expire_timer(&Thread::Group(master_key_bytes))
-                    .unwrap_or_default();
-
-                *timer = store_expire_timer.map(|(t, _)| t);
-            }
-            _ => {}
-        }
         let mut sender = self.new_message_sender().await?;
 
         let mut groups_manager = self.groups_manager()?;
@@ -1006,17 +969,31 @@ impl<S: Store> Manager<S, Registered> {
         };
 
         let mut push_service = self.identified_push_service();
-        save_message(
-            &mut self.store,
-            &mut push_service,
-            content,
-            Some(Thread::Group(master_key_bytes)),
-        )
-        .await?;
+        save_message(&mut self.store, &mut push_service, content, Some(thread)).await?;
 
         Ok(())
     }
 
+    fn restore_thread_timer(&mut self, thread: &Thread, content_body: &mut ContentBody) {
+        let store_expire_timer = self.store.expire_timer(thread).unwrap_or_default();
+
+        match content_body {
+            ContentBody::DataMessage(DataMessage {
+                expire_timer: ref mut timer,
+                expire_timer_version: ref mut version,
+                ..
+            }) => {
+                if timer.is_none() {
+                    *timer = store_expire_timer.map(|(t, _)| t);
+                    *version = Some(store_expire_timer.map(|(_, v)| v).unwrap_or_default());
+                } else {
+                    *version = Some(store_expire_timer.map(|(_, v)| v).unwrap_or_default() + 1);
+                }
+            }
+            _ => (),
+        }
+    }
+
     /// Clears all sessions established wiht [recipient](ServiceAddress).
     pub async fn clear_sessions(&self, recipient: &ServiceAddress) -> Result<(), Error<S::Error>> {
         use libsignal_service::session_store::SessionStoreExt;