Refactor onSentMessage and onMessageReceived

Since they are so similar, we create the handlers using new
`createMessageHandler` function. This allows us to ensure both synced and
received messages go through schema upgrade pipeline.

js/background.js

@@ -497,63 +497,73 @@
 
   /* eslint-enable */
   /* jshint ignore:start */
-  async function onMessageReceived(ev) {
+  function createMessageHandler(
-    const { data } = ev;
+    { createMessage, getMessageDescriptor, handleProfileUpdate }
+  ) {
+    return async (event) => {
+      const { data, confirm } = event;
 
+      const messageDescriptor = getMessageDescriptor(data);
+
+      const isProfileUpdate = Boolean(
         // eslint-disable-next-line no-bitwise
-    if (data.message.flags & textsecure.protobuf.DataMessage.Flags.PROFILE_KEY_UPDATE) {
+        data.message.flags & textsecure.protobuf.DataMessage.Flags.PROFILE_KEY_UPDATE
-      const profileKey = data.message.profileKey.toArrayBuffer();
+      );
-      const sender =
+      if (isProfileUpdate) {
-        await ConversationController.getOrCreateAndWait(data.source, 'private');
+        return handleProfileUpdate({ data, confirm, messageDescriptor });
-      await sender.setProfileKey(profileKey);
-      return ev.confirm();
       }
 
-    const message = initIncomingMessage(data);
+      const message = createMessage(data);
       const isDuplicate = await isMessageDuplicate(message);
-
       if (isDuplicate) {
         console.log('Received duplicate message', message.idForLogging());
-      // TODO: Is `ev.confirm` a `Promise`? Original code didn’t return it:
+        return event.confirm();
-      return ev.confirm();
       }
 
-    const { type, id } = data.message.group
-      ? { type: 'group', id: data.message.group.id }
-      : { type: 'private', id: data.source };
-
       const upgradedMessage = await Message.upgradeSchema(data.message);
-
+      await ConversationController.getOrCreateAndWait(
-    await ConversationController.getOrCreateAndWait(id, type);
+        messageDescriptor.id, messageDescriptor.type
+      );
       return message.handleDataMessage(
         upgradedMessage,
-      ev.confirm,
+        event.confirm,
         { initialLoadComplete }
       );
-  }
+    };
-  /* jshint ignore:end */
-  /* eslint-disable */
-
-    function onSentMessage(ev) {
-        var now = new Date().getTime();
-        var data = ev.data;
-
-        var type, id;
-        if (data.message.group) {
-            type = 'group';
-            id = data.message.group.id;
-        } else {
-            type = 'private';
-            id = data.destination;
   }
 
-        if (data.message.flags & textsecure.protobuf.DataMessage.Flags.PROFILE_KEY_UPDATE) {
+  // Received:
-            return ConversationController.getOrCreateAndWait(id, type).then(function(convo) {
+  async function handleMessageReceivedProfileUpdate(
-              return convo.save({profileSharing: true}).then(ev.confirm);
+    { data, confirm, messageDescriptor }
+  ) {
+    const profileKey = data.message.profileKey.toArrayBuffer();
+    const sender = await ConversationController.getOrCreateAndWait(
+      messageDescriptor.source, 'private'
+    );
+    await sender.setProfileKey(profileKey);
+    return confirm();
+  }
+
+  const onMessageReceived = createMessageHandler({
+    handleProfileUpdate: handleMessageReceivedProfileUpdate,
+    getMessageDescriptor: Message.getDescriptorForReceived,
+    createMessage: initIncomingMessage,
   });
+
+  // Sent:
+  async function handleMessageSentProfileUpdate(
+    { confirm, messageDescriptor }
+  ) {
+    const conversation = await ConversationController.getOrCreateAndWait(
+      messageDescriptor.id, messageDescriptor.type
+    );
+    await conversation.save({ profileSharing: true });
+    return confirm();
   }
 
-        var message = new Whisper.Message({
+  function createSentMessage(data) {
+    const now = Date.now();
+    return new Whisper.Message({
       source: textsecure.storage.user.getNumber(),
       sourceDevice: data.device,
       sent_at: data.timestamp,
@@ -563,21 +573,15 @@
       sent: true,
       expirationStartTimestamp: data.expirationStartTimestamp,
     });
-
-        return isMessageDuplicate(message).then(function(isDuplicate) {
-            if (isDuplicate) {
-                console.log('Received duplicate message', message.idForLogging());
-                ev.confirm();
-                return;
   }
 
-            return ConversationController.getOrCreateAndWait(id, type).then(function() {
+  const onSentMessage = createMessageHandler({
-                return message.handleDataMessage(data.message, ev.confirm, {
+    handleProfileUpdate: handleMessageSentProfileUpdate,
-                    initialLoadComplete: initialLoadComplete
+    getMessageDescriptor: Message.getDescriptorForSent,
+    createMessage: createSentMessage,
   });
-            });
+  /* jshint ignore:end */
-        });
+  /* eslint-disable */
-    }
 
     function isMessageDuplicate(message) {
         return new Promise(function(resolve) {