From c6ac53dd7c29094e10dc6bc45d2e60cd13ff758a Mon Sep 17 00:00:00 2001
From: Jesse Luehrs <doy@tozt.net>
Date: Wed, 13 Nov 2019 16:21:19 -0500
Subject: remove the need for the connection state to be cloneable

---
 src/server.rs | 64 ++++++++++++++++++++++++-----------------------------------
 1 file changed, 26 insertions(+), 38 deletions(-)

diff --git a/src/server.rs b/src/server.rs
index 4dcd914..5f0da66 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -49,7 +49,7 @@ struct TerminalInfo {
     size: crate::term::Size,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 // XXX https://github.com/rust-lang/rust/issues/64362
 #[allow(dead_code)]
 enum ConnectionState {
@@ -88,6 +88,16 @@ impl ConnectionState {
         }
     }
 
+    fn term_info(&mut self) -> Option<&TerminalInfo> {
+        match self {
+            Self::Accepted => None,
+            Self::LoggingIn { term_info, .. } => Some(term_info),
+            Self::LoggedIn { term_info, .. } => Some(term_info),
+            Self::Streaming { term_info, .. } => Some(term_info),
+            Self::Watching { term_info, .. } => Some(term_info),
+        }
+    }
+
     fn term_info_mut(&mut self) -> Option<&mut TerminalInfo> {
         match self {
             Self::Accepted => None,
@@ -147,25 +157,6 @@ impl ConnectionState {
         }
     }
 
-    fn login_oauth(
-        &mut self,
-        term_type: &str,
-        size: crate::term::Size,
-        username: &str,
-    ) {
-        if let Self::Accepted = self {
-            *self = Self::LoggedIn {
-                username: username.to_string(),
-                term_info: TerminalInfo {
-                    term: term_type.to_string(),
-                    size,
-                },
-            };
-        } else {
-            unreachable!()
-        }
-    }
-
     fn login_oauth_start(
         &mut self,
         term_type: &str,
@@ -183,17 +174,6 @@ impl ConnectionState {
         }
     }
 
-    fn login_oauth_finish(&mut self, username: &str) {
-        if let Self::LoggingIn { term_info } = self {
-            *self = Self::LoggedIn {
-                username: username.to_string(),
-                term_info: term_info.clone(),
-            };
-        } else {
-            unreachable!()
-        }
-    }
-
     fn stream(&mut self, buffer_size: usize) {
         if let Self::LoggedIn {
             username,
@@ -436,7 +416,6 @@ impl<S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Send + 'static>
                 {
                     let term_type = term_type.to_string();
                     let client = conn.oauth_client.take().unwrap();
-                    let mut new_state = conn.state.clone();
                     let fut = tokio::fs::File::open(token_filename.clone())
                         .with_context(move || crate::error::OpenFile {
                             filename: token_filename
@@ -463,10 +442,14 @@ impl<S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Send + 'static>
                                 })
                         })
                         .map(move |username| {
-                            new_state
-                                .login_oauth(&term_type, size, &username);
                             (
-                                new_state,
+                                ConnectionState::LoggedIn {
+                                    username: username.clone(),
+                                    term_info: TerminalInfo {
+                                        term: term_type,
+                                        size,
+                                    },
+                                },
                                 crate::protocol::Message::logged_in(
                                     &username,
                                 ),
@@ -625,13 +608,18 @@ impl<S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Send + 'static>
             }
         })?;
 
-        let mut new_state = conn.state.clone();
+        let term_info = conn.state.term_info().unwrap().clone();
         let fut = client
             .get_access_token_from_auth_code(code)
             .and_then(|token| client.get_username_from_access_token(&token))
             .map(|username| {
-                new_state.login_oauth_finish(&username);
-                (new_state, crate::protocol::Message::logged_in(&username))
+                (
+                    ConnectionState::LoggedIn {
+                        term_info,
+                        username: username.clone(),
+                    },
+                    crate::protocol::Message::logged_in(&username),
+                )
             });
 
         Ok(Some(Box::new(fut)))
-- 
cgit v1.2.3-54-g00ecf