Make ProofBatch async to avoid blocking the ledger utility process

vendor/bat-native-ledger/src/bat_contribution.cc

@@ -11,6 +11,8 @@
 #include <utility>
 
 #include "anon/anon.h"
+#include "base/task/post_task.h"
+#include "base/task_runner_util.h"
 #include "bat_contribution.h"
 #include "ledger_impl.h"
 #include "rapidjson_bat_helper.h"
@@ -1130,7 +1132,7 @@ void BatContribution::PrepareBatchCallback(
 }
 
 void BatContribution::Proof() {
-  braveledger_bat_helper::BathProofs batch_proof;
+  braveledger_bat_helper::BatchProofs batch_proofs;
 
   braveledger_bat_helper::Transactions transactions =
     ledger_->GetTransactions();
@@ -1148,29 +1150,37 @@ void BatContribution::Proof() {
           braveledger_bat_helper::BATCH_PROOF batch_proof_el;
           batch_proof_el.transaction_ = transactions[k];
           batch_proof_el.ballot_ = ballots[i];
-          batch_proof.push_back(batch_proof_el);
+          batch_proofs.push_back(batch_proof_el);
         }
       }
     }
   }
 
-  ProofBatch(batch_proof);
+  base::PostTaskAndReplyWithResult(
+      ledger_->GetTaskRunner().get(),
+      FROM_HERE,
+      base::BindOnce(&BatContribution::ProofBatch,
+        base::Unretained(this),
+        batch_proofs),
+      base::BindOnce(&BatContribution::ProofBatchCallback,
+        base::Unretained(this),
+        batch_proofs));
 }
 
