refactor: remove tr_session* argument from tr_rpc_response_func (#8160)

gtk/Session.cc

@@ -1241,7 +1241,7 @@ bool core_read_rpc_response_idle(tr_variant& response)
     return false;
 }
 
-void core_read_rpc_response(tr_session* /*session*/, tr_variant&& response)
+void core_read_rpc_response(tr_variant&& response)
 {
     auto owned_response = std::make_shared<tr_variant>(std::move(response));
     Glib::signal_idle().connect([owned_response]() mutable { return core_read_rpc_response_idle(*owned_response); });
@@ -1272,7 +1272,7 @@ void Session::Impl::send_rpc_request(
     }
 
     // add id if we want a response
-    auto callback = std::function<void(tr_session*, tr_variant&&)>{};
+    auto callback = std::function<void(tr_variant&&)>{};
     if (on_response)
     {
         auto const id = nextId++;

libtransmission/rpc-server.cc

@@ -367,7 +367,7 @@ void handle_rpc_from_json(struct evhttp_request* req, tr_rpc_server* server, std
         server->session,
         json,
         // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
-        [req, server](tr_session* /*session*/, tr_variant&& content)
+        [req, server](tr_variant&& content)
         {
             if (!content.has_value())
             {

libtransmission/rpcimpl.cc

@@ -221,11 +221,11 @@ void tr_rpc_idle_done(struct tr_rpc_idle_data* data, JsonRpc::Error::Code code,
         {
             libtransmission::api_compat::convert(response, libtransmission::api_compat::Style::Tr4);
         }
-        data->callback(data->session, std::move(response));
+        data->callback(std::move(response));
     }
     else // notification
     {
-        data->callback(data->session, {});
+        data->callback({});
     }
 
     delete data;
@@ -2801,7 +2801,7 @@ auto const async_handlers = small::max_size_map<tr_quark, std::pair<AsyncHandler
     { TR_KEY_torrent_rename_path, { torrentRenamePath, true } },
 } };
 
-void noop_response_callback(tr_session* /*session*/, tr_variant&& /*response*/)
+void noop_response_callback(tr_variant&& /*response*/)
 {
 }
 
@@ -2817,12 +2817,10 @@ void tr_rpc_request_exec_impl(tr_session* session, tr_variant& request, tr_rpc_r
     auto const* map = request.get_if<tr_variant::Map>();
     if (map == nullptr)
     {
-        callback(
-            session,
-            build_response(
-                Error::INVALID_REQUEST,
-                nullptr,
-                Error::build_data(is_batch ? "request must be an Object"sv : "request must be an Array or Object"sv, {})));
+        callback(build_response(
+            Error::INVALID_REQUEST,
+            nullptr,
+            Error::build_data(is_batch ? "request must be an Object"sv : "request must be an Array or Object"sv, {})));
         return;
     }
 
@@ -2833,9 +2831,7 @@ void tr_rpc_request_exec_impl(tr_session* session, tr_variant& request, tr_rpc_r
     }
     else if (jsonrpc || is_batch)
     {
-        callback(
-            session,
-            build_response(Error::INVALID_REQUEST, nullptr, Error::build_data("JSON-RPC version is not 2.0"sv, {})));
+        callback(build_response(Error::INVALID_REQUEST, nullptr, Error::build_data("JSON-RPC version is not 2.0"sv, {})));
         return;
     }
     else
@@ -2851,7 +2847,7 @@ void tr_rpc_request_exec_impl(tr_session* session, tr_variant& request, tr_rpc_r
                 TR_KEY_result,
                 tr_variant::unmanaged_string(
                     "bug in api-compat, please report a bug at https://github.com/transmission/transmission/issues"sv));
-            callback(session, std::move(response));
+            callback(std::move(response));
             return;
         }
     }
@@ -2928,7 +2924,7 @@ void tr_rpc_request_exec_batch(tr_session* session, tr_variant::Vector& requests
         tr_rpc_request_exec_impl(
             session,
             requests[i],
-            [responses, n_requests, n_responses, i, cb](tr_session* s, tr_variant&& response)
+            [responses, n_requests, n_responses, i, cb](tr_variant&& response)
             {
                 (*responses)[i] = std::move(response);
 
@@ -2941,7 +2937,7 @@ void tr_rpc_request_exec_batch(tr_session* session, tr_variant::Vector& requests
                         [](auto const& r) { return !r.has_value(); });
                     responses->erase(it_end, std::end(*responses));
 
-                    (*cb)(s, !std::empty(*responses) ? std::move(*responses) : tr_variant{});
+                    (*cb)(!std::empty(*responses) ? std::move(*responses) : tr_variant{});
                 }
             },
             true);
@@ -2974,5 +2970,5 @@ void tr_rpc_request_exec(tr_session* session, std::string_view request, tr_rpc_r
         return;
     }
 
-    callback(session, build_response(Error::PARSE_ERROR, nullptr, Error::build_data(serde.error_.message(), {})));
+    callback(build_response(Error::PARSE_ERROR, nullptr, Error::build_data(serde.error_.message(), {})));
 }

libtransmission/rpcimpl.h

@@ -48,7 +48,7 @@ enum Code : int16_t
 } // namespace Error
 } // namespace JsonRpc
 
