ClangPchManager: Show extra progress for dependency building

Task-number: QTCREATORBUG-21956
Change-Id: Id244c9ef9fc7825489daa143b21fcca78164d8c7
Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>

src/libs/clangsupport/clangsupport_global.h

@@ -235,11 +235,5 @@ enum class SymbolTag : uchar
 
 using SymbolTags = Utils::SizedArray<SymbolTag, 7>;
 
-enum class ProgressType
+enum class ProgressType { Invalid, PrecompiledHeader, Indexing, DependencyCreation };
-{
+} // namespace ClangBackEnd
-    Invalid,
-    PrecompiledHeader,
-    Indexing
-};
-
-}

src/libs/clangsupport/progressmessage.h

@@ -36,23 +36,27 @@ class ProgressMessage
 public:
     ProgressMessage() = default;
     ProgressMessage(ProgressType progressType, int progress, int total)
-        : progressType(progressType),
+        : progress(progress)
-          progress(progress),
+        , total(total)
-          total(total)
+        , progressType(progressType)
     {}
 
     friend QDataStream &operator<<(QDataStream &out, const ProgressMessage &message)
     {
         out << message.progress;
         out << message.total;
+        out << static_cast<int>(message.progressType);
 
         return out;
     }
 
     friend QDataStream &operator>>(QDataStream &in, ProgressMessage &message)
     {
+        int progressTupe;
         in >> message.progress;
         in >> message.total;
+        in >> progressTupe;
+        message.progressType = static_cast<ProgressType>(progressTupe);
 
         return in;
     }
@@ -69,9 +73,9 @@ public:
     }
 
 public:
-    ProgressType progressType = ProgressType::Invalid;
     int progress = 0;
     int total = 0;
+    ProgressType progressType = ProgressType::Invalid;
 };
 
 DECLARE_MESSAGE(ProgressMessage)

src/plugins/clangpchmanager/clangpchmanagerplugin.cpp

@@ -65,12 +65,19 @@ public:
     Sqlite::Database database{Utils::PathString{Core::ICore::userResourcePath() + "/symbol-experimental-v1.db"}, 1000ms};
     ClangBackEnd::RefactoringDatabaseInitializer<Sqlite::Database> databaseInitializer{database};
     ClangBackEnd::FilePathCaching filePathCache{database};
