Minor refactoring in FileSystemWatcher.

src/file_system_watcher.rs

         // Spawn the task that watches the file system as soon as unpause() is called.
         let (state_send, pause_receive) = mpsc::channel(1);
         tokio::spawn(async move {
-            Self::task_paused(file_tree, pause_receive, errors).await;
+            let mut fsw_task = FileSystemWatcherTask { file_tree, errors };
+            fsw_task.task_paused(pause_receive).await;
         });
 
         Ok(FileSystemWatcher { state_send })
             .unwrap();
         receive.await.unwrap();
     }
+}
+
+struct FileSystemWatcherTask {
+    file_tree: Arc<Mutex<FileTree>>,
+    errors: mpsc::Sender<SynchronizationError>,
+}
 
+impl FileSystemWatcherTask {
     async fn task_paused(
-        mut file_tree: Arc<Mutex<FileTree>>,
+        &mut self,
         mut state_receive: mpsc::Receiver<(StateChange, oneshot::Sender<()>)>,
-        mut errors: mpsc::Sender<SynchronizationError>,
     ) {
         let mut paused = true;
 
             } else {
                 // We were unpaused, initialize the file system watcher and start waiting for
                 // that as well.
-                let next_state =
-                    Self::task_unpaused(&mut file_tree, &mut state_receive, &mut errors).await;
+                let next_state = self.task_unpaused(&mut state_receive).await;
                 match next_state {
                     StateChange::Pause => paused = true,
                     StateChange::Unpause => paused = false,
     }
 
     async fn task_unpaused(
-        file_tree: &mut Arc<Mutex<FileTree>>,
+        &mut self,
         state_receive: &mut mpsc::Receiver<(StateChange, oneshot::Sender<()>)>,
-        errors: &mut mpsc::Sender<SynchronizationError>,
     ) -> StateChange {
-        let root_path = file_tree.lock().await.root_path().to_owned();
+        let root_path = self.file_tree.lock().await.root_path().to_owned();
         let fsw = match fswatcher::FileSystemWatcher::new(&root_path) {
             Ok(fsw) => fsw,
-            Err(e) => return Self::wait_for_pause(e.into(), state_receive, errors).await,
+            Err(e) => return self.wait_for_pause(e.into(), state_receive).await,
         };
         let mut file_events = FileEventDelay::new(fsw, Duration::from_secs(3));
 
                 Either::Left((event, _state_future)) => {
                     // We cannot get any end-of-stream None here - we would first get a "Stopped"
                     // file event.
-                    if let Err(error) =
-                        Self::handle_file_event(file_tree, errors, event.unwrap()).await
-                    {
+                    if let Err(error) = self.handle_file_event(event.unwrap()).await {
                         error_needs_pause = Some(error);
                     }
                 }
                 }
             };
         }
-        return Self::wait_for_pause(error_needs_pause.unwrap(), state_receive, errors).await;
+        return self
+            .wait_for_pause(error_needs_pause.unwrap(), state_receive)
+            .await;
     }
 
     async fn wait_for_pause(
+        &mut self,
         reason: Error,
         state_receive: &mut mpsc::Receiver<(StateChange, oneshot::Sender<()>)>,
-        errors: &mut mpsc::Sender<SynchronizationError>,
     ) -> StateChange {
-        match errors
+        match self
+            .errors
             .send(SynchronizationError {
                 needs_pause: true,
                 error: reason,
         }
     }
 
-    async fn handle_file_event(
-        file_tree: &mut Arc<Mutex<FileTree>>,
-        errors: &mut mpsc::Sender<SynchronizationError>,
-        event: FileSystemEvent,
-    ) -> Result<(), Error> {
+    async fn handle_file_event(&mut self, event: FileSystemEvent) -> Result<(), Error> {
         // When we get an I/O error, we simply ignore the corresponding file/directory. Most
         // likely, it has been deleted, and we will get a deletion event later. If a file or
         // directory is not readable, we do not want to synchronize it.
                     .filter(|x| x.is_ok())
                     .map(|x| (x.as_ref().unwrap().file_name(), x.unwrap()))
                     .collect::<HashMap<_, _>>();
-                let db_entries = match file_tree.lock().await.get_directory_listing(&path) {
+                let db_entries = match self.file_tree.lock().await.get_directory_listing(&path) {
                     Some(entries) => entries,
                     None => return Ok(()),
                 };
                 // TODO
             }
             FileSystemEvent::Error(e) => {
-                Self::send_error_no_pause(e.into(), None, errors).await;
+                self.send_error_no_pause(e.into(), None).await;
             }
         }
 
         Ok(())
     }
 
-    async fn send_error_no_pause(
-        error: Error,
-        _path: Option<OsString>,
-        errors: &mut mpsc::Sender<SynchronizationError>,
-    ) {
+    async fn send_error_no_pause(&mut self, error: Error, _path: Option<OsString>) {
         // TODO: Encode the path in the error!
-        errors
+        self.errors
             .send(SynchronizationError {
                 needs_pause: false,
                 error: error,