From 9f061a0a10c23957fda7b0d8227067a688b38140 Mon Sep 17 00:00:00 2001
From: Lewin Bormann <lewin@lewin-bormann.info>
Date: Sun, 9 Jun 2019 11:25:53 +0200
Subject: [PATCH] Work on Installed flow for futures

---
 src/authenticator.rs |  2 +-
 src/installed.rs     | 72 +++++++++++++++++++++++---------------------
 2 files changed, 38 insertions(+), 36 deletions(-)

diff --git a/src/authenticator.rs b/src/authenticator.rs
index d3240e9..a48b0f1 100644
--- a/src/authenticator.rs
+++ b/src/authenticator.rs
@@ -102,7 +102,7 @@ where
         }
 
         let mut flow = InstalledFlow::new(self.client.clone(), installed_type);
-        flow.obtain_token(&mut self.delegate, &self.secret, scopes.iter())
+        flow.obtain_token(self.delegate, self.secret.clone(), scopes.iter())
     }
 
     fn retrieve_device_token(
diff --git a/src/installed.rs b/src/installed.rs
index 07b4695..f964091 100644
--- a/src/installed.rs
+++ b/src/installed.rs
@@ -7,10 +7,9 @@ use std::error::Error;
 use std::io;
 use std::sync::{Arc, Mutex};
 
-use futures;
 use futures::stream::Stream;
 use futures::sync::oneshot;
-use futures::Future;
+use futures::{future, prelude::*};
 use hyper;
 use hyper::{header, StatusCode, Uri};
 use serde_json::error;
@@ -116,51 +115,54 @@ where
     /// It's recommended not to use the DefaultAuthenticatorDelegate, but a specialized one.
     pub fn obtain_token<'a, AD: AuthenticatorDelegate, S, T>(
         &mut self,
-        auth_delegate: &mut AD,
-        appsecret: &ApplicationSecret,
+        auth_delegate: AD,
+        appsecret: ApplicationSecret,
         scopes: S,
-    ) -> Result<Token, Box<Error>>
+    ) -> impl Future<Item = Token, Error = Box<Error>>
     where
         T: AsRef<str> + 'a,
         S: Iterator<Item = &'a T>,
     {
-        let authcode = self.get_authorization_code(auth_delegate, &appsecret, scopes)?;
-        let tokens = self.request_token(&appsecret, &authcode, auth_delegate.redirect_uri())?;
+        self.get_authorization_code(auth_delegate, appsecret, scopes)
+            .and_then(|authcode| {
+                self.request_token(&appsecret, &authcode, auth_delegate.redirect_uri())
+            })
+            .and_then(|tokens| {
+                // Successful response
+                if tokens.access_token.is_some() {
+                    let mut token = Token {
+                        access_token: tokens.access_token.unwrap(),
+                        refresh_token: tokens.refresh_token.unwrap(),
+                        token_type: tokens.token_type.unwrap(),
+                        expires_in: tokens.expires_in,
+                        expires_in_timestamp: None,
+                    };
 
-        // Successful response
-        if tokens.access_token.is_some() {
-            let mut token = Token {
-                access_token: tokens.access_token.unwrap(),
-                refresh_token: tokens.refresh_token.unwrap(),
-                token_type: tokens.token_type.unwrap(),
-                expires_in: tokens.expires_in,
-                expires_in_timestamp: None,
-            };
-
-            token.set_expiry_absolute();
-            Result::Ok(token)
-        } else {
-            let err = io::Error::new(
-                io::ErrorKind::Other,
-                format!(
-                    "Token API error: {} {}",
-                    tokens.error.unwrap_or("<unknown err>".to_string()),
-                    tokens.error_description.unwrap_or("".to_string())
-                )
-                .as_str(),
-            );
-            Result::Err(Box::new(err))
-        }
+                    token.set_expiry_absolute();
+                    Result::Ok(token)
+                } else {
+                    let err = Box::new(io::Error::new(
+                        io::ErrorKind::Other,
+                        format!(
+                            "Token API error: {} {}",
+                            tokens.error.unwrap_or("<unknown err>".to_string()),
+                            tokens.error_description.unwrap_or("".to_string())
+                        )
+                        .as_str(),
+                    )) as Box<dyn Error>;
+                    Result::Err(err)
+                }
+            })
     }
 
     /// Obtains an authorization code either interactively or via HTTP redirect (see
     /// InstalledFlowReturnMethod).
     fn get_authorization_code<'a, AD: AuthenticatorDelegate, S, T>(
         &mut self,
-        auth_delegate: &mut AD,
-        appsecret: &ApplicationSecret,
+        auth_delegate: AD,
+        appsecret: ApplicationSecret,
         scopes: S,
-    ) -> Result<String, Box<Error>>
+    ) -> impl Future<Item = String, Error = Box<Error>>
     where
         T: AsRef<str> + 'a,
         S: Iterator<Item = &'a T>,
@@ -211,7 +213,7 @@ where
             }
         };
 
-        result
+        result.into_future()
     }
 
     /// Sends the authorization code to the provider in order to obtain access and refresh tokens.