Improve function names.

5 files changed, 38 insertions, 38 deletions

diff --git a/td/telegram/CallbackQueriesManager.cpp b/td/telegram/CallbackQueriesManager.cpp
index b8df58a9a..9edde67ce 100644
--- a/td/telegram/CallbackQueriesManager.cpp
+++ b/td/telegram/CallbackQueriesManager.cpp
@@ -206,9 +206,9 @@ tl_object_ptr<td_api::CallbackQueryPayload> CallbackQueriesManager::get_query_pa
   return nullptr;
 }
 
-void CallbackQueriesManager::on_new_query(int64 callback_query_id, UserId sender_user_id, DialogId dialog_id,
-                                          MessageId message_id, BufferSlice &&data, int64 chat_instance,
-                                          string &&game_short_name) {
+void CallbackQueriesManager::on_new_callback_query(int64 callback_query_id, UserId sender_user_id, DialogId dialog_id,
+                                                   MessageId message_id, BufferSlice &&data, int64 chat_instance,
+                                                   string &&game_short_name) {
   if (!dialog_id.is_valid()) {
     LOG(ERROR) << "Receive new callback query in invalid " << dialog_id;
     return;
@@ -241,7 +241,7 @@ void CallbackQueriesManager::on_new_query(int64 callback_query_id, UserId sender
                    chat_instance, std::move(payload)));
 }
 
-void CallbackQueriesManager::on_new_ephemeral_query(
+void CallbackQueriesManager::on_new_ephemeral_callback_query(
     int64 callback_query_id, UserId sender_user_id, BufferSlice &&data,
     telegram_api::object_ptr<telegram_api::ephemeralMessage> &&message) {
   if (!sender_user_id.is_valid()) {
@@ -273,7 +273,7 @@ void CallbackQueriesManager::on_new_ephemeral_query(
                    message_id.get(), 0, std::move(payload)));
 }
 
-void CallbackQueriesManager::on_new_inline_query(
+void CallbackQueriesManager::on_new_inline_callback_query(
     int64 callback_query_id, UserId sender_user_id,
     tl_object_ptr<telegram_api::InputBotInlineMessageID> &&inline_message_id, BufferSlice &&data, int64 chat_instance,
     string &&game_short_name) {
@@ -300,11 +300,10 @@ void CallbackQueriesManager::on_new_inline_query(
           std::move(payload)));
 }
 
-void CallbackQueriesManager::on_new_business_query(int64 callback_query_id, UserId sender_user_id,
-                                                   string &&connection_id,
-                                                   telegram_api::object_ptr<telegram_api::Message> &&message,
-                                                   telegram_api::object_ptr<telegram_api::Message> &&reply_to_message,
-                                                   BufferSlice &&data, int64 chat_instance) {
+void CallbackQueriesManager::on_new_business_callback_query(
+    int64 callback_query_id, UserId sender_user_id, string &&connection_id,
+    telegram_api::object_ptr<telegram_api::Message> &&message,
+    telegram_api::object_ptr<telegram_api::Message> &&reply_to_message, BufferSlice &&data, int64 chat_instance) {
   if (!sender_user_id.is_valid()) {
     LOG(ERROR) << "Receive new callback query from invalid " << sender_user_id;
     return;
diff --git a/td/telegram/CallbackQueriesManager.h b/td/telegram/CallbackQueriesManager.h
index 9428cbcfd..6c100b92e 100644
--- a/td/telegram/CallbackQueriesManager.h
+++ b/td/telegram/CallbackQueriesManager.h
@@ -28,20 +28,20 @@ class CallbackQueriesManager {
   void answer_callback_query(int64 callback_query_id, const string &text, bool show_alert, const string &url,
                              int32 cache_time, Promise<Unit> &&promise) const;
 
-  void on_new_query(int64 callback_query_id, UserId sender_user_id, DialogId dialog_id, MessageId message_id,
-                    BufferSlice &&data, int64 chat_instance, string &&game_short_name);
+  void on_new_callback_query(int64 callback_query_id, UserId sender_user_id, DialogId dialog_id, MessageId message_id,
+                             BufferSlice &&data, int64 chat_instance, string &&game_short_name);
 
-  void on_new_ephemeral_query(int64 callback_query_id, UserId sender_user_id, BufferSlice &&data,
-                              telegram_api::object_ptr<telegram_api::ephemeralMessage> &&message);
+  void on_new_ephemeral_callback_query(int64 callback_query_id, UserId sender_user_id, BufferSlice &&data,
+                                       telegram_api::object_ptr<telegram_api::ephemeralMessage> &&message);
 
-  void on_new_inline_query(int64 callback_query_id, UserId sender_user_id,
-                           tl_object_ptr<telegram_api::InputBotInlineMessageID> &&inline_message_id, BufferSlice &&data,
-                           int64 chat_instance, string &&game_short_name);
+  void on_new_inline_callback_query(int64 callback_query_id, UserId sender_user_id,
+                                    tl_object_ptr<telegram_api::InputBotInlineMessageID> &&inline_message_id,
+                                    BufferSlice &&data, int64 chat_instance, string &&game_short_name);
 
-  void on_new_business_query(int64 callback_query_id, UserId sender_user_id, string &&connection_id,
-                             telegram_api::object_ptr<telegram_api::Message> &&message,
-                             telegram_api::object_ptr<telegram_api::Message> &&reply_to_message, BufferSlice &&data,
-                             int64 chat_instance);
+  void on_new_business_callback_query(int64 callback_query_id, UserId sender_user_id, string &&connection_id,
+                                      telegram_api::object_ptr<telegram_api::Message> &&message,
+                                      telegram_api::object_ptr<telegram_api::Message> &&reply_to_message,
+                                      BufferSlice &&data, int64 chat_instance);
 
   void send_callback_query(MessageFullId message_full_id, tl_object_ptr<td_api::CallbackQueryPayload> &&payload,
                            Promise<td_api::object_ptr<td_api::callbackQueryAnswer>> &&promise);
diff --git a/td/telegram/InlineQueriesManager.cpp b/td/telegram/InlineQueriesManager.cpp
index 78662e2f7..61a265344 100644
--- a/td/telegram/InlineQueriesManager.cpp
+++ b/td/telegram/InlineQueriesManager.cpp
@@ -2444,9 +2444,9 @@ bool InlineQueriesManager::load_recently_used_bots(Promise<Unit> &promise) {
   return false;
 }
 
-void InlineQueriesManager::on_new_query(int64 query_id, UserId sender_user_id, Location user_location,
-                                        tl_object_ptr<telegram_api::InlineQueryPeerType> peer_type, const string &query,
-                                        const string &offset) {
+void InlineQueriesManager::on_new_inline_query(int64 query_id, UserId sender_user_id, Location user_location,
+                                               telegram_api::object_ptr<telegram_api::InlineQueryPeerType> peer_type,
+                                               const string &query, const string &offset) {
   if (!sender_user_id.is_valid()) {
     LOG(ERROR) << "Receive new inline query from invalid " << sender_user_id;
     return;
diff --git a/td/telegram/InlineQueriesManager.h b/td/telegram/InlineQueriesManager.h
index f8ca5155c..10fe50f48 100644
--- a/td/telegram/InlineQueriesManager.h
+++ b/td/telegram/InlineQueriesManager.h
@@ -98,9 +98,9 @@ class InlineQueriesManager final : public Actor {
   void on_get_requested_web_view_button(UserId bot_user_id, const string &prepared_button_id,
                                         const RequestedDialogType *requested_dialog_type);
 
-  void on_new_query(int64 query_id, UserId sender_user_id, Location user_location,
-                    tl_object_ptr<telegram_api::InlineQueryPeerType> peer_type, const string &query,
-                    const string &offset);
+  void on_new_inline_query(int64 query_id, UserId sender_user_id, Location user_location,
+                           telegram_api::object_ptr<telegram_api::InlineQueryPeerType> peer_type, const string &query,
+                           const string &offset);
 
   void on_chosen_result(UserId user_id, Location user_location, const string &query, const string &result_id,
                         tl_object_ptr<telegram_api::InputBotInlineMessageID> &&input_bot_inline_message_id);
diff --git a/td/telegram/UpdatesManager.cpp b/td/telegram/UpdatesManager.cpp
index fd84b1db8..4f83dbd26 100644
--- a/td/telegram/UpdatesManager.cpp
+++ b/td/telegram/UpdatesManager.cpp
@@ -4495,8 +4495,9 @@ void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateDcOptions> upda
 }
 
 void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateBotInlineQuery> update, Promise<Unit> &&promise) {
-  td_->inline_queries_manager_->on_new_query(update->query_id_, UserId(update->user_id_), Location(td_, update->geo_),
-                                             std::move(update->peer_type_), update->query_, update->offset_);
+  td_->inline_queries_manager_->on_new_inline_query(update->query_id_, UserId(update->user_id_),
+                                                    Location(td_, update->geo_), std::move(update->peer_type_),
+                                                    update->query_, update->offset_);
   promise.set_value(Unit());
 }
 
@@ -4507,30 +4508,30 @@ void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateBotInlineSend>
 }
 
 void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateBotCallbackQuery> update, Promise<Unit> &&promise) {
-  td_->callback_queries_manager_->on_new_query(update->query_id_, UserId(update->user_id_), DialogId(update->peer_),
-                                               MessageId(ServerMessageId(update->msg_id_)), std::move(update->data_),
-                                               update->chat_instance_, std::move(update->game_short_name_));
+  td_->callback_queries_manager_->on_new_callback_query(
+      update->query_id_, UserId(update->user_id_), DialogId(update->peer_), MessageId(ServerMessageId(update->msg_id_)),
+      std::move(update->data_), update->chat_instance_, std::move(update->game_short_name_));
   promise.set_value(Unit());
 }
 
 void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateEphemeralBotCallbackQuery> update,
                                Promise<Unit> &&promise) {
-  td_->callback_queries_manager_->on_new_ephemeral_query(update->query_id_, UserId(update->user_id_),
-                                                         std::move(update->data_), std::move(update->message_));
+  td_->callback_queries_manager_->on_new_ephemeral_callback_query(
+      update->query_id_, UserId(update->user_id_), std::move(update->data_), std::move(update->message_));
   promise.set_value(Unit());
 }
 
 void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateInlineBotCallbackQuery> update,
                                Promise<Unit> &&promise) {
-  td_->callback_queries_manager_->on_new_inline_query(update->query_id_, UserId(update->user_id_),
-                                                      std::move(update->msg_id_), std::move(update->data_),
-                                                      update->chat_instance_, std::move(update->game_short_name_));
+  td_->callback_queries_manager_->on_new_inline_callback_query(
+      update->query_id_, UserId(update->user_id_), std::move(update->msg_id_), std::move(update->data_),
+      update->chat_instance_, std::move(update->game_short_name_));
   promise.set_value(Unit());
 }
 
 void UpdatesManager::on_update(tl_object_ptr<telegram_api::updateBusinessBotCallbackQuery> update,
                                Promise<Unit> &&promise) {
-  td_->callback_queries_manager_->on_new_business_query(
+  td_->callback_queries_manager_->on_new_business_callback_query(
       update->query_id_, UserId(update->user_id_), std::move(update->connection_id_), std::move(update->message_),
       std::move(update->reply_to_message_), std::move(update->data_), update->chat_instance_);
   promise.set_value(Unit());