Codechange: pass network tokens as std::string_view or with move semantics where appropriate

src/network/network_coordinator.cpp

@@ -45,7 +45,7 @@ public:
 	 * @param token The token as given by the Game Coordinator to track this connection attempt.
 	 * @param tracking_number The tracking number as given by the Game Coordinator to track this connection attempt.
 	 */
-	NetworkDirectConnecter(const std::string &hostname, uint16_t port, const std::string &token, uint8_t tracking_number) : TCPConnecter(hostname, port), token(token), tracking_number(tracking_number) {}
+	NetworkDirectConnecter(std::string_view hostname, uint16_t port, std::string &&token, uint8_t tracking_number) : TCPConnecter(hostname, port), token(std::move(token)), tracking_number(tracking_number) {}
 
 	void OnFailure() override
 	{
@@ -76,7 +76,7 @@ public:
 	 * @param tracking_number The tracking number of the connection.
 	 * @param family The family this connection is using.
 	 */
-	NetworkReuseStunConnecter(const std::string &hostname, uint16_t port, const NetworkAddress &bind_address, std::string token, uint8_t tracking_number, uint8_t family) :
+	NetworkReuseStunConnecter(std::string_view hostname, uint16_t port, const NetworkAddress &bind_address, std::string &&token, uint8_t tracking_number, uint8_t family) :
 		TCPConnecter(hostname, port, bind_address),
 		token(std::move(token)),
 		tracking_number(tracking_number),
@@ -305,7 +305,7 @@ bool ClientNetworkCoordinatorSocketHandler::Receive_GC_DIRECT_CONNECT(Packet &p)
 		this->game_connecter = nullptr;
 	}
 
-	this->game_connecter = TCPConnecter::Create<NetworkDirectConnecter>(hostname, port, token, tracking_number);
+	this->game_connecter = TCPConnecter::Create<NetworkDirectConnecter>(hostname, port, std::move(token), tracking_number);
 	return true;
 }
 
@@ -348,7 +348,7 @@ bool ClientNetworkCoordinatorSocketHandler::Receive_GC_STUN_CONNECT(Packet &p)
 	 * STUN server. This means that if there is any NAT in the local network,
 	 * the public ip:port is still pointing to the local address, and as such
 	 * a connection can be established. */
-	this->game_connecter = TCPConnecter::Create<NetworkReuseStunConnecter>(host, port, family_it->second->local_addr, token, tracking_number, family);
+	this->game_connecter = TCPConnecter::Create<NetworkReuseStunConnecter>(host, port, family_it->second->local_addr, std::move(token), tracking_number, family);
 	return true;
 }
 
@@ -393,7 +393,7 @@ bool ClientNetworkCoordinatorSocketHandler::Receive_GC_TURN_CONNECT(Packet &p)
 				break;
 
 			case URS_ASK:
-				ShowNetworkAskRelay(connecter_it->second.first, connection_string, token);
+				ShowNetworkAskRelay(connecter_it->second.first, std::move(connection_string), std::move(token));
 				break;
 
 			case URS_ALLOW:
@@ -407,7 +407,7 @@ bool ClientNetworkCoordinatorSocketHandler::Receive_GC_TURN_CONNECT(Packet &p)
 	return true;
 }
 
