refactor: Pass SynchronizationState enum to GUI

hebasto · ryanofsky · hebasto · commit ebc93a0d80b2 · 2020-03-04T23:19:25.000+02:00
Co-authored-by: Russell Yanofsky &lt;russ@yanofsky.org&gt;
diff --git a/src/init.cpp b/src/init.cpp
@@ -582,9 +582,9 @@ std::string LicenseInfo()
 }
 
 #if HAVE_SYSTEM
-static void BlockNotifyCallback(bool initialSync, const CBlockIndex *pBlockIndex)
+static void BlockNotifyCallback(SynchronizationState sync_state, const CBlockIndex* pBlockIndex)
 {
-    if (initialSync || !pBlockIndex)
+    if (sync_state != SynchronizationState::POST_INIT || !pBlockIndex)
         return;
 
     std::string strCmd = gArgs.GetArg("-blocknotify", "");
diff --git a/src/interfaces/node.cpp b/src/interfaces/node.cpp
@@ -305,16 +305,16 @@ class NodeImpl : public Node
     }
     std::unique_ptr<Handler> handleNotifyBlockTip(NotifyBlockTipFn fn) override
     {
-        return MakeHandler(::uiInterface.NotifyBlockTip_connect([fn](bool initial_download, const CBlockIndex* block) {
-            fn(initial_download, block->nHeight, block->GetBlockTime(),
+        return MakeHandler(::uiInterface.NotifyBlockTip_connect([fn](SynchronizationState sync_state, const CBlockIndex* block) {
+            fn(sync_state, block->nHeight, block->GetBlockTime(),
                 GuessVerificationProgress(Params().TxData(), block));
         }));
     }
     std::unique_ptr<Handler> handleNotifyHeaderTip(NotifyHeaderTipFn fn) override
     {
         return MakeHandler(
-            ::uiInterface.NotifyHeaderTip_connect([fn](bool initial_download, const CBlockIndex* block) {
-                fn(initial_download, block->nHeight, block->GetBlockTime(),
+            ::uiInterface.NotifyHeaderTip_connect([fn](SynchronizationState sync_state, const CBlockIndex* block) {
+                fn(sync_state, block->nHeight, block->GetBlockTime(),
                     /* verification progress is unused when a header was received */ 0);
             }));
     }
diff --git a/src/interfaces/node.h b/src/interfaces/node.h
@@ -29,6 +29,7 @@ class UniValue;
 class proxyType;
 struct CNodeStateStats;
 struct NodeContext;
+enum class SynchronizationState;
 enum class WalletCreationStatus;
 
 namespace interfaces {
@@ -248,12 +249,12 @@ class Node
 
     //! Register handler for block tip messages.
     using NotifyBlockTipFn =
-        std::function<void(bool initial_download, int height, int64_t block_time, double verification_progress)>;
+        std::function<void(SynchronizationState, int height, int64_t block_time, double verification_progress)>;
     virtual std::unique_ptr<Handler> handleNotifyBlockTip(NotifyBlockTipFn fn) = 0;
 
     //! Register handler for header tip messages.
     using NotifyHeaderTipFn =
-        std::function<void(bool initial_download, int height, int64_t block_time, double verification_progress)>;
+        std::function<void(SynchronizationState, int height, int64_t block_time, double verification_progress)>;
     virtual std::unique_ptr<Handler> handleNotifyHeaderTip(NotifyHeaderTipFn fn) = 0;
 
     //! Return pointer to internal chain interface, useful for testing.
diff --git a/src/qt/clientmodel.cpp b/src/qt/clientmodel.cpp
@@ -226,8 +226,10 @@ static void BannedListChanged(ClientModel *clientmodel)
     assert(invoked);
 }
 
-static void BlockTipChanged(ClientModel *clientmodel, bool initialSync, int height, int64_t blockTime, double verificationProgress, bool fHeader)
+static void BlockTipChanged(ClientModel* clientmodel, SynchronizationState sync_state, int height, int64_t blockTime, double verificationProgress, bool fHeader)
 {
+    const bool initialSync = sync_state != SynchronizationState::POST_INIT;
+
     // lock free async UI updates in case we have a new block tip
     // during initial sync, only update the UI if the last update
     // was > 250ms (MODEL_UPDATE_DELAY) ago
diff --git a/src/ui_interface.cpp b/src/ui_interface.cpp
@@ -47,8 +47,8 @@ void CClientUIInterface::NotifyNumConnectionsChanged(int newNumConnections) { re
 void CClientUIInterface::NotifyNetworkActiveChanged(bool networkActive) { return g_ui_signals.NotifyNetworkActiveChanged(networkActive); }
 void CClientUIInterface::NotifyAlertChanged() { return g_ui_signals.NotifyAlertChanged(); }
 void CClientUIInterface::ShowProgress(const std::string& title, int nProgress, bool resume_possible) { return g_ui_signals.ShowProgress(title, nProgress, resume_possible); }
-void CClientUIInterface::NotifyBlockTip(bool b, const CBlockIndex* i) { return g_ui_signals.NotifyBlockTip(b, i); }
-void CClientUIInterface::NotifyHeaderTip(bool b, const CBlockIndex* i) { return g_ui_signals.NotifyHeaderTip(b, i); }
+void CClientUIInterface::NotifyBlockTip(SynchronizationState s, const CBlockIndex* i) { return g_ui_signals.NotifyBlockTip(s, i); }
+void CClientUIInterface::NotifyHeaderTip(SynchronizationState s, const CBlockIndex* i) { return g_ui_signals.NotifyHeaderTip(s, i); }
 void CClientUIInterface::BannedListChanged() { return g_ui_signals.BannedListChanged(); }
 
 
diff --git a/src/ui_interface.h b/src/ui_interface.h
@@ -11,6 +11,7 @@
 #include <string>
 
 class CBlockIndex;
+enum class SynchronizationState;
 namespace boost {
 namespace signals2 {
 class connection;
@@ -108,10 +109,10 @@ class CClientUIInterface
     ADD_SIGNALS_DECL_WRAPPER(ShowProgress, void, const std::string& title, int nProgress, bool resume_possible);
 
     /** New block has been accepted */
-    ADD_SIGNALS_DECL_WRAPPER(NotifyBlockTip, void, bool, const CBlockIndex*);
+    ADD_SIGNALS_DECL_WRAPPER(NotifyBlockTip, void, SynchronizationState, const CBlockIndex*);
 
     /** Best header has changed */
-    ADD_SIGNALS_DECL_WRAPPER(NotifyHeaderTip, void, bool, const CBlockIndex*);
+    ADD_SIGNALS_DECL_WRAPPER(NotifyHeaderTip, void, SynchronizationState, const CBlockIndex*);
 
     /** Banlist did change. */
     ADD_SIGNALS_DECL_WRAPPER(BannedListChanged, void, void);
diff --git a/src/util/system.h b/src/util/system.h
@@ -107,6 +107,12 @@ inline bool IsSwitchChar(char c)
 #endif
 }
 
+enum class SynchronizationState {
+    INIT_DOWNLOAD,
+    INIT_REINDEX,
+    POST_INIT
+};
+
 enum class OptionsCategory {
     OPTIONS,
     CONNECTION,
diff --git a/src/validation.cpp b/src/validation.cpp
@@ -2789,6 +2789,13 @@ bool CChainState::ActivateBestChainStep(BlockValidationState& state, const CChai
     return true;
 }
 
+static SynchronizationState GetSynchronizationState(bool init)
+{
+    if (!init) return SynchronizationState::POST_INIT;
+    if (::fReindex) return SynchronizationState::INIT_REINDEX;
+    return SynchronizationState::INIT_DOWNLOAD;
+}
+
 static bool NotifyHeaderTip() LOCKS_EXCLUDED(cs_main) {
     bool fNotify = false;
     bool fInitialBlockDownload = false;
@@ -2806,7 +2813,7 @@ static bool NotifyHeaderTip() LOCKS_EXCLUDED(cs_main) {
     }
     // Send block tip changed notifications without cs_main
     if (fNotify) {
-        uiInterface.NotifyHeaderTip(fInitialBlockDownload, pindexHeader);
+        uiInterface.NotifyHeaderTip(GetSynchronizationState(fInitialBlockDownload), pindexHeader);
     }
     return fNotify;
 }
@@ -2895,7 +2902,7 @@ bool CChainState::ActivateBestChain(BlockValidationState &state, const CChainPar
                 GetMainSignals().UpdatedBlockTip(pindexNewTip, pindexFork, fInitialDownload);
 
                 // Always notify the UI if a new block tip was connected
-                uiInterface.NotifyBlockTip(fInitialDownload, pindexNewTip);
+                uiInterface.NotifyBlockTip(GetSynchronizationState(fInitialDownload), pindexNewTip);
             }
         }
         // When we reach this point, we switched to a new tip (stored in pindexNewTip).
@@ -3086,7 +3093,7 @@ bool CChainState::InvalidateBlock(BlockValidationState& state, const CChainParam
 
     // Only notify about a new block tip if the active chain was modified.
     if (pindex_was_in_chain) {
-        uiInterface.NotifyBlockTip(IsInitialBlockDownload(), to_mark_failed->pprev);
+        uiInterface.NotifyBlockTip(GetSynchronizationState(IsInitialBlockDownload()), to_mark_failed->pprev);
     }
     return true;
 }

Original file line number	Diff line number	Diff line change
`@@ -582,9 +582,9 @@ std::string LicenseInfo()`
`582`	`582`	`}`
`583`	`583`
`584`	`584`	`#if HAVE_SYSTEM`
`585`		`-static void BlockNotifyCallback(bool initialSync, const CBlockIndex *pBlockIndex)`
	`585`	`+static void BlockNotifyCallback(SynchronizationState sync_state, const CBlockIndex* pBlockIndex)`
`586`	`586`	`{`
`587`		`- if (initialSync \|\| !pBlockIndex)`
	`587`	`+ if (sync_state != SynchronizationState::POST_INIT \|\| !pBlockIndex)`
`588`	`588`	`return;`
`589`	`589`
`590`	`590`	`std::string strCmd = gArgs.GetArg("-blocknotify", "");`
Original file line number	Diff line number	Diff line change
`@@ -305,16 +305,16 @@ class NodeImpl : public Node`
`305`	`305`	`}`
`306`	`306`	`std::unique_ptr<Handler> handleNotifyBlockTip(NotifyBlockTipFn fn) override`
`307`	`307`	`{`
`308`		`- return MakeHandler(::uiInterface.NotifyBlockTip_connect([fn](bool initial_download, const CBlockIndex* block) {`
`309`		`- fn(initial_download, block->nHeight, block->GetBlockTime(),`
	`308`	`+ return MakeHandler(::uiInterface.NotifyBlockTip_connect([fn](SynchronizationState sync_state, const CBlockIndex* block) {`
	`309`	`+ fn(sync_state, block->nHeight, block->GetBlockTime(),`
`310`	`310`	`GuessVerificationProgress(Params().TxData(), block));`
`311`	`311`	`}));`
`312`	`312`	`}`
`313`	`313`	`std::unique_ptr<Handler> handleNotifyHeaderTip(NotifyHeaderTipFn fn) override`
`314`	`314`	`{`
`315`	`315`	`return MakeHandler(`
`316`		`- ::uiInterface.NotifyHeaderTip_connect([fn](bool initial_download, const CBlockIndex* block) {`
`317`		`- fn(initial_download, block->nHeight, block->GetBlockTime(),`
	`316`	`+ ::uiInterface.NotifyHeaderTip_connect([fn](SynchronizationState sync_state, const CBlockIndex* block) {`
	`317`	`+ fn(sync_state, block->nHeight, block->GetBlockTime(),`
`318`	`318`	`/* verification progress is unused when a header was received */ 0);`
`319`	`319`	`}));`
`320`	`320`	`}`
Original file line number	Diff line number	Diff line change
`@@ -226,8 +226,10 @@ static void BannedListChanged(ClientModel *clientmodel)`
`226`	`226`	`assert(invoked);`
`227`	`227`	`}`
`228`	`228`
`229`		`-static void BlockTipChanged(ClientModel *clientmodel, bool initialSync, int height, int64_t blockTime, double verificationProgress, bool fHeader)`
	`229`	`+static void BlockTipChanged(ClientModel* clientmodel, SynchronizationState sync_state, int height, int64_t blockTime, double verificationProgress, bool fHeader)`
`230`	`230`	`{`
	`231`	`+ const bool initialSync = sync_state != SynchronizationState::POST_INIT;`
	`232`	`+`
`231`	`233`	`// lock free async UI updates in case we have a new block tip`
`232`	`234`	`// during initial sync, only update the UI if the last update`
`233`	`235`	`// was > 250ms (MODEL_UPDATE_DELAY) ago`
Original file line number	Diff line number	Diff line change
`@@ -2789,6 +2789,13 @@ bool CChainState::ActivateBestChainStep(BlockValidationState& state, const CChai`
`2789`	`2789`	`return true;`
`2790`	`2790`	`}`
`2791`	`2791`
	`2792`	`+static SynchronizationState GetSynchronizationState(bool init)`
	`2793`	`+{`
	`2794`	`+ if (!init) return SynchronizationState::POST_INIT;`
	`2795`	`+ if (::fReindex) return SynchronizationState::INIT_REINDEX;`
	`2796`	`+ return SynchronizationState::INIT_DOWNLOAD;`
	`2797`	`+}`
	`2798`	`+`
`2792`	`2799`	`static bool NotifyHeaderTip() LOCKS_EXCLUDED(cs_main) {`
`2793`	`2800`	`bool fNotify = false;`
`2794`	`2801`	`bool fInitialBlockDownload = false;`
`@@ -2806,7 +2813,7 @@ static bool NotifyHeaderTip() LOCKS_EXCLUDED(cs_main) {`
`2806`	`2813`	`}`
`2807`	`2814`	`// Send block tip changed notifications without cs_main`
`2808`	`2815`	`if (fNotify) {`
`2809`		`- uiInterface.NotifyHeaderTip(fInitialBlockDownload, pindexHeader);`
	`2816`	`+ uiInterface.NotifyHeaderTip(GetSynchronizationState(fInitialBlockDownload), pindexHeader);`
`2810`	`2817`	`}`
`2811`	`2818`	`return fNotify;`
`2812`	`2819`	`}`
`@@ -2895,7 +2902,7 @@ bool CChainState::ActivateBestChain(BlockValidationState &state, const CChainPar`
`2895`	`2902`	`GetMainSignals().UpdatedBlockTip(pindexNewTip, pindexFork, fInitialDownload);`
`2896`	`2903`
`2897`	`2904`	`// Always notify the UI if a new block tip was connected`
`2898`		`- uiInterface.NotifyBlockTip(fInitialDownload, pindexNewTip);`
	`2905`	`+ uiInterface.NotifyBlockTip(GetSynchronizationState(fInitialDownload), pindexNewTip);`
`2899`	`2906`	`}`
`2900`	`2907`	`}`
`2901`	`2908`	`// When we reach this point, we switched to a new tip (stored in pindexNewTip).`
`@@ -3086,7 +3093,7 @@ bool CChainState::InvalidateBlock(BlockValidationState& state, const CChainParam`
`3086`	`3093`
`3087`	`3094`	`// Only notify about a new block tip if the active chain was modified.`
`3088`	`3095`	`if (pindex_was_in_chain) {`
`3089`		`- uiInterface.NotifyBlockTip(IsInitialBlockDownload(), to_mark_failed->pprev);`
	`3096`	`+ uiInterface.NotifyBlockTip(GetSynchronizationState(IsInitialBlockDownload()), to_mark_failed->pprev);`
`3090`	`3097`	`}`
`3091`	`3098`	`return true;`
`3092`	`3099`	`}`