Make Error Send + Sync + 'static

When using jpeg-decoder in a multi-threaded application, or with a
library like `anyhow`, it is desirable to have the error type meet the
`Error + Send + Sync + 'static` bounds. `jpeg_decoder::Error` has an
`Internal(Box<dyn std::Error>)` variant that prevented the type from
being `Send` and `Sync`.

The only use of this variant was for errors related to communicating
with the worker thread. `SendError` contains the object that failed to
be sent on the channel, which made it not `Sync`. `SendError` doesn't
seem to be designed to be propagated with `?` -- returning this internal
message object is not useful to expose to the caller of `jpeg_decoder`.

Those channel related errors can only occur if the worker thread panics
or otherwise exits prematurely. This would be a library bug, not
something caused by user input, so it seems like the kind of fault
that should just be a panic rather than a variant of the `Error` type.

Because `Error::Internal` is a part of the public API, and crates like
`image` match on it, this commit leaves it in place but unused, just
adding the necessary trait bounds. It can be removed in version 0.2.

Author: kevinmehall

src/error.rs

@@ -1,8 +1,6 @@
-use std::any::Any;
 use std::error::Error as StdError;
 use std::fmt;
 use std::io::Error as IoError;
-use std::sync::mpsc::{RecvError, SendError};
 
 pub type Result<T> = ::std::result::Result<T, Error>;
 
@@ -41,7 +39,7 @@ pub enum Error {
     /// An I/O error occurred while decoding the image.
     Io(IoError),
     /// An internal error occurred while decoding the image.
-    Internal(Box<dyn StdError>),
+    Internal(Box<dyn StdError + Send + Sync + 'static>), //TODO: not used, can be removed with the next version bump
 }
 
 impl fmt::Display for Error {
@@ -79,15 +77,3 @@ impl From<IoError> for Error {
         Error::Io(err)
     }
 }
-
-impl From<RecvError> for Error {
-    fn from(err: RecvError) -> Error {
-        Error::Internal(Box::new(err))
-    }
-}
-
-impl<T: Any + Send> From<SendError<T>> for Error {
-    fn from(err: SendError<T>) -> Error {
-        Error::Internal(Box::new(err))
-    }
-}

src/worker/threaded.rs

@@ -40,14 +40,14 @@ impl Worker for ThreadedWorker {
         Ok(ThreadedWorker { sender: tx })
     }
     fn start(&mut self, row_data: RowData) -> Result<()> {
-        Ok(self.sender.send(WorkerMsg::Start(row_data))?)
+        Ok(self.sender.send(WorkerMsg::Start(row_data)).expect("jpeg-decoder worker thread error"))
     }
     fn append_row(&mut self, row: (usize, Vec<i16>)) -> Result<()> {
-        Ok(self.sender.send(WorkerMsg::AppendRow(row))?)
+        Ok(self.sender.send(WorkerMsg::AppendRow(row)).expect("jpeg-decoder worker thread error"))
     }
     fn get_result(&mut self, index: usize) -> Result<Vec<u8>> {
         let (tx, rx) = mpsc::channel();
-        self.sender.send(WorkerMsg::GetResult((index, tx)))?;
-        Ok(rx.recv()?)
+        self.sender.send(WorkerMsg::GetResult((index, tx))).expect("jpeg-decoder worker thread error");
+        Ok(rx.recv().expect("jpeg-decoder worker thread error"))
     }
 }