-void ClientNetworkCoordinatorSocketHandler::StartTurnConnection(std::string &token)
+void ClientNetworkCoordinatorSocketHandler::StartTurnConnection(std::string_view token)
 {
 	auto turn_it = this->turn_handlers.find(token);
 	if (turn_it == this->turn_handlers.end()) return;
@@ -511,7 +511,7 @@ void ClientNetworkCoordinatorSocketHandler::GetListing()
  * @param invite_code The invite code of the server to connect to.
  * @param connecter The connecter of the request.
  */
-void ClientNetworkCoordinatorSocketHandler::ConnectToServer(const std::string &invite_code, TCPServerConnecter *connecter)
+void ClientNetworkCoordinatorSocketHandler::ConnectToServer(std::string_view invite_code, TCPServerConnecter *connecter)
 {
 	assert(invite_code.starts_with("+"));
 
@@ -525,7 +525,7 @@ void ClientNetworkCoordinatorSocketHandler::ConnectToServer(const std::string &i
 
 	/* Initially we store based on invite code; on first reply we know the
 	 * token, and will start using that key instead. */
-	this->connecter_pre[invite_code] = connecter;
+	this->connecter_pre[std::string(invite_code)] = connecter;
 
 	this->Connect();
 
@@ -541,7 +541,7 @@ void ClientNetworkCoordinatorSocketHandler::ConnectToServer(const std::string &i
  * @param token Token of the connecter that failed.
  * @param tracking_number Tracking number of the connecter that failed.
  */
-void ClientNetworkCoordinatorSocketHandler::ConnectFailure(const std::string &token, uint8_t tracking_number)
+void ClientNetworkCoordinatorSocketHandler::ConnectFailure(std::string_view token, uint8_t tracking_number)
 {
 	/* Connecter will destroy itself. */
 	this->game_connecter = nullptr;
@@ -563,7 +563,7 @@ void ClientNetworkCoordinatorSocketHandler::ConnectFailure(const std::string &to
  * @param token Token of the connecter that succeeded.
  * @param sock The socket that the connecter can now use.
  */
-void ClientNetworkCoordinatorSocketHandler::ConnectSuccess(const std::string &token, SOCKET sock, NetworkAddress &address)
+void ClientNetworkCoordinatorSocketHandler::ConnectSuccess(std::string_view token, SOCKET sock, NetworkAddress &address)
 {
 	assert(sock != INVALID_SOCKET);
 
@@ -603,7 +603,7 @@ void ClientNetworkCoordinatorSocketHandler::ConnectSuccess(const std::string &to
  * This helps the Game Coordinator not to wait for a timeout on its end, but
  * rather react as soon as the client/server knows the result.
  */
-void ClientNetworkCoordinatorSocketHandler::StunResult(const std::string &token, uint8_t family, bool result)
+void ClientNetworkCoordinatorSocketHandler::StunResult(std::string_view token, uint8_t family, bool result)
 {
 	auto p = std::make_unique<Packet>(this, PACKET_COORDINATOR_SERCLI_STUN_RESULT);
 	p->Send_uint8(NETWORK_COORDINATOR_VERSION);
@@ -618,7 +618,7 @@ void ClientNetworkCoordinatorSocketHandler::StunResult(const std::string &token,
  * @param token The token used for the STUN handlers.
  * @param family The family of STUN handlers to close. AF_UNSPEC to close all STUN handlers for this token.
  */
-void ClientNetworkCoordinatorSocketHandler::CloseStunHandler(const std::string &token, uint8_t family)
+void ClientNetworkCoordinatorSocketHandler::CloseStunHandler(std::string_view token, uint8_t family)
 {
 	auto stun_it = this->stun_handlers.find(token);
 	if (stun_it == this->stun_handlers.end()) return;
@@ -645,7 +645,7 @@ void ClientNetworkCoordinatorSocketHandler::CloseStunHandler(const std::string &
  * Close the TURN handler.
  * @param token The token used for the TURN handler.
  */
-void ClientNetworkCoordinatorSocketHandler::CloseTurnHandler(const std::string &token)
+void ClientNetworkCoordinatorSocketHandler::CloseTurnHandler(std::string_view token)
 {
 	CloseWindowByClass(WC_NETWORK_ASK_RELAY, NRWCD_HANDLED);
 
@@ -664,7 +664,7 @@ void ClientNetworkCoordinatorSocketHandler::CloseTurnHandler(const std::string &
  * Close everything related to this connection token.
  * @param token The connection token to close.
  */
-void ClientNetworkCoordinatorSocketHandler::CloseToken(const std::string &token)
+void ClientNetworkCoordinatorSocketHandler::CloseToken(std::string_view token)
 {
 	/* Close all remaining STUN / TURN connections. */
 	this->CloseStunHandler(token);

src/network/network_coordinator.h

@@ -53,10 +53,10 @@
 class ClientNetworkCoordinatorSocketHandler : public NetworkCoordinatorSocketHandler {
 private:
 	std::chrono::steady_clock::time_point next_update; ///< When to send the next update (if server and public).
-	std::map<std::string, std::pair<std::string, TCPServerConnecter *>> connecter; ///< Based on tokens, the current (invite-code, connecter) that are pending.
-	std::map<std::string, TCPServerConnecter *> connecter_pre; ///< Based on invite codes, the current connecters that are pending.
-	std::map<std::string, std::map<int, std::unique_ptr<ClientNetworkStunSocketHandler>>> stun_handlers; ///< All pending STUN handlers, stored by token:family.
-	std::map<std::string, std::unique_ptr<ClientNetworkTurnSocketHandler>> turn_handlers; ///< Pending TURN handler (if any), stored by token.
+	std::map<std::string, std::pair<std::string, TCPServerConnecter *>, std::less<>> connecter; ///< Based on tokens, the current (invite-code, connecter) that are pending.
+	std::map<std::string, TCPServerConnecter *, std::less<>> connecter_pre; ///< Based on invite codes, the current connecters that are pending.
+	std::map<std::string, std::map<int, std::unique_ptr<ClientNetworkStunSocketHandler>>, std::less<>> stun_handlers; ///< All pending STUN handlers, stored by token:family.
+	std::map<std::string, std::unique_ptr<ClientNetworkTurnSocketHandler>, std::less<>> turn_handlers; ///< Pending TURN handler (if any), stored by token.
 	std::shared_ptr<TCPConnecter> game_connecter{}; ///< Pending connecter to the game server.
 
 	uint32_t newgrf_lookup_table_cursor = 0; ///< Last received cursor for the #GameInfoNewGRFLookupTable updates.
@@ -86,22 +86,22 @@ public:
 	NetworkRecvStatus CloseConnection(bool error = true) override;
 	void SendReceive();
 
-	void ConnectFailure(const std::string &token, uint8_t tracking_number);
-	void ConnectSuccess(const std::string &token, SOCKET sock, NetworkAddress &address);
-	void StunResult(const std::string &token, uint8_t family, bool result);
+	void ConnectFailure(std::string_view token, uint8_t tracking_number);
+	void ConnectSuccess(std::string_view token, SOCKET sock, NetworkAddress &address);
+	void StunResult(std::string_view token, uint8_t family, bool result);
 
 	void Connect();
-	void CloseToken(const std::string &token);
+	void CloseToken(std::string_view token);
 	void CloseAllConnections();
-	void CloseStunHandler(const std::string &token, uint8_t family = AF_UNSPEC);
-	void CloseTurnHandler(const std::string &token);
+	void CloseStunHandler(std::string_view token, uint8_t family = AF_UNSPEC);
+	void CloseTurnHandler(std::string_view token);
 
 	void Register();
 	void SendServerUpdate();
 	void GetListing();
 
-	void ConnectToServer(const std::string &invite_code, TCPServerConnecter *connecter);
-	void StartTurnConnection(std::string &token);
+	void ConnectToServer(std::string_view invite_code, TCPServerConnecter *connecter);
+	void StartTurnConnection(std::string_view token);
 };
 
 extern ClientNetworkCoordinatorSocketHandler _network_coordinator_client;

src/network/network_gui.cpp

@@ -2186,11 +2186,11 @@ struct NetworkAskRelayWindow : public Window {
 	std::string relay_connection_string{}; ///< The relay server we want to connect to.
 	std::string token{}; ///< The token for this connection.
 
-	NetworkAskRelayWindow(WindowDesc &desc, Window *parent, const std::string &server_connection_string, const std::string &relay_connection_string, const std::string &token) :
+	NetworkAskRelayWindow(WindowDesc &desc, Window *parent, std::string_view server_connection_string, std::string &&relay_connection_string, std::string &&token) :
 		Window(desc),
 		server_connection_string(server_connection_string),
-		relay_connection_string(relay_connection_string),
-		token(token)
+		relay_connection_string(std::move(relay_connection_string)),
+		token(std::move(token))
 	{
 		this->parent = parent;
 		this->InitNested(0);
@@ -2276,12 +2276,12 @@ static WindowDesc _network_ask_relay_desc(
  * @param relay_connection_string The relay server we want to connect to.
  * @param token The token for this connection.
  */
-void ShowNetworkAskRelay(const std::string &server_connection_string, const std::string &relay_connection_string, const std::string &token)
+void ShowNetworkAskRelay(std::string_view server_connection_string, std::string &&relay_connection_string, std::string &&token)
 {
 	CloseWindowByClass(WC_NETWORK_ASK_RELAY, NRWCD_HANDLED);
 
 	Window *parent = GetMainWindow();
-	new NetworkAskRelayWindow(_network_ask_relay_desc, parent, server_connection_string, relay_connection_string, token);
+	new NetworkAskRelayWindow(_network_ask_relay_desc, parent, server_connection_string, std::move(relay_connection_string), std::move(token));
 }
 
 /**

src/network/network_gui.h

@@ -22,7 +22,7 @@ void ShowNetworkChatQueryWindow(DestType type, int dest);
 void ShowJoinStatusWindow();
 void ShowNetworkGameWindow();
 void ShowClientList();
-void ShowNetworkAskRelay(const std::string &server_connection_string, const std::string &relay_connection_string, const std::string &token);
+void ShowNetworkAskRelay(std::string_view server_connection_string, std::string &&relay_connection_string, std::string &&token);
 void ShowNetworkAskSurvey();
 void ShowSurveyResultTextfileWindow();
 

src/network/network_stun.cpp

@@ -28,7 +28,7 @@ public:
 	 * @param stun_handler The handler for this request.
 	 * @param connection_string The address of the server.
 	 */
-	NetworkStunConnecter(ClientNetworkStunSocketHandler *stun_handler, std::string_view connection_string, const std::string &token, uint8_t family) :
+	NetworkStunConnecter(ClientNetworkStunSocketHandler *stun_handler, std::string_view connection_string, std::string_view token, uint8_t family) :
 		TCPConnecter(connection_string, NETWORK_STUN_SERVER_PORT, NetworkAddress(), family),
 		stun_handler(stun_handler),
 		token(token),
@@ -70,7 +70,7 @@ public:
  * @param token The token as received from the Game Coordinator.
  * @param family What IP family to use.
  */
-void ClientNetworkStunSocketHandler::Connect(const std::string &token, uint8_t family)
+void ClientNetworkStunSocketHandler::Connect(std::string_view token, uint8_t family)
 {
 	this->token = token;
 	this->family = family;
@@ -86,7 +86,7 @@ void ClientNetworkStunSocketHandler::Connect(const std::string &token, uint8_t f
  * @param family What IP family this STUN request is for.
  * @return The handler for this STUN request.
  */
-std::unique_ptr<ClientNetworkStunSocketHandler> ClientNetworkStunSocketHandler::Stun(const std::string &token, uint8_t family)
+std::unique_ptr<ClientNetworkStunSocketHandler> ClientNetworkStunSocketHandler::Stun(std::string_view token, uint8_t family)
 {
 	auto stun_handler = std::make_unique<ClientNetworkStunSocketHandler>();
 

src/network/network_stun.h

@@ -27,9 +27,9 @@ public:
 	~ClientNetworkStunSocketHandler() override;
 	void SendReceive();
 
-	void Connect(const std::string &token, uint8_t family);
+	void Connect(std::string_view token, uint8_t family);
 
-	static std::unique_ptr<ClientNetworkStunSocketHandler> Stun(const std::string &token, uint8_t family);
+	static std::unique_ptr<ClientNetworkStunSocketHandler> Stun(std::string_view token, uint8_t family);
 };
 
 #endif /* NETWORK_STUN_H */

src/network/network_turn.cpp

@@ -96,7 +96,7 @@ void ClientNetworkTurnSocketHandler::Connect()
  * @param connection_string Connection string of the TURN server.
  * @return The handler for this TURN connection.
  */
-/* static */ std::unique_ptr<ClientNetworkTurnSocketHandler> ClientNetworkTurnSocketHandler::Turn(const std::string &token, uint8_t tracking_number, const std::string &ticket, std::string_view connection_string)
+/* static */ std::unique_ptr<ClientNetworkTurnSocketHandler> ClientNetworkTurnSocketHandler::Turn(std::string_view token, uint8_t tracking_number, std::string_view ticket, std::string_view connection_string)
 {
 	auto turn_handler = std::make_unique<ClientNetworkTurnSocketHandler>(token, tracking_number, connection_string);
 

src/network/network_turn.h

@@ -27,7 +27,7 @@ public:
 	std::shared_ptr<TCPConnecter> connecter{}; ///< Connecter instance.
 	bool connect_started = false;      ///< Whether we started the connection.
 
-	ClientNetworkTurnSocketHandler(const std::string &token, uint8_t tracking_number, std::string_view connection_string) : token(token), tracking_number(tracking_number), connection_string(connection_string) {}
+	ClientNetworkTurnSocketHandler(std::string_view token, uint8_t tracking_number, std::string_view connection_string) : token(token), tracking_number(tracking_number), connection_string(connection_string) {}
 
 	NetworkRecvStatus CloseConnection(bool error = true) override;
 	~ClientNetworkTurnSocketHandler() override;
@@ -36,7 +36,7 @@ public:
 	void Connect();
 	void ConnectFailure();
 
-	static std::unique_ptr<ClientNetworkTurnSocketHandler> Turn(const std::string &token, uint8_t tracking_number, const std::string &ticket, std::string_view connection_string);
+	static std::unique_ptr<ClientNetworkTurnSocketHandler> Turn(std::string_view token, uint8_t tracking_number, std::string_view ticket, std::string_view connection_string);
 };
 
 #endif /* NETWORK_TURN_H */