tdlight-team/tdlight
tdlight-team/tdlight
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove all NetActorOnce usages.

Browse Source
This commit is contained in:
levlam 2022-02-04 00:46:10 +03:00
parent 4bfdd1e7a8
commit 6e82e51243
4 changed files with 128 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
td/telegram/GameManager.cpp
View File

@ -16,7 +16,6 @@
#include "td/telegram/MessageId.h" #include "td/telegram/MessageId.h"
#include "td/telegram/MessagesManager.h" #include "td/telegram/MessagesManager.h"
#include "td/telegram/net/DcId.h" #include "td/telegram/net/DcId.h"
#include "td/telegram/net/NetActor.h"
#include "td/telegram/net/NetQueryCreator.h" #include "td/telegram/net/NetQueryCreator.h"
#include "td/telegram/Td.h" #include "td/telegram/Td.h"
#include "td/telegram/UpdatesManager.h" #include "td/telegram/UpdatesManager.h"
@ -27,12 +26,12 @@
namespace td { namespace td {
class SetGameScoreActor final : public NetActorOnce { class SetGameScoreQuery final : public Td::ResultHandler {
Promise<Unit> promise_; Promise<Unit> promise_;
DialogId dialog_id_; DialogId dialog_id_;
public: public:
explicit SetGameScoreActor(Promise<Unit> &&promise) : promise_(std::move(promise)) { explicit SetGameScoreQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
} }
void send(DialogId dialog_id, MessageId message_id, bool edit_message, void send(DialogId dialog_id, MessageId message_id, bool edit_message,
@ -49,9 +48,7 @@ class SetGameScoreActor final : public NetActorOnce {
auto input_peer = td_->messages_manager_->get_input_peer(dialog_id, AccessRights::Edit); auto input_peer = td_->messages_manager_->get_input_peer(dialog_id, AccessRights::Edit);
if (input_peer == nullptr) { if (input_peer == nullptr) {
on_error(Status::Error(400, "Can't access the chat")); return on_error(Status::Error(400, "Can't access the chat"));
stop();
return;
} }
CHECK(input_user != nullptr); CHECK(input_user != nullptr);
@ -73,8 +70,8 @@ class SetGameScoreActor final : public NetActorOnce {
} }
void on_error(Status status) final { void on_error(Status status) final {
LOG(INFO) << "Receive error for SetGameScore: " << status; LOG(INFO) << "Receive error for SetGameScoreQuery: " << status;
td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SetGameScoreActor"); td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SetGameScoreQuery");
promise_.set_error(std::move(status)); promise_.set_error(std::move(status));
} }
}; };
@ -229,8 +226,8 @@ void GameManager::set_game_score(FullMessageId full_message_id, bool edit_messag
} }
send_closure(actor_id, &GameManager::on_set_game_score, full_message_id, std::move(promise)); send_closure(actor_id, &GameManager::on_set_game_score, full_message_id, std::move(promise));
}); });
send_closure(td_->create_net_actor<SetGameScoreActor>(std::move(query_promise)), &SetGameScoreActor::send, dialog_id, td_->create_handler<SetGameScoreQuery>(std::move(query_promise))
full_message_id.get_message_id(), edit_message, r_input_user.move_as_ok(), score, force, ->send(dialog_id, full_message_id.get_message_id(), edit_message, r_input_user.move_as_ok(), score, force,
MessagesManager::get_sequence_dispatcher_id(dialog_id, MessageContentType::None)); MessagesManager::get_sequence_dispatcher_id(dialog_id, MessageContentType::None));
} }

202
td/telegram/MessagesManager.cpp
View File

