From 47fe7c47d2a4f9a9afd5bc03f15d4fb64b6ee468 Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Sat, 23 Jul 2022 01:04:34 -0500 Subject: [PATCH] refactor: replace per-torrent callbacks with per-session ones. (#3495) --- gtk/Session.cc | 21 +++--- libtransmission/crypto-utils-ccrypto.cc | 14 ---- libtransmission/peer-mgr.cc | 6 +- libtransmission/session.cc | 27 ++++++++ libtransmission/session.h | 89 ++++++++++++++++++++++++ libtransmission/torrent.cc | 90 ++----------------------- libtransmission/torrent.h | 15 ----- libtransmission/transmission.h | 25 +++---- macosx/Controller.mm | 61 +++++++++++++++++ macosx/Torrent.h | 5 ++ macosx/Torrent.mm | 42 ------------ tests/libtransmission/move-test.cc | 2 +- 12 files changed, 209 insertions(+), 188 deletions(-) diff --git a/gtk/Session.cc b/gtk/Session.cc index 87bfc0f60..db418bef8 100644 --- a/gtk/Session.cc +++ b/gtk/Session.cc @@ -828,6 +828,17 @@ Session::Impl::Impl(Session& core, tr_session* session) on_pref_changed(TR_KEY_peer_limit_global); on_pref_changed(TR_KEY_inhibit_desktop_hibernation); signal_prefs_changed.connect([this](auto key) { on_pref_changed(key); }); + + tr_sessionSetMetadataCallback( + session, + [](auto* /*session*/, auto* tor, gpointer impl) { static_cast(impl)->on_torrent_metadata_changed(tor); }, + this); + + tr_sessionSetCompletenessCallback( + session, + [](auto* tor, auto completeness, bool was_running, gpointer impl) + { static_cast(impl)->on_torrent_completeness_changed(tor, completeness, was_running); }, + this); } tr_session* Session::close() @@ -986,16 +997,6 @@ void Session::Impl::add_torrent(tr_torrent* tor, bool do_notify) { gtr_notify_torrent_added(get_core_ptr(), tr_torrentId(tor)); } - - tr_torrentSetMetadataCallback( - tor, - [](auto* tor2, gpointer impl) { static_cast(impl)->on_torrent_metadata_changed(tor2); }, - this); - tr_torrentSetCompletenessCallback( - tor, - [](auto* tor2, auto completeness, bool was_running, gpointer impl) - { static_cast(impl)->on_torrent_completeness_changed(tor2, completeness, was_running); }, - this); } } diff --git a/libtransmission/crypto-utils-ccrypto.cc b/libtransmission/crypto-utils-ccrypto.cc index 13640667f..abdc50f44 100644 --- a/libtransmission/crypto-utils-ccrypto.cc +++ b/libtransmission/crypto-utils-ccrypto.cc @@ -93,20 +93,6 @@ bool check_ccrypto_result(CCCryptorStatus result, char const* file, int line) #define check_result(result) check_ccrypto_result((result), __FILE__, __LINE__) -bool check_ccrypto_pointer(void const* pointer, CCCryptorStatus const* result, char const* file, int line) -{ - bool const ret = pointer != nullptr; - - if (!ret) - { - log_ccrypto_error(*result, file, line); - } - - return ret; -} - -#define check_pointer(pointer, result) check_ccrypto_pointer((pointer), (result), __FILE__, __LINE__) - } // namespace /*** diff --git a/libtransmission/peer-mgr.cc b/libtransmission/peer-mgr.cc index 608a52bb3..630dd3951 100644 --- a/libtransmission/peer-mgr.cc +++ b/libtransmission/peer-mgr.cc @@ -2546,11 +2546,7 @@ void queuePulse(tr_session* session, tr_direction dir) for (auto* tor : tr_sessionGetNextQueuedTorrents(session, dir, n)) { tr_torrentStartNow(tor); - - if (tor->queue_started_callback != nullptr) - { - (*tor->queue_started_callback)(tor, tor->queue_started_user_data); - } + session->onQueuedTorrentStarted(tor); } } } diff --git a/libtransmission/session.cc b/libtransmission/session.cc index d0720699a..46d3c57cf 100644 --- a/libtransmission/session.cc +++ b/libtransmission/session.cc @@ -2968,3 +2968,30 @@ void tr_session::closeTorrentFile(tr_torrent* tor, tr_file_index_t file_num) noe this->cache->flushFile(tor, file_num); openFiles().closeFile(tor->id(), file_num); } + +/// + +void tr_sessionSetQueueStartCallback(tr_session* session, void (*cb)(tr_session*, tr_torrent*, void*), void* user_data) +{ + session->setQueueStartCallback(cb, user_data); +} + +void tr_sessionSetRatioLimitHitCallback(tr_session* session, tr_session_ratio_limit_hit_func cb, void* user_data) +{ + session->setRatioLimitHitCallback(cb, user_data); +} + +void tr_sessionSetIdleLimitHitCallback(tr_session* session, tr_session_idle_limit_hit_func cb, void* user_data) +{ + session->setIdleLimitHitCallback(cb, user_data); +} + +void tr_sessionSetMetadataCallback(tr_session* session, tr_session_metadata_func func, void* user_data) +{ + session->setMetadataCallback(func, user_data); +} + +void tr_sessionSetCompletenessCallback(tr_session* session, tr_torrent_completeness_func cb, void* user_data) +{ + session->setTorrentCompletenessCallback(cb, user_data); +} diff --git a/libtransmission/session.h b/libtransmission/session.h index 75ffe0881..5884d4399 100644 --- a/libtransmission/session.h +++ b/libtransmission/session.h @@ -310,6 +310,80 @@ public: announce_ip_enabled_ = enabled; } + // callbacks + + using queue_start_callback_t = void (*)(tr_session*, tr_torrent*, void* user_data); + + void setQueueStartCallback(queue_start_callback_t cb, void* user_data) + { + queue_start_callback_ = cb; + queue_start_user_data_ = user_data; + } + + void onQueuedTorrentStarted(tr_torrent* tor) + { + if (queue_start_callback_ != nullptr) + { + queue_start_callback_(this, tor, queue_start_user_data_); + } + } + + void setIdleLimitHitCallback(tr_session_idle_limit_hit_func cb, void* user_data) + { + idle_limit_hit_callback_ = cb; + idle_limit_hit_user_data_ = user_data; + } + + void onIdleLimitHit(tr_torrent* tor) + { + if (idle_limit_hit_callback_ != nullptr) + { + idle_limit_hit_callback_(this, tor, idle_limit_hit_user_data_); + } + } + + void setRatioLimitHitCallback(tr_session_ratio_limit_hit_func cb, void* user_data) + { + ratio_limit_hit_cb_ = cb; + ratio_limit_hit_user_data_ = user_data; + } + + void onRatioLimitHit(tr_torrent* tor) + { + if (ratio_limit_hit_cb_ != nullptr) + { + ratio_limit_hit_cb_(this, tor, ratio_limit_hit_user_data_); + } + } + + void setMetadataCallback(tr_session_metadata_func cb, void* user_data) + { + got_metadata_cb_ = cb; + got_metadata_user_data_ = user_data; + } + + void onMetadataCompleted(tr_torrent* tor) + { + if (got_metadata_cb_ != nullptr) + { + got_metadata_cb_(this, tor, got_metadata_user_data_); + } + } + + void setTorrentCompletenessCallback(tr_torrent_completeness_func cb, void* user_data) + { + completeness_func_ = cb; + completeness_func_user_data_ = user_data; + } + + void onTorrentCompletenessChanged(tr_torrent* tor, tr_completeness completeness, bool was_running) + { + if (completeness_func_ != nullptr) + { + completeness_func_(tor, completeness, was_running, completeness_func_user_data_); + } + } + public: static constexpr std::array, 3> Scripts{ { { TR_KEY_script_torrent_added_enabled, TR_KEY_script_torrent_added_filename, TR_SCRIPT_ON_TORRENT_ADDED }, @@ -480,6 +554,21 @@ private: std::string peer_congestion_algorithm_; std::optional external_ip_; + queue_start_callback_t queue_start_callback_ = nullptr; + void* queue_start_user_data_ = nullptr; + + tr_session_idle_limit_hit_func idle_limit_hit_callback_ = nullptr; + void* idle_limit_hit_user_data_ = nullptr; + + tr_session_ratio_limit_hit_func ratio_limit_hit_cb_ = nullptr; + void* ratio_limit_hit_user_data_ = nullptr; + + tr_session_metadata_func got_metadata_cb_ = nullptr; + void* got_metadata_user_data_ = nullptr; + + tr_torrent_completeness_func completeness_func_ = nullptr; + void* completeness_func_user_data_ = nullptr; + std::array scripts_enabled_; bool blocklist_enabled_ = false; bool incomplete_dir_enabled_ = false; diff --git a/libtransmission/torrent.cc b/libtransmission/torrent.cc index 484094792..dac3e662b 100644 --- a/libtransmission/torrent.cc +++ b/libtransmission/torrent.cc @@ -486,14 +486,8 @@ void tr_torrentCheckSeedLimit(tr_torrent* tor) if (tr_torrentIsSeedRatioDone(tor)) { tr_logAddInfoTor(tor, _("Seed ratio reached; pausing torrent")); - tor->isStopping = true; - - /* maybe notify the client */ - if (tor->ratio_limit_hit_func != nullptr) - { - (*tor->ratio_limit_hit_func)(tor, tor->ratio_limit_hit_func_user_data); - } + tor->session->onRatioLimitHit(tor); } /* if we're seeding and reach our inactivity limit, stop the torrent */ else if (tr_torrentIsSeedIdleLimitDone(tor)) @@ -502,12 +496,7 @@ void tr_torrentCheckSeedLimit(tr_torrent* tor) tor->isStopping = true; tor->finishedSeedingByIdle = true; - - /* maybe notify the client */ - if (tor->idle_limit_hit_func != nullptr) - { - (*tor->idle_limit_hit_func)(tor, tor->idle_limit_hit_func_user_data); - } + tor->session->onIdleLimitHit(tor); } if (tor->isStopping) @@ -584,8 +573,6 @@ struct torrent_start_opts static void torrentStart(tr_torrent* tor, torrent_start_opts opts); -static void tr_torrentFireMetadataCompleted(tr_torrent* tor); - static void torrentInitFromInfoDict(tr_torrent* tor) { tor->completion = tr_completion{ tor, &tor->blockInfo() }; @@ -613,7 +600,7 @@ void tr_torrent::setMetainfo(tr_torrent_metainfo const& tm) torrentInitFromInfoDict(this); tr_peerMgrOnTorrentGotMetainfo(this); - tr_torrentFireMetadataCompleted(this); + session->onMetadataCompleted(this); this->setDirty(); } @@ -1643,7 +1630,6 @@ void tr_torrentFree(tr_torrent* tor) auto const lock = tor->unique_lock(); - tr_torrentClearCompletenessCallback(tor); tr_runInEventThread(session, closeTorrent, tor); } } @@ -1670,7 +1656,6 @@ static void removeTorrentInEventThread(tr_torrent* tor, bool delete_flag, tr_fil tor->metainfo_.files().remove(tor->currentDir(), tor->name(), delete_func_wrapper); } - tr_torrentClearCompletenessCallback(tor); closeTorrent(tor); } @@ -1707,45 +1692,6 @@ static char const* getCompletionString(int type) } } -static void fireCompletenessChange(tr_torrent* tor, tr_completeness status, bool wasRunning) -{ - TR_ASSERT(status == TR_LEECH || status == TR_SEED || status == TR_PARTIAL_SEED); - - if (tor->completeness_func != nullptr) - { - (*tor->completeness_func)(tor, status, wasRunning, tor->completeness_func_user_data); - } -} - -void tr_torrentSetCompletenessCallback(tr_torrent* tor, tr_torrent_completeness_func func, void* user_data) -{ - TR_ASSERT(tr_isTorrent(tor)); - - tor->completeness_func = func; - tor->completeness_func_user_data = user_data; -} - -void tr_torrentClearCompletenessCallback(tr_torrent* torrent) -{ - tr_torrentSetCompletenessCallback(torrent, nullptr, nullptr); -} - -void tr_torrentSetRatioLimitHitCallback(tr_torrent* tor, tr_torrent_ratio_limit_hit_func func, void* user_data) -{ - TR_ASSERT(tr_isTorrent(tor)); - - tor->ratio_limit_hit_func = func; - tor->ratio_limit_hit_func_user_data = user_data; -} - -void tr_torrentSetIdleLimitHitCallback(tr_torrent* tor, tr_torrent_idle_limit_hit_func func, void* user_data) -{ - TR_ASSERT(tr_isTorrent(tor)); - - tor->idle_limit_hit_func = func; - tor->idle_limit_hit_func_user_data = user_data; -} - static std::string buildLabelsString(tr_torrent const* tor) { auto buf = std::stringstream{}; @@ -1872,7 +1818,7 @@ void tr_torrent::recheckCompleteness() } } - fireCompletenessChange(this, completeness, wasRunning); + this->session->onTorrentCompletenessChanged(this, completeness, wasRunning); if (this->isDone() && wasLeeching && wasRunning) { @@ -1891,28 +1837,6 @@ void tr_torrent::recheckCompleteness() } } -/*** -**** -***/ - -static void tr_torrentFireMetadataCompleted(tr_torrent* tor) -{ - TR_ASSERT(tr_isTorrent(tor)); - - if (tor->metadata_func != nullptr) - { - (*tor->metadata_func)(tor, tor->metadata_func_user_data); - } -} - -void tr_torrentSetMetadataCallback(tr_torrent* tor, tr_torrent_metadata_func func, void* user_data) -{ - TR_ASSERT(tr_isTorrent(tor)); - - tor->metadata_func = func; - tor->metadata_func_user_data = user_data; -} - /** *** File DND **/ @@ -2576,12 +2500,6 @@ static void torrentSetQueued(tr_torrent* tor, bool queued) } } -void tr_torrentSetQueueStartCallback(tr_torrent* torrent, void (*callback)(tr_torrent*, void*), void* user_data) -{ - torrent->queue_started_callback = callback; - torrent->queue_started_user_data = user_data; -} - /*** **** **** RENAME diff --git a/libtransmission/torrent.h b/libtransmission/torrent.h index fdb9644d8..c96881f1d 100644 --- a/libtransmission/torrent.h +++ b/libtransmission/torrent.h @@ -660,21 +660,6 @@ public: * other peers */ struct tr_incomplete_metadata* incompleteMetadata = nullptr; - tr_torrent_metadata_func metadata_func = nullptr; - void* metadata_func_user_data = nullptr; - - tr_torrent_completeness_func completeness_func = nullptr; - void* completeness_func_user_data = nullptr; - - tr_torrent_ratio_limit_hit_func ratio_limit_hit_func = nullptr; - void* ratio_limit_hit_func_user_data = nullptr; - - tr_torrent_idle_limit_hit_func idle_limit_hit_func = nullptr; - void* idle_limit_hit_func_user_data = nullptr; - - void* queue_started_user_data = nullptr; - void (*queue_started_callback)(tr_torrent*, void* queue_started_user_data) = nullptr; - time_t peer_id_creation_time_ = 0; time_t dhtAnnounceAt = 0; diff --git a/libtransmission/transmission.h b/libtransmission/transmission.h index 0f9c1eb34..4808a6c98 100644 --- a/libtransmission/transmission.h +++ b/libtransmission/transmission.h @@ -695,11 +695,8 @@ void tr_sessionSetQueueStalledEnabled(tr_session*, bool); /** @return true if we're torrents idle for over N minutes will be flagged as 'stalled' */ bool tr_sessionGetQueueStalledEnabled(tr_session const*); -/** -**/ - /** @brief Set a callback that is invoked when the queue starts a torrent */ -void tr_torrentSetQueueStartCallback(tr_torrent* torrent, void (*callback)(tr_torrent*, void*), void* user_data); +void tr_sessionSetQueueStartCallback(tr_session*, void (*callback)(tr_session*, tr_torrent*, void*), void* user_data); /*** **** @@ -1185,9 +1182,9 @@ using tr_torrent_completeness_func = void (*)( // bool wasRunning, void* user_data); -using tr_torrent_ratio_limit_hit_func = void (*)(tr_torrent* torrent, void* user_data); +using tr_session_ratio_limit_hit_func = void (*)(tr_session*, tr_torrent* torrent, void* user_data); -using tr_torrent_idle_limit_hit_func = void (*)(tr_torrent* torrent, void* user_data); +using tr_session_idle_limit_hit_func = void (*)(tr_session*, tr_torrent* torrent, void* user_data); /** * Register to be notified whenever a torrent's "completeness" @@ -1202,11 +1199,9 @@ using tr_torrent_idle_limit_hit_func = void (*)(tr_torrent* torrent, void* user_ * * @see tr_completeness */ -void tr_torrentSetCompletenessCallback(tr_torrent* torrent, tr_torrent_completeness_func func, void* user_data); +void tr_sessionSetCompletenessCallback(tr_session* session, tr_torrent_completeness_func func, void* user_data); -void tr_torrentClearCompletenessCallback(tr_torrent* torrent); - -using tr_torrent_metadata_func = void (*)(tr_torrent* torrent, void* user_data); +using tr_session_metadata_func = void (*)(tr_session* session, tr_torrent* torrent, void* user_data); /** * Register to be notified whenever a torrent changes from @@ -1214,25 +1209,25 @@ using tr_torrent_metadata_func = void (*)(tr_torrent* torrent, void* user_data); * This happens when a magnet link finishes downloading * metadata from its peers. */ -void tr_torrentSetMetadataCallback(tr_torrent* tor, tr_torrent_metadata_func func, void* user_data); +void tr_sessionSetMetadataCallback(tr_session* session, tr_session_metadata_func func, void* user_data); /** * Register to be notified whenever a torrent's ratio limit * has been hit. This will be called when the torrent's * ul/dl ratio has met or exceeded the designated ratio limit. * - * Has the same restrictions as tr_torrentSetCompletenessCallback + * Has the same restrictions as tr_sessionSetCompletenessCallback */ -void tr_torrentSetRatioLimitHitCallback(tr_torrent* torrent, tr_torrent_ratio_limit_hit_func func, void* user_data); +void tr_sessionSetRatioLimitHitCallback(tr_session* torrent, tr_session_ratio_limit_hit_func func, void* user_data); /** * Register to be notified whenever a torrent's idle limit * has been hit. This will be called when the seeding torrent's * idle time has met or exceeded the designated idle limit. * - * Has the same restrictions as tr_torrentSetCompletenessCallback + * Has the same restrictions as tr_sessionSetCompletenessCallback */ -void tr_torrentSetIdleLimitHitCallback(tr_torrent* torrent, tr_torrent_idle_limit_hit_func func, void* user_data); +void tr_sessionSetIdleLimitHitCallback(tr_session* torrent, tr_session_idle_limit_hit_func func, void* user_data); /** * MANUAL ANNOUNCE diff --git a/macosx/Controller.mm b/macosx/Controller.mm index e19af8aa1..822962f6b 100644 --- a/macosx/Controller.mm +++ b/macosx/Controller.mm @@ -359,6 +359,61 @@ static void removeKeRangerRansomware() } } +void onStartQueue(tr_session* session, tr_torrent* tor, void* vself) +{ + auto* controller = (__bridge Controller*)(vself); + auto const hashstr = @(tr_torrentView(tor).hash_string); + + dispatch_async(dispatch_get_main_queue(), ^{ + auto* const torrent = [controller torrentForHash:hashstr]; + [torrent startQueue]; + }); +} + +void onIdleLimitHit(tr_session* session, tr_torrent* tor, void* vself) +{ + auto* const controller = (__bridge Controller*)(vself); + auto const hashstr = @(tr_torrentView(tor).hash_string); + + dispatch_async(dispatch_get_main_queue(), ^{ + auto* const torrent = [controller torrentForHash:hashstr]; + [torrent idleLimitHit]; + }); +} + +void onRatioLimitHit(tr_session* session, tr_torrent* tor, void* vself) +{ + auto* const controller = (__bridge Controller*)(vself); + auto const hashstr = @(tr_torrentView(tor).hash_string); + + dispatch_async(dispatch_get_main_queue(), ^{ + auto* const torrent = [controller torrentForHash:hashstr]; + [torrent ratioLimitHit]; + }); +} + +void onMetadataCompleted(tr_session* session, tr_torrent* tor, void* vself) +{ + auto* const controller = (__bridge Controller*)(vself); + auto const hashstr = @(tr_torrentView(tor).hash_string); + + dispatch_async(dispatch_get_main_queue(), ^{ + auto* const torrent = [controller torrentForHash:hashstr]; + [torrent metadataRetrieved]; + }); +} + +void onTorrentCompletenessChanged(tr_torrent* tor, tr_completeness status, bool wasRunning, void* vself) +{ + auto* const controller = (__bridge Controller*)(vself); + auto const hashstr = @(tr_torrentView(tor).hash_string); + + dispatch_async(dispatch_get_main_queue(), ^{ + auto* const torrent = [controller torrentForHash:hashstr]; + [torrent completenessChange:status wasRunning:wasRunning]; + }); +} + - (instancetype)init { if ((self = [super init])) @@ -514,6 +569,12 @@ static void removeKeRangerRansomware() _fConfigDirectory = @(default_config_dir); tr_free(default_config_dir); + tr_sessionSetIdleLimitHitCallback(_fLib, onIdleLimitHit, (__bridge void*)(self)); + tr_sessionSetQueueStartCallback(_fLib, onStartQueue, (__bridge void*)(self)); + tr_sessionSetRatioLimitHitCallback(_fLib, onRatioLimitHit, (__bridge void*)(self)); + tr_sessionSetMetadataCallback(_fLib, onMetadataCompleted, (__bridge void*)(self)); + tr_sessionSetCompletenessCallback(_fLib, onTorrentCompletenessChanged, (__bridge void*)(self)); + NSApp.delegate = self; //register for magnet URLs (has to be in init) diff --git a/macosx/Torrent.h b/macosx/Torrent.h index b59aec71b..6ec554e5b 100644 --- a/macosx/Torrent.h +++ b/macosx/Torrent.h @@ -44,8 +44,13 @@ typedef NS_ENUM(unsigned int, TorrentDeterminationType) { - (void)startTransferNoQueue; - (void)startTransfer; - (void)stopTransfer; +- (void)startQueue; - (void)sleep; - (void)wakeUp; +- (void)idleLimitHit; +- (void)ratioLimitHit; +- (void)metadataRetrieved; +- (void)completenessChange:(tr_completeness)status wasRunning:(BOOL)wasRunning; @property(nonatomic) NSUInteger queuePosition; diff --git a/macosx/Torrent.mm b/macosx/Torrent.mm index 054ee6223..f21b63dad 100644 --- a/macosx/Torrent.mm +++ b/macosx/Torrent.mm @@ -64,7 +64,6 @@ - (void)sortFileList:(NSMutableArray*)fileNodes; - (void)startQueue; -- (void)completenessChange:(tr_completeness)status wasRunning:(BOOL)wasRunning; - (void)ratioLimitHit; - (void)idleLimitHit; - (void)metadataRetrieved; @@ -81,41 +80,6 @@ @end -void startQueueCallback(tr_torrent* torrent, void* torrentData) -{ - dispatch_async(dispatch_get_main_queue(), ^{ - [(__bridge Torrent*)torrentData startQueue]; - }); -} - -void completenessChangeCallback(tr_torrent* torrent, tr_completeness status, bool wasRunning, void* torrentData) -{ - dispatch_async(dispatch_get_main_queue(), ^{ - [(__bridge Torrent*)torrentData completenessChange:status wasRunning:wasRunning]; - }); -} - -void ratioLimitHitCallback(tr_torrent* torrent, void* torrentData) -{ - dispatch_async(dispatch_get_main_queue(), ^{ - [(__bridge Torrent*)torrentData ratioLimitHit]; - }); -} - -void idleLimitHitCallback(tr_torrent* torrent, void* torrentData) -{ - dispatch_async(dispatch_get_main_queue(), ^{ - [(__bridge Torrent*)torrentData idleLimitHit]; - }); -} - -void metadataCallback(tr_torrent* torrent, void* torrentData) -{ - dispatch_async(dispatch_get_main_queue(), ^{ - [(__bridge Torrent*)torrentData metadataRetrieved]; - }); -} - void renameCallback(tr_torrent* torrent, char const* oldPathCharString, char const* newNameCharString, int error, void* contextInfo) { @autoreleasepool @@ -1811,12 +1775,6 @@ bool trashDataFile(char const* filename, tr_error** error) } } - tr_torrentSetQueueStartCallback(self.fHandle, startQueueCallback, (__bridge void*)(self)); - tr_torrentSetCompletenessCallback(self.fHandle, completenessChangeCallback, (__bridge void*)(self)); - tr_torrentSetRatioLimitHitCallback(self.fHandle, ratioLimitHitCallback, (__bridge void*)(self)); - tr_torrentSetIdleLimitHitCallback(self.fHandle, idleLimitHitCallback, (__bridge void*)(self)); - tr_torrentSetMetadataCallback(self.fHandle, metadataCallback, (__bridge void*)(self)); - _fResumeOnWake = NO; //don't do after this point - it messes with auto-group functionality diff --git a/tests/libtransmission/move-test.cc b/tests/libtransmission/move-test.cc index 380c0d294..14fa412c8 100644 --- a/tests/libtransmission/move-test.cc +++ b/tests/libtransmission/move-test.cc @@ -74,7 +74,7 @@ TEST_P(IncompleteDirTest, incompleteDir) { *static_cast(vc) = c; }; - tr_torrentSetCompletenessCallback(tor, zeroes_completeness_func, &completeness); + tr_sessionSetCompletenessCallback(session_, zeroes_completeness_func, &completeness); struct TestIncompleteDirData {