Actually allow multiple producers to run

libraries/lib-cloud-audiocom/sync/MissingBlocksUploader.cpp

@@ -82,8 +82,6 @@ void MissingBlocksUploader::Cancel()
 
    mConsumerThread.join();
 
-   // mProgressMutex can be held by the consumer thread, so we need to wait
-   // until it's released.
    std::lock_guard lock(mProgressDataMutex);
 }
 
@@ -219,29 +217,38 @@ void MissingBlocksUploader::ProducerThread()
 {
    while (mIsRunning.load(std::memory_order_consume))
    {
-      std::lock_guard<std::mutex> lock(mBlocksMutex);
+      BlockUploadTask task;
 
-      if (mFirstUnprocessedBlockIndex >= mUploadTasks.size())
-         return;
+      {
+         std::lock_guard<std::mutex> lock(mBlocksMutex);
+
+         if (mFirstUnprocessedBlockIndex >= mUploadTasks.size())
+            return;
+
+         const auto index = mFirstUnprocessedBlockIndex++;
+         task = std::move(mUploadTasks[index]);
+      }
 
-      auto item = ProduceBlock();
+      auto compressedData = CompressBlock(task.Block);
 
-      if (item.CompressedData.empty())
+      if (compressedData.empty())
       {
          MissingBlocksUploadProgress progressData;
          {
             std::lock_guard<std::mutex> lock(mProgressDataMutex);
             mProgressData.FailedBlocks++;
             progressData = mProgressData;
          }
+
          mProgressCallback(
-            progressData, item.Task.Block,
+            progressData, task.Block,
             { SyncResultCode::InternalClientError, {} });
-
-         return;
       }
-
-      PushBlockToQueue(std::move(item));
+      else
+      {
+         PushBlockToQueue(
+            ProducedItem { std::move(task), std::move(compressedData) });
+      }
    }
 }