[identity] rustfmt account_handler

Change-Id: I8fc8b0e8a472dd071f019b55504a2569cd89bb3e
diff --git a/src/identity/bin/account_handler/src/account.rs b/src/identity/bin/account_handler/src/account.rs
index 59d6bb8..dc66dd8 100644
--- a/src/identity/bin/account_handler/src/account.rs
+++ b/src/identity/bin/account_handler/src/account.rs
@@ -240,12 +240,10 @@
             PersonaContext { auth_ui_context_provider: context.auth_ui_context_provider.clone() };
         match persona_server_end.into_stream() {
             Ok(stream) => {
-                fasync::spawn(
-                    async move {
-                        await!(persona_clone.handle_requests_from_stream(&persona_context, stream))
-                            .unwrap_or_else(|e| error!("Error handling Persona channel {:?}", e))
-                    },
-                );
+                fasync::spawn(async move {
+                    await!(persona_clone.handle_requests_from_stream(&persona_context, stream))
+                        .unwrap_or_else(|e| error!("Error handling Persona channel {:?}", e))
+                });
                 (Status::Ok, Some(self.default_persona.id().clone().into()))
             }
             Err(e) => {
@@ -406,14 +404,10 @@
                 auth_ui_context_provider: ui_context_provider_client_end.into_proxy().unwrap(),
             };
 
-            fasync::spawn(
-                async move {
-                    await!(test_object.handle_requests_from_stream(&context, request_stream))
-                        .unwrap_or_else(|err| {
-                            panic!("Fatal error handling test request: {:?}", err)
-                        })
-                },
-            );
+            fasync::spawn(async move {
+                await!(test_object.handle_requests_from_stream(&context, request_stream))
+                    .unwrap_or_else(|err| panic!("Fatal error handling test request: {:?}", err))
+            });
 
             self.executor.run_singlethreaded(test_fn(account_proxy)).expect("Executor run failed.")
         }
diff --git a/src/identity/bin/account_handler/src/account_handler.rs b/src/identity/bin/account_handler/src/account_handler.rs
index 1401ddf2..e51cbf0 100644
--- a/src/identity/bin/account_handler/src/account_handler.rs
+++ b/src/identity/bin/account_handler/src/account_handler.rs
@@ -203,12 +203,10 @@
             }
         };
 
-        fasync::spawn(
-            async move {
-                await!(account.handle_requests_from_stream(&context, stream))
-                    .unwrap_or_else(|e| error!("Error handling Account channel {:?}", e))
-            },
-        );
+        fasync::spawn(async move {
+            await!(account.handle_requests_from_stream(&context, stream))
+                .unwrap_or_else(|e| error!("Error handling Account channel {:?}", e))
+        });
         Status::Ok
     }
 }
@@ -243,12 +241,10 @@
         let proxy = client_end.into_proxy().unwrap();
         let request_stream = server_end.into_stream().unwrap();
 
-        fasync::spawn(
-            async move {
-                await!(test_object.handle_requests_from_stream(request_stream))
-                    .unwrap_or_else(|err| panic!("Fatal error handling test request: {:?}", err))
-            },
-        );
+        fasync::spawn(async move {
+            await!(test_object.handle_requests_from_stream(request_stream))
+                .unwrap_or_else(|err| panic!("Fatal error handling test request: {:?}", err))
+        });
 
         executor.run_singlethreaded(test_fn(proxy, ahc_client_end)).expect("Executor run failed.")
     }
diff --git a/src/identity/bin/account_handler/src/auth_provider_supplier.rs b/src/identity/bin/account_handler/src/auth_provider_supplier.rs
index fade5b8..70136eb 100644
--- a/src/identity/bin/account_handler/src/auth_provider_supplier.rs
+++ b/src/identity/bin/account_handler/src/auth_provider_supplier.rs
@@ -42,19 +42,17 @@
             }
         };
 
-        FutureObj::new(Box::new(
-            async move {
-                match await!(self
-                    .account_handler_context
-                    .get_auth_provider(auth_provider_type, server_end))
-                {
-                    Ok(fidl_fuchsia_auth_account::Status::Ok) => Ok(client_end),
-                    Ok(stat) => Err(TokenManagerError::new(Status::AuthProviderServiceUnavailable)
-                        .with_cause(format_err!("AccountHandlerContext returned {:?}", stat))),
-                    Err(err) => Err(TokenManagerError::new(Status::UnknownError).with_cause(err)),
-                }
-            },
-        ))
+        FutureObj::new(Box::new(async move {
+            match await!(self
+                .account_handler_context
+                .get_auth_provider(auth_provider_type, server_end))
+            {
+                Ok(fidl_fuchsia_auth_account::Status::Ok) => Ok(client_end),
+                Ok(stat) => Err(TokenManagerError::new(Status::AuthProviderServiceUnavailable)
+                    .with_cause(format_err!("AccountHandlerContext returned {:?}", stat))),
+                Err(err) => Err(TokenManagerError::new(Status::UnknownError).with_cause(err)),
+            }
+        }))
     }
 }
 