@ -327,12 +327,12 @@ class GetDialogsQuery final : public Td::ResultHandler {
} }
}; };
class GetPinnedDialogsActor final : public NetActorOnce { class GetPinnedDialogsQuery final : public Td::ResultHandler {
FolderId folder_id_; FolderId folder_id_;
Promise<Unit> promise_; Promise<Unit> promise_;
public: public:
explicit GetPinnedDialogsActor(Promise<Unit> &&promise) : promise_(std::move(promise)) { explicit GetPinnedDialogsQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
} }
NetQueryRef send(FolderId folder_id, uint64 sequence_id) { NetQueryRef send(FolderId folder_id, uint64 sequence_id) {
@ -353,8 +353,8 @@ class GetPinnedDialogsActor final : public NetActorOnce {
auto result = result_ptr.move_as_ok(); auto result = result_ptr.move_as_ok();
LOG(INFO) << "Receive pinned chats in " << folder_id_ << ": " << to_string(result); LOG(INFO) << "Receive pinned chats in " << folder_id_ << ": " << to_string(result);
td_->contacts_manager_->on_get_users(std::move(result->users_), "GetPinnedDialogsActor"); td_->contacts_manager_->on_get_users(std::move(result->users_), "GetPinnedDialogsQuery");
td_->contacts_manager_->on_get_chats(std::move(result->chats_), "GetPinnedDialogsActor"); td_->contacts_manager_->on_get_chats(std::move(result->chats_), "GetPinnedDialogsQuery");
td_->messages_manager_->on_get_dialogs(folder_id_, std::move(result->dialogs_), -2, std::move(result->messages_), td_->messages_manager_->on_get_dialogs(folder_id_, std::move(result->dialogs_), -2, std::move(result->messages_),
std::move(promise_)); std::move(promise_));
} }
@ -775,12 +775,12 @@ class ExportChannelMessageLinkQuery final : public Td::ResultHandler {
} }
}; };
class GetDialogListActor final : public NetActorOnce { class GetDialogListQuery final : public Td::ResultHandler {
FolderId folder_id_; FolderId folder_id_;
Promise<Unit> promise_; Promise<Unit> promise_;
public: public:
explicit GetDialogListActor(Promise<Unit> &&promise) : promise_(std::move(promise)) { explicit GetDialogListQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
} }
void send(FolderId folder_id, int32 offset_date, ServerMessageId offset_message_id, DialogId offset_dialog_id, void send(FolderId folder_id, int32 offset_date, ServerMessageId offset_message_id, DialogId offset_dialog_id,
@ -808,8 +808,8 @@ class GetDialogListActor final : public NetActorOnce {
switch (ptr->get_id()) { switch (ptr->get_id()) {
case telegram_api::messages_dialogs::ID: { case telegram_api::messages_dialogs::ID: {
auto dialogs = move_tl_object_as<telegram_api::messages_dialogs>(ptr); auto dialogs = move_tl_object_as<telegram_api::messages_dialogs>(ptr);
td_->contacts_manager_->on_get_users(std::move(dialogs->users_), "GetDialogListActor"); td_->contacts_manager_->on_get_users(std::move(dialogs->users_), "GetDialogListQuery");
td_->contacts_manager_->on_get_chats(std::move(dialogs->chats_), "GetDialogListActor"); td_->contacts_manager_->on_get_chats(std::move(dialogs->chats_), "GetDialogListQuery");
td_->messages_manager_->on_get_dialogs(folder_id_, std::move(dialogs->dialogs_), td_->messages_manager_->on_get_dialogs(folder_id_, std::move(dialogs->dialogs_),
narrow_cast<int32>(dialogs->dialogs_.size()), narrow_cast<int32>(dialogs->dialogs_.size()),
std::move(dialogs->messages_), std::move(promise_)); std::move(dialogs->messages_), std::move(promise_));
@ -817,8 +817,8 @@ class GetDialogListActor final : public NetActorOnce {
} }
case telegram_api::messages_dialogsSlice::ID: { case telegram_api::messages_dialogsSlice::ID: {
auto dialogs = move_tl_object_as<telegram_api::messages_dialogsSlice>(ptr); auto dialogs = move_tl_object_as<telegram_api::messages_dialogsSlice>(ptr);
td_->contacts_manager_->on_get_users(std::move(dialogs->users_), "GetDialogListActor"); td_->contacts_manager_->on_get_users(std::move(dialogs->users_), "GetDialogListQuery");
td_->contacts_manager_->on_get_chats(std::move(dialogs->chats_), "GetDialogListActor"); td_->contacts_manager_->on_get_chats(std::move(dialogs->chats_), "GetDialogListQuery");
td_->messages_manager_->on_get_dialogs(folder_id_, std::move(dialogs->dialogs_), max(dialogs->count_, 0), td_->messages_manager_->on_get_dialogs(folder_id_, std::move(dialogs->dialogs_), max(dialogs->count_, 0),
std::move(dialogs->messages_), std::move(promise_)); std::move(dialogs->messages_), std::move(promise_));
break; break;
@ -1833,13 +1833,13 @@ class ToggleDialogUnreadMarkQuery final : public Td::ResultHandler {
} }
}; };
class ToggleDialogIsBlockedActor final : public NetActorOnce { class ToggleDialogIsBlockedQuery final : public Td::ResultHandler {
Promise<Unit> promise_; Promise<Unit> promise_;
DialogId dialog_id_; DialogId dialog_id_;
bool is_blocked_; bool is_blocked_;
public: public:
explicit ToggleDialogIsBlockedActor(Promise<Unit> &&promise) : promise_(std::move(promise)) { explicit ToggleDialogIsBlockedQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
} }
void send(DialogId dialog_id, bool is_blocked, uint64 sequence_dispatcher_id) { void send(DialogId dialog_id, bool is_blocked, uint64 sequence_dispatcher_id) {
@ -1869,13 +1869,13 @@ class ToggleDialogIsBlockedActor final : public NetActorOnce {
} }
void on_error(Status status) final { void on_error(Status status) final {
if (!td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "ToggleDialogIsBlockedActor")) { if (!td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "ToggleDialogIsBlockedQuery")) {
LOG(ERROR) << "Receive error for ToggleDialogIsBlockedActor: " << status; LOG(ERROR) << "Receive error for ToggleDialogIsBlockedQuery: " << status;
} }
if (!G()->close_flag()) { if (!G()->close_flag()) {
td_->messages_manager_->on_update_dialog_is_blocked(dialog_id_, !is_blocked_); td_->messages_manager_->on_update_dialog_is_blocked(dialog_id_, !is_blocked_);
td_->messages_manager_->get_dialog_info_full(dialog_id_, Auto(), "ToggleDialogIsBlockedActor"); td_->messages_manager_->get_dialog_info_full(dialog_id_, Auto(), "ToggleDialogIsBlockedQuery");
td_->messages_manager_->reget_dialog_action_bar(dialog_id_, "ToggleDialogIsBlockedActor"); td_->messages_manager_->reget_dialog_action_bar(dialog_id_, "ToggleDialogIsBlockedQuery");
} }
promise_.set_error(std::move(status)); promise_.set_error(std::move(status));
} }
@ -3076,11 +3076,11 @@ class ReadReactionsQuery final : public Td::ResultHandler {
} }
}; };
class SaveDefaultSendAsActor final : public NetActorOnce { class SaveDefaultSendAsQuery final : public Td::ResultHandler {
Promise<Unit> promise_; Promise<Unit> promise_;
public: public:
explicit SaveDefaultSendAsActor(Promise<Unit> &&promise) : promise_(std::move(promise)) { explicit SaveDefaultSendAsQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
} }
void send(DialogId dialog_id, DialogId send_as_dialog_id, uint64 sequence_dispatcher_id) { void send(DialogId dialog_id, DialogId send_as_dialog_id, uint64 sequence_dispatcher_id) {
@ -3102,13 +3102,13 @@ class SaveDefaultSendAsActor final : public NetActorOnce {
} }
auto success = result_ptr.move_as_ok(); auto success = result_ptr.move_as_ok();
LOG(INFO) << "Receive result for SaveDefaultSendAsActor: " << success; LOG(INFO) << "Receive result for SaveDefaultSendAsQuery: " << success;
promise_.set_value(Unit()); promise_.set_value(Unit());
} }
void on_error(Status status) final { void on_error(Status status) final {
// td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SaveDefaultSendAsActor"); // td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SaveDefaultSendAsQuery");
promise_.set_error(std::move(status)); promise_.set_error(std::move(status));
} }
}; };
@ -3164,7 +3164,7 @@ class SendSecretMessageActor final : public NetActor {
} }
}; };
class SendMessageActor final : public NetActorOnce { class SendMessageQuery final : public Td::ResultHandler {
int64 random_id_; int64 random_id_;
DialogId dialog_id_; DialogId dialog_id_;
@ -3178,9 +3178,7 @@ class SendMessageActor final : public NetActorOnce {
auto input_peer = td_->messages_manager_->get_input_peer(dialog_id, AccessRights::Write); auto input_peer = td_->messages_manager_->get_input_peer(dialog_id, AccessRights::Write);
if (input_peer == nullptr) { if (input_peer == nullptr) {
on_error(Status::Error(400, "Have no write access to the chat")); return on_error(Status::Error(400, "Have no write access to the chat"));
stop();
return;
} }
if (!entities.empty()) { if (!entities.empty()) {
@ -3214,7 +3212,7 @@ class SendMessageActor final : public NetActorOnce {
} }
auto ptr = result_ptr.move_as_ok(); auto ptr = result_ptr.move_as_ok();
LOG(INFO) << "Receive result for SendMessage for " << random_id_ << ": " << to_string(ptr); LOG(INFO) << "Receive result for SendMessageQuery for " << random_id_ << ": " << to_string(ptr);
auto constructor_id = ptr->get_id(); auto constructor_id = ptr->get_id();
if (constructor_id != telegram_api::updateShortSentMessage::ID) { if (constructor_id != telegram_api::updateShortSentMessage::ID) {
@ -3247,7 +3245,7 @@ class SendMessageActor final : public NetActorOnce {
// do not send error, message will be re-sent // do not send error, message will be re-sent
return; return;
} }
td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SendMessageActor"); td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SendMessageQuery");
td_->messages_manager_->on_send_message_fail(random_id_, std::move(status)); td_->messages_manager_->on_send_message_fail(random_id_, std::move(status));
} }
}; };
@ -3352,7 +3350,7 @@ class SendInlineBotResultQuery final : public Td::ResultHandler {
} }
}; };
class SendMultiMediaActor final : public NetActorOnce { class SendMultiMediaQuery final : public Td::ResultHandler {
vector<FileId> file_ids_; vector<FileId> file_ids_;
vector<string> file_references_; vector<string> file_references_;
vector<int64> random_ids_; vector<int64> random_ids_;
@ -3373,9 +3371,7 @@ class SendMultiMediaActor final : public NetActorOnce {
auto input_peer = td_->messages_manager_->get_input_peer(dialog_id, AccessRights::Write); auto input_peer = td_->messages_manager_->get_input_peer(dialog_id, AccessRights::Write);
if (input_peer == nullptr) { if (input_peer == nullptr) {
on_error(Status::Error(400, "Have no write access to the chat")); return on_error(Status::Error(400, "Have no write access to the chat"));
stop();
return;
} }
if (as_input_peer != nullptr) { if (as_input_peer != nullptr) {
@ -3429,7 +3425,7 @@ class SendMultiMediaActor final : public NetActorOnce {
} }
} }
if (is_result_wrong) { if (is_result_wrong) {
LOG(ERROR) << "Receive wrong result for SendMultiMedia with random_ids " << format::as_array(random_ids_) LOG(ERROR) << "Receive wrong result for SendMultiMediaQuery with random_ids " << format::as_array(random_ids_)
<< " to " << dialog_id_ << ": " << oneline(to_string(ptr)); << " to " << dialog_id_ << ": " << oneline(to_string(ptr));
td_->updates_manager_->schedule_get_difference("Wrong sendMultiMedia result"); td_->updates_manager_->schedule_get_difference("Wrong sendMultiMedia result");
} }
@ -3455,14 +3451,14 @@ class SendMultiMediaActor final : public NetActorOnce {
<< ", message_count = " << file_ids_.size(); << ", message_count = " << file_ids_.size();
} }
} }
td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SendMultiMediaActor"); td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SendMultiMediaQuery");
for (auto &random_id : random_ids_) { for (auto &random_id : random_ids_) {
td_->messages_manager_->on_send_message_fail(random_id, status.clone()); td_->messages_manager_->on_send_message_fail(random_id, status.clone());
} }
} }
}; };
class SendMediaActor final : public NetActorOnce { class SendMediaQuery final : public Td::ResultHandler {
int64 random_id_ = 0; int64 random_id_ = 0;
FileId file_id_; FileId file_id_;
FileId thumbnail_file_id_; FileId thumbnail_file_id_;
@ -3488,9 +3484,7 @@ class SendMediaActor final : public NetActorOnce {
auto input_peer = td_->messages_manager_->get_input_peer(dialog_id, AccessRights::Write); auto input_peer = td_->messages_manager_->get_input_peer(dialog_id, AccessRights::Write);
if (input_peer == nullptr) { if (input_peer == nullptr) {
on_error(Status::Error(400, "Have no write access to the chat")); return on_error(Status::Error(400, "Have no write access to the chat"));
stop();
return;
} }
if (!entities.empty()) { if (!entities.empty()) {
@ -3531,7 +3525,7 @@ class SendMediaActor final : public NetActorOnce {
} }
auto ptr = result_ptr.move_as_ok(); auto ptr = result_ptr.move_as_ok();
LOG(INFO) << "Receive result for SendMedia for " << random_id_ << ": " << to_string(ptr); LOG(INFO) << "Receive result for SendMediaQuery for " << random_id_ << ": " << to_string(ptr);
td_->messages_manager_->check_send_message_result(random_id_, dialog_id_, ptr.get(), "SendMedia"); td_->messages_manager_->check_send_message_result(random_id_, dialog_id_, ptr.get(), "SendMedia");
td_->updates_manager_->on_get_updates(std::move(ptr), Promise<Unit>()); td_->updates_manager_->on_get_updates(std::move(ptr), Promise<Unit>());
} }
@ -3571,7 +3565,7 @@ class SendMediaActor final : public NetActorOnce {
} }
} }
td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SendMediaActor"); td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SendMediaQuery");
td_->messages_manager_->on_send_message_fail(random_id_, std::move(status)); td_->messages_manager_->on_send_message_fail(random_id_, std::move(status));
} }
}; };
@ -3655,12 +3649,12 @@ class UploadMediaQuery final : public Td::ResultHandler {
} }
}; };
class SendScheduledMessageActor final : public NetActorOnce { class SendScheduledMessageQuery final : public Td::ResultHandler {
Promise<Unit> promise_; Promise<Unit> promise_;
DialogId dialog_id_; DialogId dialog_id_;
public: public:
explicit SendScheduledMessageActor(Promise<Unit> &&promise) : promise_(std::move(promise)) { explicit SendScheduledMessageQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
} }
void send(DialogId dialog_id, MessageId message_id, uint64 sequence_dispatcher_id) { void send(DialogId dialog_id, MessageId message_id, uint64 sequence_dispatcher_id) {
@ -3668,9 +3662,7 @@ class SendScheduledMessageActor final : public NetActorOnce {
auto input_peer = td_->messages_manager_->get_input_peer(dialog_id, AccessRights::Edit); auto input_peer = td_->messages_manager_->get_input_peer(dialog_id, AccessRights::Edit);
if (input_peer == nullptr) { if (input_peer == nullptr) {
on_error(Status::Error(400, "Can't access the chat")); return on_error(Status::Error(400, "Can't access the chat"));
stop();
return;
} }
int32 server_message_id = message_id.get_scheduled_server_message_id().get(); int32 server_message_id = message_id.get_scheduled_server_message_id().get();
@ -3686,23 +3678,23 @@ class SendScheduledMessageActor final : public NetActorOnce {
} }
auto ptr = result_ptr.move_as_ok(); auto ptr = result_ptr.move_as_ok();
LOG(INFO) << "Receive result for SendScheduledMessageActor: " << to_string(ptr); LOG(INFO) << "Receive result for SendScheduledMessageQuery: " << to_string(ptr);
td_->updates_manager_->on_get_updates(std::move(ptr), std::move(promise_)); td_->updates_manager_->on_get_updates(std::move(ptr), std::move(promise_));
} }
void on_error(Status status) final { void on_error(Status status) final {
LOG(INFO) << "Receive error for SendScheduledMessageActor: " << status; LOG(INFO) << "Receive error for SendScheduledMessageQuery: " << status;
td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SendScheduledMessageActor"); td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SendScheduledMessageQuery");
promise_.set_error(std::move(status)); promise_.set_error(std::move(status));
} }
}; };
class EditMessageActor final : public NetActorOnce { class EditMessageQuery final : public Td::ResultHandler {
Promise<int32> promise_; Promise<int32> promise_;
DialogId dialog_id_; DialogId dialog_id_;
public: public:
explicit EditMessageActor(Promise<Unit> &&promise) { explicit EditMessageQuery(Promise<Unit> &&promise) {
promise_ = PromiseCreator::lambda([promise = std::move(promise)](Result<int32> result) mutable { promise_ = PromiseCreator::lambda([promise = std::move(promise)](Result<int32> result) mutable {
if (result.is_error()) { if (result.is_error()) {
promise.set_error(result.move_as_error()); promise.set_error(result.move_as_error());
@ -3711,7 +3703,7 @@ class EditMessageActor final : public NetActorOnce {
} }
}); });
} }
explicit EditMessageActor(Promise<int32> &&promise) : promise_(std::move(promise)) { explicit EditMessageQuery(Promise<int32> &&promise) : promise_(std::move(promise)) {
} }
void send(int32 flags, DialogId dialog_id, MessageId message_id, const string &text, void send(int32 flags, DialogId dialog_id, MessageId message_id, const string &text,
@ -3722,16 +3714,12 @@ class EditMessageActor final : public NetActorOnce {
dialog_id_ = dialog_id; dialog_id_ = dialog_id;
if (input_media != nullptr && false) { if (input_media != nullptr && false) {
on_error(Status::Error(400, "FILE_PART_1_MISSING")); return on_error(Status::Error(400, "FILE_PART_1_MISSING"));
stop();
return;
} }
auto input_peer = td_->messages_manager_->get_input_peer(dialog_id, AccessRights::Edit); auto input_peer = td_->messages_manager_->get_input_peer(dialog_id, AccessRights::Edit);
if (input_peer == nullptr) { if (input_peer == nullptr) {
on_error(Status::Error(400, "Can't access the chat")); return on_error(Status::Error(400, "Can't access the chat"));
stop();
return;
} }
if (reply_markup != nullptr) { if (reply_markup != nullptr) {
@ -3766,7 +3754,7 @@ class EditMessageActor final : public NetActorOnce {
} }
auto ptr = result_ptr.move_as_ok(); auto ptr = result_ptr.move_as_ok();
LOG(INFO) << "Receive result for EditMessageActor: " << to_string(ptr); LOG(INFO) << "Receive result for EditMessageQuery: " << to_string(ptr);
auto pts = td_->updates_manager_->get_update_edit_message_pts(ptr.get()); auto pts = td_->updates_manager_->get_update_edit_message_pts(ptr.get());
auto promise = PromiseCreator::lambda( auto promise = PromiseCreator::lambda(
[promise = std::move(promise_), pts](Result<Unit> result) mutable { promise.set_value(std::move(pts)); }); [promise = std::move(promise_), pts](Result<Unit> result) mutable { promise.set_value(std::move(pts)); });
@ -3778,7 +3766,7 @@ class EditMessageActor final : public NetActorOnce {
if (!td_->auth_manager_->is_bot() && status.message() == "MESSAGE_NOT_MODIFIED") { if (!td_->auth_manager_->is_bot() && status.message() == "MESSAGE_NOT_MODIFIED") {
return promise_.set_value(0); return promise_.set_value(0);
} }
td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "EditMessageActor"); td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "EditMessageQuery");
promise_.set_error(std::move(status)); promise_.set_error(std::move(status));
} }
}; };
@ -3838,14 +3826,14 @@ class EditInlineMessageQuery final : public Td::ResultHandler {
} }
}; };
class ForwardMessagesActor final : public NetActorOnce { class ForwardMessagesQuery final : public Td::ResultHandler {
Promise<Unit> promise_; Promise<Unit> promise_;
vector<int64> random_ids_; vector<int64> random_ids_;
DialogId from_dialog_id_; DialogId from_dialog_id_;
DialogId to_dialog_id_; DialogId to_dialog_id_;
public: public:
explicit ForwardMessagesActor(Promise<Unit> &&promise) : promise_(std::move(promise)) { explicit ForwardMessagesQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
} }
void send(int32 flags, DialogId to_dialog_id, DialogId from_dialog_id, void send(int32 flags, DialogId to_dialog_id, DialogId from_dialog_id,
@ -3857,16 +3845,12 @@ class ForwardMessagesActor final : public NetActorOnce {
auto to_input_peer = td_->messages_manager_->get_input_peer(to_dialog_id, AccessRights::Write); auto to_input_peer = td_->messages_manager_->get_input_peer(to_dialog_id, AccessRights::Write);
if (to_input_peer == nullptr) { if (to_input_peer == nullptr) {
on_error(Status::Error(400, "Have no write access to the chat")); return on_error(Status::Error(400, "Have no write access to the chat"));
stop();
return;
} }
auto from_input_peer = td_->messages_manager_->get_input_peer(from_dialog_id, AccessRights::Read); auto from_input_peer = td_->messages_manager_->get_input_peer(from_dialog_id, AccessRights::Read);
if (from_input_peer == nullptr) { if (from_input_peer == nullptr) {
on_error(Status::Error(400, "Can't access the chat to forward messages from")); return on_error(Status::Error(400, "Can't access the chat to forward messages from"));
stop();
return;
} }
if (as_input_peer != nullptr) { if (as_input_peer != nullptr) {
@ -3898,7 +3882,8 @@ class ForwardMessagesActor final : public NetActorOnce {
} }
auto ptr = result_ptr.move_as_ok(); auto ptr = result_ptr.move_as_ok();
LOG(INFO) << "Receive result for ForwardMessages for " << format::as_array(random_ids_) << ": " << to_string(ptr); LOG(INFO) << "Receive result for ForwardMessagesQuery for " << format::as_array(random_ids_) << ": "
<< to_string(ptr);
auto sent_random_ids = UpdatesManager::get_sent_messages_random_ids(ptr.get()); auto sent_random_ids = UpdatesManager::get_sent_messages_random_ids(ptr.get());
bool is_result_wrong = false; bool is_result_wrong = false;
auto sent_random_ids_size = sent_random_ids.size(); auto sent_random_ids_size = sent_random_ids.size();
@ -12295,8 +12280,8 @@ void MessagesManager::repair_server_dialog_total_count(DialogListId dialog_list_
} }
LOG(INFO) << "Repair total chat count in " << dialog_list_id; LOG(INFO) << "Repair total chat count in " << dialog_list_id;
send_closure(td_->create_net_actor<GetDialogListActor>(Promise<Unit>()), &GetDialogListActor::send, td_->create_handler<GetDialogListQuery>(Promise<Unit>())
dialog_list_id.get_folder_id(), 2147483647, ServerMessageId(), DialogId(), 1, ->send(dialog_list_id.get_folder_id(), 2147483647, ServerMessageId(), DialogId(), 1,
get_sequence_dispatcher_id(DialogId(), MessageContentType::None)); get_sequence_dispatcher_id(DialogId(), MessageContentType::None));
} }
@ -16659,9 +16644,8 @@ void MessagesManager::load_folder_dialog_list(FolderId folder_id, int32 limit, b
auto lock = multipromise.get_promise(); auto lock = multipromise.get_promise();
reload_pinned_dialogs(DialogListId(folder_id), multipromise.get_promise()); reload_pinned_dialogs(DialogListId(folder_id), multipromise.get_promise());
if (folder.folder_last_dialog_date_ == folder.last_server_dialog_date_) { if (folder.folder_last_dialog_date_ == folder.last_server_dialog_date_) {
send_closure( td_->create_handler<GetDialogListQuery>(multipromise.get_promise())
td_->create_net_actor<GetDialogListActor>(multipromise.get_promise()), &GetDialogListActor::send, folder_id, ->send(folder_id, folder.last_server_dialog_date_.get_date(),
folder.last_server_dialog_date_.get_date(),
folder.last_server_dialog_date_.get_message_id().get_next_server_message_id().get_server_message_id(), folder.last_server_dialog_date_.get_message_id().get_next_server_message_id().get_server_message_id(),
folder.last_server_dialog_date_.get_dialog_id(), int32{MAX_GET_DIALOGS}, folder.last_server_dialog_date_.get_dialog_id(), int32{MAX_GET_DIALOGS},
get_sequence_dispatcher_id(DialogId(), MessageContentType::None)); get_sequence_dispatcher_id(DialogId(), MessageContentType::None));
@ -16930,8 +16914,8 @@ void MessagesManager::reload_pinned_dialogs(DialogListId dialog_list_id, Promise
CHECK(!td_->auth_manager_->is_bot()); CHECK(!td_->auth_manager_->is_bot());
if (dialog_list_id.is_folder()) { if (dialog_list_id.is_folder()) {
send_closure(td_->create_net_actor<GetPinnedDialogsActor>(std::move(promise)), &GetPinnedDialogsActor::send, td_->create_handler<GetPinnedDialogsQuery>(std::move(promise))
dialog_list_id.get_folder_id(), get_sequence_dispatcher_id(DialogId(), MessageContentType::None)); ->send(dialog_list_id.get_folder_id(), get_sequence_dispatcher_id(DialogId(), MessageContentType::None));
} else if (dialog_list_id.is_filter()) { } else if (dialog_list_id.is_filter()) {
schedule_dialog_filters_reload(0.0); schedule_dialog_filters_reload(0.0);
dialog_filter_reload_queries_.push_back(std::move(promise)); dialog_filter_reload_queries_.push_back(std::move(promise));
@ -20085,9 +20069,8 @@ void MessagesManager::toggle_dialog_is_blocked_on_server(DialogId dialog_id, boo
log_event_id = save_toggle_dialog_is_blocked_on_server_log_event(dialog_id, is_blocked); log_event_id = save_toggle_dialog_is_blocked_on_server_log_event(dialog_id, is_blocked);
} }
send_closure(td_->create_net_actor<ToggleDialogIsBlockedActor>(get_erase_log_event_promise(log_event_id)), td_->create_handler<ToggleDialogIsBlockedQuery>(get_erase_log_event_promise(log_event_id))
&ToggleDialogIsBlockedActor::send, dialog_id, is_blocked, ->send(dialog_id, is_blocked, get_sequence_dispatcher_id(dialog_id, MessageContentType::Text));
get_sequence_dispatcher_id(dialog_id, MessageContentType::Text));
} }
Status MessagesManager::toggle_dialog_silent_send_message(DialogId dialog_id, bool silent_send_message) { Status MessagesManager::toggle_dialog_silent_send_message(DialogId dialog_id, bool silent_send_message) {
@ -25045,8 +25028,8 @@ void MessagesManager::set_dialog_default_send_message_as_dialog_id(DialogId dial
} }
// TODO save order with all types of messages // TODO save order with all types of messages
send_closure(td_->create_net_actor<SaveDefaultSendAsActor>(std::move(promise)), &SaveDefaultSendAsActor::send, td_->create_handler<SaveDefaultSendAsQuery>(std::move(promise))
dialog_id, message_sender_dialog_id, get_sequence_dispatcher_id(dialog_id, MessageContentType::Text)); ->send(dialog_id, message_sender_dialog_id, get_sequence_dispatcher_id(dialog_id, MessageContentType::Text));
on_update_dialog_default_send_message_as_dialog_id(dialog_id, message_sender_dialog_id, true); on_update_dialog_default_send_message_as_dialog_id(dialog_id, message_sender_dialog_id, true);
} }
@ -25507,8 +25490,8 @@ void MessagesManager::on_message_media_uploaded(DialogId dialog_id, const Messag
thumbnail_file_id, was_uploaded, was_thumbnail_uploaded, std::move(file_reference), thumbnail_file_id, was_uploaded, was_thumbnail_uploaded, std::move(file_reference),
schedule_date, generation, std::move(result)); schedule_date, generation, std::move(result));
}); });
send_closure(td_->create_net_actor<EditMessageActor>(std::move(promise)), &EditMessageActor::send, 1 << 11, td_->create_handler<EditMessageQuery>(std::move(promise))
dialog_id, message_id, caption == nullptr ? "" : caption->text, ->send(1 << 11, dialog_id, message_id, caption == nullptr ? "" : caption->text,
get_input_message_entities(td_->contacts_manager_.get(), caption, "edit_message_media"), get_input_message_entities(td_->contacts_manager_.get(), caption, "edit_message_media"),
std::move(input_media), std::move(input_reply_markup), schedule_date, std::move(input_media), std::move(input_reply_markup), schedule_date,
get_sequence_dispatcher_id(dialog_id, MessageContentType::None)); get_sequence_dispatcher_id(dialog_id, MessageContentType::None));
@ -25532,10 +25515,9 @@ void MessagesManager::on_message_media_uploaded(DialogId dialog_id, const Messag
LOG(INFO) << "Send media from " << m->message_id << " in " << dialog_id << " in reply to " LOG(INFO) << "Send media from " << m->message_id << " in " << dialog_id << " in reply to "
<< m->reply_to_message_id; << m->reply_to_message_id;
int64 random_id = begin_send_message(dialog_id, m); int64 random_id = begin_send_message(dialog_id, m);
send_closure( td_->create_handler<SendMediaQuery>()->send(
td_->create_net_actor<SendMediaActor>(), &SendMediaActor::send, file_id, thumbnail_file_id, file_id, thumbnail_file_id, get_message_flags(m), dialog_id, get_send_message_as_input_peer(m),
get_message_flags(m), dialog_id, get_send_message_as_input_peer(m), m->reply_to_message_id, m->reply_to_message_id, get_message_schedule_date(m), get_input_reply_markup(m->reply_markup),
get_message_schedule_date(m), get_input_reply_markup(m->reply_markup),
get_input_message_entities(td_->contacts_manager_.get(), caption, "on_message_media_uploaded"), get_input_message_entities(td_->contacts_manager_.get(), caption, "on_message_media_uploaded"),
caption == nullptr ? "" : caption->text, std::move(input_media), random_id, &m->send_query_ref, caption == nullptr ? "" : caption->text, std::move(input_media), random_id, &m->send_query_ref,
get_sequence_dispatcher_id(dialog_id, m->is_copy ? MessageContentType::None : m->content->get_type())); get_sequence_dispatcher_id(dialog_id, m->is_copy ? MessageContentType::None : m->content->get_type()));
@ -25872,8 +25854,8 @@ void MessagesManager::do_send_message_group(int64 media_album_id) {
if (input_single_media.empty()) { if (input_single_media.empty()) {
LOG(INFO) << "Media group " << media_album_id << " from " << dialog_id << " is empty"; LOG(INFO) << "Media group " << media_album_id << " from " << dialog_id << " is empty";
} }
send_closure(td_->create_net_actor<SendMultiMediaActor>(), &SendMultiMediaActor::send, flags, dialog_id, td_->create_handler<SendMultiMediaQuery>()->send(
std::move(as_input_peer), reply_to_message_id, schedule_date, std::move(file_ids), flags, dialog_id, std::move(as_input_peer), reply_to_message_id, schedule_date, std::move(file_ids),
std::move(input_single_media), std::move(input_single_media),
get_sequence_dispatcher_id(dialog_id, is_copy ? MessageContentType::None : MessageContentType::Photo)); get_sequence_dispatcher_id(dialog_id, is_copy ? MessageContentType::None : MessageContentType::Photo));
} }
@ -25908,12 +25890,11 @@ void MessagesManager::on_text_message_ready_to_send(DialogId dialog_id, MessageI
get_input_secret_message_entities(message_text->entities, layer), m->via_bot_user_id, get_input_secret_message_entities(message_text->entities, layer), m->via_bot_user_id,
m->media_album_id, m->disable_notification, random_id); m->media_album_id, m->disable_notification, random_id);
} else { } else {
send_closure(td_->create_net_actor<SendMessageActor>(), &SendMessageActor::send, get_message_flags(m), dialog_id, td_->create_handler<SendMessageQuery>()->send(
get_send_message_as_input_peer(m), m->reply_to_message_id, get_message_schedule_date(m), get_message_flags(m), dialog_id, get_send_message_as_input_peer(m), m->reply_to_message_id,
get_input_reply_markup(m->reply_markup), get_message_schedule_date(m), get_input_reply_markup(m->reply_markup),
get_input_message_entities(td_->contacts_manager_.get(), message_text->entities, "do_send_message"), get_input_message_entities(td_->contacts_manager_.get(), message_text->entities, "do_send_message"),
message_text->text, random_id, &m->send_query_ref, message_text->text, random_id, &m->send_query_ref, get_sequence_dispatcher_id(dialog_id, content_type));
get_sequence_dispatcher_id(dialog_id, content_type));
} }
} }
@ -26628,10 +26609,10 @@ void MessagesManager::edit_message_text(FullMessageId full_message_id,
flags |= SEND_MESSAGE_FLAG_DISABLE_WEB_PAGE_PREVIEW; flags |= SEND_MESSAGE_FLAG_DISABLE_WEB_PAGE_PREVIEW;
} }
send_closure( td_->create_handler<EditMessageQuery>(std::move(promise))
td_->create_net_actor<EditMessageActor>(std::move(promise)), &EditMessageActor::send, flags, dialog_id, ->send(flags, dialog_id, m->message_id, input_message_text.text.text,
m->message_id, input_message_text.text.text, get_input_message_entities(td_->contacts_manager_.get(), input_message_text.text.entities,
get_input_message_entities(td_->contacts_manager_.get(), input_message_text.text.entities, "edit_message_text"), "edit_message_text"),
nullptr, std::move(input_reply_markup), get_message_schedule_date(m), nullptr, std::move(input_reply_markup), get_message_schedule_date(m),
get_sequence_dispatcher_id(dialog_id, MessageContentType::None)); get_sequence_dispatcher_id(dialog_id, MessageContentType::None));
} }
@ -26691,9 +26672,9 @@ void MessagesManager::edit_message_live_location(FullMessageId full_message_id,
flags |= telegram_api::inputMediaGeoLive::PROXIMITY_NOTIFICATION_RADIUS_MASK; flags |= telegram_api::inputMediaGeoLive::PROXIMITY_NOTIFICATION_RADIUS_MASK;
auto input_media = telegram_api::make_object<telegram_api::inputMediaGeoLive>( auto input_media = telegram_api::make_object<telegram_api::inputMediaGeoLive>(
flags, false /*ignored*/, location.get_input_geo_point(), heading, 0, proximity_alert_radius); flags, false /*ignored*/, location.get_input_geo_point(), heading, 0, proximity_alert_radius);
send_closure(td_->create_net_actor<EditMessageActor>(std::move(promise)), &EditMessageActor::send, 0, dialog_id, td_->create_handler<EditMessageQuery>(std::move(promise))
m->message_id, string(), vector<tl_object_ptr<telegram_api::MessageEntity>>(), std::move(input_media), ->send(0, dialog_id, m->message_id, string(), vector<tl_object_ptr<telegram_api::MessageEntity>>(),
std::move(input_reply_markup), get_message_schedule_date(m), std::move(input_media), std::move(input_reply_markup), get_message_schedule_date(m),
get_sequence_dispatcher_id(dialog_id, MessageContentType::None)); get_sequence_dispatcher_id(dialog_id, MessageContentType::None));
} }
@ -26918,8 +26899,8 @@ void MessagesManager::edit_message_caption(FullMessageId full_message_id,
} }
auto input_reply_markup = get_input_reply_markup(r_new_reply_markup.ok()); auto input_reply_markup = get_input_reply_markup(r_new_reply_markup.ok());
send_closure(td_->create_net_actor<EditMessageActor>(std::move(promise)), &EditMessageActor::send, 1 << 11, dialog_id, td_->create_handler<EditMessageQuery>(std::move(promise))
m->message_id, caption.text, ->send(1 << 11, dialog_id, m->message_id, caption.text,
get_input_message_entities(td_->contacts_manager_.get(), caption.entities, "edit_message_caption"), get_input_message_entities(td_->contacts_manager_.get(), caption.entities, "edit_message_caption"),
nullptr, std::move(input_reply_markup), get_message_schedule_date(m), nullptr, std::move(input_reply_markup), get_message_schedule_date(m),
get_sequence_dispatcher_id(dialog_id, MessageContentType::None)); get_sequence_dispatcher_id(dialog_id, MessageContentType::None));
@ -26958,8 +26939,8 @@ void MessagesManager::edit_message_reply_markup(FullMessageId full_message_id,
return promise.set_error(r_new_reply_markup.move_as_error()); return promise.set_error(r_new_reply_markup.move_as_error());
} }
auto input_reply_markup = get_input_reply_markup(r_new_reply_markup.ok()); auto input_reply_markup = get_input_reply_markup(r_new_reply_markup.ok());
send_closure(td_->create_net_actor<EditMessageActor>(std::move(promise)), &EditMessageActor::send, 0, dialog_id, td_->create_handler<EditMessageQuery>(std::move(promise))
m->message_id, string(), vector<tl_object_ptr<telegram_api::MessageEntity>>(), nullptr, ->send(0, dialog_id, m->message_id, string(), vector<tl_object_ptr<telegram_api::MessageEntity>>(), nullptr,
std::move(input_reply_markup), get_message_schedule_date(m), std::move(input_reply_markup), get_message_schedule_date(m),
get_sequence_dispatcher_id(dialog_id, MessageContentType::None)); get_sequence_dispatcher_id(dialog_id, MessageContentType::None));
} }
@ -27190,12 +27171,12 @@ void MessagesManager::edit_message_scheduling_state(
m->edited_schedule_date = schedule_date; m->edited_schedule_date = schedule_date;
if (schedule_date > 0) { if (schedule_date > 0) {
send_closure(td_->create_net_actor<EditMessageActor>(std::move(promise)), &EditMessageActor::send, 0, dialog_id, td_->create_handler<EditMessageQuery>(std::move(promise))
m->message_id, string(), vector<tl_object_ptr<telegram_api::MessageEntity>>(), nullptr, nullptr, ->send(0, dialog_id, m->message_id, string(), vector<tl_object_ptr<telegram_api::MessageEntity>>(), nullptr,
schedule_date, get_sequence_dispatcher_id(dialog_id, MessageContentType::None)); nullptr, schedule_date, get_sequence_dispatcher_id(dialog_id, MessageContentType::None));
} else { } else {
send_closure(td_->create_net_actor<SendScheduledMessageActor>(std::move(promise)), &SendScheduledMessageActor::send, td_->create_handler<SendScheduledMessageQuery>(std::move(promise))
dialog_id, m->message_id, get_sequence_dispatcher_id(dialog_id, MessageContentType::None)); ->send(dialog_id, m->message_id, get_sequence_dispatcher_id(dialog_id, MessageContentType::None));
} }
} }
@ -27725,10 +27706,9 @@ void MessagesManager::do_forward_messages(DialogId to_dialog_id, DialogId from_d
vector<int64> random_ids = vector<int64> random_ids =
transform(messages, [this, to_dialog_id](const Message *m) { return begin_send_message(to_dialog_id, m); }); transform(messages, [this, to_dialog_id](const Message *m) { return begin_send_message(to_dialog_id, m); });
send_closure(td_->create_net_actor<ForwardMessagesActor>(get_erase_log_event_promise(log_event_id)), td_->create_handler<ForwardMessagesQuery>(get_erase_log_event_promise(log_event_id))
&ForwardMessagesActor::send, flags, to_dialog_id, from_dialog_id, ->send(flags, to_dialog_id, from_dialog_id, get_send_message_as_input_peer(messages[0]), message_ids,
get_send_message_as_input_peer(messages[0]), message_ids, std::move(random_ids), schedule_date, std::move(random_ids), schedule_date, get_sequence_dispatcher_id(to_dialog_id, MessageContentType::None));
get_sequence_dispatcher_id(to_dialog_id, MessageContentType::None));
} }
Result<td_api::object_ptr<td_api::message>> MessagesManager::forward_message( Result<td_api::object_ptr<td_api::message>> MessagesManager::forward_message(

24
td/telegram/PollManager.cpp
View File

@ -16,7 +16,6 @@
#include "td/telegram/logevent/LogEventHelper.h" #include "td/telegram/logevent/LogEventHelper.h"
#include "td/telegram/MessagesManager.h" #include "td/telegram/MessagesManager.h"
#include "td/telegram/misc.h" #include "td/telegram/misc.h"
#include "td/telegram/net/NetActor.h"
#include "td/telegram/PollId.hpp" #include "td/telegram/PollId.hpp"
#include "td/telegram/PollManager.hpp" #include "td/telegram/PollManager.hpp"
#include "td/telegram/StateManager.h" #include "td/telegram/StateManager.h"
@ -137,12 +136,12 @@ class GetPollVotersQuery final : public Td::ResultHandler {
} }
}; };
class SetPollAnswerActor final : public NetActorOnce { class SendVoteQuery final : public Td::ResultHandler {
Promise<tl_object_ptr<telegram_api::Updates>> promise_; Promise<tl_object_ptr<telegram_api::Updates>> promise_;
DialogId dialog_id_; DialogId dialog_id_;
public: public:
explicit SetPollAnswerActor(Promise<tl_object_ptr<telegram_api::Updates>> &&promise) : promise_(std::move(promise)) { explicit SendVoteQuery(Promise<tl_object_ptr<telegram_api::Updates>> &&promise) : promise_(std::move(promise)) {
} }
void send(FullMessageId full_message_id, vector<BufferSlice> &&options, uint64 generation, NetQueryRef *query_ref) { void send(FullMessageId full_message_id, vector<BufferSlice> &&options, uint64 generation, NetQueryRef *query_ref) {
@ -168,22 +167,22 @@ class SetPollAnswerActor final : public NetActorOnce {
} }
auto result = result_ptr.move_as_ok(); auto result = result_ptr.move_as_ok();
LOG(INFO) << "Receive sendVote result: " << to_string(result); LOG(INFO) << "Receive SendVoteQuery result: " << to_string(result);
promise_.set_value(std::move(result)); promise_.set_value(std::move(result));
} }
void on_error(Status status) final { void on_error(Status status) final {
td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SetPollAnswerActor"); td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "SendVoteQuery");
promise_.set_error(std::move(status)); promise_.set_error(std::move(status));
} }
}; };
class StopPollActor final : public NetActorOnce { class StopPollQuery final : public Td::ResultHandler {
Promise<Unit> promise_; Promise<Unit> promise_;
DialogId dialog_id_; DialogId dialog_id_;
public: public:
explicit StopPollActor(Promise<Unit> &&promise) : promise_(std::move(promise)) { explicit StopPollQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
} }
void send(FullMessageId full_message_id, unique_ptr<ReplyMarkup> &&reply_markup) { void send(FullMessageId full_message_id, unique_ptr<ReplyMarkup> &&reply_markup) {
@ -222,7 +221,7 @@ class StopPollActor final : public NetActorOnce {
} }
auto result = result_ptr.move_as_ok(); auto result = result_ptr.move_as_ok();
LOG(INFO) << "Receive result for StopPoll: " << to_string(result); LOG(INFO) << "Receive result for StopPollQuery: " << to_string(result);
td_->updates_manager_->on_get_updates(std::move(result), std::move(promise_)); td_->updates_manager_->on_get_updates(std::move(result), std::move(promise_));
} }
@ -230,7 +229,7 @@ class StopPollActor final : public NetActorOnce {
if (!td_->auth_manager_->is_bot() && status.message() == "MESSAGE_NOT_MODIFIED") { if (!td_->auth_manager_->is_bot() && status.message() == "MESSAGE_NOT_MODIFIED") {
return promise_.set_value(Unit()); return promise_.set_value(Unit());
} }
td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "StopPollActor"); td_->messages_manager_->on_get_dialog_error(dialog_id_, status, "StopPollQuery");
promise_.set_error(std::move(status)); promise_.set_error(std::move(status));
} }
}; };
@ -818,8 +817,8 @@ void PollManager::do_set_poll_answer(PollId poll_id, FullMessageId full_message_
[poll_id, generation, actor_id = actor_id(this)](Result<tl_object_ptr<telegram_api::Updates>> &&result) { [poll_id, generation, actor_id = actor_id(this)](Result<tl_object_ptr<telegram_api::Updates>> &&result) {
send_closure(actor_id, &PollManager::on_set_poll_answer, poll_id, generation, std::move(result)); send_closure(actor_id, &PollManager::on_set_poll_answer, poll_id, generation, std::move(result));
}); });
send_closure(td_->create_net_actor<SetPollAnswerActor>(std::move(query_promise)), &SetPollAnswerActor::send, td_->create_handler<SendVoteQuery>(std::move(query_promise))
full_message_id, std::move(sent_options), generation, &pending_answer.query_ref_); ->send(full_message_id, std::move(sent_options), generation, &pending_answer.query_ref_);
} }
void PollManager::on_set_poll_answer(PollId poll_id, uint64 generation, void PollManager::on_set_poll_answer(PollId poll_id, uint64 generation,
@ -1131,8 +1130,7 @@ void PollManager::do_stop_poll(PollId poll_id, FullMessageId full_message_id, un
CHECK(is_inserted); CHECK(is_inserted);
auto new_promise = get_erase_log_event_promise(log_event_id, std::move(promise)); auto new_promise = get_erase_log_event_promise(log_event_id, std::move(promise));
send_closure(td_->create_net_actor<StopPollActor>(std::move(new_promise)), &StopPollActor::send, full_message_id, td_->create_handler<StopPollQuery>(std::move(new_promise))->send(full_message_id, std::move(reply_markup));
std::move(reply_markup));
} }
void PollManager::stop_local_poll(PollId poll_id) { void PollManager::stop_local_poll(PollId poll_id) {

12
td/telegram/net/NetActor.h
View File

@ -6,7 +6,6 @@
// //
#pragma once #pragma once
#include "td/telegram/Global.h"
#include "td/telegram/net/NetQuery.h" #include "td/telegram/net/NetQuery.h"
#include "td/actor/actor.h" #include "td/actor/actor.h"
@ -45,15 +44,4 @@ class NetActor : public NetQueryCallback {
void send_query(NetQueryPtr query); void send_query(NetQueryPtr query);
}; };
class NetActorOnce : public NetActor {
void hangup() override {
on_error(Global::request_aborted_error());
stop();
}
void on_result_finish() override {
stop();
}
};
} // namespace td } // namespace td