-using tr_rpc_response_func = std::function<void(tr_session* session, tr_variant&& response)>;
+using tr_rpc_response_func = std::function<void(tr_variant&& response)>;
 
 void tr_rpc_request_exec(tr_session* session, tr_variant& request, tr_rpc_response_func&& callback = {});
 

qt/RpcClient.cc

@@ -156,7 +156,7 @@ void RpcClient::sendLocalRequest(tr_variant& req, QFutureInterface<RpcResponse>
     tr_rpc_request_exec(
         session_,
         req,
-        [this](tr_session* /*session*/, tr_variant&& response)
+        [this](tr_variant&& response)
         {
             api_compat::convert_incoming_data(response);
 

tests/libtransmission/rpc-test.cc

@@ -43,10 +43,7 @@ namespace
     }
 
     auto response = tr_variant{};
-    tr_rpc_request_exec(
-        session,
-        *request,
-        [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); });
+    tr_rpc_request_exec(session, *request, [&response](tr_variant&& resp) { response = std::move(resp); });
 
     return serde.to_string(response);
 }
@@ -57,10 +54,7 @@ TEST_F(RpcTest, EmptyRequest)
     static auto constexpr Request = ""sv;
 
     auto response = tr_variant{};
-    tr_rpc_request_exec(
-        session_,
-        Request,
-        [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); });
+    tr_rpc_request_exec(session_, Request, [&response](tr_variant&& resp) { response = std::move(resp); });
 
     auto const* const response_map = response.get_if<tr_variant::Map>();
     ASSERT_NE(response_map, nullptr);
@@ -90,10 +84,7 @@ TEST_F(RpcTest, NotArrayOrObject)
     for (auto& req : requests)
     {
         auto response = tr_variant{};
-        tr_rpc_request_exec(
-            session_,
-            req,
-            [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); });
+        tr_rpc_request_exec(session_, req, [&response](tr_variant&& resp) { response = std::move(resp); });
 
         auto const* const response_map = response.get_if<tr_variant::Map>();
         ASSERT_NE(response_map, nullptr);
@@ -126,10 +117,7 @@ TEST_F(RpcTest, JsonRpcWrongVersion)
     auto request = tr_variant{ std::move(request_map) };
 
     auto response = tr_variant{};
-    tr_rpc_request_exec(
-        session_,
-        request,
-        [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); });
+    tr_rpc_request_exec(session_, request, [&response](tr_variant&& resp) { response = std::move(resp); });
 
     auto const* const response_map = response.get_if<tr_variant::Map>();
     ASSERT_NE(response_map, nullptr);
@@ -169,10 +157,7 @@ TEST_F(RpcTest, idSync)
         auto request = tr_variant{ std::move(request_map) };
 
         auto response = tr_variant{};
-        tr_rpc_request_exec(
-            session_,
-            request,
-            [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); });
+        tr_rpc_request_exec(session_, request, [&response](tr_variant&& resp) { response = std::move(resp); });
 
         auto const* const response_map = response.get_if<tr_variant::Map>();
         ASSERT_NE(response_map, nullptr);
@@ -217,10 +202,7 @@ TEST_F(RpcTest, idWrongType)
         auto request = tr_variant{ std::move(request_map) };
 
         auto response = tr_variant{};
-        tr_rpc_request_exec(
-            session_,
-            request,
-            [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); });
+        tr_rpc_request_exec(session_, request, [&response](tr_variant&& resp) { response = std::move(resp); });
 
         auto const* const response_map = response.get_if<tr_variant::Map>();
         ASSERT_NE(response_map, nullptr);
@@ -252,10 +234,7 @@ TEST_F(RpcTest, tagSyncLegacy)
     auto request = tr_variant{ std::move(request_map) };
 
     auto response = tr_variant{};
-    tr_rpc_request_exec(
-        session_,
-        request,
-        [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); });
+    tr_rpc_request_exec(session_, request, [&response](tr_variant&& resp) { response = std::move(resp); });
 
     auto const* const response_map = response.get_if<tr_variant::Map>();
     ASSERT_NE(response_map, nullptr);
@@ -293,10 +272,7 @@ TEST_F(RpcTest, idAsync)
         auto request = tr_variant{ std::move(request_map) };
         auto promise = std::promise<tr_variant>{};
         auto future = promise.get_future();
-        tr_rpc_request_exec(
-            session_,
-            request,
-            [&promise](tr_session* /*session*/, tr_variant&& resp) { promise.set_value(std::move(resp)); });
+        tr_rpc_request_exec(session_, request, [&promise](tr_variant&& resp) { promise.set_value(std::move(resp)); });
         auto const response = future.get();
 
         auto const* const response_map = response.get_if<tr_variant::Map>();
