TrackAnalysisScheduler: Remove dependency on TrackDAO

src/analyzer/trackanalysisscheduler.cpp

@@ -1,6 +1,5 @@
 #include "analyzer/trackanalysisscheduler.h"
 
-#include "library/dao/trackdao.h"
 #include "moc_trackanalysisscheduler.cpp"
 #include "track/track.h"
 #include "util/logger.h"
@@ -31,13 +30,13 @@ TrackAnalysisScheduler::NullPointer::NullPointer()
 
 //static
 TrackAnalysisScheduler::Pointer TrackAnalysisScheduler::createInstance(
-        const TrackDAO* pTrackDao,
+        std::unique_ptr<const TrackAnalysisSchedulerEnvironment> pEnvironment,
         int numWorkerThreads,
         const mixxx::DbConnectionPoolPtr& pDbConnectionPool,
         const UserSettingsPointer& pConfig,
         AnalyzerModeFlags modeFlags) {
     return Pointer(new TrackAnalysisScheduler(
-                           pTrackDao,
+                           std::move(pEnvironment),
                            numWorkerThreads,
                            pDbConnectionPool,
                            pConfig,
@@ -46,17 +45,18 @@ TrackAnalysisScheduler::Pointer TrackAnalysisScheduler::createInstance(
 }
 
 TrackAnalysisScheduler::TrackAnalysisScheduler(
-        const TrackDAO* pTrackDao,
+        std::unique_ptr<const TrackAnalysisSchedulerEnvironment> pEnvironment,
         int numWorkerThreads,
         const mixxx::DbConnectionPoolPtr& pDbConnectionPool,
         const UserSettingsPointer& pConfig,
         AnalyzerModeFlags modeFlags)
-        : m_pTrackDao(pTrackDao),
+        : m_pEnvironment(std::move(pEnvironment)),
           m_currentTrackProgress(kAnalyzerProgressUnknown),
           m_currentTrackNumber(0),
           m_dequeuedTracksCount(0),
           // The first signal should always be emitted
           m_lastProgressEmittedAt(Clock::now() - kProgressInhibitDuration) {
+    DEBUG_ASSERT(m_pEnvironment);
     VERIFY_OR_DEBUG_ASSERT(numWorkerThreads > 0) {
             kLogger.warning()
                     << "Invalid number of worker threads:"
@@ -275,17 +275,12 @@ void TrackAnalysisScheduler::resume() {
 
 bool TrackAnalysisScheduler::submitNextTrack(Worker* worker) {
     DEBUG_ASSERT(worker);
-    const auto* const pTrackDao = m_pTrackDao.data();
-    VERIFY_OR_DEBUG_ASSERT(pTrackDao) {
-        kLogger.critical() << "TrackDAO pointer is dangling";
-        return false;
-    }
     while (!m_queuedTrackIds.empty()) {
         TrackId nextTrackId = m_queuedTrackIds.front();
         DEBUG_ASSERT(nextTrackId.isValid());
         if (nextTrackId.isValid()) {
             TrackPointer nextTrack =
-                    pTrackDao->getTrackById(nextTrackId);
+                    m_pEnvironment->loadTrackById(nextTrackId);
             if (nextTrack) {
                 if (m_pendingTrackIds.insert(nextTrackId).second) {
                     if (worker->submitNextTrack(std::move(nextTrack))) {

src/analyzer/trackanalysisscheduler.h

@@ -8,10 +8,18 @@
 
 #include "analyzer/analyzerthread.h"
 #include "util/db/dbconnectionpool.h"
-#include "util/qt.h"
 
-// forward declaration(s)
-class TrackDAO;
+/// Callbacks for triggering side-effects in the outer context of
+/// TrackAnalysisScheduler.
+///
+/// All functions will only be called from the host thread of
+/// TrackAnalysisScheduler, not from worker threads.
+class TrackAnalysisSchedulerEnvironment {
+  public:
+    virtual ~TrackAnalysisSchedulerEnvironment() = default;
+
+    virtual TrackPointer loadTrackById(TrackId trackId) const = 0;
+};
 
 class TrackAnalysisScheduler : public QObject {
     Q_OBJECT
@@ -25,17 +33,17 @@ class TrackAnalysisScheduler : public QObject {
     };
 
     static Pointer createInstance(
-            const TrackDAO* pTrackDao,
+            std::unique_ptr<const TrackAnalysisSchedulerEnvironment> pEnvironment,
             int numWorkerThreads,
             const mixxx::DbConnectionPoolPtr& pDbConnectionPool,
             const UserSettingsPointer& pConfig,
             AnalyzerModeFlags modeFlags);
 
     /*private*/ TrackAnalysisScheduler(
-            const TrackDAO* pTrackDao,
+            std::unique_ptr<const TrackAnalysisSchedulerEnvironment> pEnvironment,
             int numWorkerThreads,
             const mixxx::DbConnectionPoolPtr& pDbConnectionPool,
-            const UserSettingsPointer& pConfig,
+            const UserSettingsPointer& pUserSettings,
             AnalyzerModeFlags modeFlags);
     ~TrackAnalysisScheduler() override;
 
@@ -139,7 +147,7 @@ class TrackAnalysisScheduler : public QObject {
                 m_pendingTrackIds.empty();
     }
 
-    const mixxx::SafeQPointer<const TrackDAO> m_pTrackDao;
+    const std::unique_ptr<const TrackAnalysisSchedulerEnvironment> m_pEnvironment;
 
     std::vector<Worker> m_workers;
 

src/library/library.cpp

@@ -261,11 +261,29 @@ TrackCollectionManager* Library::trackCollectionManager() const {
     return m_pTrackCollectionManager;
 }
 
+namespace {
+class TrackAnalysisSchedulerEnvironmentImpl : public TrackAnalysisSchedulerEnvironment {
+  public:
+    explicit TrackAnalysisSchedulerEnvironmentImpl(const Library* pLibrary)
+            : m_pLibrary(pLibrary) {
+        DEBUG_ASSERT(m_pLibrary);
+    }
+    ~TrackAnalysisSchedulerEnvironmentImpl() override = default;
+
+    TrackPointer loadTrackById(TrackId trackId) const override {
+        return m_pLibrary->trackCollectionManager()->getTrackById(trackId);
+    }
+
+  private:
+    const Library* const m_pLibrary;
+};
+} // namespace
+
 TrackAnalysisScheduler::Pointer Library::createTrackAnalysisScheduler(
         int numWorkerThreads,
         AnalyzerModeFlags modeFlags) const {
     return TrackAnalysisScheduler::createInstance(
-            &m_pTrackCollectionManager->internalCollection()->getTrackDAO(),
+            std::make_unique<const TrackAnalysisSchedulerEnvironmentImpl>(this),
             numWorkerThreads,
             m_pDbConnectionPool,
             m_pConfig,