Perform decryptions inline.

app/src/androidTest/java/org/thoughtcrime/securesms/SignalInstrumentationApplicationContext.kt

@@ -22,6 +22,7 @@ class SignalInstrumentationApplicationContext : ApplicationContext() {
   override fun initializeAppDependencies() {
     val default = ApplicationDependencyProvider(this)
     ApplicationDependencies.init(this, InstrumentationApplicationDependencyProvider(this, default))
+    ApplicationDependencies.getDeadlockDetector().start()
   }
 
   override fun initializeLogging() {

app/src/androidTest/java/org/thoughtcrime/securesms/messages/MessageProcessingPerformanceTest.kt

@@ -22,7 +22,7 @@ import org.thoughtcrime.securesms.testing.Entry
 import org.thoughtcrime.securesms.testing.FakeClientHelpers
 import org.thoughtcrime.securesms.testing.SignalActivityRule
 import org.thoughtcrime.securesms.testing.awaitFor
-import org.whispersystems.signalservice.api.messages.SignalServiceEnvelope
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos.Envelope
 import kotlin.time.Duration.Companion.minutes
 import kotlin.time.Duration.Companion.seconds
 
@@ -86,16 +86,17 @@ class MessageProcessingPerformanceTest {
       .inMemoryLogger
       .getLockForUntil(TimingMessageContentProcessor.endTagPredicate(firstPreKeyMessageTimestamp))
 
-    Thread { aliceClient.process(encryptedEnvelope) }.start()
+    Thread { aliceClient.process(encryptedEnvelope, System.currentTimeMillis()) }.start()
     aliceProcessFirstMessageLatch.awaitFor(15.seconds)
 
     // Send message from Alice to Bob
-    bobClient.decrypt(aliceClient.encrypt(System.currentTimeMillis(), bob))
+    val aliceNow = System.currentTimeMillis()
+    bobClient.decrypt(aliceClient.encrypt(aliceNow, bob), aliceNow)
 
     // Build N messages from Bob to Alice
 
     val messageCount = 100
-    val envelopes = ArrayList<SignalServiceEnvelope>(messageCount)
+    val envelopes = ArrayList<Envelope>(messageCount)
     var now = System.currentTimeMillis()
     for (i in 0..messageCount) {
       envelopes += bobClient.encrypt(now)
@@ -114,7 +115,7 @@ class MessageProcessingPerformanceTest {
     Thread {
       for (envelope in envelopes) {
         Log.i(TIMING_TAG, "Retrieved envelope! ${envelope.timestamp}")
-        aliceClient.process(envelope)
+        aliceClient.process(envelope, envelope.timestamp)
       }
     }.start()
 
@@ -125,41 +126,6 @@ class MessageProcessingPerformanceTest {
     // Process logs for timing data
     val entries = harness.inMemoryLogger.entries()
 
-    // Calculate decrypt jobs
-    var skipFirst = true
-    var decryptJobCount = 0L
-    var decryptJobDuration = 0L
-    var decryptJobSinceSubmission = 0L
-    var firstDuration = 0L
-    var firstSinceSubmission = 0L
-    entries.filter { it.tag == "JobRunner" }
-      .forEach {
-        val match = jobFinishRegex.matchEntire(it.message!!)
-
-        if (match != null) {
-          val job = match.groupValues[1]
-          if (job == "PushDecryptMessageJob") {
-            if (skipFirst) {
-              skipFirst = false
-            } else {
-              val duration = match.groupValues[2].toLong()
-              val sinceSubmission = match.groupValues[3].toLong()
-              decryptJobCount++
-              decryptJobDuration += duration
-              decryptJobSinceSubmission += sinceSubmission
-
-              if (decryptJobCount == 1L) {
-                firstDuration = duration
-                firstSinceSubmission = sinceSubmission
-              }
-            }
-          }
-        }
-      }
-
-    android.util.Log.w(TAG, "Push Decrypt Job: First runtime ${firstDuration}ms First since submission: ${firstSinceSubmission}ms")
-    android.util.Log.w(TAG, "Push Decrypt Job: Average runtime: ${decryptJobDuration.toFloat() / decryptJobCount.toFloat()}ms Average since submission: ${decryptJobSinceSubmission.toFloat() / decryptJobCount.toFloat()}ms")
-
     // Calculate MessageContentProcessor
 
     val takeLast: List<Entry> = entries.filter { it.tag == TimingMessageContentProcessor.TAG }.drop(2)

app/src/androidTest/java/org/thoughtcrime/securesms/testing/AliceClient.kt

@@ -6,10 +6,10 @@ import org.thoughtcrime.securesms.crypto.ProfileKeyUtil
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
 import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.recipients.Recipient
-import org.thoughtcrime.securesms.testing.FakeClientHelpers.toSignalServiceEnvelope
-import org.whispersystems.signalservice.api.messages.SignalServiceEnvelope
+import org.thoughtcrime.securesms.testing.FakeClientHelpers.toEnvelope
 import org.whispersystems.signalservice.api.push.ServiceId
 import org.whispersystems.signalservice.api.push.SignalServiceAddress
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos.Envelope
 
 /**
  * Welcome to Alice's Client.
@@ -28,17 +28,17 @@ class AliceClient(val serviceId: ServiceId, val e164: String, val trustRoot: ECK
     expires = 31337
   )
 
-  fun process(envelope: SignalServiceEnvelope) {
-    ApplicationDependencies.getIncomingMessageProcessor().acquire().use { processor -> processor.processEnvelope(envelope) }
+  fun process(envelope: Envelope, serverDeliveredTimestamp: Long) {
+    ApplicationDependencies.getIncomingMessageObserver().processEnvelope(envelope, serverDeliveredTimestamp)
   }
 
-  fun encrypt(now: Long, destination: Recipient): SignalServiceEnvelope {
+  fun encrypt(now: Long, destination: Recipient): Envelope {
     return ApplicationDependencies.getSignalServiceMessageSender().getEncryptedMessage(
       SignalServiceAddress(destination.requireServiceId(), destination.requireE164()),
       FakeClientHelpers.getTargetUnidentifiedAccess(ProfileKeyUtil.getSelfProfileKey(), ProfileKey(destination.profileKey), aliceSenderCertificate),
       1,
       FakeClientHelpers.encryptedTextMessage(now),
       false
-    ).toSignalServiceEnvelope(now, destination.requireServiceId())
+    ).toEnvelope(now, destination.requireServiceId())
   }
 }

app/src/androidTest/java/org/thoughtcrime/securesms/testing/BobClient.kt

@@ -21,16 +21,16 @@ import org.thoughtcrime.securesms.database.OneTimePreKeyTable
 import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.database.SignedPreKeyTable
 import org.thoughtcrime.securesms.keyvalue.SignalStore
-import org.thoughtcrime.securesms.testing.FakeClientHelpers.toSignalServiceEnvelope
+import org.thoughtcrime.securesms.testing.FakeClientHelpers.toEnvelope
 import org.whispersystems.signalservice.api.SignalServiceAccountDataStore
 import org.whispersystems.signalservice.api.SignalSessionLock
 import org.whispersystems.signalservice.api.crypto.SignalServiceCipher
 import org.whispersystems.signalservice.api.crypto.SignalSessionBuilder
 import org.whispersystems.signalservice.api.crypto.UnidentifiedAccess
-import org.whispersystems.signalservice.api.messages.SignalServiceEnvelope
 import org.whispersystems.signalservice.api.push.DistributionId
 import org.whispersystems.signalservice.api.push.ServiceId
 import org.whispersystems.signalservice.api.push.SignalServiceAddress
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos
 import java.util.Optional
 import java.util.UUID
 import java.util.concurrent.locks.ReentrantLock
@@ -59,7 +59,7 @@ class BobClient(val serviceId: ServiceId, val e164: String, val identityKeyPair:
   }
 
   /** Inspired by SignalServiceMessageSender#getEncryptedMessage */
-  fun encrypt(now: Long): SignalServiceEnvelope {
+  fun encrypt(now: Long): SignalServiceProtos.Envelope {
     val envelopeContent = FakeClientHelpers.encryptedTextMessage(now)
 
     val cipher = SignalServiceCipher(serviceAddress, 1, aciStore, sessionLock, null)
@@ -70,12 +70,12 @@ class BobClient(val serviceId: ServiceId, val e164: String, val identityKeyPair:
     }
 
     return cipher.encrypt(getAliceProtocolAddress(), getAliceUnidentifiedAccess(), envelopeContent)
-      .toSignalServiceEnvelope(envelopeContent.content.get().dataMessage.timestamp, getAliceServiceId())
+      .toEnvelope(envelopeContent.content.get().dataMessage.timestamp, getAliceServiceId())
   }
 
-  fun decrypt(envelope: SignalServiceEnvelope) {
+  fun decrypt(envelope: SignalServiceProtos.Envelope, serverDeliveredTimestamp: Long) {
     val cipher = SignalServiceCipher(serviceAddress, 1, aciStore, sessionLock, UnidentifiedAccessUtil.getCertificateValidator())
-    cipher.decrypt(envelope)
+    cipher.decrypt(envelope, serverDeliveredTimestamp)
   }
 
   private fun getAliceServiceId(): ServiceId {

app/src/androidTest/java/org/thoughtcrime/securesms/testing/FakeClientHelpers.kt

@@ -9,14 +9,15 @@ import org.signal.libsignal.protocol.ecc.Curve
 import org.signal.libsignal.protocol.ecc.ECKeyPair
 import org.signal.libsignal.protocol.ecc.ECPublicKey
 import org.signal.libsignal.zkgroup.profiles.ProfileKey
+import org.thoughtcrime.securesms.database.model.toProtoByteString
 import org.whispersystems.signalservice.api.crypto.ContentHint
 import org.whispersystems.signalservice.api.crypto.EnvelopeContent
 import org.whispersystems.signalservice.api.crypto.UnidentifiedAccess
 import org.whispersystems.signalservice.api.crypto.UnidentifiedAccessPair
-import org.whispersystems.signalservice.api.messages.SignalServiceEnvelope
 import org.whispersystems.signalservice.api.push.ServiceId
 import org.whispersystems.signalservice.internal.push.OutgoingPushMessage
 import org.whispersystems.signalservice.internal.push.SignalServiceProtos
+import org.whispersystems.signalservice.internal.push.SignalServiceProtos.Envelope
 import org.whispersystems.util.Base64
 import java.util.Optional
 import java.util.UUID
@@ -62,20 +63,17 @@ object FakeClientHelpers {
     return EnvelopeContent.encrypted(content.build(), ContentHint.RESENDABLE, Optional.empty())
   }
 
-  fun OutgoingPushMessage.toSignalServiceEnvelope(timestamp: Long, destination: ServiceId): SignalServiceEnvelope {
-    return SignalServiceEnvelope(
-      this.type,
-      Optional.empty(),
-      1,
-      timestamp,
-      Base64.decode(this.content),
-      timestamp + 1,
-      timestamp + 2,
-      UUID.randomUUID().toString(),
-      destination.toString(),
-      true,
-      false,
-      null
-    )
+  fun OutgoingPushMessage.toEnvelope(timestamp: Long, destination: ServiceId): Envelope {
+    return Envelope.newBuilder()
+      .setType(Envelope.Type.valueOf(this.type))
+      .setSourceDevice(1)
+      .setTimestamp(timestamp)
+      .setServerTimestamp(timestamp + 1)
+      .setDestinationUuid(destination.toString())
+      .setServerGuid(UUID.randomUUID().toString())
+      .setContent(Base64.decode(this.content).toProtoByteString())
+      .setUrgent(true)
+      .setStory(false)
+      .build()
   }
 }