-    ClangPchManager::ProgressManager progressManager{
+    ClangPchManager::ProgressManager pchCreationProgressManager{[](QFutureInterface<void> &promise) {
-        [] (QFutureInterface<void> &promise) {
+        auto title = QCoreApplication::translate("ClangPchProgressManager",
-            auto title = QCoreApplication::translate("ClangPchProgressManager", "Creating PCHs", "PCH stands for precompiled header");
+                                                 "Creating PCHs",
-            Core::ProgressManager::addTask(promise.future(), title, "pch creation", nullptr);
+                                                 "PCH stands for precompiled header");
+        Core::ProgressManager::addTask(promise.future(), title, "pch creation", nullptr);
     }};
-    PchManagerClient pchManagerClient{progressManager};
+    ClangPchManager::ProgressManager dependencyCreationProgressManager{
+        [](QFutureInterface<void> &promise) {
+            auto title = QCoreApplication::translate("ClangPchProgressManager",
+                                                     "Creating Dependencies");
+            Core::ProgressManager::addTask(promise.future(), title, "dependency creation", nullptr);
+        }};
+    PchManagerClient pchManagerClient{pchCreationProgressManager, dependencyCreationProgressManager};
     PchManagerConnectionClient connectionClient{&pchManagerClient};
     QtCreatorProjectUpdater<PchManagerProjectUpdater> projectUpdate{connectionClient.serverProxy(),
                                                                     pchManagerClient,

src/plugins/clangpchmanager/pchmanagerclient.cpp

@@ -53,7 +53,16 @@ void PchManagerClient::precompiledHeadersUpdated(ClangBackEnd::PrecompiledHeader
 
 void PchManagerClient::progress(ClangBackEnd::ProgressMessage &&message)
 {
-    m_progressManager.setProgress(message.progress, message.total);
+    switch (message.progressType) {
+    case ClangBackEnd::ProgressType::PrecompiledHeader:
+        m_pchCreationProgressManager.setProgress(message.progress, message.total);
+        break;
+    case ClangBackEnd::ProgressType::DependencyCreation:
+        m_dependencyCreationProgressManager.setProgress(message.progress, message.total);
+        break;
+    default:
+        break;
+    }
 }
 
 void PchManagerClient::precompiledHeaderRemoved(const QString &projectPartId)

src/plugins/clangpchmanager/pchmanagerclient.h

@@ -42,8 +42,10 @@ class CLANGPCHMANAGER_EXPORT PchManagerClient final : public ClangBackEnd::PchMa
 {
     friend class PchManagerNotifierInterface;
 public:
-    PchManagerClient(ProgressManagerInterface &progressManager)
+    PchManagerClient(ProgressManagerInterface &pchCreationProgressManager,
-        : m_progressManager(progressManager)
+                     ProgressManagerInterface &dependencyCreationProgressManager)
+        : m_pchCreationProgressManager(pchCreationProgressManager)
+        , m_dependencyCreationProgressManager(dependencyCreationProgressManager)
     {}
 
     void alive() override;
@@ -78,7 +80,8 @@ private:
     ClangBackEnd::ProjectPartPchs m_projectPartPchs;
     std::vector<PchManagerNotifierInterface*> m_notifiers;
     PchManagerConnectionClient *m_connectionClient=nullptr;
-    ProgressManagerInterface &m_progressManager;
+    ProgressManagerInterface &m_pchCreationProgressManager;
+    ProgressManagerInterface &m_dependencyCreationProgressManager;
 };
 
 } // namespace ClangPchManager

src/tools/clangpchmanagerbackend/clangpchmanagerbackendmain.cpp

@@ -224,12 +224,19 @@ struct Data // because we have a cycle dependency
                                         clangPchManagerServer,
                                         includeWatcher};
     PrecompiledHeaderStorage<> preCompiledHeaderStorage{database};
-    ClangBackEnd::ProgressCounter progressCounter{[&](int progress, int total) {
+    ClangBackEnd::ProgressCounter pchCreationProgressCounter{[&](int progress, int total) {
-        executeInLoop([&] { clangPchManagerServer.setProgress(progress, total); });
+        executeInLoop([&] {
+            clangPchManagerServer.setPchCreationProgress(progress, total);
+        });
+    }};
+    ClangBackEnd::ProgressCounter dependencyCreationProgressCounter{[&](int progress, int total) {
+        executeInLoop([&] {
+            clangPchManagerServer.setDependencyCreationProgress(progress, total);
+        });
     }};
     ClangBackEnd::PchTaskQueue pchTaskQueue{systemTaskScheduler,
                                             projectTaskScheduler,
-                                            progressCounter,
+                                            pchCreationProgressCounter,
                                             preCompiledHeaderStorage,
                                             database};
     ClangBackEnd::PchTasksMerger pchTaskMerger{pchTaskQueue};
@@ -248,19 +255,19 @@ struct Data // because we have a cycle dependency
                                                                     database};
     ClangBackEnd::PchTaskGenerator pchTaskGenerator{buildDependencyProvider,
                                                     pchTaskMerger,
-                                                    progressCounter};
+                                                    dependencyCreationProgressCounter};
     PchManagerServer clangPchManagerServer{includeWatcher,
                                            pchTaskGenerator,
                                            projectParts,
                                            generatedFiles};
     TaskScheduler systemTaskScheduler{pchCreatorManager,
                                       pchTaskQueue,
-                                      progressCounter,
+                                      pchCreationProgressCounter,
                                       std::thread::hardware_concurrency(),
                                       ClangBackEnd::CallDoInMainThreadAfterFinished::No};
     TaskScheduler projectTaskScheduler{pchCreatorManager,
                                        pchTaskQueue,
-                                       progressCounter,
+                                       pchCreationProgressCounter,
                                        std::thread::hardware_concurrency(),
                                        ClangBackEnd::CallDoInMainThreadAfterFinished::Yes};
 };

src/tools/clangpchmanagerbackend/source/pchmanagerserver.cpp

@@ -132,9 +132,14 @@ void PchManagerServer::pathsChanged(const FilePathIds &/*filePathIds*/)
 {
 }
 
-void PchManagerServer::setProgress(int progress, int total)
+void PchManagerServer::setPchCreationProgress(int progress, int total)
 {
     client()->progress({ProgressType::PrecompiledHeader, progress, total});
 }
 
+void PchManagerServer::setDependencyCreationProgress(int progress, int total)
+{
+    client()->progress({ProgressType::DependencyCreation, progress, total});
+}
+
 } // namespace ClangBackEnd

src/tools/clangpchmanagerbackend/source/pchmanagerserver.h

@@ -60,7 +60,8 @@ public:
     void pathsWithIdsChanged(const Utils::SmallStringVector &ids) override;
     void pathsChanged(const FilePathIds &filePathIds) override;
 
-    void setProgress(int progress, int total);
+    void setPchCreationProgress(int progress, int total);
+    void setDependencyCreationProgress(int progress, int total);
 
 private:
     ClangPathWatcherInterface &m_fileSystemWatcher;

tests/unit/unittest/pchmanagerclient-test.cpp

@@ -53,9 +53,11 @@ using testing::Not;
 class PchManagerClient : public ::testing::Test
 {
 protected:
-    NiceMock<MockProgressManager> mockProgressManager;
+    NiceMock<MockProgressManager> mockPchCreationProgressManager;
+    NiceMock<MockProgressManager> mockDependencyCreationProgressManager;
+    ClangPchManager::PchManagerClient client{mockPchCreationProgressManager,
+                                             mockDependencyCreationProgressManager};
     NiceMock<MockPchManagerServer> mockPchManagerServer;
-    ClangPchManager::PchManagerClient client{mockProgressManager};
     NiceMock<MockPchManagerNotifier> mockPchManagerNotifier{client};
     Sqlite::Database database{":memory:", Sqlite::JournalMode::Memory};
     ClangBackEnd::RefactoringDatabaseInitializer<Sqlite::Database> initializer{database};
@@ -158,11 +160,17 @@ TEST_F(PchManagerClient, ProjectPartPchForProjectPartIdIsUpdated)
                 42);
 }
 
