andreacavalli/tdlib-fork
Archived
1
0
Fork 0
Code Pull Requests Releases Activity

Add source to on_get_user and on_get_chat.

Browse Source 
GitOrigin-RevId: a3f187dc0d7d981df6ca3f2566f66678b4ad4774
This commit is contained in:
levlam 2019-01-12 06:48:39 +03:00
parent f0dd4b1bad
commit e22e23a5ff
13 changed files with 136 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
td/telegram/AuthManager.cpp
View File

@ -918,7 +918,7 @@ void AuthManager::on_authorization(tl_object_ptr<telegram_api::auth_authorizatio
code_.clear(); code_.clear();
password_.clear(); password_.clear();
state_ = State::Ok; state_ = State::Ok;
td->contacts_manager_->on_get_user(std::move(auth->user_), true); td->contacts_manager_->on_get_user(std::move(auth->user_), "on_authorization", true);
update_state(State::Ok, true); update_state(State::Ok, true);
if (!td->contacts_manager_->get_my_id().is_valid()) { if (!td->contacts_manager_->get_my_id().is_valid()) {
LOG(ERROR) << "Server doesn't send proper authorization"; LOG(ERROR) << "Server doesn't send proper authorization";

2
td/telegram/CallActor.cpp
View File

@ -242,7 +242,7 @@ void CallActor::update_call(tl_object_ptr<telegram_api::PhoneCall> call) {
void CallActor::update_call_inner(tl_object_ptr<telegram_api::phone_phoneCall> call) { void CallActor::update_call_inner(tl_object_ptr<telegram_api::phone_phoneCall> call) {
LOG(INFO) << "Update call with " << to_string(call); LOG(INFO) << "Update call with " << to_string(call);
send_closure(G()->contacts_manager(), &ContactsManager::on_get_users, std::move(call->users_)); send_closure(G()->contacts_manager(), &ContactsManager::on_get_users, std::move(call->users_), "UpdatePhoneCall");
update_call(std::move(call->phone_call_)); update_call(std::move(call->phone_call_));
} }

153
td/telegram/ContactsManager.cpp
View File

@ -232,7 +232,7 @@ class GetWebAuthorizationsQuery : public Td::ResultHandler {
auto ptr = result_ptr.move_as_ok(); auto ptr = result_ptr.move_as_ok();
LOG(INFO) << "Receive result for GetWebAuthorizationsQuery: " << to_string(ptr); LOG(INFO) << "Receive result for GetWebAuthorizationsQuery: " << to_string(ptr);
td->contacts_manager_->on_get_users(std::move(ptr->users_)); td->contacts_manager_->on_get_users(std::move(ptr->users_), "GetWebAuthorizationsQuery");
auto results = make_tl_object<td_api::connectedWebsites>(); auto results = make_tl_object<td_api::connectedWebsites>();
results->websites_.reserve(ptr->authorizations_.size()); results->websites_.reserve(ptr->authorizations_.size());
@ -389,7 +389,7 @@ class GetBlockedUsersQuery : public Td::ResultHandler {
case telegram_api::contacts_blocked::ID: { case telegram_api::contacts_blocked::ID: {
auto blocked_users = move_tl_object_as<telegram_api::contacts_blocked>(ptr); auto blocked_users = move_tl_object_as<telegram_api::contacts_blocked>(ptr);
td->contacts_manager_->on_get_users(std::move(blocked_users->users_)); td->contacts_manager_->on_get_users(std::move(blocked_users->users_), "GetBlockedUsersQuery");
td->contacts_manager_->on_get_blocked_users_result(offset_, limit_, random_id_, td->contacts_manager_->on_get_blocked_users_result(offset_, limit_, random_id_,
narrow_cast<int32>(blocked_users->blocked_.size()), narrow_cast<int32>(blocked_users->blocked_.size()),
std::move(blocked_users->blocked_)); std::move(blocked_users->blocked_));
@ -398,7 +398,7 @@ class GetBlockedUsersQuery : public Td::ResultHandler {
case telegram_api::contacts_blockedSlice::ID: { case telegram_api::contacts_blockedSlice::ID: {
auto blocked_users = move_tl_object_as<telegram_api::contacts_blockedSlice>(ptr); auto blocked_users = move_tl_object_as<telegram_api::contacts_blockedSlice>(ptr);
td->contacts_manager_->on_get_users(std::move(blocked_users->users_)); td->contacts_manager_->on_get_users(std::move(blocked_users->users_), "GetBlockedUsersQuery");
td->contacts_manager_->on_get_blocked_users_result(offset_, limit_, random_id_, blocked_users->count_, td->contacts_manager_->on_get_blocked_users_result(offset_, limit_, random_id_, blocked_users->count_,
std::move(blocked_users->blocked_)); std::move(blocked_users->blocked_));
break; break;
@ -506,7 +506,7 @@ class ImportContactsQuery : public Td::ResultHandler {
auto ptr = result_ptr.move_as_ok(); auto ptr = result_ptr.move_as_ok();
LOG(INFO) << "Receive result for importContacts: " << to_string(ptr); LOG(INFO) << "Receive result for importContacts: " << to_string(ptr);
td->contacts_manager_->on_get_users(std::move(ptr->users_)); td->contacts_manager_->on_get_users(std::move(ptr->users_), "ImportContactsQuery");
for (auto &imported_contact : ptr->imported_) { for (auto &imported_contact : ptr->imported_) {
int64 client_id = imported_contact->client_id_; int64 client_id = imported_contact->client_id_;
if (client_id < 0 || client_id >= static_cast<int64>(imported_user_ids_.size())) { if (client_id < 0 || client_id >= static_cast<int64>(imported_user_ids_.size())) {
@ -689,7 +689,7 @@ class UploadProfilePhotoQuery : public Td::ResultHandler {
auto ptr = result_ptr.move_as_ok(); auto ptr = result_ptr.move_as_ok();
LOG(INFO) << "Receive result for uploadProfilePhoto: " << to_string(ptr); LOG(INFO) << "Receive result for uploadProfilePhoto: " << to_string(ptr);
td->contacts_manager_->on_get_users(std::move(ptr->users_)); td->contacts_manager_->on_get_users(std::move(ptr->users_), "UploadProfilePhotoQuery");
// ignore ptr->photo_ // ignore ptr->photo_
td->file_manager_->delete_partial_remote_location(file_id_); td->file_manager_->delete_partial_remote_location(file_id_);
@ -797,7 +797,7 @@ class UpdateProfileQuery : public Td::ResultHandler {
} }
LOG(DEBUG) << "Receive result for updateProfile " << to_string(result_ptr.ok()); LOG(DEBUG) << "Receive result for updateProfile " << to_string(result_ptr.ok());
td->contacts_manager_->on_get_user(result_ptr.move_as_ok()); td->contacts_manager_->on_get_user(result_ptr.move_as_ok(), "UpdateProfileQuery");
td->contacts_manager_->on_update_profile_success(flags_, first_name_, last_name_, about_); td->contacts_manager_->on_update_profile_success(flags_, first_name_, last_name_, about_);
promise_.set_value(Unit()); promise_.set_value(Unit());
@ -851,7 +851,7 @@ class UpdateUsernameQuery : public Td::ResultHandler {
} }
LOG(DEBUG) << "Receive result for updateUsername " << to_string(result_ptr.ok()); LOG(DEBUG) << "Receive result for updateUsername " << to_string(result_ptr.ok());
td->contacts_manager_->on_get_user(result_ptr.move_as_ok()); td->contacts_manager_->on_get_user(result_ptr.move_as_ok(), "UpdateUsernameQuery");
promise_.set_value(Unit()); promise_.set_value(Unit());
} }
@ -1852,7 +1852,7 @@ class GetUsersQuery : public Td::ResultHandler {
return on_error(id, result_ptr.move_as_error()); return on_error(id, result_ptr.move_as_error());
} }
td->contacts_manager_->on_get_users(result_ptr.move_as_ok()); td->contacts_manager_->on_get_users(result_ptr.move_as_ok(), "GetUsersQuery");
promise_.set_value(Unit()); promise_.set_value(Unit());
} }
@ -1919,14 +1919,14 @@ class GetUserPhotosQuery : public Td::ResultHandler {
if (constructor_id == telegram_api::photos_photos::ID) { if (constructor_id == telegram_api::photos_photos::ID) {
auto photos = move_tl_object_as<telegram_api::photos_photos>(ptr); auto photos = move_tl_object_as<telegram_api::photos_photos>(ptr);
td->contacts_manager_->on_get_users(std::move(photos->users_)); td->contacts_manager_->on_get_users(std::move(photos->users_), "GetUserPhotosQuery");
int32 photos_size = narrow_cast<int32>(photos->photos_.size()); int32 photos_size = narrow_cast<int32>(photos->photos_.size());
td->contacts_manager_->on_get_user_photos(user_id_, offset_, limit_, photos_size, std::move(photos->photos_)); td->contacts_manager_->on_get_user_photos(user_id_, offset_, limit_, photos_size, std::move(photos->photos_));
} else { } else {
CHECK(constructor_id == telegram_api::photos_photosSlice::ID); CHECK(constructor_id == telegram_api::photos_photosSlice::ID);
auto photos = move_tl_object_as<telegram_api::photos_photosSlice>(ptr); auto photos = move_tl_object_as<telegram_api::photos_photosSlice>(ptr);
td->contacts_manager_->on_get_users(std::move(photos->users_)); td->contacts_manager_->on_get_users(std::move(photos->users_), "GetUserPhotosQuery");
td->contacts_manager_->on_get_user_photos(user_id_, offset_, limit_, photos->count_, std::move(photos->photos_)); td->contacts_manager_->on_get_user_photos(user_id_, offset_, limit_, photos->count_, std::move(photos->photos_));
} }
@ -1960,13 +1960,13 @@ class GetChatsQuery : public Td::ResultHandler {
switch (constructor_id) { switch (constructor_id) {
case telegram_api::messages_chats::ID: { case telegram_api::messages_chats::ID: {
auto chats = move_tl_object_as<telegram_api::messages_chats>(chats_ptr); auto chats = move_tl_object_as<telegram_api::messages_chats>(chats_ptr);
td->contacts_manager_->on_get_chats(std::move(chats->chats_)); td->contacts_manager_->on_get_chats(std::move(chats->chats_), "GetChatsQuery");
break; break;
} }
case telegram_api::messages_chatsSlice::ID: { case telegram_api::messages_chatsSlice::ID: {
auto chats = move_tl_object_as<telegram_api::messages_chatsSlice>(chats_ptr); auto chats = move_tl_object_as<telegram_api::messages_chatsSlice>(chats_ptr);
LOG(ERROR) << "Receive chatsSlice in result of GetChatsQuery"; LOG(ERROR) << "Receive chatsSlice in result of GetChatsQuery";
td->contacts_manager_->on_get_chats(std::move(chats->chats_)); td->contacts_manager_->on_get_chats(std::move(chats->chats_), "GetChatsQuery");
break; break;
} }
default: default:
@ -1999,8 +1999,8 @@ class GetFullChatQuery : public Td::ResultHandler {
auto ptr = result_ptr.move_as_ok(); auto ptr = result_ptr.move_as_ok();
// LOG(INFO) << "Receive result for getFullChat query: " << to_string(ptr); // LOG(INFO) << "Receive result for getFullChat query: " << to_string(ptr);
td->contacts_manager_->on_get_users(std::move(ptr->users_)); td->contacts_manager_->on_get_users(std::move(ptr->users_), "GetFullChatQuery");
td->contacts_manager_->on_get_chats(std::move(ptr->chats_)); td->contacts_manager_->on_get_chats(std::move(ptr->chats_), "GetFullChatQuery");
td->contacts_manager_->on_get_chat_full(std::move(ptr->full_chat_)); td->contacts_manager_->on_get_chat_full(std::move(ptr->full_chat_));
td->contacts_manager_->on_get_chat_full_success(chat_id_); td->contacts_manager_->on_get_chat_full_success(chat_id_);
@ -2043,13 +2043,13 @@ class GetChannelsQuery : public Td::ResultHandler {
switch (constructor_id) { switch (constructor_id) {
case telegram_api::messages_chats::ID: { case telegram_api::messages_chats::ID: {
auto chats = move_tl_object_as<telegram_api::messages_chats>(chats_ptr); auto chats = move_tl_object_as<telegram_api::messages_chats>(chats_ptr);
td->contacts_manager_->on_get_chats(std::move(chats->chats_)); td->contacts_manager_->on_get_chats(std::move(chats->chats_), "GetChannelsQuery");
break; break;
} }
case telegram_api::messages_chatsSlice::ID: { case telegram_api::messages_chatsSlice::ID: {
auto chats = move_tl_object_as<telegram_api::messages_chatsSlice>(chats_ptr); auto chats = move_tl_object_as<telegram_api::messages_chatsSlice>(chats_ptr);
LOG(ERROR) << "Receive chatsSlice in result of GetChannelsQuery"; LOG(ERROR) << "Receive chatsSlice in result of GetChannelsQuery";
td->contacts_manager_->on_get_chats(std::move(chats->chats_)); td->contacts_manager_->on_get_chats(std::move(chats->chats_), "GetChannelsQuery");
break; break;
} }
default: default:
@ -2083,8 +2083,8 @@ class GetFullChannelQuery : public Td::ResultHandler {
auto ptr = result_ptr.move_as_ok(); auto ptr = result_ptr.move_as_ok();
// LOG(INFO) << "Receive result for getFullChannel query: " << to_string(ptr); // LOG(INFO) << "Receive result for getFullChannel query: " << to_string(ptr);
td->contacts_manager_->on_get_users(std::move(ptr->users_)); td->contacts_manager_->on_get_users(std::move(ptr->users_), "GetFullChannelQuery");
td->contacts_manager_->on_get_chats(std::move(ptr->chats_)); td->contacts_manager_->on_get_chats(std::move(ptr->chats_), "GetFullChannelQuery");
td->contacts_manager_->on_get_chat_full(std::move(ptr->full_chat_)); td->contacts_manager_->on_get_chat_full(std::move(ptr->full_chat_));
td->contacts_manager_->on_get_channel_full_success(channel_id_); td->contacts_manager_->on_get_channel_full_success(channel_id_);
@ -2128,7 +2128,7 @@ class GetChannelParticipantQuery : public Td::ResultHandler {
auto participant = result_ptr.move_as_ok(); auto participant = result_ptr.move_as_ok();
LOG(INFO) << "Receive result for GetChannelParticipantQuery: " << to_string(participant); LOG(INFO) << "Receive result for GetChannelParticipantQuery: " << to_string(participant);
td->contacts_manager_->on_get_users(std::move(participant->users_)); td->contacts_manager_->on_get_users(std::move(participant->users_), "GetChannelParticipantQuery");
promise_.set_value( promise_.set_value(
td->contacts_manager_->get_dialog_participant(channel_id_, std::move(participant->participant_))); td->contacts_manager_->get_dialog_participant(channel_id_, std::move(participant->participant_)));
} }
@ -2183,7 +2183,7 @@ class GetChannelParticipantsQuery : public Td::ResultHandler {
switch (participants_ptr->get_id()) { switch (participants_ptr->get_id()) {
case telegram_api::channels_channelParticipants::ID: { case telegram_api::channels_channelParticipants::ID: {
auto participants = telegram_api::move_object_as<telegram_api::channels_channelParticipants>(participants_ptr); auto participants = telegram_api::move_object_as<telegram_api::channels_channelParticipants>(participants_ptr);
td->contacts_manager_->on_get_users(std::move(participants->users_)); td->contacts_manager_->on_get_users(std::move(participants->users_), "GetChannelParticipantsQuery");
td->contacts_manager_->on_get_channel_participants_success(channel_id_, std::move(filter_), offset_, limit_, td->contacts_manager_->on_get_channel_participants_success(channel_id_, std::move(filter_), offset_, limit_,
random_id_, participants->count_, random_id_, participants->count_,
std::move(participants->participants_)); std::move(participants->participants_));
@ -2238,7 +2238,7 @@ class GetChannelAdministratorsQuery : public Td::ResultHandler {
switch (participants_ptr->get_id()) { switch (participants_ptr->get_id()) {
case telegram_api::channels_channelParticipants::ID: { case telegram_api::channels_channelParticipants::ID: {
auto participants = telegram_api::move_object_as<telegram_api::channels_channelParticipants>(participants_ptr); auto participants = telegram_api::move_object_as<telegram_api::channels_channelParticipants>(participants_ptr);
td->contacts_manager_->on_get_users(std::move(participants->users_)); td->contacts_manager_->on_get_users(std::move(participants->users_), "GetChannelAdministratorsQuery");
vector<UserId> administrator_user_ids; vector<UserId> administrator_user_ids;
administrator_user_ids.reserve(participants->participants_.size()); administrator_user_ids.reserve(participants->participants_.size());
for (auto &participant : participants->participants_) { for (auto &participant : participants->participants_) {
@ -2288,7 +2288,7 @@ class GetSupportUserQuery : public Td::ResultHandler {
auto ptr = result_ptr.move_as_ok(); auto ptr = result_ptr.move_as_ok();
LOG(INFO) << "Receive result for GetSupportUserQuery: " << to_string(ptr); LOG(INFO) << "Receive result for GetSupportUserQuery: " << to_string(ptr);
td->contacts_manager_->on_get_user(std::move(ptr->user_), false, true); td->contacts_manager_->on_get_user(std::move(ptr->user_), "GetSupportUserQuery", false, true);
promise_.set_value(Unit()); promise_.set_value(Unit());
} }
@ -4771,7 +4771,7 @@ void ContactsManager::on_get_created_public_channels(vector<tl_object_ptr<telegr
default: default:
UNREACHABLE(); UNREACHABLE();
} }
on_get_chat(std::move(chat)); on_get_chat(std::move(chat), "on_get_created_public_channels");
} }
} }
@ -4878,7 +4878,7 @@ void ContactsManager::on_get_contacts(tl_object_ptr<telegram_api::contacts_Conta
} }
contact_user_ids.insert(user_id); contact_user_ids.insert(user_id);
} }
on_get_users(std::move(contacts->users_)); on_get_users(std::move(contacts->users_), "on_get_contacts");
UserId my_id = get_my_id(); UserId my_id = get_my_id();
for (auto &p : users_) { for (auto &p : users_) {
@ -4998,7 +4998,7 @@ void ContactsManager::on_update_online_status_privacy() {
void ContactsManager::on_get_contacts_link(tl_object_ptr<telegram_api::contacts_link> &&link) { void ContactsManager::on_get_contacts_link(tl_object_ptr<telegram_api::contacts_link> &&link) {
UserId user_id = get_user_id(link->user_); UserId user_id = get_user_id(link->user_);
on_get_user(std::move(link->user_)); on_get_user(std::move(link->user_), "on_get_contacts_link");
on_update_user_links(user_id, std::move(link->my_link_), std::move(link->foreign_link_)); on_update_user_links(user_id, std::move(link->my_link_), std::move(link->foreign_link_));
} }
@ -5041,21 +5041,22 @@ ChannelId ContactsManager::get_channel_id(const tl_object_ptr<telegram_api::Chat
} }
} }
void ContactsManager::on_get_user(tl_object_ptr<telegram_api::User> &&user_ptr, bool is_me, bool is_support) { void ContactsManager::on_get_user(tl_object_ptr<telegram_api::User> &&user_ptr, const char *source, bool is_me,
LOG(DEBUG) << "Receive " << to_string(user_ptr); bool is_support) {
LOG(DEBUG) << "Receive from " << source << ' ' << to_string(user_ptr);
int32 constructor_id = user_ptr->get_id(); int32 constructor_id = user_ptr->get_id();
if (constructor_id == telegram_api::userEmpty::ID) { if (constructor_id == telegram_api::userEmpty::ID) {
auto user = move_tl_object_as<telegram_api::userEmpty>(user_ptr); auto user = move_tl_object_as<telegram_api::userEmpty>(user_ptr);
UserId user_id(user->id_); UserId user_id(user->id_);
if (!user_id.is_valid()) { if (!user_id.is_valid()) {
LOG(ERROR) << "Receive invalid " << user_id; LOG(ERROR) << "Receive invalid " << user_id << " from " << source;
return; return;
} }
LOG(INFO) << "Receive empty " << user_id; LOG(INFO) << "Receive empty " << user_id << " from " << source;
User *u = get_user_force(user_id); User *u = get_user_force(user_id);
if (u == nullptr) { if (u == nullptr) {
LOG(ERROR) << "Have no information about " << user_id << ", but received userEmpty"; LOG(ERROR) << "Have no information about " << user_id << ", but received userEmpty from " << source;
} }
return; return;
} }
@ -5068,9 +5069,9 @@ void ContactsManager::on_get_user(tl_object_ptr<telegram_api::User> &&user_ptr,
return; return;
} }
int32 flags = user->flags_; int32 flags = user->flags_;
LOG(INFO) << "Receive " << user_id << " with flags " << flags; LOG(INFO) << "Receive " << user_id << " with flags " << flags << " from " << source;
if (is_me && (flags & USER_FLAG_IS_ME) == 0) { if (is_me && (flags & USER_FLAG_IS_ME) == 0) {
LOG(ERROR) << user_id << " doesn't have flag IS_ME, but must have it"; LOG(ERROR) << user_id << " doesn't have flag IS_ME, but must have it when received from " << source;
flags |= USER_FLAG_IS_ME; flags |= USER_FLAG_IS_ME;
} }
@ -5144,10 +5145,12 @@ void ContactsManager::on_get_user(tl_object_ptr<telegram_api::User> &&user_ptr,
bool need_location_bot = (flags & USER_FLAG_NEED_LOCATION_BOT) != 0; bool need_location_bot = (flags & USER_FLAG_NEED_LOCATION_BOT) != 0;
bool has_bot_info_version = (flags & USER_FLAG_HAS_BOT_INFO_VERSION) != 0; bool has_bot_info_version = (flags & USER_FLAG_HAS_BOT_INFO_VERSION) != 0;
LOG_IF(ERROR, !can_join_groups && !is_bot) << "Receive not bot which can't join groups"; LOG_IF(ERROR, !can_join_groups && !is_bot) << "Receive not bot which can't join groups from " << source;
LOG_IF(ERROR, can_read_all_group_messages && !is_bot) << "Receive not bot which can read all group messages"; LOG_IF(ERROR, can_read_all_group_messages && !is_bot)
LOG_IF(ERROR, is_inline_bot && !is_bot) << "Receive not bot which is inline bot"; << "Receive not bot which can read all group messages from " << source;
LOG_IF(ERROR, need_location_bot && !is_inline_bot) << "Receive not inline bot which needs user location"; LOG_IF(ERROR, is_inline_bot && !is_bot) << "Receive not bot which is inline bot from " << source;
LOG_IF(ERROR, need_location_bot && !is_inline_bot)
<< "Receive not inline bot which needs user location from " << source;
if (is_received && !u->is_received) { if (is_received && !u->is_received) {
u->is_received = true; u->is_received = true;
@ -5168,14 +5171,14 @@ void ContactsManager::on_get_user(tl_object_ptr<telegram_api::User> &&user_ptr,
has_bot_info_version = false; has_bot_info_version = false;
} }
LOG_IF(ERROR, has_bot_info_version && !is_bot) << "Receive not bot which has bot info version"; LOG_IF(ERROR, has_bot_info_version && !is_bot) << "Receive not bot which has bot info version from " << source;
int32 bot_info_version = has_bot_info_version ? user->bot_info_version_ : -1; int32 bot_info_version = has_bot_info_version ? user->bot_info_version_ : -1;
if (is_verified != u->is_verified || is_bot != u->is_bot || can_join_groups != u->can_join_groups || if (is_verified != u->is_verified || is_bot != u->is_bot || can_join_groups != u->can_join_groups ||
can_read_all_group_messages != u->can_read_all_group_messages || restriction_reason != u->restriction_reason || can_read_all_group_messages != u->can_read_all_group_messages || restriction_reason != u->restriction_reason ||
is_inline_bot != u->is_inline_bot || inline_query_placeholder != u->inline_query_placeholder || is_inline_bot != u->is_inline_bot || inline_query_placeholder != u->inline_query_placeholder ||
need_location_bot != u->need_location_bot) { need_location_bot != u->need_location_bot) {
LOG_IF(ERROR, is_bot != u->is_bot && !is_deleted && !u->is_deleted) << "User.is_bot has changed"; LOG_IF(ERROR, is_bot != u->is_bot && !is_deleted && !u->is_deleted) << "User.is_bot has changed from " << source;
u->is_verified = is_verified; u->is_verified = is_verified;
u->is_bot = is_bot; u->is_bot = is_bot;
u->can_join_groups = can_join_groups; u->can_join_groups = can_join_groups;
@ -5207,7 +5210,7 @@ void ContactsManager::on_get_user(tl_object_ptr<telegram_api::User> &&user_ptr,
} }
bool has_language_code = (flags & USER_FLAG_HAS_LANGUAGE_CODE) != 0; bool has_language_code = (flags & USER_FLAG_HAS_LANGUAGE_CODE) != 0;
LOG_IF(ERROR, has_language_code && !td_->auth_manager_->is_bot()) << "Receive language code"; LOG_IF(ERROR, has_language_code && !td_->auth_manager_->is_bot()) << "Receive language code from " << source;
if (u->language_code != user->lang_code_ && !user->lang_code_.empty()) { if (u->language_code != user->lang_code_ && !user->lang_code_.empty()) {
u->language_code = user->lang_code_; u->language_code = user->lang_code_;
@ -5443,7 +5446,7 @@ ContactsManager::User *ContactsManager::get_user_force(UserId user_id) {
false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/, false /*ignored*/,
false /*ignored*/, 777000, 1, "Telegram", "Updates", string(), "42777", std::move(profile_photo), nullptr, 0, false /*ignored*/, 777000, 1, "Telegram", "Updates", string(), "42777", std::move(profile_photo), nullptr, 0,
string(), string(), string()); string(), string(), string());
on_get_user(std::move(user)); on_get_user(std::move(user), "get_user_force");
u = get_user(user_id); u = get_user(user_id);
CHECK(u != nullptr && u->is_received); CHECK(u != nullptr && u->is_received);
} }
@ -6421,9 +6424,9 @@ void ContactsManager::update_channel_full(ChannelFull *channel_full, ChannelId c
} }
} }
void ContactsManager::on_get_users(vector<tl_object_ptr<telegram_api::User>> &&users) { void ContactsManager::on_get_users(vector<tl_object_ptr<telegram_api::User>> &&users, const char *source) {
for (auto &user : users) { for (auto &user : users) {
on_get_user(std::move(user)); on_get_user(std::move(user), source);
} }
} }
@ -6434,7 +6437,7 @@ void ContactsManager::on_get_user_full(tl_object_ptr<telegram_api::userFull> &&u
return; return;
} }
on_get_user(std::move(user_full->user_)); on_get_user(std::move(user_full->user_), "on_get_user_full");
const User *u = get_user(user_id); const User *u = get_user(user_id);
if (u == nullptr) { if (u == nullptr) {
return; return;
@ -6572,23 +6575,23 @@ bool ContactsManager::on_update_user_full_bot_info(UserFull *user_full, UserId u
return true; return true;
} }
void ContactsManager::on_get_chat(tl_object_ptr<telegram_api::Chat> &&chat) { void ContactsManager::on_get_chat(tl_object_ptr<telegram_api::Chat> &&chat, const char *source) {
LOG(DEBUG) << "Receive " << to_string(chat); LOG(DEBUG) << "Receive from " << source << ' ' << to_string(chat);
downcast_call(*chat, [this](auto &c) { this->on_chat_update(c); }); downcast_call(*chat, [this, source](auto &c) { this->on_chat_update(c, source); });
} }
void ContactsManager::on_get_chats(vector<tl_object_ptr<telegram_api::Chat>> &&chats) { void ContactsManager::on_get_chats(vector<tl_object_ptr<telegram_api::Chat>> &&chats, const char *source) {
for (auto &chat : chats) { for (auto &chat : chats) {
auto constuctor_id = chat->get_id(); auto constuctor_id = chat->get_id();
if (constuctor_id == telegram_api::channel::ID || constuctor_id == telegram_api::channelForbidden::ID) { if (constuctor_id == telegram_api::channel::ID || constuctor_id == telegram_api::channelForbidden::ID) {
// apply info about megagroups before corresponding chats // apply info about megagroups before corresponding chats
on_get_chat(std::move(chat)); on_get_chat(std::move(chat), source);
chat = nullptr; chat = nullptr;
} }
} }
for (auto &chat : chats) { for (auto &chat : chats) {
if (chat != nullptr) { if (chat != nullptr) {
on_get_chat(std::move(chat)); on_get_chat(std::move(chat), source);
chat = nullptr; chat = nullptr;
} }
} }
@ -7256,7 +7259,7 @@ bool ContactsManager::on_get_channel_error(ChannelId channel_id, const Status &s
} }
telegram_api::channelForbidden update(flags, false /*ignored*/, false /*ignored*/, channel_id.get(), telegram_api::channelForbidden update(flags, false /*ignored*/, false /*ignored*/, channel_id.get(),
c->access_hash, c->title, 0); c->access_hash, c->title, 0);
on_chat_update(update); on_chat_update(update, "CHANNEL_PRIVATE");
} else if (!c->username.empty()) { } else if (!c->username.empty()) {
LOG(INFO) << "Drop username of " << channel_id; LOG(INFO) << "Drop username of " << channel_id;
on_update_channel_username(c, channel_id, ""); on_update_channel_username(c, channel_id, "");
@ -7476,7 +7479,7 @@ void ContactsManager::on_get_dialog_invite_link_info(const string &invite_link,
LOG(ERROR) << "Receive invalid " << channel_id; LOG(ERROR) << "Receive invalid " << channel_id;
channel_id = ChannelId(); channel_id = ChannelId();
} }
on_get_chat(std::move(chat_invite_already->chat_)); on_get_chat(std::move(chat_invite_already->chat_), "chatInviteAlready");
CHECK(chat_id == ChatId() || channel_id == ChannelId()); CHECK(chat_id == ChatId() || channel_id == ChannelId());
invite_link_info->chat_id = chat_id; invite_link_info->chat_id = chat_id;
@ -7503,7 +7506,7 @@ void ContactsManager::on_get_dialog_invite_link_info(const string &invite_link,
if (!user_id.is_valid()) { if (!user_id.is_valid()) {
LOG(ERROR) << "Receive invalid " << user_id; LOG(ERROR) << "Receive invalid " << user_id;
} else { } else {
on_get_user(std::move(user)); on_get_user(std::move(user), "chatInvite");
} }
invite_link_info->participant_user_ids.push_back(user_id); invite_link_info->participant_user_ids.push_back(user_id);
} }
@ -9305,30 +9308,30 @@ void ContactsManager::reload_dialog_administrators(DialogId dialog_id, int32 has
} }
} }
void ContactsManager::on_chat_update(telegram_api::chatEmpty &chat) { void ContactsManager::on_chat_update(telegram_api::chatEmpty &chat, const char *source) {
ChatId chat_id(chat.id_); ChatId chat_id(chat.id_);
if (!chat_id.is_valid()) { if (!chat_id.is_valid()) {
LOG(ERROR) << "Receive invalid " << chat_id; LOG(ERROR) << "Receive invalid " << chat_id << " from " << source;
return; return;
} }
if (!have_chat(chat_id)) { if (!have_chat(chat_id)) {
LOG(ERROR) << "Have no information about " << chat_id << " but received chatEmpty"; LOG(ERROR) << "Have no information about " << chat_id << " but received chatEmpty from " << source;
} }
} }
void ContactsManager::on_chat_update(telegram_api::chat &chat) { void ContactsManager::on_chat_update(telegram_api::chat &chat, const char *source) {
auto debug_str = oneline(to_string(chat)); auto debug_str = PSTRING() << " from " << source << " in " << oneline(to_string(chat));
ChatId chat_id(chat.id_); ChatId chat_id(chat.id_);
if (!chat_id.is_valid()) { if (!chat_id.is_valid()) {
LOG(ERROR) << "Receive invalid " << chat_id << " in " << debug_str; LOG(ERROR) << "Receive invalid " << chat_id << debug_str;
return; return;
} }
bool has_left = 0 != (chat.flags_ & CHAT_FLAG_USER_HAS_LEFT); bool has_left = 0 != (chat.flags_ & CHAT_FLAG_USER_HAS_LEFT);
bool was_kicked = 0 != (chat.flags_ & CHAT_FLAG_USER_WAS_KICKED); bool was_kicked = 0 != (chat.flags_ & CHAT_FLAG_USER_WAS_KICKED);
if (was_kicked) { if (was_kicked) {
LOG_IF(ERROR, has_left) << "Kicked and left in " << debug_str; // only one of the flags can be set LOG_IF(ERROR, has_left) << "Kicked and left" << debug_str; // only one of the flags can be set
has_left = true; has_left = true;
} }
@ -9342,7 +9345,7 @@ void ContactsManager::on_chat_update(telegram_api::chat &chat) {
if (chat.flags_ & CHAT_FLAG_WAS_MIGRATED) { if (chat.flags_ & CHAT_FLAG_WAS_MIGRATED) {
switch (chat.migrated_to_->get_id()) { switch (chat.migrated_to_->get_id()) {
case telegram_api::inputChannelEmpty::ID: { case telegram_api::inputChannelEmpty::ID: {
LOG(ERROR) << "Receive empty upgraded to supergroup for " << chat_id << " in " << debug_str; LOG(ERROR) << "Receive empty upgraded to supergroup for " << chat_id << debug_str;
break; break;
} }
case telegram_api::inputChannel::ID: { case telegram_api::inputChannel::ID: {
@ -9350,7 +9353,7 @@ void ContactsManager::on_chat_update(telegram_api::chat &chat) {
migrated_to_channel_id = ChannelId(input_channel->channel_id_); migrated_to_channel_id = ChannelId(input_channel->channel_id_);
if (!have_channel(migrated_to_channel_id)) { if (!have_channel(migrated_to_channel_id)) {
if (!migrated_to_channel_id.is_valid()) { if (!migrated_to_channel_id.is_valid()) {
LOG(ERROR) << "Receive invalid " << migrated_to_channel_id << " in " << debug_str; LOG(ERROR) << "Receive invalid " << migrated_to_channel_id << debug_str;
} else { } else {
// temporarily create the channel // temporarily create the channel
Channel *c = add_channel(migrated_to_channel_id, "on_chat_update"); Channel *c = add_channel(migrated_to_channel_id, "on_chat_update");
@ -9379,7 +9382,7 @@ void ContactsManager::on_chat_update(telegram_api::chat &chat) {
on_update_chat_participant_count(c, chat_id, chat.participants_count_, chat.version_, debug_str); on_update_chat_participant_count(c, chat_id, chat.participants_count_, chat.version_, debug_str);
} }
if (c->date != chat.date_) { if (c->date != chat.date_) {
LOG_IF(ERROR, c->date != 0) << "Chat creation date has changed from " << c->date << " to " << chat.date_ << " in " LOG_IF(ERROR, c->date != 0) << "Chat creation date has changed from " << c->date << " to " << chat.date_
<< debug_str; << debug_str;
c->date = chat.date_; c->date = chat.date_;
c->is_changed = true; c->is_changed = true;
@ -9393,10 +9396,10 @@ void ContactsManager::on_chat_update(telegram_api::chat &chat) {
update_chat(c, chat_id); update_chat(c, chat_id);
} }
void ContactsManager::on_chat_update(telegram_api::chatForbidden &chat) { void ContactsManager::on_chat_update(telegram_api::chatForbidden &chat, const char *source) {
ChatId chat_id(chat.id_); ChatId chat_id(chat.id_);
if (!chat_id.is_valid()) { if (!chat_id.is_valid()) {
LOG(ERROR) << "Receive invalid " << chat_id; LOG(ERROR) << "Receive invalid " << chat_id << " from " << source;
return; return;
} }
@ -9421,16 +9424,16 @@ void ContactsManager::on_chat_update(telegram_api::chatForbidden &chat) {
update_chat(c, chat_id); update_chat(c, chat_id);
} }
void ContactsManager::on_chat_update(telegram_api::channel &channel) { void ContactsManager::on_chat_update(telegram_api::channel &channel, const char *source) {
ChannelId channel_id(channel.id_); ChannelId channel_id(channel.id_);
if (!channel_id.is_valid()) { if (!channel_id.is_valid()) {
LOG(ERROR) << "Receive invalid " << channel_id << ": " << to_string(channel); LOG(ERROR) << "Receive invalid " << channel_id << " from " << source << ": " << to_string(channel);
return; return;
} }
if (channel.flags_ == 0 && channel.access_hash_ == 0 && channel.title_.empty()) { if (channel.flags_ == 0 && channel.access_hash_ == 0 && channel.title_.empty()) {
Channel *c = get_channel_force(channel_id); Channel *c = get_channel_force(channel_id);
LOG(ERROR) << "Receive empty " << to_string(channel) << ", have " LOG(ERROR) << "Receive empty " << to_string(channel) << " from " << source << ", have "
<< to_string(get_supergroup_object(channel_id, c)); << to_string(get_supergroup_object(channel_id, c));
if (c == nullptr) { if (c == nullptr) {
min_channels_.insert(channel_id); min_channels_.insert(channel_id);
@ -9453,17 +9456,17 @@ void ContactsManager::on_chat_update(telegram_api::channel &channel) {
{ {
bool is_broadcast = (channel.flags_ & CHANNEL_FLAG_IS_BROADCAST) != 0; bool is_broadcast = (channel.flags_ & CHANNEL_FLAG_IS_BROADCAST) != 0;
LOG_IF(ERROR, is_broadcast == is_megagroup) LOG_IF(ERROR, is_broadcast == is_megagroup)
<< "Receive wrong channel flag is_broadcast == is_megagroup == " << is_megagroup << ": " << "Receive wrong channel flag is_broadcast == is_megagroup == " << is_megagroup << " from " << source << ": "
<< oneline(to_string(channel)); << oneline(to_string(channel));
} }
if (!is_megagroup && anyone_can_invite) { if (!is_megagroup && anyone_can_invite) {
LOG(ERROR) << "Anyone can invite new members to the " << channel_id; LOG(ERROR) << "Anyone can invite new members to the " << channel_id << " from " << source;
anyone_can_invite = false; anyone_can_invite = false;
} }
if (is_megagroup) { if (is_megagroup) {
LOG_IF(ERROR, sign_messages) << "Need to sign messages in the supergroup " << channel_id; LOG_IF(ERROR, sign_messages) << "Need to sign messages in the supergroup " << channel_id << " from " << source;
sign_messages = true; sign_messages = true;
} }
@ -9510,7 +9513,7 @@ void ContactsManager::on_chat_update(telegram_api::channel &channel) {
return; return;
} }
if (!has_access_hash) { if (!has_access_hash) {
LOG(ERROR) << "Receive non-min " << channel_id << " without access_hash"; LOG(ERROR) << "Receive non-min " << channel_id << " without access_hash from " << source;
return; return;
} }
@ -9551,16 +9554,16 @@ void ContactsManager::on_chat_update(telegram_api::channel &channel) {
update_channel(c, channel_id); update_channel(c, channel_id);
} }
void ContactsManager::on_chat_update(telegram_api::channelForbidden &channel) { void ContactsManager::on_chat_update(telegram_api::channelForbidden &channel, const char *source) {
ChannelId channel_id(channel.id_); ChannelId channel_id(channel.id_);
if (!channel_id.is_valid()) { if (!channel_id.is_valid()) {
LOG(ERROR) << "Receive invalid " << channel_id << ": " << to_string(channel); LOG(ERROR) << "Receive invalid " << channel_id << " from " << source << ": " << to_string(channel);
return; return;
} }
if (channel.flags_ == 0 && channel.access_hash_ == 0 && channel.title_.empty()) { if (channel.flags_ == 0 && channel.access_hash_ == 0 && channel.title_.empty()) {
Channel *c = get_channel_force(channel_id); Channel *c = get_channel_force(channel_id);
LOG(ERROR) << "Receive empty " << to_string(channel) << ", have " LOG(ERROR) << "Receive empty " << to_string(channel) << " from " << source << ", have "
<< to_string(get_supergroup_object(channel_id, c)); << to_string(get_supergroup_object(channel_id, c));
if (c == nullptr) { if (c == nullptr) {
min_channels_.insert(channel_id); min_channels_.insert(channel_id);
@ -9595,7 +9598,7 @@ void ContactsManager::on_chat_update(telegram_api::channelForbidden &channel) {
{ {
bool is_broadcast = (channel.flags_ & CHANNEL_FLAG_IS_BROADCAST) != 0; bool is_broadcast = (channel.flags_ & CHANNEL_FLAG_IS_BROADCAST) != 0;
LOG_IF(ERROR, is_broadcast == is_megagroup) LOG_IF(ERROR, is_broadcast == is_megagroup)
<< "Receive wrong channel flag is_broadcast == is_megagroup == " << is_megagroup << ": " << "Receive wrong channel flag is_broadcast == is_megagroup == " << is_megagroup << " from " << source << ": "
<< oneline(to_string(channel)); << oneline(to_string(channel));
} }

19
td/telegram/ContactsManager.h
View File

@ -125,8 +125,9 @@ class ContactsManager : public Actor {
void on_get_contacts_link(tl_object_ptr<telegram_api::contacts_link> &&link); void on_get_contacts_link(tl_object_ptr<telegram_api::contacts_link> &&link);
void on_get_user(tl_object_ptr<telegram_api::User> &&user, bool is_me = false, bool is_support = false); void on_get_user(tl_object_ptr<telegram_api::User> &&user, const char *source, bool is_me = false,
void on_get_users(vector<tl_object_ptr<telegram_api::User>> &&users); bool is_support = false);
void on_get_users(vector<tl_object_ptr<telegram_api::User>> &&users, const char *source);
void on_binlog_user_event(BinlogEvent &&event); void on_binlog_user_event(BinlogEvent &&event);
void on_binlog_chat_event(BinlogEvent &&event); void on_binlog_chat_event(BinlogEvent &&event);
@ -138,8 +139,8 @@ class ContactsManager : public Actor {
void on_get_user_photos(UserId user_id, int32 offset, int32 limit, int32 total_count, void on_get_user_photos(UserId user_id, int32 offset, int32 limit, int32 total_count,
vector<tl_object_ptr<telegram_api::Photo>> photos); vector<tl_object_ptr<telegram_api::Photo>> photos);
void on_get_chat(tl_object_ptr<telegram_api::Chat> &&chat); void on_get_chat(tl_object_ptr<telegram_api::Chat> &&chat, const char *source);
void on_get_chats(vector<tl_object_ptr<telegram_api::Chat>> &&chats); void on_get_chats(vector<tl_object_ptr<telegram_api::Chat>> &&chats, const char *source);
void on_get_chat_full(tl_object_ptr<telegram_api::ChatFull> &&chat_full); void on_get_chat_full(tl_object_ptr<telegram_api::ChatFull> &&chat_full);
@ -888,11 +889,11 @@ class ContactsManager : public Actor {
void invalidate_chat_full(ChatId chat_id); void invalidate_chat_full(ChatId chat_id);
void on_chat_update(telegram_api::chatEmpty &chat); void on_chat_update(telegram_api::chatEmpty &chat, const char *source);
void on_chat_update(telegram_api::chat &chat); void on_chat_update(telegram_api::chat &chat, const char *source);
void on_chat_update(telegram_api::chatForbidden &chat); void on_chat_update(telegram_api::chatForbidden &chat, const char *source);
void on_chat_update(telegram_api::channel &channel); void on_chat_update(telegram_api::channel &channel, const char *source);
void on_chat_update(telegram_api::channelForbidden &channel); void on_chat_update(telegram_api::channelForbidden &channel, const char *source);
void save_user(User *u, UserId user_id, bool from_binlog); void save_user(User *u, UserId user_id, bool from_binlog);
static string get_user_database_key(UserId user_id); static string get_user_database_key(UserId user_id);

2
td/telegram/InlineQueriesManager.cpp
View File

@ -1107,7 +1107,7 @@ void InlineQueriesManager::on_get_inline_query_results(UserId bot_user_id, uint6
} }
LOG(INFO) << to_string(results); LOG(INFO) << to_string(results);
td_->contacts_manager_->on_get_users(std::move(results->users_)); td_->contacts_manager_->on_get_users(std::move(results->users_), "on_get_inline_query_results");
vector<tl_object_ptr<td_api::InlineQueryResult>> output_results; vector<tl_object_ptr<td_api::InlineQueryResult>> output_results;
for (auto &result_ptr : results->results_) { for (auto &result_ptr : results->results_) {

50
td/telegram/MessagesManager.cpp
View File

@ -98,8 +98,8 @@ class GetDialogQuery : public Td::ResultHandler {
auto result = result_ptr.move_as_ok(); auto result = result_ptr.move_as_ok();
LOG(INFO) << "Receive chat: " << to_string(result); LOG(INFO) << "Receive chat: " << to_string(result);
td->contacts_manager_->on_get_users(std::move(result->users_)); td->contacts_manager_->on_get_users(std::move(result->users_), "GetDialogQuery");
td->contacts_manager_->on_get_chats(std::move(result->chats_)); td->contacts_manager_->on_get_chats(std::move(result->chats_), "GetDialogQuery");
td->messages_manager_->on_get_dialogs( td->messages_manager_->on_get_dialogs(
std::move(result->dialogs_), -1, std::move(result->messages_), std::move(result->dialogs_), -1, std::move(result->messages_),
PromiseCreator::lambda([td = td, dialog_id = dialog_id_](Result<> result) { PromiseCreator::lambda([td = td, dialog_id = dialog_id_](Result<> result) {
@ -145,8 +145,8 @@ class GetPinnedDialogsQuery : public NetActorOnce {
auto result = result_ptr.move_as_ok(); auto result = result_ptr.move_as_ok();
LOG(INFO) << "Receive pinned chats: " << to_string(result); LOG(INFO) << "Receive pinned chats: " << to_string(result);
td->contacts_manager_->on_get_users(std::move(result->users_)); td->contacts_manager_->on_get_users(std::move(result->users_), "GetPinnedDialogsQuery");
td->contacts_manager_->on_get_chats(std::move(result->chats_)); td->contacts_manager_->on_get_chats(std::move(result->chats_), "GetPinnedDialogsQuery");
std::reverse(result->dialogs_.begin(), result->dialogs_.end()); std::reverse(result->dialogs_.begin(), result->dialogs_.end());
td->messages_manager_->on_get_dialogs(std::move(result->dialogs_), -2, std::move(result->messages_), td->messages_manager_->on_get_dialogs(std::move(result->dialogs_), -2, std::move(result->messages_),
std::move(promise_)); std::move(promise_));
@ -381,8 +381,8 @@ class GetDialogListQuery : 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_)); td->contacts_manager_->on_get_users(std::move(dialogs->users_), "GetDialogListQuery");
td->contacts_manager_->on_get_chats(std::move(dialogs->chats_)); td->contacts_manager_->on_get_chats(std::move(dialogs->chats_), "GetDialogListQuery");
td->messages_manager_->on_get_dialogs(std::move(dialogs->dialogs_), td->messages_manager_->on_get_dialogs(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_));
@ -390,8 +390,8 @@ class GetDialogListQuery : 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_)); td->contacts_manager_->on_get_users(std::move(dialogs->users_), "GetDialogListQuery");
td->contacts_manager_->on_get_chats(std::move(dialogs->chats_)); td->contacts_manager_->on_get_chats(std::move(dialogs->chats_), "GetDialogListQuery");
td->messages_manager_->on_get_dialogs(std::move(dialogs->dialogs_), max(dialogs->count_, 0), td->messages_manager_->on_get_dialogs(std::move(dialogs->dialogs_), max(dialogs->count_, 0),
std::move(dialogs->messages_), std::move(promise_)); std::move(dialogs->messages_), std::move(promise_));
break; break;
@ -427,8 +427,8 @@ class SearchPublicDialogsQuery : public Td::ResultHandler {
auto dialogs = result_ptr.move_as_ok(); auto dialogs = result_ptr.move_as_ok();
LOG(INFO) << "Receive result for SearchPublicDialogsQuery " << to_string(dialogs); LOG(INFO) << "Receive result for SearchPublicDialogsQuery " << to_string(dialogs);
td->contacts_manager_->on_get_users(std::move(dialogs->users_)); td->contacts_manager_->on_get_users(std::move(dialogs->users_), "SearchPublicDialogsQuery");
td->contacts_manager_->on_get_chats(std::move(dialogs->chats_)); td->contacts_manager_->on_get_chats(std::move(dialogs->chats_), "SearchPublicDialogsQuery");
td->messages_manager_->on_get_public_dialogs_search_result(query_, std::move(dialogs->my_results_), td->messages_manager_->on_get_public_dialogs_search_result(query_, std::move(dialogs->my_results_),
std::move(dialogs->results_)); std::move(dialogs->results_));
} }
@ -3164,8 +3164,8 @@ class ResolveUsernameQuery : public Td::ResultHandler {
auto ptr = result_ptr.move_as_ok(); auto ptr = result_ptr.move_as_ok();
LOG(DEBUG) << "Receive result for resolveUsername " << to_string(ptr); LOG(DEBUG) << "Receive result for resolveUsername " << to_string(ptr);
td->contacts_manager_->on_get_users(std::move(ptr->users_)); td->contacts_manager_->on_get_users(std::move(ptr->users_), "ResolveUsernameQuery");
td->contacts_manager_->on_get_chats(std::move(ptr->chats_)); td->contacts_manager_->on_get_chats(std::move(ptr->chats_), "ResolveUsernameQuery");
td->messages_manager_->on_resolved_username(username_, DialogId(ptr->peer_)); td->messages_manager_->on_resolved_username(username_, DialogId(ptr->peer_));
@ -6497,8 +6497,8 @@ MessagesManager::MessagesInfo MessagesManager::on_get_messages(
break; break;
} }
td_->contacts_manager_->on_get_users(std::move(users)); td_->contacts_manager_->on_get_users(std::move(users), source);
td_->contacts_manager_->on_get_chats(std::move(chats)); td_->contacts_manager_->on_get_chats(std::move(chats), source);
return result; return result;
} }
@ -6850,7 +6850,7 @@ void MessagesManager::on_get_dialog_messages_search_result(DialogId dialog_id, c
} }
for (auto &message : messages) { for (auto &message : messages) {
auto new_message = on_get_message(std::move(message), false, dialog_id.get_type() == DialogType::Channel, false, auto new_message = on_get_message(std::move(message), false, dialog_id.get_type() == DialogType::Channel, false,
false, "search chat messages"); false, "SearchMessagesQuery");
if (new_message != FullMessageId()) { if (new_message != FullMessageId()) {
if (new_message.get_dialog_id() != dialog_id) { if (new_message.get_dialog_id() != dialog_id) {
LOG(ERROR) << "Receive " << new_message << " instead of a message in " << dialog_id; LOG(ERROR) << "Receive " << new_message << " instead of a message in " << dialog_id;
@ -11399,7 +11399,7 @@ void MessagesManager::on_get_common_dialogs(UserId user_id, vector<tl_object_ptr
UNREACHABLE(); UNREACHABLE();
} }
CHECK(dialog_id.is_valid()); CHECK(dialog_id.is_valid());
td_->contacts_manager_->on_get_chat(std::move(chat)); td_->contacts_manager_->on_get_chat(std::move(chat), "on_get_common_dialogs");
if (std::find(result.begin(), result.end(), dialog_id) == result.end()) { if (std::find(result.begin(), result.end(), dialog_id) == result.end()) {
force_create_dialog(dialog_id, "get common dialogs"); force_create_dialog(dialog_id, "get common dialogs");
@ -16853,7 +16853,7 @@ void MessagesManager::on_get_game_high_scores(int64 random_id,
return; return;
} }
td_->contacts_manager_->on_get_users(std::move(high_scores->users_)); td_->contacts_manager_->on_get_users(std::move(high_scores->users_), "on_get_game_high_scores");
result = make_tl_object<td_api::gameHighScores>(); result = make_tl_object<td_api::gameHighScores>();
@ -20543,8 +20543,8 @@ void MessagesManager::on_get_event_log(int64 random_id,
LOG(INFO) << "Receive " << to_string(events); LOG(INFO) << "Receive " << to_string(events);
td_->contacts_manager_->on_get_users(std::move(events->users_)); td_->contacts_manager_->on_get_users(std::move(events->users_), "on_get_event_log");
td_->contacts_manager_->on_get_chats(std::move(events->chats_)); td_->contacts_manager_->on_get_chats(std::move(events->chats_), "on_get_event_log");
result = make_tl_object<td_api::chatEvents>(); result = make_tl_object<td_api::chatEvents>();
result->events_.reserve(events->events_.size()); result->events_.reserve(events->events_.size());
@ -23280,8 +23280,8 @@ void MessagesManager::on_get_channel_difference(
new_pts = request_pts + 1; new_pts = request_pts + 1;
} }
td_->contacts_manager_->on_get_users(std::move(difference->users_)); td_->contacts_manager_->on_get_users(std::move(difference->users_), "updates.channelDifference");
td_->contacts_manager_->on_get_chats(std::move(difference->chats_)); td_->contacts_manager_->on_get_chats(std::move(difference->chats_), "updates.channelDifference");
process_get_channel_difference_updates(dialog_id, std::move(difference->new_messages_), process_get_channel_difference_updates(dialog_id, std::move(difference->new_messages_),
std::move(difference->other_updates_)); std::move(difference->other_updates_));
@ -23308,8 +23308,8 @@ void MessagesManager::on_get_channel_difference(
} }
} }
td_->contacts_manager_->on_get_users(std::move(difference->users_)); td_->contacts_manager_->on_get_users(std::move(difference->users_), "updates.channelDifferenceTooLong");
td_->contacts_manager_->on_get_chats(std::move(difference->chats_)); td_->contacts_manager_->on_get_chats(std::move(difference->chats_), "updates.channelDifferenceTooLong");
on_get_channel_dialog(dialog_id, MessageId(ServerMessageId(difference->top_message_)), on_get_channel_dialog(dialog_id, MessageId(ServerMessageId(difference->top_message_)),
MessageId(ServerMessageId(difference->read_inbox_max_id_)), difference->unread_count_, MessageId(ServerMessageId(difference->read_inbox_max_id_)), difference->unread_count_,
@ -24400,8 +24400,8 @@ void MessagesManager::on_get_sponsored_dialog_id(tl_object_ptr<telegram_api::Pee
return; return;
} }
td_->contacts_manager_->on_get_users(std::move(users)); td_->contacts_manager_->on_get_users(std::move(users), "on_get_sponsored_dialog_id");
td_->contacts_manager_->on_get_chats(std::move(chats)); td_->contacts_manager_->on_get_chats(std::move(chats), "on_get_sponsored_dialog_id");
set_sponsored_dialog_id(DialogId(peer)); set_sponsored_dialog_id(DialogId(peer));
} }

4
td/telegram/Payments.cpp
View File

@ -271,7 +271,7 @@ class GetPaymentFormQuery : public Td::ResultHandler {
auto payment_form = result_ptr.move_as_ok(); auto payment_form = result_ptr.move_as_ok();
LOG(INFO) << "Receive payment form: " << to_string(payment_form); LOG(INFO) << "Receive payment form: " << to_string(payment_form);
td->contacts_manager_->on_get_users(std::move(payment_form->users_)); td->contacts_manager_->on_get_users(std::move(payment_form->users_), "GetPaymentFormQuery");
bool can_save_credentials = bool can_save_credentials =
(payment_form->flags_ & telegram_api::payments_paymentForm::CAN_SAVE_CREDENTIALS_MASK) != 0; (payment_form->flags_ & telegram_api::payments_paymentForm::CAN_SAVE_CREDENTIALS_MASK) != 0;
@ -404,7 +404,7 @@ class GetPaymentReceiptQuery : public Td::ResultHandler {
auto payment_receipt = result_ptr.move_as_ok(); auto payment_receipt = result_ptr.move_as_ok();
LOG(INFO) << "Receive payment receipt: " << to_string(payment_receipt); LOG(INFO) << "Receive payment receipt: " << to_string(payment_receipt);
td->contacts_manager_->on_get_users(std::move(payment_receipt->users_)); td->contacts_manager_->on_get_users(std::move(payment_receipt->users_), "GetPaymentReceiptQuery");
UserId payments_provider_user_id(payment_receipt->provider_id_); UserId payments_provider_user_id(payment_receipt->provider_id_);
if (!payments_provider_user_id.is_valid()) { if (!payments_provider_user_id.is_valid()) {

2
td/telegram/PrivacyManager.cpp
View File

@ -211,7 +211,7 @@ vector<int32> PrivacyManager::UserPrivacySettingRule::user_ids_as_td_api() const
Result<PrivacyManager::UserPrivacySettingRules> PrivacyManager::UserPrivacySettingRules::from_telegram_api( Result<PrivacyManager::UserPrivacySettingRules> PrivacyManager::UserPrivacySettingRules::from_telegram_api(
tl_object_ptr<telegram_api::account_privacyRules> rules) { tl_object_ptr<telegram_api::account_privacyRules> rules) {
G()->td().get_actor_unsafe()->contacts_manager_->on_get_users(std::move(rules->users_)); G()->td().get_actor_unsafe()->contacts_manager_->on_get_users(std::move(rules->users_), "on get privacy rules");
return from_telegram_api(std::move(rules->rules_)); return from_telegram_api(std::move(rules->rules_));
} }

3
td/telegram/SecureManager.cpp
View File

@ -927,7 +927,8 @@ void SecureManager::on_get_passport_authorization_form(
auto authorization_form = r_authorization_form.move_as_ok(); auto authorization_form = r_authorization_form.move_as_ok();
LOG(INFO) << "Receive " << to_string(authorization_form); LOG(INFO) << "Receive " << to_string(authorization_form);
G()->td().get_actor_unsafe()->contacts_manager_->on_get_users(std::move(authorization_form->users_)); G()->td().get_actor_unsafe()->contacts_manager_->on_get_users(std::move(authorization_form->users_),
"on_get_passport_authoriation_form");
vector<vector<SuitableSecureValue>> required_types; vector<vector<SuitableSecureValue>> required_types;
std::map<SecureValueType, SuitableSecureValue> all_types; std::map<SecureValueType, SuitableSecureValue> all_types;

4
td/telegram/Td.cpp
View File

@ -223,8 +223,8 @@ class GetRecentMeUrlsQuery : public Td::ResultHandler {
} }
auto urls_full = result_ptr.move_as_ok(); auto urls_full = result_ptr.move_as_ok();
td->contacts_manager_->on_get_users(std::move(urls_full->users_)); td->contacts_manager_->on_get_users(std::move(urls_full->users_), "GetRecentMeUrlsQuery");
td->contacts_manager_->on_get_chats(std::move(urls_full->chats_)); td->contacts_manager_->on_get_chats(std::move(urls_full->chats_), "GetRecentMeUrlsQuery");
auto urls = std::move(urls_full->urls_); auto urls = std::move(urls_full->urls_);
auto results = make_tl_object<td_api::tMeUrls>(); auto results = make_tl_object<td_api::tMeUrls>();

6
td/telegram/TopDialogManager.cpp
View File

@ -417,8 +417,10 @@ void TopDialogManager::on_result(NetQueryPtr net_query) {
set_is_enabled(true); // apply immediately set_is_enabled(true); // apply immediately
auto top_peers = move_tl_object_as<telegram_api::contacts_topPeers>(std::move(top_peers_parent)); auto top_peers = move_tl_object_as<telegram_api::contacts_topPeers>(std::move(top_peers_parent));
send_closure(G()->contacts_manager(), &ContactsManager::on_get_users, std::move(top_peers->users_)); send_closure(G()->contacts_manager(), &ContactsManager::on_get_users, std::move(top_peers->users_),
send_closure(G()->contacts_manager(), &ContactsManager::on_get_chats, std::move(top_peers->chats_)); "on get top chats");
send_closure(G()->contacts_manager(), &ContactsManager::on_get_chats, std::move(top_peers->chats_),
"on get top chats");
for (auto &category : top_peers->categories_) { for (auto &category : top_peers->categories_) {
auto dialog_category = top_dialog_category_from_telegram_api(*category->category_); auto dialog_category = top_dialog_category_from_telegram_api(*category->category_);
auto pos = static_cast<size_t>(dialog_category); auto pos = static_cast<size_t>(dialog_category);

16
td/telegram/UpdatesManager.cpp
View File

@ -710,16 +710,16 @@ void UpdatesManager::on_get_updates(tl_object_ptr<telegram_api::Updates> &&updat
} }
case telegram_api::updatesCombined::ID: { case telegram_api::updatesCombined::ID: {
auto updates = move_tl_object_as<telegram_api::updatesCombined>(updates_ptr); auto updates = move_tl_object_as<telegram_api::updatesCombined>(updates_ptr);
td_->contacts_manager_->on_get_users(std::move(updates->users_)); td_->contacts_manager_->on_get_users(std::move(updates->users_), "updatesCombined");
td_->contacts_manager_->on_get_chats(std::move(updates->chats_)); td_->contacts_manager_->on_get_chats(std::move(updates->chats_), "updatesCombined");
on_pending_updates(std::move(updates->updates_), updates->seq_start_, updates->seq_, updates->date_, on_pending_updates(std::move(updates->updates_), updates->seq_start_, updates->seq_, updates->date_,
"telegram_api::updatesCombined"); "telegram_api::updatesCombined");
break; break;
} }
case telegram_api::updates::ID: { case telegram_api::updates::ID: {
auto updates = move_tl_object_as<telegram_api::updates>(updates_ptr); auto updates = move_tl_object_as<telegram_api::updates>(updates_ptr);
td_->contacts_manager_->on_get_users(std::move(updates->users_)); td_->contacts_manager_->on_get_users(std::move(updates->users_), "updates");
td_->contacts_manager_->on_get_chats(std::move(updates->chats_)); td_->contacts_manager_->on_get_chats(std::move(updates->chats_), "updates");
on_pending_updates(std::move(updates->updates_), updates->seq_, updates->seq_, updates->date_, on_pending_updates(std::move(updates->updates_), updates->seq_, updates->seq_, updates->date_,
"telegram_api::updates"); "telegram_api::updates");
break; break;
@ -1000,8 +1000,8 @@ void UpdatesManager::on_get_difference(tl_object_ptr<telegram_api::updates_Diffe
auto difference = move_tl_object_as<telegram_api::updates_difference>(difference_ptr); auto difference = move_tl_object_as<telegram_api::updates_difference>(difference_ptr);
VLOG(get_difference) << "In get difference receive " << difference->users_.size() << " users and " VLOG(get_difference) << "In get difference receive " << difference->users_.size() << " users and "
<< difference->chats_.size() << " chats"; << difference->chats_.size() << " chats";
td_->contacts_manager_->on_get_users(std::move(difference->users_)); td_->contacts_manager_->on_get_users(std::move(difference->users_), "updates.difference");
td_->contacts_manager_->on_get_chats(std::move(difference->chats_)); td_->contacts_manager_->on_get_chats(std::move(difference->chats_), "updates.difference");
set_state(State::Type::ApplyingDifference); set_state(State::Type::ApplyingDifference);
@ -1025,8 +1025,8 @@ void UpdatesManager::on_get_difference(tl_object_ptr<telegram_api::updates_Diffe
VLOG(get_difference) << "In get difference receive " << difference->users_.size() << " users and " VLOG(get_difference) << "In get difference receive " << difference->users_.size() << " users and "
<< difference->chats_.size() << " chats"; << difference->chats_.size() << " chats";
td_->contacts_manager_->on_get_users(std::move(difference->users_)); td_->contacts_manager_->on_get_users(std::move(difference->users_), "updates.differenceSlice");
td_->contacts_manager_->on_get_chats(std::move(difference->chats_)); td_->contacts_manager_->on_get_chats(std::move(difference->chats_), "updates.differenceSlice");
set_state(State::Type::ApplyingDifferenceSlice); set_state(State::Type::ApplyingDifferenceSlice);

2
td/telegram/WebPagesManager.cpp
View File

@ -2491,7 +2491,7 @@ unique_ptr<WebPagesManager::PageBlock> WebPagesManager::get_page_block(
} }
if (td_->contacts_manager_->have_channel_force(channel_id)) { if (td_->contacts_manager_->have_channel_force(channel_id)) {
td_->contacts_manager_->on_get_chat(std::move(page_block->channel_)); td_->contacts_manager_->on_get_chat(std::move(page_block->channel_), "pageBlockChannel");
LOG(INFO) << "Receive known min " << channel_id; LOG(INFO) << "Receive known min " << channel_id;
return td::make_unique<PageBlockChatLink>(td_->contacts_manager_->get_channel_title(channel_id), return td::make_unique<PageBlockChatLink>(td_->contacts_manager_->get_channel_title(channel_id),
*td_->contacts_manager_->get_channel_dialog_photo(channel_id), *td_->contacts_manager_->get_channel_dialog_photo(channel_id),