qt: Assert QMetaObject::invokeMethod result

promag · promag · commit 64fee489448c · 2019-07-08T21:30:25.000+01:00
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
@@ -1375,12 +1375,13 @@ static bool ThreadSafeMessageBox(BitcoinGUI* gui, const std::string& message, co
     style &= ~CClientUIInterface::SECURE;
     bool ret = false;
     // In case of modal message, use blocking connection to wait for user to click a button
-    QMetaObject::invokeMethod(gui, "message",
+    bool invoked = QMetaObject::invokeMethod(gui, "message",
                                modal ? GUIUtil::blockingGUIThreadConnection() : Qt::QueuedConnection,
                                Q_ARG(QString, QString::fromStdString(caption)),
                                Q_ARG(QString, QString::fromStdString(message)),
                                Q_ARG(unsigned int, style),
                                Q_ARG(bool*, &ret));
+    assert(invoked);
     return ret;
 }
 
diff --git a/src/qt/clientmodel.cpp b/src/qt/clientmodel.cpp
@@ -184,34 +184,39 @@ void ClientModel::updateBanlist()
 static void ShowProgress(ClientModel *clientmodel, const std::string &title, int nProgress)
 {
     // emits signal "showProgress"
-    QMetaObject::invokeMethod(clientmodel, "showProgress", Qt::QueuedConnection,
+    bool invoked = QMetaObject::invokeMethod(clientmodel, "showProgress", Qt::QueuedConnection,
                               Q_ARG(QString, QString::fromStdString(title)),
                               Q_ARG(int, nProgress));
+    assert(invoked);
 }
 
 static void NotifyNumConnectionsChanged(ClientModel *clientmodel, int newNumConnections)
 {
     // Too noisy: qDebug() << "NotifyNumConnectionsChanged: " + QString::number(newNumConnections);
-    QMetaObject::invokeMethod(clientmodel, "updateNumConnections", Qt::QueuedConnection,
+    bool invoked = QMetaObject::invokeMethod(clientmodel, "updateNumConnections", Qt::QueuedConnection,
                               Q_ARG(int, newNumConnections));
+    assert(invoked);
 }
 
 static void NotifyNetworkActiveChanged(ClientModel *clientmodel, bool networkActive)
 {
-    QMetaObject::invokeMethod(clientmodel, "updateNetworkActive", Qt::QueuedConnection,
+    bool invoked = QMetaObject::invokeMethod(clientmodel, "updateNetworkActive", Qt::QueuedConnection,
                               Q_ARG(bool, networkActive));
+    assert(invoked);
 }
 
 static void NotifyAlertChanged(ClientModel *clientmodel)
 {
     qDebug() << "NotifyAlertChanged";
-    QMetaObject::invokeMethod(clientmodel, "updateAlert", Qt::QueuedConnection);
+    bool invoked = QMetaObject::invokeMethod(clientmodel, "updateAlert", Qt::QueuedConnection);
+    assert(invoked);
 }
 
 static void BannedListChanged(ClientModel *clientmodel)
 {
     qDebug() << QString("%1: Requesting update for peer banlist").arg(__func__);
-    QMetaObject::invokeMethod(clientmodel, "updateBanlist", Qt::QueuedConnection);
+    bool invoked = QMetaObject::invokeMethod(clientmodel, "updateBanlist", Qt::QueuedConnection);
+    assert(invoked);
 }
 
 static void BlockTipChanged(ClientModel *clientmodel, bool initialSync, int height, int64_t blockTime, double verificationProgress, bool fHeader)
@@ -233,11 +238,12 @@ static void BlockTipChanged(ClientModel *clientmodel, bool initialSync, int heig
     // if we are in-sync or if we notify a header update, update the UI regardless of last update time
     if (fHeader || !initialSync || now - nLastUpdateNotification > MODEL_UPDATE_DELAY) {
         //pass an async signal to the UI thread
-        QMetaObject::invokeMethod(clientmodel, "numBlocksChanged", Qt::QueuedConnection,
+        bool invoked = QMetaObject::invokeMethod(clientmodel, "numBlocksChanged", Qt::QueuedConnection,
                                   Q_ARG(int, height),
                                   Q_ARG(QDateTime, QDateTime::fromTime_t(blockTime)),
                                   Q_ARG(double, verificationProgress),
                                   Q_ARG(bool, fHeader));
+        assert(invoked);
         nLastUpdateNotification = now;
     }
 }
diff --git a/src/qt/splashscreen.cpp b/src/qt/splashscreen.cpp
@@ -156,11 +156,12 @@ void SplashScreen::finish()
 
 static void InitMessage(SplashScreen *splash, const std::string &message)
 {
-    QMetaObject::invokeMethod(splash, "showMessage",
+    bool invoked = QMetaObject::invokeMethod(splash, "showMessage",
         Qt::QueuedConnection,
         Q_ARG(QString, QString::fromStdString(message)),
         Q_ARG(int, Qt::AlignBottom|Qt::AlignHCenter),
         Q_ARG(QColor, QColor(55,55,55)));
+    assert(invoked);
 }
 
 static void ShowProgress(SplashScreen *splash, const std::string &title, int nProgress, bool resume_possible)
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
@@ -68,7 +68,8 @@ uint256 SendCoins(CWallet& wallet, SendCoinsDialog& sendCoinsDialog, const CTxDe
         if (status == CT_NEW) txid = hash;
     }));
     ConfirmSend();
-    QMetaObject::invokeMethod(&sendCoinsDialog, "on_sendButton_clicked");
+    bool invoked = QMetaObject::invokeMethod(&sendCoinsDialog, "on_sendButton_clicked");
+    assert(invoked);
     return txid;
 }
 
diff --git a/src/qt/transactiontablemodel.cpp b/src/qt/transactiontablemodel.cpp
@@ -687,10 +687,11 @@ struct TransactionNotification
     {
         QString strHash = QString::fromStdString(hash.GetHex());
         qDebug() << "NotifyTransactionChanged: " + strHash + " status= " + QString::number(status);
-        QMetaObject::invokeMethod(ttm, "updateTransaction", Qt::QueuedConnection,
+        bool invoked = QMetaObject::invokeMethod(ttm, "updateTransaction", Qt::QueuedConnection,
                                   Q_ARG(QString, strHash),
                                   Q_ARG(int, status),
                                   Q_ARG(bool, showTransaction));
+        assert(invoked);
     }
 private:
     uint256 hash;
@@ -725,12 +726,16 @@ static void ShowProgress(TransactionTableModel *ttm, const std::string &title, i
     if (nProgress == 100)
     {
         fQueueNotifications = false;
-        if (vQueueNotifications.size() > 10) // prevent balloon spam, show maximum 10 balloons
-            QMetaObject::invokeMethod(ttm, "setProcessingQueuedTransactions", Qt::QueuedConnection, Q_ARG(bool, true));
+        if (vQueueNotifications.size() > 10) { // prevent balloon spam, show maximum 10 balloons
+            bool invoked = QMetaObject::invokeMethod(ttm, "setProcessingQueuedTransactions", Qt::QueuedConnection, Q_ARG(bool, true));
+            assert(invoked);
+        }
         for (unsigned int i = 0; i < vQueueNotifications.size(); ++i)
         {
-            if (vQueueNotifications.size() - i <= 10)
-                QMetaObject::invokeMethod(ttm, "setProcessingQueuedTransactions", Qt::QueuedConnection, Q_ARG(bool, false));
+            if (vQueueNotifications.size() - i <= 10) {
+                bool invoked = QMetaObject::invokeMethod(ttm, "setProcessingQueuedTransactions", Qt::QueuedConnection, Q_ARG(bool, false));
+                assert(invoked);
+            }
 
             vQueueNotifications[i].invoke(ttm);
         }
diff --git a/src/qt/walletcontroller.cpp b/src/qt/walletcontroller.cpp
@@ -124,7 +124,8 @@ WalletModel* WalletController::getOrCreateWallet(std::unique_ptr<interfaces::Wal
     } else {
         // Handler callback runs in a different thread so fix wallet model thread affinity.
         wallet_model->moveToThread(thread());
-        QMetaObject::invokeMethod(this, "addWallet", Qt::QueuedConnection, Q_ARG(WalletModel*, wallet_model));
+        bool invoked = QMetaObject::invokeMethod(this, "addWallet", Qt::QueuedConnection, Q_ARG(WalletModel*, wallet_model));
+        assert(invoked);
     }
 
     return wallet_model;
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
@@ -374,13 +374,15 @@ bool WalletModel::changePassphrase(const SecureString &oldPass, const SecureStri
 static void NotifyUnload(WalletModel* walletModel)
 {
     qDebug() << "NotifyUnload";
-    QMetaObject::invokeMethod(walletModel, "unload");
+    bool invoked = QMetaObject::invokeMethod(walletModel, "unload");
+    assert(invoked);
 }
 
 static void NotifyKeyStoreStatusChanged(WalletModel *walletmodel)
 {
     qDebug() << "NotifyKeyStoreStatusChanged";
-    QMetaObject::invokeMethod(walletmodel, "updateStatus", Qt::QueuedConnection);
+    bool invoked = QMetaObject::invokeMethod(walletmodel, "updateStatus", Qt::QueuedConnection);
+    assert(invoked);
 }
 
 static void NotifyAddressBookChanged(WalletModel *walletmodel,
@@ -392,38 +394,43 @@ static void NotifyAddressBookChanged(WalletModel *walletmodel,
     QString strPurpose = QString::fromStdString(purpose);
 
     qDebug() << "NotifyAddressBookChanged: " + strAddress + " " + strLabel + " isMine=" + QString::number(isMine) + " purpose=" + strPurpose + " status=" + QString::number(status);
-    QMetaObject::invokeMethod(walletmodel, "updateAddressBook", Qt::QueuedConnection,
+    bool invoked = QMetaObject::invokeMethod(walletmodel, "updateAddressBook", Qt::QueuedConnection,
                               Q_ARG(QString, strAddress),
                               Q_ARG(QString, strLabel),
                               Q_ARG(bool, isMine),
                               Q_ARG(QString, strPurpose),
                               Q_ARG(int, status));
+    assert(invoked);
 }
 
 static void NotifyTransactionChanged(WalletModel *walletmodel, const uint256 &hash, ChangeType status)
 {
     Q_UNUSED(hash);
     Q_UNUSED(status);
-    QMetaObject::invokeMethod(walletmodel, "updateTransaction", Qt::QueuedConnection);
+    bool invoked = QMetaObject::invokeMethod(walletmodel, "updateTransaction", Qt::QueuedConnection);
+    assert(invoked);
 }
 
 static void ShowProgress(WalletModel *walletmodel, const std::string &title, int nProgress)
 {
     // emits signal "showProgress"
-    QMetaObject::invokeMethod(walletmodel, "showProgress", Qt::QueuedConnection,
+    bool invoked = QMetaObject::invokeMethod(walletmodel, "showProgress", Qt::QueuedConnection,
                               Q_ARG(QString, QString::fromStdString(title)),
                               Q_ARG(int, nProgress));
+    assert(invoked);
 }
 
 static void NotifyWatchonlyChanged(WalletModel *walletmodel, bool fHaveWatchonly)
 {
-    QMetaObject::invokeMethod(walletmodel, "updateWatchOnlyFlag", Qt::QueuedConnection,
+    bool invoked = QMetaObject::invokeMethod(walletmodel, "updateWatchOnlyFlag", Qt::QueuedConnection,
                               Q_ARG(bool, fHaveWatchonly));
+    assert(invoked);
 }
 
 static void NotifyCanGetAddressesChanged(WalletModel* walletmodel)
 {
-    QMetaObject::invokeMethod(walletmodel, "canGetAddressesChanged");
+    bool invoked = QMetaObject::invokeMethod(walletmodel, "canGetAddressesChanged");
+    assert(invoked);
 }
 
 void WalletModel::subscribeToCoreSignals()

Original file line number	Diff line number	Diff line change
`@@ -184,34 +184,39 @@ void ClientModel::updateBanlist()`
`184`	`184`	`static void ShowProgress(ClientModel *clientmodel, const std::string &title, int nProgress)`
`185`	`185`	`{`
`186`	`186`	`// emits signal "showProgress"`
`187`		`- QMetaObject::invokeMethod(clientmodel, "showProgress", Qt::QueuedConnection,`
	`187`	`+ bool invoked = QMetaObject::invokeMethod(clientmodel, "showProgress", Qt::QueuedConnection,`
`188`	`188`	`Q_ARG(QString, QString::fromStdString(title)),`
`189`	`189`	`Q_ARG(int, nProgress));`
	`190`	`+ assert(invoked);`
`190`	`191`	`}`
`191`	`192`
`192`	`193`	`static void NotifyNumConnectionsChanged(ClientModel *clientmodel, int newNumConnections)`
`193`	`194`	`{`
`194`	`195`	`// Too noisy: qDebug() << "NotifyNumConnectionsChanged: " + QString::number(newNumConnections);`
`195`		`- QMetaObject::invokeMethod(clientmodel, "updateNumConnections", Qt::QueuedConnection,`
	`196`	`+ bool invoked = QMetaObject::invokeMethod(clientmodel, "updateNumConnections", Qt::QueuedConnection,`
`196`	`197`	`Q_ARG(int, newNumConnections));`
	`198`	`+ assert(invoked);`
`197`	`199`	`}`
`198`	`200`
`199`	`201`	`static void NotifyNetworkActiveChanged(ClientModel *clientmodel, bool networkActive)`
`200`	`202`	`{`
`201`		`- QMetaObject::invokeMethod(clientmodel, "updateNetworkActive", Qt::QueuedConnection,`
	`203`	`+ bool invoked = QMetaObject::invokeMethod(clientmodel, "updateNetworkActive", Qt::QueuedConnection,`
`202`	`204`	`Q_ARG(bool, networkActive));`
	`205`	`+ assert(invoked);`
`203`	`206`	`}`
`204`	`207`
`205`	`208`	`static void NotifyAlertChanged(ClientModel *clientmodel)`
`206`	`209`	`{`
`207`	`210`	`qDebug() << "NotifyAlertChanged";`
`208`		`- QMetaObject::invokeMethod(clientmodel, "updateAlert", Qt::QueuedConnection);`
	`211`	`+ bool invoked = QMetaObject::invokeMethod(clientmodel, "updateAlert", Qt::QueuedConnection);`
	`212`	`+ assert(invoked);`
`209`	`213`	`}`
`210`	`214`
`211`	`215`	`static void BannedListChanged(ClientModel *clientmodel)`
`212`	`216`	`{`
`213`	`217`	`qDebug() << QString("%1: Requesting update for peer banlist").arg(__func__);`
`214`		`- QMetaObject::invokeMethod(clientmodel, "updateBanlist", Qt::QueuedConnection);`
	`218`	`+ bool invoked = QMetaObject::invokeMethod(clientmodel, "updateBanlist", Qt::QueuedConnection);`
	`219`	`+ assert(invoked);`
`215`	`220`	`}`
`216`	`221`
`217`	`222`	`static void BlockTipChanged(ClientModel *clientmodel, bool initialSync, int height, int64_t blockTime, double verificationProgress, bool fHeader)`
`@@ -233,11 +238,12 @@ static void BlockTipChanged(ClientModel *clientmodel, bool initialSync, int heig`
`233`	`238`	`// if we are in-sync or if we notify a header update, update the UI regardless of last update time`
`234`	`239`	`if (fHeader \|\| !initialSync \|\| now - nLastUpdateNotification > MODEL_UPDATE_DELAY) {`
`235`	`240`	`//pass an async signal to the UI thread`
`236`		`- QMetaObject::invokeMethod(clientmodel, "numBlocksChanged", Qt::QueuedConnection,`
	`241`	`+ bool invoked = QMetaObject::invokeMethod(clientmodel, "numBlocksChanged", Qt::QueuedConnection,`
`237`	`242`	`Q_ARG(int, height),`
`238`	`243`	`Q_ARG(QDateTime, QDateTime::fromTime_t(blockTime)),`
`239`	`244`	`Q_ARG(double, verificationProgress),`
`240`	`245`	`Q_ARG(bool, fHeader));`
	`246`	`+ assert(invoked);`
`241`	`247`	`nLastUpdateNotification = now;`
`242`	`248`	`}`
`243`	`249`	`}`
Original file line number	Diff line number	Diff line change
`@@ -156,11 +156,12 @@ void SplashScreen::finish()`
`156`	`156`
`157`	`157`	`static void InitMessage(SplashScreen *splash, const std::string &message)`
`158`	`158`	`{`
`159`		`- QMetaObject::invokeMethod(splash, "showMessage",`
	`159`	`+ bool invoked = QMetaObject::invokeMethod(splash, "showMessage",`
`160`	`160`	`Qt::QueuedConnection,`
`161`	`161`	`Q_ARG(QString, QString::fromStdString(message)),`
`162`	`162`	`Q_ARG(int, Qt::AlignBottom\|Qt::AlignHCenter),`
`163`	`163`	`Q_ARG(QColor, QColor(55,55,55)));`
	`164`	`+ assert(invoked);`
`164`	`165`	`}`
`165`	`166`
`166`	`167`	`static void ShowProgress(SplashScreen *splash, const std::string &title, int nProgress, bool resume_possible)`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,8 @@ uint256 SendCoins(CWallet& wallet, SendCoinsDialog& sendCoinsDialog, const CTxDe`
`68`	`68`	`if (status == CT_NEW) txid = hash;`
`69`	`69`	`}));`
`70`	`70`	`ConfirmSend();`
`71`		`- QMetaObject::invokeMethod(&sendCoinsDialog, "on_sendButton_clicked");`
	`71`	`+ bool invoked = QMetaObject::invokeMethod(&sendCoinsDialog, "on_sendButton_clicked");`
	`72`	`+ assert(invoked);`
`72`	`73`	`return txid;`
`73`	`74`	`}`
`74`	`75`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,8 @@ WalletModel* WalletController::getOrCreateWallet(std::unique_ptr<interfaces::Wal`
`124`	`124`	`} else {`
`125`	`125`	`// Handler callback runs in a different thread so fix wallet model thread affinity.`
`126`	`126`	`wallet_model->moveToThread(thread());`
`127`		`- QMetaObject::invokeMethod(this, "addWallet", Qt::QueuedConnection, Q_ARG(WalletModel*, wallet_model));`
	`127`	`+ bool invoked = QMetaObject::invokeMethod(this, "addWallet", Qt::QueuedConnection, Q_ARG(WalletModel*, wallet_model));`
	`128`	`+ assert(invoked);`
`128`	`129`	`}`
`129`	`130`
`130`	`131`	`return wallet_model;`
Original file line number	Diff line number	Diff line change
`@@ -374,13 +374,15 @@ bool WalletModel::changePassphrase(const SecureString &oldPass, const SecureStri`
`374`	`374`	`static void NotifyUnload(WalletModel* walletModel)`
`375`	`375`	`{`
`376`	`376`	`qDebug() << "NotifyUnload";`
`377`		`- QMetaObject::invokeMethod(walletModel, "unload");`
	`377`	`+ bool invoked = QMetaObject::invokeMethod(walletModel, "unload");`
	`378`	`+ assert(invoked);`
`378`	`379`	`}`
`379`	`380`
`380`	`381`	`static void NotifyKeyStoreStatusChanged(WalletModel *walletmodel)`
`381`	`382`	`{`
`382`	`383`	`qDebug() << "NotifyKeyStoreStatusChanged";`
`383`		`- QMetaObject::invokeMethod(walletmodel, "updateStatus", Qt::QueuedConnection);`
	`384`	`+ bool invoked = QMetaObject::invokeMethod(walletmodel, "updateStatus", Qt::QueuedConnection);`
	`385`	`+ assert(invoked);`
`384`	`386`	`}`
`385`	`387`
`386`	`388`	`static void NotifyAddressBookChanged(WalletModel *walletmodel,`
`@@ -392,38 +394,43 @@ static void NotifyAddressBookChanged(WalletModel *walletmodel,`
`392`	`394`	`QString strPurpose = QString::fromStdString(purpose);`
`393`	`395`
`394`	`396`	`qDebug() << "NotifyAddressBookChanged: " + strAddress + " " + strLabel + " isMine=" + QString::number(isMine) + " purpose=" + strPurpose + " status=" + QString::number(status);`
`395`		`- QMetaObject::invokeMethod(walletmodel, "updateAddressBook", Qt::QueuedConnection,`
	`397`	`+ bool invoked = QMetaObject::invokeMethod(walletmodel, "updateAddressBook", Qt::QueuedConnection,`
`396`	`398`	`Q_ARG(QString, strAddress),`
`397`	`399`	`Q_ARG(QString, strLabel),`
`398`	`400`	`Q_ARG(bool, isMine),`
`399`	`401`	`Q_ARG(QString, strPurpose),`
`400`	`402`	`Q_ARG(int, status));`
	`403`	`+ assert(invoked);`
`401`	`404`	`}`
`402`	`405`
`403`	`406`	`static void NotifyTransactionChanged(WalletModel *walletmodel, const uint256 &hash, ChangeType status)`
`404`	`407`	`{`
`405`	`408`	`Q_UNUSED(hash);`
`406`	`409`	`Q_UNUSED(status);`
`407`		`- QMetaObject::invokeMethod(walletmodel, "updateTransaction", Qt::QueuedConnection);`
	`410`	`+ bool invoked = QMetaObject::invokeMethod(walletmodel, "updateTransaction", Qt::QueuedConnection);`
	`411`	`+ assert(invoked);`
`408`	`412`	`}`
`409`	`413`
`410`	`414`	`static void ShowProgress(WalletModel *walletmodel, const std::string &title, int nProgress)`
`411`	`415`	`{`
`412`	`416`	`// emits signal "showProgress"`
`413`		`- QMetaObject::invokeMethod(walletmodel, "showProgress", Qt::QueuedConnection,`
	`417`	`+ bool invoked = QMetaObject::invokeMethod(walletmodel, "showProgress", Qt::QueuedConnection,`
`414`	`418`	`Q_ARG(QString, QString::fromStdString(title)),`
`415`	`419`	`Q_ARG(int, nProgress));`
	`420`	`+ assert(invoked);`
`416`	`421`	`}`
`417`	`422`
`418`	`423`	`static void NotifyWatchonlyChanged(WalletModel *walletmodel, bool fHaveWatchonly)`
`419`	`424`	`{`
`420`		`- QMetaObject::invokeMethod(walletmodel, "updateWatchOnlyFlag", Qt::QueuedConnection,`
	`425`	`+ bool invoked = QMetaObject::invokeMethod(walletmodel, "updateWatchOnlyFlag", Qt::QueuedConnection,`
`421`	`426`	`Q_ARG(bool, fHaveWatchonly));`
	`427`	`+ assert(invoked);`
`422`	`428`	`}`
`423`	`429`
`424`	`430`	`static void NotifyCanGetAddressesChanged(WalletModel* walletmodel)`
`425`	`431`	`{`
`426`		`- QMetaObject::invokeMethod(walletmodel, "canGetAddressesChanged");`
	`432`	`+ bool invoked = QMetaObject::invokeMethod(walletmodel, "canGetAddressesChanged");`
	`433`	`+ assert(invoked);`
`427`	`434`	`}`
`428`	`435`
`429`	`436`	`void WalletModel::subscribeToCoreSignals()`