Replace workaround with proper ContinueWith syntax

Author: Trolldemorted

Signal-Windows.Lib/IncomingMessages.cs

@@ -39,25 +39,27 @@ public IncomingMessages(CancellationToken token, Task<SignalServiceMessagePipe>
         public async Task HandleIncomingMessages()
         {
             Logger.LogDebug("HandleIncomingMessages()");
-            var pipe = await PipeTask;
-            await Task.Delay(1);
-            while (!Token.IsCancellationRequested)
+            await PipeTask.ContinueWith(async _ =>
             {
-                try
+                var pipe = await PipeTask;
+                while (!Token.IsCancellationRequested)
                 {
-                    await pipe.ReadBlocking(this);
-                }
-                catch (OperationCanceledException)
-                {
-                    break;
-                }
-                catch (Exception e)
-                {
-                    var line = new StackTrace(e, true).GetFrames()[0].GetFileLineNumber();
-                    Logger.LogWarning("HandleIncomingMessages() failed: {0} occured ({1}):\n{2}", e.GetType(), e.Message, e.StackTrace);
+                    try
+                    {
+                        await pipe.ReadBlocking(this);
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        break;
+                    }
+                    catch (Exception e)
+                    {
+                        var line = new StackTrace(e, true).GetFrames()[0].GetFileLineNumber();
+                        Logger.LogWarning("HandleIncomingMessages() failed: {0} occured ({1}):\n{2}", e.GetType(), e.Message, e.StackTrace);
+                    }
                 }
-            }
-            Logger.LogInformation("HandleIncomingMessages() finished");
+                Logger.LogInformation("HandleIncomingMessages() finished");
+            }, TaskContinuationOptions.RunContinuationsAsynchronously);
         }
 
         public async Task OnMessage(SignalServiceMessagePipeMessage message)

Signal-Windows.Lib/OutgoingMessages.cs

@@ -161,56 +161,58 @@ public async Task HandleOutgoingMessages()
             Logger.LogDebug("HandleOutgoingMessages()");
             try
             {
-                var pipe = await CreatePipeTask;
-                await Task.Delay(1);
-                var messageSender = new SignalServiceMessageSender(Token, LibUtils.ServiceConfiguration, Store.Username, Store.Password, (int)Store.DeviceId, new Store(), pipe, null, LibUtils.USER_AGENT);
-                while (!Token.IsCancellationRequested)
+                await CreatePipeTask.ContinueWith(async _ =>
                 {
-                    ISendable sendable = null;
-                    try
-                    {
-                        sendable = Handle.OutgoingQueue.Take(Token);
-                        Logger.LogTrace($"Sending {sendable.GetType()}");
-                        await sendable.Send(messageSender, Token);
-                    }
-                    catch (OperationCanceledException) { return; }
-                    catch (EncapsulatedExceptions exceptions)
+                    var pipe = await CreatePipeTask;
+                    var messageSender = new SignalServiceMessageSender(Token, LibUtils.ServiceConfiguration, Store.Username, Store.Password, (int)Store.DeviceId, new Store(), pipe, null, LibUtils.USER_AGENT);
+                    while (!Token.IsCancellationRequested)
                     {
-                        sendable.Status = SignalMessageStatus.Confirmed;
-                        Logger.LogError("HandleOutgoingMessages() encountered libsignal exceptions");
-                        IList<UntrustedIdentityException> identityExceptions = exceptions.UntrustedIdentityExceptions;
-                        if (exceptions.NetworkExceptions.Count > 0)
+                        ISendable sendable = null;
+                        try
                         {
-                            sendable.Status = SignalMessageStatus.Failed_Network;
+                            sendable = Handle.OutgoingQueue.Take(Token);
+                            Logger.LogTrace($"Sending {sendable.GetType()}");
+                            await sendable.Send(messageSender, Token);
                         }
-                        if (identityExceptions.Count > 0)
+                        catch (OperationCanceledException) { return; }
+                        catch (EncapsulatedExceptions exceptions)
                         {
-                            sendable.Status = SignalMessageStatus.Failed_Identity;
+                            sendable.Status = SignalMessageStatus.Confirmed;
+                            Logger.LogError("HandleOutgoingMessages() encountered libsignal exceptions");
+                            IList<UntrustedIdentityException> identityExceptions = exceptions.UntrustedIdentityExceptions;
+                            if (exceptions.NetworkExceptions.Count > 0)
+                            {
+                                sendable.Status = SignalMessageStatus.Failed_Network;
+                            }
+                            if (identityExceptions.Count > 0)
+                            {
+                                sendable.Status = SignalMessageStatus.Failed_Identity;
+                            }
+                            foreach (UntrustedIdentityException e in identityExceptions)
+                            {
+                                await Handle.HandleOutgoingKeyChangeLocked(e.E164number, Base64.EncodeBytes(e.IdentityKey.serialize()));
+                            }
                         }
-                        foreach (UntrustedIdentityException e in identityExceptions)
+                        catch (RateLimitException)
                         {
+                            Logger.LogError("HandleOutgoingMessages() could not send due to rate limits");
+                            sendable.Status = SignalMessageStatus.Failed_Ratelimit;
+                        }
+                        catch (UntrustedIdentityException e)
+                        {
+                            Logger.LogError("HandleOutgoingMessages() could not send due to untrusted identities");
+                            sendable.Status = SignalMessageStatus.Failed_Identity;
                             await Handle.HandleOutgoingKeyChangeLocked(e.E164number, Base64.EncodeBytes(e.IdentityKey.serialize()));
                         }
+                        catch (Exception e)
+                        {
+                            var line = new StackTrace(e, true).GetFrames()[0].GetFileLineNumber();
+                            Logger.LogError("HandleOutgoingMessages() failed in line {0}: {1}\n{2}", line, e.Message, e.StackTrace);
+                            sendable.Status = SignalMessageStatus.Failed_Unknown;
+                        }
+                        await Handle.HandleMessageSentLocked(sendable);
                     }
-                    catch (RateLimitException)
-                    {
-                        Logger.LogError("HandleOutgoingMessages() could not send due to rate limits");
-                        sendable.Status = SignalMessageStatus.Failed_Ratelimit;
-                    }
-                    catch (UntrustedIdentityException e)
-                    {
-                        Logger.LogError("HandleOutgoingMessages() could not send due to untrusted identities");
-                        sendable.Status = SignalMessageStatus.Failed_Identity;
-                        await Handle.HandleOutgoingKeyChangeLocked(e.E164number, Base64.EncodeBytes(e.IdentityKey.serialize()));
-                    }
-                    catch (Exception e)
-                    {
-                        var line = new StackTrace(e, true).GetFrames()[0].GetFileLineNumber();
-                        Logger.LogError("HandleOutgoingMessages() failed in line {0}: {1}\n{2}", line, e.Message, e.StackTrace);
-                        sendable.Status = SignalMessageStatus.Failed_Unknown;
-                    }
-                    await Handle.HandleMessageSentLocked(sendable);
-                }
+                }, TaskContinuationOptions.RunContinuationsAsynchronously);
             }
             catch (OperationCanceledException) { }
             catch (Exception e)