@@ -80,20 +78,18 @@
     ) {
         let proxy = client_end.into_proxy().unwrap();
         let auth_provider_supplier = AuthProviderSupplier::new(proxy);
-        executor.run_singlethreaded(
-            async move {
-                let result = await!(auth_provider_supplier.get(TEST_AUTH_PROVIDER_TYPE));
-                match expected_error {
-                    Some(status) => {
-                        assert!(result.is_err());
-                        assert_eq!(status, result.unwrap_err().status);
-                    }
-                    None => {
-                        assert!(result.is_ok());
-                    }
+        executor.run_singlethreaded(async move {
+            let result = await!(auth_provider_supplier.get(TEST_AUTH_PROVIDER_TYPE));
+            match expected_error {
+                Some(status) => {
+                    assert!(result.is_err());
+                    assert_eq!(status, result.unwrap_err().status);
                 }
-            },
-        );
+                None => {
+                    assert!(result.is_ok());
+                }
+            }
+        });
     }
 
     /// Spawns a trivial task to respond to the first AccountHandlerContextRequest with the
@@ -102,22 +98,20 @@
         server_end: ServerEnd<AccountHandlerContextMarker>,
         status: fidl_fuchsia_auth_account::Status,
     ) {
-        fasync::spawn(
-            async move {
-                let mut request_stream = server_end.into_stream().unwrap();
-                // Only respond to the first received message, only when its of the intended type.
-                if let Ok(Some(AccountHandlerContextRequest::GetAuthProvider {
-                    auth_provider_type,
-                    auth_provider: _,
-                    responder,
-                })) = await!(request_stream.try_next())
-                {
-                    if auth_provider_type == TEST_AUTH_PROVIDER_TYPE {
-                        responder.send(status).expect("Failed to send test response");
-                    }
+        fasync::spawn(async move {
+            let mut request_stream = server_end.into_stream().unwrap();
+            // Only respond to the first received message, only when its of the intended type.
+            if let Ok(Some(AccountHandlerContextRequest::GetAuthProvider {
+                auth_provider_type,
+                auth_provider: _,
+                responder,
+            })) = await!(request_stream.try_next())
+            {
+                if auth_provider_type == TEST_AUTH_PROVIDER_TYPE {
+                    responder.send(status).expect("Failed to send test response");
                 }
-            },
-        );
+            }
+        });
     }
 
     #[test]
diff --git a/src/identity/bin/account_handler/src/main.rs b/src/identity/bin/account_handler/src/main.rs
index d807821..83a22c2 100644
--- a/src/identity/bin/account_handler/src/main.rs
+++ b/src/identity/bin/account_handler/src/main.rs
@@ -40,13 +40,10 @@
     let mut fs = ServiceFs::new();
     fs.dir("public").add_fidl_service(move |stream| {
         let account_handler_clone = Arc::clone(&account_handler);
-        fasync::spawn(
-            async move {
-                await!(account_handler_clone.handle_requests_from_stream(stream)).unwrap_or_else(
-                    |e| error!("Error handling AccountHandlerControl channel {:?}", e),
-                )
-            },
-        );
+        fasync::spawn(async move {
+            await!(account_handler_clone.handle_requests_from_stream(stream))
+                .unwrap_or_else(|e| error!("Error handling AccountHandlerControl channel {:?}", e))
+        });
     });
     fs.take_and_serve_directory_handle()?;
 
diff --git a/src/identity/bin/account_handler/src/persona.rs b/src/identity/bin/account_handler/src/persona.rs
index 4b1ca61..272e908 100644
--- a/src/identity/bin/account_handler/src/persona.rs
+++ b/src/identity/bin/account_handler/src/persona.rs
@@ -127,15 +127,11 @@
         };
         match token_manager_server_end.into_stream() {
             Ok(stream) => {
-                fasync::spawn(
-                    async move {
-                        await!(token_manager_clone
-                            .handle_requests_from_stream(&token_manager_context, stream))
-                        .unwrap_or_else(|err| {
-                            warn!("Error handling TokenManager channel {:?}", err)
-                        })
-                    },
-                );
+                fasync::spawn(async move {
+                    await!(token_manager_clone
+                        .handle_requests_from_stream(&token_manager_context, stream))
+                    .unwrap_or_else(|err| warn!("Error handling TokenManager channel {:?}", err))
+                });
                 Status::Ok
             }
             Err(err) => {
@@ -207,14 +203,10 @@
                 auth_ui_context_provider: ui_context_provider_client_end.into_proxy().unwrap(),
             };
 
-            fasync::spawn(
-                async move {
-                    await!(test_object.handle_requests_from_stream(&context, request_stream))
-                        .unwrap_or_else(|err| {
-                            panic!("Fatal error handling test request: {:?}", err)
-                        })
-                },
-            );
+            fasync::spawn(async move {
+                await!(test_object.handle_requests_from_stream(&context, request_stream))
+                    .unwrap_or_else(|err| panic!("Fatal error handling test request: {:?}", err))
+            });
 
             self.executor.run_singlethreaded(test_fn(persona_proxy)).expect("Executor run failed.")
         }
diff --git a/src/identity/bin/account_handler/src/test_util.rs b/src/identity/bin/account_handler/src/test_util.rs
index 055b217..e9884b5 100644
--- a/src/identity/bin/account_handler/src/test_util.rs
+++ b/src/identity/bin/account_handler/src/test_util.rs
@@ -101,12 +101,10 @@
     let (client_end, server_end) = create_endpoints().unwrap();
     let request_stream = server_end.into_stream().unwrap();
     let context_clone = Arc::clone(&context);
-    fasync::spawn(
-        async move {
-            await!(context_clone.handle_requests_from_stream(request_stream))
-                .unwrap_or_else(|err| error!("Error handling FakeAccountHandlerContext: {:?}", err))
-        },
-    );
+    fasync::spawn(async move {
+        await!(context_clone.handle_requests_from_stream(request_stream))
+            .unwrap_or_else(|err| error!("Error handling FakeAccountHandlerContext: {:?}", err))
+    });
     client_end
 }