@@ -346,10 +322,7 @@ TEST_F(RpcTest, tagAsyncLegacy)
     auto request = tr_variant{ std::move(request_map) };
     auto promise = std::promise<tr_variant>{};
     auto future = promise.get_future();
-    tr_rpc_request_exec(
-        session_,
-        request,
-        [&promise](tr_session* /*session*/, tr_variant&& resp) { promise.set_value(std::move(resp)); });
+    tr_rpc_request_exec(session_, request, [&promise](tr_variant&& resp) { promise.set_value(std::move(resp)); });
     auto const response = future.get();
 
     auto const* const response_map = response.get_if<tr_variant::Map>();
@@ -373,10 +346,7 @@ TEST_F(RpcTest, NotificationSync)
     auto request = tr_variant{ std::move(request_map) };
 
     auto response = tr_variant{};
-    tr_rpc_request_exec(
-        session_,
-        request,
-        [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); });
+    tr_rpc_request_exec(session_, request, [&response](tr_variant&& resp) { response = std::move(resp); });
 
     EXPECT_FALSE(response.has_value());
 }
@@ -398,10 +368,7 @@ TEST_F(RpcTest, NotificationAsync)
     auto request = tr_variant{ std::move(request_map) };
     auto promise = std::promise<tr_variant>{};
     auto future = promise.get_future();
-    tr_rpc_request_exec(
-        session_,
-        request,
-        [&promise](tr_session* /*session*/, tr_variant&& resp) { promise.set_value(std::move(resp)); });
+    tr_rpc_request_exec(session_, request, [&promise](tr_variant&& resp) { promise.set_value(std::move(resp)); });
     auto const response = future.get();
 
     EXPECT_FALSE(response.has_value());
@@ -419,10 +386,7 @@ TEST_F(RpcTest, tagNoHandler)
     auto request = tr_variant{ std::move(request_map) };
 
     auto response = tr_variant{};
-    tr_rpc_request_exec(
-        session_,
-        request,
-        [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); });
+    tr_rpc_request_exec(session_, request, [&response](tr_variant&& resp) { response = std::move(resp); });
 
     auto const* const response_map = response.get_if<tr_variant::Map>();
     ASSERT_NE(response_map, nullptr);
@@ -452,10 +416,7 @@ TEST_F(RpcTest, tagNoHandlerLegacy)
     auto request = tr_variant{ std::move(request_map) };
 
     auto response = tr_variant{};
-    tr_rpc_request_exec(
-        session_,
-        request,
-        [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); });
+    tr_rpc_request_exec(session_, request, [&response](tr_variant&& resp) { response = std::move(resp); });
 
     auto const* const response_map = response.get_if<tr_variant::Map>();
     ASSERT_NE(response_map, nullptr);
@@ -513,10 +474,7 @@ TEST_F(RpcTest, batch)
 
     auto request = tr_variant{ std::move(request_vec) };
     auto response = tr_variant{};
-    tr_rpc_request_exec(
-        session_,
-        request,
-        [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); });
+    tr_rpc_request_exec(session_, request, [&response](tr_variant&& resp) { response = std::move(resp); });
 
     auto* const response_vec_ptr = response.get_if<tr_variant::Vector>();
     ASSERT_NE(response_vec_ptr, nullptr);
@@ -632,10 +590,7 @@ TEST_F(RpcTest, sessionGet)
     auto request = tr_variant{ std::move(request_map) };
 
     auto response = tr_variant{};
-    tr_rpc_request_exec(
-        session_,
-        request,
-        [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); });
+    tr_rpc_request_exec(session_, request, [&response](tr_variant&& resp) { response = std::move(resp); });
 
     auto* response_map = response.get_if<tr_variant::Map>();
     ASSERT_NE(response_map, nullptr);
@@ -758,10 +713,7 @@ TEST_F(RpcTest, torrentGet)
 
     auto request = tr_variant{ std::move(request_map) };
     auto response = tr_variant{};
-    tr_rpc_request_exec(
-        session_,
-        request,
-        [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); });
+    tr_rpc_request_exec(session_, request, [&response](tr_variant&& resp) { response = std::move(resp); });
 
     auto* response_map = response.get_if<tr_variant::Map>();
     ASSERT_NE(response_map, nullptr);
@@ -799,10 +751,7 @@ TEST_F(RpcTest, torrentGetLegacy)
 
     auto request = tr_variant{ std::move(request_map) };
     auto response = tr_variant{};
-    tr_rpc_request_exec(
-        session_,
-        request,
-        [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); });
+    tr_rpc_request_exec(session_, request, [&response](tr_variant&& resp) { response = std::move(resp); });
 
     auto* response_map = response.get_if<tr_variant::Map>();
     ASSERT_NE(response_map, nullptr);