-TEST_F(PchManagerClient, SetProgress)
+TEST_F(PchManagerClient, SetPchCreationProgress)
 {
-    EXPECT_CALL(mockProgressManager, setProgress(10, 20));
+    EXPECT_CALL(mockPchCreationProgressManager, setProgress(10, 20));
 
     client.progress({ClangBackEnd::ProgressType::PrecompiledHeader, 10, 20});
 }
 
+TEST_F(PchManagerClient, SetDependencyCreationProgress)
+{
+    EXPECT_CALL(mockDependencyCreationProgressManager, setProgress(30, 40));
+
+    client.progress({ClangBackEnd::ProgressType::DependencyCreation, 30, 40});
 }
+} // namespace

tests/unit/unittest/pchmanagerserver-test.cpp

@@ -176,12 +176,26 @@ TEST_F(PchManagerServer, UpdateProjectPartQueueByPathIds)
     server.pathsWithIdsChanged({projectPartId1});
 }
 
-TEST_F(PchManagerServer, SetProgress)
+TEST_F(PchManagerServer, SetPchCreationProgress)
 {
-    EXPECT_CALL(mockPchManagerClient, progress(AllOf(Field(&ClangBackEnd::ProgressMessage::progress, 20),
+    EXPECT_CALL(mockPchManagerClient,
-                                                     Field(&ClangBackEnd::ProgressMessage::total, 30))));
+                progress(AllOf(Field(&ClangBackEnd::ProgressMessage::progressType,
+                                     ClangBackEnd::ProgressType::PrecompiledHeader),
+                               Field(&ClangBackEnd::ProgressMessage::progress, 20),
+                               Field(&ClangBackEnd::ProgressMessage::total, 30))));
 
-    server.setProgress(20, 30);
+    server.setPchCreationProgress(20, 30);
+}
+
+TEST_F(PchManagerServer, SetDependencyCreationProgress)
+{
+    EXPECT_CALL(mockPchManagerClient,
+                progress(AllOf(Field(&ClangBackEnd::ProgressMessage::progressType,
+                                     ClangBackEnd::ProgressType::DependencyCreation),
+                               Field(&ClangBackEnd::ProgressMessage::progress, 20),
+                               Field(&ClangBackEnd::ProgressMessage::total, 30))));
+
+    server.setDependencyCreationProgress(20, 30);
 }
 
 TEST_F(PchManagerServer, RemoveToolChainsArguments)

tests/unit/unittest/projectupdater-test.cpp

@@ -135,8 +135,10 @@ protected:
     Sqlite::Database database{":memory:", Sqlite::JournalMode::Memory};
     ClangBackEnd::RefactoringDatabaseInitializer<Sqlite::Database> initializer{database};
     ClangBackEnd::FilePathCaching filePathCache{database};
-    NiceMock<MockProgressManager> mockProgressManager;
+    NiceMock<MockProgressManager> mockPchCreationProgressManager;
-    ClangPchManager::PchManagerClient pchManagerClient{mockProgressManager};
+    NiceMock<MockProgressManager> mockDependencyCreationProgressManager;
+    ClangPchManager::PchManagerClient pchManagerClient{mockPchCreationProgressManager,
+                                                       mockDependencyCreationProgressManager};
     MockPchManagerNotifier mockPchManagerNotifier{pchManagerClient};
     NiceMock<MockPchManagerServer> mockPchManagerServer;
     ClangPchManager::ProjectUpdater updater{mockPchManagerServer, filePathCache};

tests/unit/unittest/refactoringprojectupdater-test.cpp

@@ -87,8 +87,10 @@ protected:
     ClangBackEnd::RefactoringDatabaseInitializer<Sqlite::Database> initializer{database};
     ClangBackEnd::FilePathCaching filePathCache{database};
     NiceMock<MockRefactoringServer> mockRefactoringServer;
-    NiceMock<MockProgressManager> mockProgressManager;
+    NiceMock<MockProgressManager> mockPchCreationProgressManager;
-    ClangPchManager::PchManagerClient pchManagerClient{mockProgressManager};
+    NiceMock<MockProgressManager> mockDependencyCreationProgressManager;
+    ClangPchManager::PchManagerClient pchManagerClient{mockPchCreationProgressManager,
+                                                       mockDependencyCreationProgressManager};
     MockCppModelManager mockCppModelManager;
     ClangRefactoring::RefactoringProjectUpdater updater{mockRefactoringServer, pchManagerClient, mockCppModelManager, filePathCache};
     Utils::SmallString projectPartId;