websocketserver: Clean up WebSocketSession class implementation

Makes it header-only with inlines, so there's theoretically some very
small performance improvements too.

CMakeLists.txt

@@ -53,7 +53,6 @@ target_sources(
   PRIVATE src/websocketserver/WebSocketServer.cpp
           src/websocketserver/WebSocketServer_Protocol.cpp
           src/websocketserver/WebSocketServer.h
-          src/websocketserver/rpc/WebSocketSession.cpp
           src/websocketserver/rpc/WebSocketSession.h
           src/websocketserver/types/WebSocketCloseCode.h
           src/websocketserver/types/WebSocketOpCode.h)

cmake/legacy.cmake

@@ -67,7 +67,6 @@ target_sources(
           src/websocketserver/WebSocketServer.cpp
           src/websocketserver/WebSocketServer_Protocol.cpp
           src/websocketserver/WebSocketServer.h
-          src/websocketserver/rpc/WebSocketSession.cpp
           src/websocketserver/rpc/WebSocketSession.h
           src/websocketserver/types/WebSocketCloseCode.h
           src/websocketserver/types/WebSocketOpCode.h

src/websocketserver/rpc/WebSocketSession.cpp

@@ -1,153 +0,0 @@
-/*
-obs-websocket
-Copyright (C) 2016-2021 Stephane Lepin <stephane.lepin@gmail.com>
-Copyright (C) 2020-2021 Kyle Manning <tt2468@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program. If not, see <https://www.gnu.org/licenses/>
-*/
-
-#include "WebSocketSession.h"
-#include "../../eventhandler/types/EventSubscription.h"
-
-WebSocketSession::WebSocketSession()
-	: _remoteAddress(""),
-	  _connectedAt(0),
-	  _incomingMessages(0),
-	  _outgoingMessages(0),
-	  _encoding(0),
-	  _challenge(""),
-	  _rpcVersion(OBS_WEBSOCKET_RPC_VERSION),
-	  _isIdentified(false),
-	  _eventSubscriptions(EventSubscription::All)
-{
-}
-
-std::string WebSocketSession::RemoteAddress()
-{
-	std::lock_guard<std::mutex> lock(_remoteAddressMutex);
-	std::string ret(_remoteAddress);
-	return ret;
-}
-
-void WebSocketSession::SetRemoteAddress(std::string address)
-{
-	std::lock_guard<std::mutex> lock(_remoteAddressMutex);
-	_remoteAddress = address;
-}
-
-uint64_t WebSocketSession::ConnectedAt()
-{
-	return _connectedAt.load();
-}
-
-void WebSocketSession::SetConnectedAt(uint64_t at)
-{
-	_connectedAt.store(at);
-}
-
-uint64_t WebSocketSession::IncomingMessages()
-{
-	return _incomingMessages.load();
-}
-
-void WebSocketSession::IncrementIncomingMessages()
-{
-	_incomingMessages++;
-}
-
-uint64_t WebSocketSession::OutgoingMessages()
-{
-	return _outgoingMessages.load();
-}
-
-void WebSocketSession::IncrementOutgoingMessages()
-{
-	_outgoingMessages++;
-}
-
-uint8_t WebSocketSession::Encoding()
-{
-	return _encoding.load();
-}
-
-void WebSocketSession::SetEncoding(uint8_t encoding)
-{
-	_encoding.store(encoding);
-}
-
-bool WebSocketSession::AuthenticationRequired()
-{
-	return _authenticationRequired.load();
-}
-
-void WebSocketSession::SetAuthenticationRequired(bool required)
-{
-	_authenticationRequired.store(required);
-}
-
-std::string WebSocketSession::Secret()
-{
-	std::lock_guard<std::mutex> lock(_secretMutex);
-	std::string ret(_secret);
-	return ret;
-}
-
-void WebSocketSession::SetSecret(std::string secret)
-{
-	std::lock_guard<std::mutex> lock(_secretMutex);
-	_secret = secret;
-}
-
-std::string WebSocketSession::Challenge()
-{
-	std::lock_guard<std::mutex> lock(_challengeMutex);
-	std::string ret(_challenge);
-	return ret;
-}
-
-void WebSocketSession::SetChallenge(std::string challengeString)
-{
-	std::lock_guard<std::mutex> lock(_challengeMutex);
-	_challenge = challengeString;
-}
-
-uint8_t WebSocketSession::RpcVersion()
-{
-	return _rpcVersion.load();
-}
-
-void WebSocketSession::SetRpcVersion(uint8_t version)
-{
-	_rpcVersion.store(version);
-}
-
-bool WebSocketSession::IsIdentified()
-{
-	return _isIdentified.load();
-}
-
-void WebSocketSession::SetIsIdentified(bool identified)
-{
-	_isIdentified.store(identified);
-}
-
-uint64_t WebSocketSession::EventSubscriptions()
-{
-	return _eventSubscriptions.load();
-}
-
-void WebSocketSession::SetEventSubscriptions(uint64_t subscriptions)
-{
-	_eventSubscriptions.store(subscriptions);
-}

src/websocketserver/rpc/WebSocketSession.h

@@ -24,6 +24,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include <atomic>
 #include <memory>
 
+#include "../../eventhandler/types/EventSubscription.h"
 #include "plugin-macros.generated.h"
 
 class WebSocketSession;
@@ -31,56 +32,78 @@ typedef std::shared_ptr<WebSocketSession> SessionPtr;
 
 class WebSocketSession {
 public:
-	WebSocketSession();
+	inline std::string RemoteAddress()
+	{
+		std::lock_guard<std::mutex> lock(_remoteAddressMutex);
+		return _remoteAddress;
+	}
+	inline void SetRemoteAddress(std::string address)
+	{
+		std::lock_guard<std::mutex> lock(_remoteAddressMutex);
+		_remoteAddress = address;
+	}
 
-	std::string RemoteAddress();
+	inline uint64_t ConnectedAt() { return _connectedAt; }
-	void SetRemoteAddress(std::string address);
+	inline void SetConnectedAt(uint64_t at) { _connectedAt = at; }
 
-	uint64_t ConnectedAt();
+	inline uint64_t IncomingMessages() { return _incomingMessages; }
-	void SetConnectedAt(uint64_t at);
+	inline void IncrementIncomingMessages() { _incomingMessages++; }
 
-	uint64_t IncomingMessages();
+	inline uint64_t OutgoingMessages() { return _outgoingMessages; }
-	void IncrementIncomingMessages();
+	inline void IncrementOutgoingMessages() { _outgoingMessages++; }
 
-	uint64_t OutgoingMessages();
+	inline uint8_t Encoding() { return _encoding; }
-	void IncrementOutgoingMessages();
+	inline void SetEncoding(uint8_t encoding) { _encoding = encoding; }
 
-	uint8_t Encoding();
+	inline bool AuthenticationRequired() { return _authenticationRequired; }
-	void SetEncoding(uint8_t encoding);
+	inline void SetAuthenticationRequired(bool required) { _authenticationRequired = required; }
 
-	bool AuthenticationRequired();
+	inline std::string Secret()
-	void SetAuthenticationRequired(bool required);
+	{
+		std::lock_guard<std::mutex> lock(_secretMutex);
+		return _secret;
+	}
+	inline void SetSecret(std::string secret)
+	{
+		std::lock_guard<std::mutex> lock(_secretMutex);
+		_secret = secret;
+	}
 
-	std::string Secret();
+	inline std::string Challenge()
-	void SetSecret(std::string secret);
+	{
+		std::lock_guard<std::mutex> lock(_challengeMutex);
+		return _challenge;
+	}
+	inline void SetChallenge(std::string challenge)
+	{
+		std::lock_guard<std::mutex> lock(_challengeMutex);
+		_challenge = challenge;
+	}
 
-	std::string Challenge();
+	inline uint8_t RpcVersion() { return _rpcVersion; }
-	void SetChallenge(std::string challenge);
+	inline void SetRpcVersion(uint8_t version) { _rpcVersion = version; }
 
-	uint8_t RpcVersion();
+	inline bool IsIdentified() { return _isIdentified; }
-	void SetRpcVersion(uint8_t version);
+	inline void SetIsIdentified(bool identified) { _isIdentified = identified; }
 
-	bool IsIdentified();
+	inline uint64_t EventSubscriptions() { return _eventSubscriptions; }
-	void SetIsIdentified(bool identified);
+	inline void SetEventSubscriptions(uint64_t subscriptions) { _eventSubscriptions = subscriptions; }
-
-	uint64_t EventSubscriptions();
-	void SetEventSubscriptions(uint64_t subscriptions);
 
 	std::mutex OperationMutex;
 
 private:
 	std::mutex _remoteAddressMutex;
 	std::string _remoteAddress;
-	std::atomic<uint64_t> _connectedAt;
+	std::atomic<uint64_t> _connectedAt = 0;
-	std::atomic<uint64_t> _incomingMessages;
+	std::atomic<uint64_t> _incomingMessages = 0;
-	std::atomic<uint64_t> _outgoingMessages;
+	std::atomic<uint64_t> _outgoingMessages = 0;
-	std::atomic<uint8_t> _encoding;
+	std::atomic<uint8_t> _encoding = 0;
-	std::atomic<bool> _authenticationRequired;
+	std::atomic<bool> _authenticationRequired = false;
 	std::mutex _secretMutex;
 	std::string _secret;
 	std::mutex _challengeMutex;
 	std::string _challenge;
-	std::atomic<uint8_t> _rpcVersion;
+	std::atomic<uint8_t> _rpcVersion = OBS_WEBSOCKET_RPC_VERSION;
-	std::atomic<bool> _isIdentified;
+	std::atomic<bool> _isIdentified = false;
-	std::atomic<uint64_t> _eventSubscriptions;
+	std::atomic<uint64_t> _eventSubscriptions = EventSubscription::All;
 };