-void BatContribution::ProofBatch(
-    const braveledger_bat_helper::BathProofs& batch_proof) {
+std::vector<std::string> BatContribution::ProofBatch(
+    const braveledger_bat_helper::BatchProofs& batch_proofs) {
   std::vector<std::string> proofs;
 
-  for (size_t i = 0; i < batch_proof.size(); i++) {
+  for (size_t i = 0; i < batch_proofs.size(); i++) {
     braveledger_bat_helper::SURVEYOR_ST surveyor;
     bool success = braveledger_bat_helper::loadFromJson(
         surveyor,
-        batch_proof[i].ballot_.prepareBallot_);
+        batch_proofs[i].ballot_.prepareBallot_);
 
     if (!success) {
       BLOG(ledger_, ledger::LogLevel::LOG_ERROR) <<
         "Failed to load surveyor state: " <<
-        batch_proof[i].ballot_.prepareBallot_;
+        batch_proofs[i].ballot_.prepareBallot_;
       continue;
     }
 
@@ -1190,13 +1200,13 @@ void BatContribution::ProofBatch(
     }
 
     std::string msg_key[1] = {"publisher"};
-    std::string msg_value[1] = {batch_proof[i].ballot_.publisher_};
+    std::string msg_value[1] = {batch_proofs[i].ballot_.publisher_};
     std::string msg = braveledger_bat_helper::stringify(msg_key, msg_value, 1);
 
     const char* proof = submitMessage(
         msg.c_str(),
-        batch_proof[i].transaction_.masterUserToken_.c_str(),
-        batch_proof[i].transaction_.registrarVK_.c_str(),
+        batch_proofs[i].transaction_.masterUserToken_.c_str(),
+        batch_proofs[i].transaction_.registrarVK_.c_str(),
         signature_to_send.c_str(),
         surveyor.surveyorId_.c_str(),
         surveyor.surveyVK_.c_str());
@@ -1210,19 +1220,25 @@ void BatContribution::ProofBatch(
     proofs.push_back(annon_proof);
   }
 
+  return proofs;
+}
+
+void BatContribution::ProofBatchCallback(
+    const braveledger_bat_helper::BatchProofs& batch_proofs,
+    const std::vector<std::string>& proofs) {
   braveledger_bat_helper::Ballots ballots = ledger_->GetBallots();
 
-  for (size_t i = 0; i < batch_proof.size(); i++) {
+  for (size_t i = 0; i < batch_proofs.size(); i++) {
     for (size_t j = 0; j < ballots.size(); j++) {
-      if (ballots[j].surveyorId_ == batch_proof[i].ballot_.surveyorId_) {
+      if (ballots[j].surveyorId_ == batch_proofs[i].ballot_.surveyorId_) {
         ballots[j].proofBallot_ = proofs[i];
       }
     }
   }
 
   ledger_->SetBallots(ballots);
 
-  if (batch_proof.size() != proofs.size()) {
+  if (batch_proofs.size() != proofs.size()) {
     AddRetry(braveledger_bat_helper::ContributionRetry::STEP_PROOF, "");
     return;
   }

vendor/bat-native-ledger/src/bat_contribution.h

@@ -63,12 +63,13 @@
 // 5. PrepareBatch
 // 6. PrepareBatchCallback
 // 7. ProofBatch
-// 8. SetTimer
-// 9. PrepareVoteBatch
-// 10. SetTimer
-// 11. VoteBatch
-// 12. VoteBatchCallback
-// 13. SetTimer - we set timer until the whole batch is processed
+// 8. ProofBatchCallback
+// 9. SetTimer
+// 10. PrepareVoteBatch
+// 12. SetTimer
+// 12. VoteBatch
+// 13. VoteBatchCallback
+// 14. SetTimer - we set timer until the whole batch is processed
 
 namespace bat_ledger {
 class LedgerImpl;
@@ -243,8 +244,11 @@ class BatContribution {
 
   void Proof();
 
-  void ProofBatch(
-      const braveledger_bat_helper::BathProofs& batch_proof);
+  std::vector<std::string> ProofBatch(
+      const braveledger_bat_helper::BatchProofs& batch_proofs);
+  void ProofBatchCallback(
+      const braveledger_bat_helper::BatchProofs& batch_proofs,
+      const std::vector<std::string>& proofs);
 
   void PrepareVoteBatch();
 

vendor/bat-native-ledger/src/bat_helper.h

@@ -425,7 +425,7 @@ struct BATCH_PROOF {
   BALLOT_ST ballot_;
 };
 
-typedef std::vector<braveledger_bat_helper::BATCH_PROOF> BathProofs;
+typedef std::vector<braveledger_bat_helper::BATCH_PROOF> BatchProofs;
 
 enum class SERVER_TYPES {
   LEDGER,

vendor/bat-native-ledger/src/ledger_impl.cc

@@ -12,6 +12,7 @@
 
 #include "ledger_impl.h"
 
+#include "base/task/post_task.h"
 #include "bat/ads/issuers_info.h"
 #include "bat/ads/notification_info.h"
 #include "bat/confirmations/confirmations.h"
@@ -45,6 +46,9 @@ LedgerImpl::LedgerImpl(ledger::LedgerClient* client) :
     bat_get_media_(new BatGetMedia(this)),
     bat_state_(new BatState(this)),
     bat_contribution_(new BatContribution(this)),
+    task_runner_(base::CreateSequencedTaskRunnerWithTraits({
+          base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+          base::TaskShutdownBehavior::BLOCK_SHUTDOWN})),
     initialized_(false),
     initializing_(false),
     last_tab_active_time_(0),
@@ -1294,4 +1298,8 @@ void LedgerImpl::GetConfirmationsHistory(
       to_timestamp_seconds, callback);
 }
 
+scoped_refptr<base::SequencedTaskRunner> LedgerImpl::GetTaskRunner() {
+  return task_runner_;
+}
+
 }  // namespace bat_ledger

vendor/bat-native-ledger/src/ledger_impl.h

@@ -12,13 +12,18 @@
 #include <fstream>
 #include <vector>
 
+#include "base/memory/scoped_refptr.h"
 #include "bat/confirmations/confirmations_client.h"
 #include "bat/ledger/ledger.h"
 #include "bat/ledger/ledger_callback_handler.h"
 #include "bat/ledger/ledger_client.h"
 #include "bat_helper.h"
 #include "logging.h"
 
+namespace base {
+class SequencedTaskRunner;
+}
+
 namespace braveledger_bat_client {
 class BatClient;
 }
@@ -430,6 +435,8 @@ class LedgerImpl : public ledger::Ledger,
       const int line,
       const ledger::LogLevel log_level) const;
 
+  scoped_refptr<base::SequencedTaskRunner> GetTaskRunner();
+
  private:
   void AddRecurringPayment(const std::string& publisher_id,
                            const double& value) override;
@@ -501,6 +508,7 @@ class LedgerImpl : public ledger::Ledger,
   std::unique_ptr<braveledger_bat_contribution::BatContribution>
   bat_contribution_;
   std::unique_ptr<confirmations::Confirmations> bat_confirmations_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   bool initialized_;
   bool initializing_;

vendor/bat-native-ledger/src/logging.h

@@ -12,11 +12,6 @@
 #define BVLOG(client, severity) \
   client->LogVerbose(__FILE__, __LINE__, severity)->stream()
 
-#endif  // BAT_REWARDS_LOGGING_H_
+#include "base/logging.h"
 
-#if defined(NDEBUG)
-#define DCHECK(x) (void)(x)
-#else
-#include "assert.h"
-#define DCHECK(x) assert(x)
-#endif
+#endif  // BAT_REWARDS_LOGGING_H_