devices: vios: remove redundant map_err closures

Fixes clippy warning "redundant closure found".

https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure

BUG=None
TEST=bin/clippy

Change-Id: Ic87dacb1a60f2125d3eb60aae60ffbcd6a774ada
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/crosvm/+/2885785
Tested-by: kokoro <noreply+kokoro@google.com>
Commit-Queue: Daniel Verkamp <dverkamp@chromium.org>
Reviewed-by: Jorge Moreira Broche <jemoreira@google.com>
Reviewed-by: Dylan Reid <dgreid@chromium.org>

bin/clippy

@@ -39,7 +39,6 @@ SUPPRESS=(
     needless_range_loop
     option_map_unit_fn
     range_plus_one
-    redundant_closure
     single_match
     slow_vector_initialization
     unnecessary_filter_map

devices/src/pci/ac97.rs

@@ -190,7 +190,7 @@ impl Ac97Dev {
             let server = Box::new(
                 // The presence of vios_server_path is checked during argument parsing
                 VioSShmStreamSource::new(param.vios_server_path.expect("Missing server path"))
-                    .map_err(|e| pci_device::Error::CreateViosClientFailed(e))?,
+                    .map_err(pci_device::Error::CreateViosClientFailed)?,
             );
             let vios_audio = Self::new(mem, Ac97Backend::VIOS, server);
             Ok(vios_audio)

devices/src/virtio/snd/vios_backend/shm_streams.rs

@@ -207,8 +207,7 @@ impl VioSndShmStream {
             // safe because we checked the result of libc::fcntl()
             File::from_raw_fd(dup_fd)
         };
-        let client_shm_clone =
-            SharedMemory::from_file(file).map_err(|e| Error::BaseMmapError(e))?;
+        let client_shm_clone = SharedMemory::from_file(file).map_err(Error::BaseMmapError)?;
 
         Ok(Box::new(Self {
             num_channels,

devices/src/virtio/snd/vios_backend/shm_vios.rs

@@ -116,15 +116,14 @@ pub struct VioSClient {
 impl VioSClient {
     /// Create a new client given the path to the audio server's socket.
     pub fn try_new<P: AsRef<Path>>(server: P) -> Result<VioSClient> {
-        let client_socket =
-            UnixSeqpacket::connect(server).map_err(|e| Error::ServerConnectionError(e))?;
+        let client_socket = UnixSeqpacket::connect(server).map_err(Error::ServerConnectionError)?;
         let mut config: VioSConfig = Default::default();
         let mut fds: Vec<RawFd> = Vec::new();
         const NUM_FDS: usize = 5;
         fds.resize(NUM_FDS, 0);
         let (recv_size, fd_count) = client_socket
             .recv_with_fds(config.as_mut_slice(), &mut fds)
-            .map_err(|e| Error::ServerError(e))?;
+            .map_err(Error::ServerError)?;
 
         // Resize the vector to the actual number of file descriptors received and wrap them in
         // SafeDescriptors to prevent leaks
@@ -184,7 +183,7 @@ impl VioSClient {
         let rx_subscribers: Arc<Mutex<HashMap<usize, Sender<(u32, usize)>>>> =
             Arc::new(Mutex::new(HashMap::new()));
         let recv_running = Arc::new(Mutex::new(true));
-        let recv_event = Event::new().map_err(|e| Error::EventCreateError(e))?;
+        let recv_event = Event::new().map_err(Error::EventCreateError)?;
 
         let mut client = VioSClient {
             config,
@@ -210,13 +209,13 @@ impl VioSClient {
             .recv_event
             .lock()
             .try_clone()
-            .map_err(|e| Error::EventDupError(e))?;
+            .map_err(Error::EventDupError)?;
         let rx_socket = self
             .rx
             .lock()
             .socket
             .try_clone()
-            .map_err(|e| Error::UnixSeqpacketDupError(e))?;
+            .map_err(Error::UnixSeqpacketDupError)?;
         let mut opt = self.recv_thread.lock();
         // The lock on recv_thread was released above to avoid holding more than one lock at a time
         // while duplicating the fds. So we have to check again the condition.
@@ -427,7 +426,7 @@ impl VioSClient {
         let control_socket_lock = self.control_socket.lock();
         let info_vec = control_socket_lock
             .recv_as_vec()
-            .map_err(|e| Error::ServerIOError(e))?;
+            .map_err(Error::ServerIOError)?;
         if info_vec.len() != num_streams * info_size {
             return Err(Error::ProtocolError(
                 ProtocolErrorKind::UnexpectedMessageSize(num_streams * info_size, info_vec.len()),
@@ -485,16 +484,16 @@ fn spawn_recv_thread(
             (&rx_socket, Token::RxBufferMsg),
             (&event, Token::Notification),
         ])
-        .map_err(|e| Error::WaitContextCreateError(e))?;
+        .map_err(Error::WaitContextCreateError)?;
         while *running.lock() {
-            let events = wait_ctx.wait().map_err(|e| Error::WaitError(e))?;
+            let events = wait_ctx.wait().map_err(Error::WaitError)?;
             for evt in events {
                 match evt.token {
                     Token::RxBufferMsg => {
                         let mut msg: IoStatusMsg = Default::default();
                         let size = rx_socket
                             .recv(msg.as_mut_slice())
-                            .map_err(|e| Error::ServerIOError(e))?;
+                            .map_err(Error::ServerIOError)?;
                         if size != std::mem::size_of::<IoStatusMsg>() {
                             return Err(Error::ProtocolError(
                                 ProtocolErrorKind::UnexpectedMessageSize(
@@ -540,9 +539,7 @@ fn spawn_recv_thread(
 }
 
 fn await_status(promise: Receiver<(u32, usize)>) -> Result<usize> {
-    let (status, consumed_len) = promise
-        .recv()
-        .map_err(|e| Error::BufferStatusSenderLost(e))?;
+    let (status, consumed_len) = promise.recv().map_err(Error::BufferStatusSenderLost)?;
     if status == VIRTIO_SND_S_OK {
         Ok(consumed_len)
     } else {
@@ -560,14 +557,12 @@ struct IoBufferQueue {
 
 impl IoBufferQueue {
     fn new(socket: UnixSeqpacket, mut file: File) -> Result<IoBufferQueue> {
-        let size = file
-            .seek(SeekFrom::End(0))
-            .map_err(|e| Error::FileSizeError(e))? as usize;
+        let size = file.seek(SeekFrom::End(0)).map_err(Error::FileSizeError)? as usize;
 
         let mmap = MemoryMappingBuilder::new(size)
             .from_file(&file)
             .build()
-            .map_err(|e| Error::ServerMmapError(e))?;
+            .map_err(Error::ServerMmapError)?;
 
         Ok(IoBufferQueue {
             socket,
@@ -597,11 +592,11 @@ impl IoBufferQueue {
         let (src_mmap, mmap_offset) = mmap_buffer(src, offset, size)?;
         let src_slice = src_mmap
             .get_slice(mmap_offset, size)
-            .map_err(|e| Error::VolatileMemoryError(e))?;
+            .map_err(Error::VolatileMemoryError)?;
         let dst_slice = self
             .mmap
             .get_slice(shm_offset, size)
-            .map_err(|e| Error::VolatileMemoryError(e))?;
+            .map_err(Error::VolatileMemoryError)?;
         src_slice.copy_to_volatile_slice(dst_slice);
         Ok(shm_offset)
     }
@@ -616,11 +611,11 @@ impl IoBufferQueue {
         let (dst_mmap, mmap_offset) = mmap_buffer(dst, dst_offset, size)?;
         let dst_slice = dst_mmap
             .get_slice(mmap_offset, size)
-            .map_err(|e| Error::VolatileMemoryError(e))?;
+            .map_err(Error::VolatileMemoryError)?;
         let src_slice = self
             .mmap
             .get_slice(src_offset, size)
-            .map_err(|e| Error::VolatileMemoryError(e))?;
+            .map_err(Error::VolatileMemoryError)?;
         src_slice.copy_to_volatile_slice(dst_slice);
         Ok(())
     }
@@ -709,7 +704,7 @@ fn mmap_buffer(
         .offset(aligned_offset as u64)
         .from_shared_memory(src)
         .build()
-        .map_err(|e| Error::GuestMmapError(e))?;
+        .map_err(Error::GuestMmapError)?;
 
     Ok((mmap, offset_from_mapping_start))
 }
@@ -718,7 +713,7 @@ fn recv_cmd_status(control_socket: &mut UnixSeqpacket) -> Result<()> {
     let mut status: virtio_snd_hdr = Default::default();
     control_socket
         .recv(status.as_mut_slice())
-        .map_err(|e| Error::ServerIOError(e))?;
+        .map_err(Error::ServerIOError)?;
     if status.code.to_native() == VIRTIO_SND_S_OK {
         Ok(())
     } else {