switch from poly_msg_socket to msg_socket2

2 files changed, 31 insertions, 40 deletions

diff --git a/src/linux.rs b/src/linux.rs
index 91f2f8c..7bd4679 100644
--- a/src/linux.rs
+++ b/src/linux.rs
@@ -40,7 +40,6 @@ use io_jail::{self, Minijail};
 use kvm::*;
 use msg_socket::{MsgError, MsgReceiver, MsgResult, MsgSender, MsgSocket};
 use net_util::{Error as NetError, MacAddress, Tap};
-use poly_msg_socket::PolyMsgSocket;
 use remain::sorted;
 use resources::{Alloc, MmioType, SystemAllocator};
 use sync::{Condvar, Mutex};
@@ -88,7 +87,7 @@ pub enum Error {
     BuildVm(<Arch as LinuxArch>::Error),
     ChownTpmStorage(sys_util::Error),
     CloneEventFd(sys_util::Error),
-    ControllerCreate(poly_msg_socket::Error),
+    ControllerCreate(msg_socket2::Error),
     CreateAc97(devices::PciDeviceError),
     CreateConsole(arch::serial::Error),
     CreateDiskError(disk::Error),
@@ -771,7 +770,7 @@ fn create_wayland_device(
     let mut path = std::env::var("XDG_RUNTIME_DIR").expect("XDG_RUNTIME_DIR missing");
     path.push_str("/crosvm-wl.sock");
     let seq_socket = UnixSeqpacket::connect(&path).expect("connect failed");
-    let msg_socket = PolyMsgSocket::new(seq_socket);
+    let msg_socket = msg_socket2::Socket::new(seq_socket);
     let dev = virtio::Controller::create(
         cfg.wayland_socket_paths.clone(),
         socket,
diff --git a/src/wl.rs b/src/wl.rs
index c04ec06..be2ca2e 100644
--- a/src/wl.rs
+++ b/src/wl.rs
@@ -1,22 +1,19 @@
 // SPDX-License-Identifier: BSD-3-Clause
 
 use devices::virtio::{
-    BincodeRequest, BincodeResponse, InterruptProxy, InterruptProxyEvent, MsgOnSocketRequest,
-    MsgOnSocketResponse, RemotePciCapability, VirtioDevice, Wl,
+    InterruptProxy, InterruptProxyEvent, RemotePciCapability, Request, Response, VirtioDevice, Wl,
 };
 use msg_socket::MsgSocket;
-use poly_msg_socket::PolyMsgSocket;
 use std::collections::BTreeMap;
 use std::fs::remove_file;
-use sys_util::{error, net::UnixSeqpacketListener, warn, GuestMemory};
+use sys_util::{error, net::UnixSeqpacketListener, GuestMemory};
 
 #[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
 pub use aarch64::arch_memory_regions;
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 pub use x86_64::arch_memory_regions;
 
-type Socket =
-    PolyMsgSocket<MsgOnSocketResponse, MsgOnSocketRequest, BincodeResponse, BincodeRequest>;
+type Socket = msg_socket2::Socket<Response, Request>;
 
 fn main() {
     eprintln!("hello world");
@@ -30,13 +27,13 @@ fn main() {
 
     // Receive connection from crosvm.
     let conn = server.accept().expect("accept failed");
-    let msg_socket: Socket = PolyMsgSocket::new(conn);
+    let msg_socket: Socket = msg_socket2::Socket::new(conn);
 
     let (vm_socket, memory_params) = match msg_socket.recv() {
-        Ok(poly_msg_socket::Value::MsgOnSocket(MsgOnSocketRequest::Create {
+        Ok(Request::Create {
             vm_socket,
             memory_params,
-        })) => (MsgSocket::new(vm_socket.owned()), memory_params),
+        }) => (MsgSocket::new(vm_socket.owned()), memory_params),
 
         Ok(msg) => {
             panic!("received unexpected message: {:?}", msg);
@@ -53,51 +50,48 @@ fn main() {
     let mut wl = Wl::new(wayland_paths, vm_socket, None).unwrap();
 
     loop {
-        use poly_msg_socket::Value::*;
         match msg_socket.recv() {
-            Ok(Bincode(BincodeRequest::DebugLabel)) => {
+            Ok(Request::DebugLabel) => {
                 let result = wl.debug_label();
-                if let Err(e) = msg_socket.send(BincodeResponse::DebugLabel(result)) {
+                if let Err(e) = msg_socket.send(Response::DebugLabel(result)) {
                     panic!("responding to DebugLabel failed: {}", e);
                 }
             }
 
-            Ok(MsgOnSocket(MsgOnSocketRequest::DeviceType)) => {
+            Ok(Request::DeviceType) => {
                 let result = wl.device_type();
-                if let Err(e) = msg_socket.send(MsgOnSocketResponse::DeviceType(result)) {
+                if let Err(e) = msg_socket.send(Response::DeviceType(result)) {
                     panic!("responding to DeviceType failed: {}", e);
                 }
             }
 
-            Ok(Bincode(BincodeRequest::QueueMaxSizes)) => {
+            Ok(Request::QueueMaxSizes) => {
                 let result = wl.queue_max_sizes();
-                if let Err(e) = msg_socket.send(BincodeResponse::QueueMaxSizes(result)) {
+                if let Err(e) = msg_socket.send(Response::QueueMaxSizes(result)) {
                     panic!("responding to QueueMaxSizes failed: {}", e);
                 }
             }
 
-            Ok(MsgOnSocket(MsgOnSocketRequest::Features)) => {
+            Ok(Request::Features) => {
                 let result = wl.features();
-                if let Err(e) = msg_socket.send(MsgOnSocketResponse::Features(result)) {
+                if let Err(e) = msg_socket.send(Response::Features(result)) {
                     panic!("responding to Features failed: {}", e);
                 }
             }
 
-            Ok(MsgOnSocket(MsgOnSocketRequest::AckFeatures(value))) => wl.ack_features(value),
+            Ok(Request::AckFeatures(value)) => wl.ack_features(value),
 
-            Ok(Bincode(BincodeRequest::ReadConfig { offset, len })) => {
+            Ok(Request::ReadConfig { offset, len }) => {
                 let mut data = vec![0; len];
                 wl.read_config(offset, &mut data);
-                if let Err(e) = msg_socket.send(BincodeResponse::ReadConfig(data)) {
+                if let Err(e) = msg_socket.send(Response::ReadConfig(data)) {
                     panic!("responding to ReadConfig failed: {}", e);
                 }
             }
 
-            Ok(Bincode(BincodeRequest::WriteConfig { offset, ref data })) => {
-                wl.write_config(offset, data)
-            }
+            Ok(Request::WriteConfig { offset, ref data }) => wl.write_config(offset, data),
 
-            Ok(MsgOnSocket(MsgOnSocketRequest::Activate {
+            Ok(Request::Activate {
                 shm,
                 interrupt,
                 interrupt_resample_evt,
@@ -105,7 +99,7 @@ fn main() {
                 out_queue,
                 in_queue_evt,
                 out_queue_evt,
-            })) => {
+            }) => {
                 let shm = shm.owned();
 
                 let regions = arch_memory_regions(memory_params);
@@ -128,45 +122,43 @@ fn main() {
                 println!("activated Wl");
             }
 
-            Ok(MsgOnSocket(MsgOnSocketRequest::Reset)) => {
+            Ok(Request::Reset) => {
                 let result = wl.reset();
-                if let Err(e) = msg_socket.send(MsgOnSocketResponse::Reset(result)) {
+                if let Err(e) = msg_socket.send(Response::Reset(result)) {
                     panic!("responding to Reset failed: {}", e);
                 }
             }
 
-            Ok(Bincode(BincodeRequest::GetDeviceBars(address))) => {
+            Ok(Request::GetDeviceBars(address)) => {
                 let result = wl.get_device_bars(address);
-                if let Err(e) = msg_socket.send(BincodeResponse::GetDeviceBars(result)) {
+                if let Err(e) = msg_socket.send(Response::GetDeviceBars(result)) {
                     panic!("responding to GetDeviceBars failed: {}", e);
                 }
             }
 
-            Ok(Bincode(BincodeRequest::GetDeviceCaps)) => {
+            Ok(Request::GetDeviceCaps) => {
                 let result = wl
                     .get_device_caps()
                     .into_iter()
                     .map(|c| RemotePciCapability::from(&*c))
                     .collect();
-                if let Err(e) = msg_socket.send(BincodeResponse::GetDeviceCaps(result)) {
+                if let Err(e) = msg_socket.send(Response::GetDeviceCaps(result)) {
                     panic!("responding to GetDeviceCaps failed: {}", e);
                 }
             }
 
-            Ok(MsgOnSocket(MsgOnSocketRequest::Kill)) => {
+            Ok(Request::Kill) => {
                 // Will block until worker shuts down.
                 drop(wl);
 
-                if let Err(e) = msg_socket.send(MsgOnSocketResponse::Kill) {
+                if let Err(e) = msg_socket.send(Response::Kill) {
                     error!("responding to Kill failed: {}", e);
                 }
 
                 break;
             }
 
-            Ok(MsgOnSocket(msg @ MsgOnSocketRequest::Create { .. })) => {
-                panic!("unexpected message {:?}", msg)
-            }
+            Ok(msg @ Request::Create { .. }) => panic!("unexpected message {:?}", msg),
 
             Err(e) => panic!("recv failed: {}", e),
         }