diff options
243 files changed, 1054 insertions, 1421 deletions
diff --git a/cast/common/channel/cast_socket.cc b/cast/common/channel/cast_socket.cc index 0e4a536e..214b50a8 100644 --- a/cast/common/channel/cast_socket.cc +++ b/cast/common/channel/cast_socket.cc @@ -13,8 +13,9 @@ namespace cast { namespace channel { using message_serialization::DeserializeResult; +using openscreen::Error; using openscreen::ErrorOr; -using openscreen::platform::TlsConnection; +using openscreen::TlsConnection; uint32_t GetNextSocketId() { static std::atomic<uint32_t> id(1); diff --git a/cast/common/channel/cast_socket.h b/cast/common/channel/cast_socket.h index bf775543..1e5dc699 100644 --- a/cast/common/channel/cast_socket.h +++ b/cast/common/channel/cast_socket.h @@ -14,9 +14,6 @@ namespace cast { namespace channel { -using openscreen::Error; -using TlsConnection = openscreen::platform::TlsConnection; - class CastMessage; uint32_t GetNextSocketId(); @@ -24,19 +21,19 @@ uint32_t GetNextSocketId(); // Represents a simple message-oriented socket for communicating with the Cast // V2 protocol. It isn't thread-safe, so it should only be used on the same // TaskRunner thread as its TlsConnection. -class CastSocket : public TlsConnection::Client { +class CastSocket : public openscreen::TlsConnection::Client { public: class Client { public: virtual ~Client() = default; // Called when a terminal error on |socket| has occurred. - virtual void OnError(CastSocket* socket, Error error) = 0; + virtual void OnError(CastSocket* socket, openscreen::Error error) = 0; virtual void OnMessage(CastSocket* socket, CastMessage message) = 0; }; - CastSocket(std::unique_ptr<TlsConnection> connection, + CastSocket(std::unique_ptr<openscreen::TlsConnection> connection, Client* client, uint32_t socket_id); ~CastSocket(); @@ -45,7 +42,7 @@ class CastSocket : public TlsConnection::Client { // write-blocked, in which case |message| will be queued. An error will be // returned if |message| cannot be serialized for any reason, even while // write-blocked. - Error SendMessage(const CastMessage& message); + openscreen::Error SendMessage(const CastMessage& message); void SetClient(Client* client); @@ -53,11 +50,13 @@ class CastSocket : public TlsConnection::Client { uint32_t socket_id() const { return socket_id_; } - // TlsConnection::Client overrides. - void OnWriteBlocked(TlsConnection* connection) override; - void OnWriteUnblocked(TlsConnection* connection) override; - void OnError(TlsConnection* connection, Error error) override; - void OnRead(TlsConnection* connection, std::vector<uint8_t> block) override; + // openscreen::TlsConnection::Client overrides. + void OnWriteBlocked(openscreen::TlsConnection* connection) override; + void OnWriteUnblocked(openscreen::TlsConnection* connection) override; + void OnError(openscreen::TlsConnection* connection, + openscreen::Error error) override; + void OnRead(openscreen::TlsConnection* connection, + std::vector<uint8_t> block) override; private: enum class State { @@ -67,7 +66,7 @@ class CastSocket : public TlsConnection::Client { }; Client* client_; // May never be null. - const std::unique_ptr<TlsConnection> connection_; + const std::unique_ptr<openscreen::TlsConnection> connection_; std::vector<uint8_t> read_buffer_; const uint32_t socket_id_; State state_ = State::kOpen; diff --git a/cast/common/channel/cast_socket_unittest.cc b/cast/common/channel/cast_socket_unittest.cc index 781fa384..e9df607e 100644 --- a/cast/common/channel/cast_socket_unittest.cc +++ b/cast/common/channel/cast_socket_unittest.cc @@ -35,7 +35,9 @@ class CastSocketTest : public ::testing::Test { } protected: - MockTlsConnection& connection() { return *fake_socket_.connection; } + openscreen::MockTlsConnection& connection() { + return *fake_socket_.connection; + } MockCastSocketClient& mock_client() { return fake_socket_.mock_client; } CastSocket& socket() { return fake_socket_.socket; } @@ -129,7 +131,7 @@ TEST_F(CastSocketTest, ErrorWhileEmptyingQueue) { frame_serial_, std::vector<uint8_t>(reinterpret_cast<const uint8_t*>(data), reinterpret_cast<const uint8_t*>(data) + len)); - connection().OnError(Error::Code::kUnknownError); + connection().OnError(openscreen::Error::Code::kUnknownError); })); connection().OnWriteUnblocked(); @@ -142,10 +144,11 @@ TEST_F(CastSocketTest, SanitizedAddress) { EXPECT_EQ(result1[0], 1u); EXPECT_EQ(result1[1], 9u); - FakeCastSocket v6_socket(IPEndpoint{{1, 2, 3, 4}, 1025}, - IPEndpoint{{0x1819, 0x1a1b, 0x1c1d, 0x1e1f, 0x207b, - 0x7c7d, 0x7e7f, 0x8081}, - 4321}); + FakeCastSocket v6_socket( + openscreen::IPEndpoint{{1, 2, 3, 4}, 1025}, + openscreen::IPEndpoint{ + {0x1819, 0x1a1b, 0x1c1d, 0x1e1f, 0x207b, 0x7c7d, 0x7e7f, 0x8081}, + 4321}); std::array<uint8_t, 2> result2 = v6_socket.socket.GetSanitizedIpAddress(); EXPECT_EQ(result2[0], 128); EXPECT_EQ(result2[1], 129); diff --git a/cast/common/channel/connection_namespace_handler_unittest.cc b/cast/common/channel/connection_namespace_handler_unittest.cc index 5686fb74..17936818 100644 --- a/cast/common/channel/connection_namespace_handler_unittest.cc +++ b/cast/common/channel/connection_namespace_handler_unittest.cc @@ -30,7 +30,10 @@ class MockSocketErrorHandler : public VirtualConnectionRouter::SocketErrorHandler { public: MOCK_METHOD(void, OnClose, (CastSocket * socket), (override)); - MOCK_METHOD(void, OnError, (CastSocket * socket, Error error), (override)); + MOCK_METHOD(void, + OnError, + (CastSocket * socket, openscreen::Error error), + (override)); }; class MockVirtualConnectionPolicy diff --git a/cast/common/channel/test/fake_cast_socket.h b/cast/common/channel/test/fake_cast_socket.h index 5efcab0e..105bfe70 100644 --- a/cast/common/channel/test/fake_cast_socket.h +++ b/cast/common/channel/test/fake_cast_socket.h @@ -14,19 +14,14 @@ namespace cast { namespace channel { -using ::testing::_; -using ::testing::Invoke; -using ::testing::NiceMock; - -using openscreen::IPEndpoint; -using openscreen::platform::MockTlsConnection; -using openscreen::platform::TlsConnection; - class MockCastSocketClient final : public CastSocket::Client { public: ~MockCastSocketClient() override = default; - MOCK_METHOD(void, OnError, (CastSocket * socket, Error error), (override)); + MOCK_METHOD(void, + OnError, + (CastSocket * socket, openscreen::Error error), + (override)); MOCK_METHOD(void, OnMessage, (CastSocket * socket, CastMessage message), @@ -36,17 +31,19 @@ class MockCastSocketClient final : public CastSocket::Client { struct FakeCastSocket { FakeCastSocket() : FakeCastSocket({{10, 0, 1, 7}, 1234}, {{10, 0, 1, 9}, 4321}) {} - FakeCastSocket(const IPEndpoint& local, const IPEndpoint& remote) + FakeCastSocket(const openscreen::IPEndpoint& local, + const openscreen::IPEndpoint& remote) : local(local), remote(remote), - moved_connection(new MockTlsConnection(local, remote)), + moved_connection( + std::make_unique<openscreen::MockTlsConnection>(local, remote)), connection(moved_connection.get()), socket(std::move(moved_connection), &mock_client, 1) {} - IPEndpoint local; - IPEndpoint remote; - std::unique_ptr<MockTlsConnection> moved_connection; - MockTlsConnection* connection; + openscreen::IPEndpoint local; + openscreen::IPEndpoint remote; + std::unique_ptr<openscreen::MockTlsConnection> moved_connection; + openscreen::MockTlsConnection* connection; MockCastSocketClient mock_client; CastSocket socket; }; @@ -57,16 +54,22 @@ struct FakeCastSocket { // |mock_client|. struct FakeCastSocketPair { FakeCastSocketPair() { - std::unique_ptr<NiceMock<MockTlsConnection>> moved_connection{ - new NiceMock<MockTlsConnection>(local, remote)}; + using ::testing::_; + using ::testing::Invoke; + + auto moved_connection = + std::make_unique<::testing::NiceMock<openscreen::MockTlsConnection>>( + local, remote); connection = moved_connection.get(); - socket.reset(new CastSocket(std::move(moved_connection), &mock_client, 1)); + socket = std::make_unique<CastSocket>(std::move(moved_connection), + &mock_client, 1); - std::unique_ptr<NiceMock<MockTlsConnection>> moved_peer{ - new NiceMock<MockTlsConnection>(remote, local)}; + auto moved_peer = + std::make_unique<::testing::NiceMock<openscreen::MockTlsConnection>>( + remote, local); peer_connection = moved_peer.get(); - peer_socket.reset( - new CastSocket(std::move(moved_peer), &mock_peer_client, 2)); + peer_socket = std::make_unique<CastSocket>(std::move(moved_peer), + &mock_peer_client, 2); ON_CALL(*connection, Write(_, _)) .WillByDefault(Invoke([this](const void* data, size_t len) { @@ -83,14 +86,14 @@ struct FakeCastSocketPair { } ~FakeCastSocketPair() = default; - IPEndpoint local{{10, 0, 1, 7}, 1234}; - IPEndpoint remote{{10, 0, 1, 9}, 4321}; + openscreen::IPEndpoint local{{10, 0, 1, 7}, 1234}; + openscreen::IPEndpoint remote{{10, 0, 1, 9}, 4321}; - NiceMock<MockTlsConnection>* connection; + ::testing::NiceMock<openscreen::MockTlsConnection>* connection; MockCastSocketClient mock_client; std::unique_ptr<CastSocket> socket; - NiceMock<MockTlsConnection>* peer_connection; + ::testing::NiceMock<openscreen::MockTlsConnection>* peer_connection; MockCastSocketClient mock_peer_client; std::unique_ptr<CastSocket> peer_socket; }; diff --git a/cast/common/channel/virtual_connection_router.cc b/cast/common/channel/virtual_connection_router.cc index e141e993..85df78d9 100644 --- a/cast/common/channel/virtual_connection_router.cc +++ b/cast/common/channel/virtual_connection_router.cc @@ -14,6 +14,8 @@ namespace cast { namespace channel { +using openscreen::Error; + VirtualConnectionRouter::VirtualConnectionRouter( VirtualConnectionManager* vc_manager) : vc_manager_(vc_manager) { diff --git a/cast/common/channel/virtual_connection_router.h b/cast/common/channel/virtual_connection_router.h index 58879f0a..745995cc 100644 --- a/cast/common/channel/virtual_connection_router.h +++ b/cast/common/channel/virtual_connection_router.h @@ -43,7 +43,7 @@ class VirtualConnectionRouter final : public CastSocket::Client { class SocketErrorHandler { public: virtual void OnClose(CastSocket* socket) = 0; - virtual void OnError(CastSocket* socket, Error error) = 0; + virtual void OnError(CastSocket* socket, openscreen::Error error) = 0; }; explicit VirtualConnectionRouter(VirtualConnectionManager* vc_manager); @@ -58,10 +58,11 @@ class VirtualConnectionRouter final : public CastSocket::Client { std::unique_ptr<CastSocket> socket); void CloseSocket(uint32_t id); - Error SendMessage(VirtualConnection virtual_conn, CastMessage&& message); + openscreen::Error SendMessage(VirtualConnection virtual_conn, + CastMessage&& message); // CastSocket::Client overrides. - void OnError(CastSocket* socket, Error error) override; + void OnError(CastSocket* socket, openscreen::Error error) override; void OnMessage(CastSocket* socket, CastMessage message) override; private: diff --git a/cast/common/channel/virtual_connection_router_unittest.cc b/cast/common/channel/virtual_connection_router_unittest.cc index 12d82f90..3c68db8b 100644 --- a/cast/common/channel/virtual_connection_router_unittest.cc +++ b/cast/common/channel/virtual_connection_router_unittest.cc @@ -23,7 +23,10 @@ class MockSocketErrorHandler : public VirtualConnectionRouter::SocketErrorHandler { public: MOCK_METHOD(void, OnClose, (CastSocket * socket), (override)); - MOCK_METHOD(void, OnError, (CastSocket * socket, Error error), (override)); + MOCK_METHOD(void, + OnError, + (CastSocket * socket, openscreen::Error error), + (override)); }; class VirtualConnectionRouterTest : public ::testing::Test { diff --git a/cast/sender/channel/cast_auth_util.cc b/cast/sender/channel/cast_auth_util.cc index 9f706259..90d63f77 100644 --- a/cast/sender/channel/cast_auth_util.cc +++ b/cast/sender/channel/cast_auth_util.cc @@ -84,11 +84,11 @@ class CastNonce { OSP_CHECK_EQ( RAND_bytes(reinterpret_cast<uint8_t*>(&nonce_[0]), kNonceSizeInBytes), 1); - nonce_generation_time_ = openscreen::platform::GetWallTimeSinceUnixEpoch(); + nonce_generation_time_ = openscreen::GetWallTimeSinceUnixEpoch(); } void EnsureNonceTimely() { - if (openscreen::platform::GetWallTimeSinceUnixEpoch() > + if (openscreen::GetWallTimeSinceUnixEpoch() > (nonce_generation_time_ + std::chrono::hours(kNonceExpirationTimeInHours))) { GenerateNonce(); @@ -233,7 +233,7 @@ ErrorOr<CastDeviceCertPolicy> AuthenticateChallengeReply( } result = VerifyTLSCertificateValidity( - peer_cert, openscreen::platform::GetWallTimeSinceUnixEpoch()); + peer_cert, openscreen::GetWallTimeSinceUnixEpoch()); if (!result.ok()) { return result; } @@ -354,7 +354,7 @@ ErrorOr<CastDeviceCertPolicy> VerifyCredentials( bool enforce_sha256_checking) { certificate::DateTime now = {}; OSP_CHECK(certificate::DateTimeFromSeconds( - openscreen::platform::GetWallTimeSinceUnixEpoch().count(), &now)); + openscreen::GetWallTimeSinceUnixEpoch().count(), &now)); certificate::CRLPolicy policy = (enforce_revocation_checking) ? certificate::CRLPolicy::kCrlRequired : certificate::CRLPolicy::kCrlOptional; diff --git a/cast/sender/channel/cast_auth_util_unittest.cc b/cast/sender/channel/cast_auth_util_unittest.cc index 6ea4ea6a..b8a8e90c 100644 --- a/cast/sender/channel/cast_auth_util_unittest.cc +++ b/cast/sender/channel/cast_auth_util_unittest.cc @@ -157,7 +157,7 @@ TEST_F(CastAuthUtilTest, VerifySuccess) { AuthResponse auth_response = CreateAuthResponse(&signed_data, SHA256); certificate::DateTime now = {}; ASSERT_TRUE(certificate::DateTimeFromSeconds( - openscreen::platform::GetWallTimeSinceUnixEpoch().count(), &now)); + openscreen::GetWallTimeSinceUnixEpoch().count(), &now)); ErrorOr<CastDeviceCertPolicy> result = VerifyCredentialsForTest( auth_response, signed_data, certificate::CRLPolicy::kCrlOptional, nullptr, nullptr, now); @@ -210,7 +210,7 @@ TEST_F(CastAuthUtilTest, VerifyUnsupportedDigest) { AuthResponse auth_response = CreateAuthResponse(&signed_data, SHA1); certificate::DateTime now = {}; ASSERT_TRUE(certificate::DateTimeFromSeconds( - openscreen::platform::GetWallTimeSinceUnixEpoch().count(), &now)); + openscreen::GetWallTimeSinceUnixEpoch().count(), &now)); ErrorOr<CastDeviceCertPolicy> result = VerifyCredentialsForTest( auth_response, signed_data, certificate::CRLPolicy::kCrlOptional, nullptr, nullptr, now, true); @@ -223,7 +223,7 @@ TEST_F(CastAuthUtilTest, VerifyBackwardsCompatibleDigest) { AuthResponse auth_response = CreateAuthResponse(&signed_data, SHA1); certificate::DateTime now = {}; ASSERT_TRUE(certificate::DateTimeFromSeconds( - openscreen::platform::GetWallTimeSinceUnixEpoch().count(), &now)); + openscreen::GetWallTimeSinceUnixEpoch().count(), &now)); ErrorOr<CastDeviceCertPolicy> result = VerifyCredentialsForTest( auth_response, signed_data, certificate::CRLPolicy::kCrlOptional, nullptr, nullptr, now); diff --git a/cast/sender/channel/sender_socket_factory.cc b/cast/sender/channel/sender_socket_factory.cc index 3e75c977..b185113d 100644 --- a/cast/sender/channel/sender_socket_factory.cc +++ b/cast/sender/channel/sender_socket_factory.cc @@ -12,7 +12,11 @@ namespace cast { namespace channel { -using openscreen::platform::TlsConnectOptions; +using openscreen::Error; +using openscreen::IPEndpoint; +using openscreen::TlsConnection; +using openscreen::TlsConnectionFactory; +using openscreen::TlsConnectOptions; bool operator<(const std::unique_ptr<SenderSocketFactory::PendingAuth>& a, uint32_t b) { diff --git a/cast/sender/channel/sender_socket_factory.h b/cast/sender/channel/sender_socket_factory.h index 63998674..c58b369a 100644 --- a/cast/sender/channel/sender_socket_factory.h +++ b/cast/sender/channel/sender_socket_factory.h @@ -20,23 +20,18 @@ namespace cast { namespace channel { -using openscreen::Error; -using openscreen::IPEndpoint; -using openscreen::IPEndpointComparator; -using openscreen::platform::TlsConnection; -using openscreen::platform::TlsConnectionFactory; - -class SenderSocketFactory final : public TlsConnectionFactory::Client, - public CastSocket::Client { +class SenderSocketFactory final + : public openscreen::TlsConnectionFactory::Client, + public CastSocket::Client { public: class Client { public: virtual void OnConnected(SenderSocketFactory* factory, - const IPEndpoint& endpoint, + const openscreen::IPEndpoint& endpoint, std::unique_ptr<CastSocket> socket) = 0; virtual void OnError(SenderSocketFactory* factory, - const IPEndpoint& endpoint, - Error error) = 0; + const openscreen::IPEndpoint& endpoint, + openscreen::Error error) = 0; }; enum class DeviceMediaPolicy { @@ -48,35 +43,39 @@ class SenderSocketFactory final : public TlsConnectionFactory::Client, explicit SenderSocketFactory(Client* client); ~SenderSocketFactory(); - void set_factory(TlsConnectionFactory* factory) { + void set_factory(openscreen::TlsConnectionFactory* factory) { OSP_DCHECK(factory); factory_ = factory; } - void Connect(const IPEndpoint& endpoint, + void Connect(const openscreen::IPEndpoint& endpoint, DeviceMediaPolicy media_policy, CastSocket::Client* client); - // TlsConnectionFactory::Client overrides. - void OnAccepted(TlsConnectionFactory* factory, - std::vector<uint8_t> der_x509_peer_cert, - std::unique_ptr<TlsConnection> connection) override; - void OnConnected(TlsConnectionFactory* factory, - std::vector<uint8_t> der_x509_peer_cert, - std::unique_ptr<TlsConnection> connection) override; - void OnConnectionFailed(TlsConnectionFactory* factory, - const IPEndpoint& remote_address) override; - void OnError(TlsConnectionFactory* factory, Error error) override; + // openscreen::TlsConnectionFactory::Client overrides. + void OnAccepted( + openscreen::TlsConnectionFactory* factory, + std::vector<uint8_t> der_x509_peer_cert, + std::unique_ptr<openscreen::TlsConnection> connection) override; + void OnConnected( + openscreen::TlsConnectionFactory* factory, + std::vector<uint8_t> der_x509_peer_cert, + std::unique_ptr<openscreen::TlsConnection> connection) override; + void OnConnectionFailed( + openscreen::TlsConnectionFactory* factory, + const openscreen::IPEndpoint& remote_address) override; + void OnError(openscreen::TlsConnectionFactory* factory, + openscreen::Error error) override; private: struct PendingConnection { - IPEndpoint endpoint; + openscreen::IPEndpoint endpoint; DeviceMediaPolicy media_policy; CastSocket::Client* client; }; struct PendingAuth { - IPEndpoint endpoint; + openscreen::IPEndpoint endpoint; DeviceMediaPolicy media_policy; std::unique_ptr<CastSocket> socket; CastSocket::Client* client; @@ -88,14 +87,14 @@ class SenderSocketFactory final : public TlsConnectionFactory::Client, friend bool operator<(uint32_t a, const std::unique_ptr<PendingAuth>& b); std::vector<PendingConnection>::iterator FindPendingConnection( - const IPEndpoint& endpoint); + const openscreen::IPEndpoint& endpoint); // CastSocket::Client overrides. - void OnError(CastSocket* socket, Error error) override; + void OnError(CastSocket* socket, openscreen::Error error) override; void OnMessage(CastSocket* socket, CastMessage message) override; Client* const client_; - TlsConnectionFactory* factory_ = nullptr; + openscreen::TlsConnectionFactory* factory_ = nullptr; std::vector<PendingConnection> pending_connections_; std::vector<std::unique_ptr<PendingAuth>> pending_auth_; }; diff --git a/cast/standalone_receiver/main.cc b/cast/standalone_receiver/main.cc index 76e7a8d2..fd4676ea 100644 --- a/cast/standalone_receiver/main.cc +++ b/cast/standalone_receiver/main.cc @@ -27,10 +27,10 @@ #include "cast/standalone_receiver/dummy_player.h" #endif // defined(CAST_STREAMING_HAVE_EXTERNAL_LIBS_FOR_DEMO_APPS) +using openscreen::Clock; using openscreen::IPEndpoint; -using openscreen::platform::Clock; -using openscreen::platform::TaskRunner; -using openscreen::platform::TaskRunnerImpl; +using openscreen::TaskRunner; +using openscreen::TaskRunnerImpl; namespace cast { namespace streaming { @@ -157,9 +157,8 @@ void DemoMain(TaskRunnerImpl* task_runner) { } // namespace cast int main(int argc, const char* argv[]) { - using openscreen::platform::PlatformClientPosix; - - class PlatformClientExposingTaskRunner : public PlatformClientPosix { + class PlatformClientExposingTaskRunner + : public openscreen::PlatformClientPosix { public: explicit PlatformClientExposingTaskRunner( std::unique_ptr<TaskRunner> task_runner) @@ -170,12 +169,12 @@ int main(int argc, const char* argv[]) { } }; - openscreen::platform::SetLogLevel(openscreen::platform::LogLevel::kInfo); + openscreen::SetLogLevel(openscreen::LogLevel::kInfo); auto* const platform_client = new PlatformClientExposingTaskRunner( std::make_unique<TaskRunnerImpl>(&Clock::now)); cast::streaming::DemoMain(static_cast<TaskRunnerImpl*>( - PlatformClientPosix::GetInstance()->GetTaskRunner())); + openscreen::PlatformClientPosix::GetInstance()->GetTaskRunner())); platform_client->ShutDown(); // Deletes |platform_client|. return 0; diff --git a/cast/standalone_receiver/sdl_audio_player.cc b/cast/standalone_receiver/sdl_audio_player.cc index 8a58870e..cbd99859 100644 --- a/cast/standalone_receiver/sdl_audio_player.cc +++ b/cast/standalone_receiver/sdl_audio_player.cc @@ -16,11 +16,11 @@ using std::chrono::duration_cast; using std::chrono::milliseconds; using std::chrono::seconds; +using openscreen::Clock; +using openscreen::ClockNowFunctionPtr; using openscreen::Error; using openscreen::ErrorOr; -using openscreen::platform::Clock; -using openscreen::platform::ClockNowFunctionPtr; -using openscreen::platform::TaskRunner; +using openscreen::TaskRunner; namespace cast { namespace streaming { diff --git a/cast/standalone_receiver/sdl_audio_player.h b/cast/standalone_receiver/sdl_audio_player.h index d7a4b0ea..89c37146 100644 --- a/cast/standalone_receiver/sdl_audio_player.h +++ b/cast/standalone_receiver/sdl_audio_player.h @@ -16,8 +16,8 @@ class SDLAudioPlayer : public SDLPlayerBase { public: // |error_callback| is run only if a fatal error occurs, at which point the // player has halted and set |error_status()|. - SDLAudioPlayer(openscreen::platform::ClockNowFunctionPtr now_function, - openscreen::platform::TaskRunner* task_runner, + SDLAudioPlayer(openscreen::ClockNowFunctionPtr now_function, + openscreen::TaskRunner* task_runner, Receiver* receiver, std::function<void()> error_callback); @@ -25,7 +25,7 @@ class SDLAudioPlayer : public SDLPlayerBase { private: // SDLPlayerBase implementation. - openscreen::ErrorOr<openscreen::platform::Clock::time_point> RenderNextFrame( + openscreen::ErrorOr<openscreen::Clock::time_point> RenderNextFrame( const SDLPlayerBase::PresentableFrame& frame) final; bool RenderWhileIdle(const SDLPlayerBase::PresentableFrame* frame) final; void Present() final; @@ -38,7 +38,7 @@ class SDLAudioPlayer : public SDLPlayerBase { // The amount of time before a target presentation time to call Present(), to // account for audio buffering (the latency until samples reach the hardware). - openscreen::platform::Clock::duration approximate_lead_time_{}; + openscreen::Clock::duration approximate_lead_time_{}; // When the decoder provides planar data, this buffer is used for storing the // interleaved conversion. diff --git a/cast/standalone_receiver/sdl_glue.cc b/cast/standalone_receiver/sdl_glue.cc index 4d12b057..300b2492 100644 --- a/cast/standalone_receiver/sdl_glue.cc +++ b/cast/standalone_receiver/sdl_glue.cc @@ -8,8 +8,8 @@ #include "platform/api/time.h" #include "util/logging.h" -using openscreen::platform::Clock; -using openscreen::platform::TaskRunner; +using openscreen::Clock; +using openscreen::TaskRunner; namespace cast { namespace streaming { diff --git a/cast/standalone_receiver/sdl_glue.h b/cast/standalone_receiver/sdl_glue.h index 2900bf57..c4674211 100644 --- a/cast/standalone_receiver/sdl_glue.h +++ b/cast/standalone_receiver/sdl_glue.h @@ -18,9 +18,7 @@ #include "util/alarm.h" namespace openscreen { -namespace platform { class TaskRunner; -} // namespace platform } // namespace openscreen namespace cast { @@ -65,7 +63,7 @@ DEFINE_SDL_UNIQUE_PTR(Texture); // event is received. class SDLEventLoopProcessor { public: - SDLEventLoopProcessor(openscreen::platform::TaskRunner* task_runner, + SDLEventLoopProcessor(openscreen::TaskRunner* task_runner, std::function<void()> quit_callback); ~SDLEventLoopProcessor(); diff --git a/cast/standalone_receiver/sdl_player_base.cc b/cast/standalone_receiver/sdl_player_base.cc index 0c5e6c9c..72c9af55 100644 --- a/cast/standalone_receiver/sdl_player_base.cc +++ b/cast/standalone_receiver/sdl_player_base.cc @@ -16,11 +16,11 @@ using std::chrono::duration_cast; using std::chrono::milliseconds; +using openscreen::Clock; +using openscreen::ClockNowFunctionPtr; using openscreen::Error; using openscreen::ErrorOr; -using openscreen::platform::Clock; -using openscreen::platform::ClockNowFunctionPtr; -using openscreen::platform::TaskRunner; +using openscreen::TaskRunner; namespace cast { namespace streaming { diff --git a/cast/standalone_receiver/sdl_player_base.h b/cast/standalone_receiver/sdl_player_base.h index 34fb278e..365846db 100644 --- a/cast/standalone_receiver/sdl_player_base.h +++ b/cast/standalone_receiver/sdl_player_base.h @@ -43,7 +43,7 @@ class SDLPlayerBase : public Receiver::Consumer, public Decoder::Client { // A decoded frame and its target presentation time. struct PresentableFrame { - openscreen::platform::Clock::time_point presentation_time; + openscreen::Clock::time_point presentation_time; AVFrameUniquePtr decoded_frame; PresentableFrame(); @@ -55,8 +55,8 @@ class SDLPlayerBase : public Receiver::Consumer, public Decoder::Client { // |error_callback| is run only if a fatal error occurs, at which point the // player has halted and set |error_status()|. |media_type| should be "audio" // or "video" (only used when logging). - SDLPlayerBase(openscreen::platform::ClockNowFunctionPtr now_function, - openscreen::platform::TaskRunner* task_runner, + SDLPlayerBase(openscreen::ClockNowFunctionPtr now_function, + openscreen::TaskRunner* task_runner, Receiver* receiver, std::function<void()> error_callback, const char* media_type); @@ -68,8 +68,8 @@ class SDLPlayerBase : public Receiver::Consumer, public Decoder::Client { void OnFatalError(std::string message) final; // Renders the |frame| and returns its [possibly adjusted] presentation time. - virtual openscreen::ErrorOr<openscreen::platform::Clock::time_point> - RenderNextFrame(const PresentableFrame& frame) = 0; + virtual openscreen::ErrorOr<openscreen::Clock::time_point> RenderNextFrame( + const PresentableFrame& frame) = 0; // Called to render when the player has no new content, and returns true if a // Present() is necessary. |frame| may be null, if it is not available. This @@ -108,7 +108,7 @@ class SDLPlayerBase : public Receiver::Consumer, public Decoder::Client { // require rendering/presenting a different output. void ResumeRendering(); - const openscreen::platform::ClockNowFunctionPtr now_; + const openscreen::ClockNowFunctionPtr now_; Receiver* const receiver_; std::function<void()> error_callback_; // Run once by OnFatalError(). const char* const media_type_; // For logging only. @@ -123,7 +123,7 @@ class SDLPlayerBase : public Receiver::Consumer, public Decoder::Client { // Queue of frames currently being decoded and decoded frames awaiting // rendering. struct PendingFrame : public PresentableFrame { - openscreen::platform::Clock::time_point start_time; + openscreen::Clock::time_point start_time; PendingFrame(); ~PendingFrame(); @@ -139,7 +139,7 @@ class SDLPlayerBase : public Receiver::Consumer, public Decoder::Client { // whenever the media (RTP) timestamps drift too much away from the rate at // which the local clock ticks. This is important for A/V synchronization. RtpTimeTicks last_sync_rtp_timestamp_{}; - openscreen::platform::Clock::time_point last_sync_reference_time_{}; + openscreen::Clock::time_point last_sync_reference_time_{}; Decoder decoder_; @@ -149,7 +149,7 @@ class SDLPlayerBase : public Receiver::Consumer, public Decoder::Client { // A cumulative moving average of recent single-frame processing times // (consume + decode + render). This is passed to the Cast Receiver so that it // can determine when to drop late frames. - openscreen::platform::Clock::duration recent_processing_time_{}; + openscreen::Clock::duration recent_processing_time_{}; // Alarms that execute the various stages of the player pipeline at certain // times. diff --git a/cast/standalone_receiver/sdl_video_player.cc b/cast/standalone_receiver/sdl_video_player.cc index 250a76c0..f91a28a1 100644 --- a/cast/standalone_receiver/sdl_video_player.cc +++ b/cast/standalone_receiver/sdl_video_player.cc @@ -9,11 +9,11 @@ #include "cast/standalone_receiver/avcodec_glue.h" #include "util/logging.h" +using openscreen::Clock; +using openscreen::ClockNowFunctionPtr; using openscreen::Error; using openscreen::ErrorOr; -using openscreen::platform::Clock; -using openscreen::platform::ClockNowFunctionPtr; -using openscreen::platform::TaskRunner; +using openscreen::TaskRunner; namespace cast { namespace streaming { diff --git a/cast/standalone_receiver/sdl_video_player.h b/cast/standalone_receiver/sdl_video_player.h index 915881ea..515649d0 100644 --- a/cast/standalone_receiver/sdl_video_player.h +++ b/cast/standalone_receiver/sdl_video_player.h @@ -16,8 +16,8 @@ class SDLVideoPlayer : public SDLPlayerBase { public: // |error_callback| is run only if a fatal error occurs, at which point the // player has halted and set |error_status()|. - SDLVideoPlayer(openscreen::platform::ClockNowFunctionPtr now_function, - openscreen::platform::TaskRunner* task_runner, + SDLVideoPlayer(openscreen::ClockNowFunctionPtr now_function, + openscreen::TaskRunner* task_runner, Receiver* receiver, SDL_Renderer* renderer, std::function<void()> error_callback); @@ -32,7 +32,7 @@ class SDLVideoPlayer : public SDLPlayerBase { // Uploads the decoded picture in |frame| to a SDL texture and draws it using // the SDL |renderer_|. - openscreen::ErrorOr<openscreen::platform::Clock::time_point> RenderNextFrame( + openscreen::ErrorOr<openscreen::Clock::time_point> RenderNextFrame( const SDLPlayerBase::PresentableFrame& frame) final; // Makes whatever is currently drawn to the SDL |renderer_| be presented diff --git a/cast/streaming/clock_drift_smoother.h b/cast/streaming/clock_drift_smoother.h index d48d166c..783c755c 100644 --- a/cast/streaming/clock_drift_smoother.h +++ b/cast/streaming/clock_drift_smoother.h @@ -17,7 +17,7 @@ namespace streaming { // moves at a rate based on the passage of time. class ClockDriftSmoother { public: - using Clock = openscreen::platform::Clock; + using Clock = openscreen::Clock; // |time_constant| is the amount of time an impulse signal takes to decay by // ~62.6%. Interpretation: If the value passed to several Update() calls is diff --git a/cast/streaming/compound_rtcp_builder.cc b/cast/streaming/compound_rtcp_builder.cc index b3cba68b..2593e95a 100644 --- a/cast/streaming/compound_rtcp_builder.cc +++ b/cast/streaming/compound_rtcp_builder.cc @@ -15,7 +15,7 @@ #include "util/std_util.h" using openscreen::AreElementsSortedAndUnique; -using openscreen::platform::Clock; +using openscreen::Clock; namespace cast { namespace streaming { diff --git a/cast/streaming/compound_rtcp_builder.h b/cast/streaming/compound_rtcp_builder.h index 58bc62fb..a2d8e26e 100644 --- a/cast/streaming/compound_rtcp_builder.h +++ b/cast/streaming/compound_rtcp_builder.h @@ -97,9 +97,8 @@ class CompoundRtcpBuilder { // should be monotonically increasing so the consuming side (the Sender) can // determine the chronological ordering of RTCP packets. The Sender might also // use this to estimate round-trip times over the network. - absl::Span<uint8_t> BuildPacket( - openscreen::platform::Clock::time_point send_time, - absl::Span<uint8_t> buffer); + absl::Span<uint8_t> BuildPacket(openscreen::Clock::time_point send_time, + absl::Span<uint8_t> buffer); // The required buffer size to be provided to BuildPacket(). This accounts for // all the possible headers and report structures that might be included, @@ -112,7 +111,7 @@ class CompoundRtcpBuilder { // |buffer| that will ultimately contain a "compound RTCP packet." void AppendReceiverReportPacket(absl::Span<uint8_t>* buffer); void AppendReceiverReferenceTimeReportPacket( - openscreen::platform::Clock::time_point send_time, + openscreen::Clock::time_point send_time, absl::Span<uint8_t>* buffer); void AppendPictureLossIndicatorPacket(absl::Span<uint8_t>* buffer); void AppendCastFeedbackPacket(absl::Span<uint8_t>* buffer); diff --git a/cast/streaming/compound_rtcp_builder_unittest.cc b/cast/streaming/compound_rtcp_builder_unittest.cc index ab6f8c00..c86859b9 100644 --- a/cast/streaming/compound_rtcp_builder_unittest.cc +++ b/cast/streaming/compound_rtcp_builder_unittest.cc @@ -15,7 +15,7 @@ #include "gtest/gtest.h" #include "platform/api/time.h" -using openscreen::platform::Clock; +using openscreen::Clock; using testing::_; using testing::Invoke; diff --git a/cast/streaming/compound_rtcp_parser.cc b/cast/streaming/compound_rtcp_parser.cc index af5336ea..b1ea4b67 100644 --- a/cast/streaming/compound_rtcp_parser.cc +++ b/cast/streaming/compound_rtcp_parser.cc @@ -11,7 +11,7 @@ #include "util/logging.h" #include "util/std_util.h" -using openscreen::platform::Clock; +using openscreen::Clock; namespace cast { namespace streaming { diff --git a/cast/streaming/compound_rtcp_parser.h b/cast/streaming/compound_rtcp_parser.h index c9b71594..1de12c3f 100644 --- a/cast/streaming/compound_rtcp_parser.h +++ b/cast/streaming/compound_rtcp_parser.h @@ -41,7 +41,7 @@ class CompoundRtcpParser { // Called when a Receiver Reference Time Report has been parsed. virtual void OnReceiverReferenceTimeAdvanced( - openscreen::platform::Clock::time_point reference_time); + openscreen::Clock::time_point reference_time); // Called when a Receiver Report with a Report Block has been parsed. virtual void OnReceiverReport(const RtcpReportBlock& receiver_report); @@ -103,7 +103,7 @@ class CompoundRtcpParser { std::vector<PacketNack>* packet_nacks); bool ParseExtendedReports( absl::Span<const uint8_t> in, - openscreen::platform::Clock::time_point* receiver_reference_time); + openscreen::Clock::time_point* receiver_reference_time); bool ParsePictureLossIndicator(absl::Span<const uint8_t> in, bool* picture_loss_indicator); @@ -113,7 +113,7 @@ class CompoundRtcpParser { // Tracks the latest timestamp seen from any Receiver Reference Time Report, // and uses this to ignore stale RTCP packets that arrived out-of-order and/or // late from the network. - openscreen::platform::Clock::time_point latest_receiver_timestamp_; + openscreen::Clock::time_point latest_receiver_timestamp_; }; } // namespace streaming diff --git a/cast/streaming/compound_rtcp_parser_fuzzer.cc b/cast/streaming/compound_rtcp_parser_fuzzer.cc index af5823df..addc6283 100644 --- a/cast/streaming/compound_rtcp_parser_fuzzer.cc +++ b/cast/streaming/compound_rtcp_parser_fuzzer.cc @@ -25,7 +25,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wexit-time-destructors" static RtcpSession session(kSenderSsrcInSeedCorpus, kReceiverSsrcInSeedCorpus, - openscreen::platform::Clock::time_point{}); + openscreen::Clock::time_point{}); static CompoundRtcpParser::Client client_that_ignores_everything; static CompoundRtcpParser parser(&session, &client_that_ignores_everything); #pragma clang diagnostic pop diff --git a/cast/streaming/compound_rtcp_parser_unittest.cc b/cast/streaming/compound_rtcp_parser_unittest.cc index 863953af..f09224f9 100644 --- a/cast/streaming/compound_rtcp_parser_unittest.cc +++ b/cast/streaming/compound_rtcp_parser_unittest.cc @@ -32,8 +32,7 @@ class CompoundRtcpParserTest : public testing::Test { CompoundRtcpParser* parser() { return &parser_; } private: - RtcpSession session_{kSenderSsrc, kReceiverSsrc, - openscreen::platform::Clock::now()}; + RtcpSession session_{kSenderSsrc, kReceiverSsrc, openscreen::Clock::now()}; StrictMock<MockCompoundRtcpParserClient> client_; CompoundRtcpParser parser_{&session_, &client_}; }; diff --git a/cast/streaming/encoded_frame.h b/cast/streaming/encoded_frame.h index b42b6340..cf36b61a 100644 --- a/cast/streaming/encoded_frame.h +++ b/cast/streaming/encoded_frame.h @@ -78,7 +78,7 @@ struct EncodedFrame { // (see |rtp_timestamp|, above). It is also meant to be used to synchronize // the presentation of multiple streams (e.g., audio and video), commonly // known as "lip-sync." It is NOT meant to be a mandatory/exact playout time. - openscreen::platform::Clock::time_point reference_time; + openscreen::Clock::time_point reference_time; // Playout delay for this and all future frames. Used by the Adaptive // Playout delay extension. Non-positive values means no change. diff --git a/cast/streaming/environment.cc b/cast/streaming/environment.cc index 954a2e0c..55094a4e 100644 --- a/cast/streaming/environment.cc +++ b/cast/streaming/environment.cc @@ -8,15 +8,15 @@ #include "platform/api/task_runner.h" #include "util/logging.h" +using openscreen::Clock; +using openscreen::ClockNowFunctionPtr; using openscreen::Error; using openscreen::ErrorOr; using openscreen::IPAddress; using openscreen::IPEndpoint; -using openscreen::platform::Clock; -using openscreen::platform::ClockNowFunctionPtr; -using openscreen::platform::TaskRunner; -using openscreen::platform::UdpPacket; -using openscreen::platform::UdpSocket; +using openscreen::TaskRunner; +using openscreen::UdpPacket; +using openscreen::UdpSocket; namespace cast { namespace streaming { @@ -124,10 +124,10 @@ void Environment::OnRead(UdpSocket* socket, // Ideally, the arrival time would come from the operating system's network // stack (e.g., by using the SO_TIMESTAMP sockopt on POSIX systems). However, // there would still be the problem of mapping the timestamp to a value in - // terms of platform::Clock. So, just sample the Clock here and call that the - // "arrival time." While this can add variance within the system, it should be - // minimal, assuming not too much time has elapsed between the actual packet - // receive event and the when this code here is executing. + // terms of Clock::time_point. So, just sample the Clock here and call that + // the "arrival time." While this can add variance within the system, it + // should be minimal, assuming not too much time has elapsed between the + // actual packet receive event and the when this code here is executing. const Clock::time_point arrival_time = now_function_(); UdpPacket packet = std::move(packet_or_error.value()); diff --git a/cast/streaming/environment.h b/cast/streaming/environment.h index 0bc99f2d..5fb613f5 100644 --- a/cast/streaming/environment.h +++ b/cast/streaming/environment.h @@ -16,9 +16,7 @@ #include "platform/base/ip_address.h" namespace openscreen { -namespace platform { class TaskRunner; -} // namespace platform } // namespace openscreen namespace cast { @@ -26,14 +24,13 @@ namespace streaming { // Provides the common environment for operating system resources shared by // multiple components. -class Environment : public openscreen::platform::UdpSocket::Client { +class Environment : public openscreen::UdpSocket::Client { public: class PacketConsumer { public: - virtual void OnReceivedPacket( - const openscreen::IPEndpoint& source, - openscreen::platform::Clock::time_point arrival_time, - std::vector<uint8_t> packet) = 0; + virtual void OnReceivedPacket(const openscreen::IPEndpoint& source, + openscreen::Clock::time_point arrival_time, + std::vector<uint8_t> packet) = 0; protected: virtual ~PacketConsumer(); @@ -42,16 +39,14 @@ class Environment : public openscreen::platform::UdpSocket::Client { // Construct with the given clock source and TaskRunner. Creates and // internally-owns a UdpSocket, and immediately binds it to the given // |local_endpoint|. - Environment(openscreen::platform::ClockNowFunctionPtr now_function, - openscreen::platform::TaskRunner* task_runner, + Environment(openscreen::ClockNowFunctionPtr now_function, + openscreen::TaskRunner* task_runner, const openscreen::IPEndpoint& local_endpoint); ~Environment() override; - openscreen::platform::ClockNowFunctionPtr now_function() const { - return now_function_; - } - openscreen::platform::TaskRunner* task_runner() const { return task_runner_; } + openscreen::ClockNowFunctionPtr now_function() const { return now_function_; } + openscreen::TaskRunner* task_runner() const { return task_runner_; } // Returns the local endpoint the socket is bound to, or the zero IPEndpoint // if socket creation/binding failed. @@ -98,25 +93,23 @@ class Environment : public openscreen::platform::UdpSocket::Client { // Common constructor that just stores the injected dependencies and does not // create a socket. Subclasses use this to provide an alternative packet // receive/send mechanism (e.g., for testing). - Environment(openscreen::platform::ClockNowFunctionPtr now_function, - openscreen::platform::TaskRunner* task_runner); + Environment(openscreen::ClockNowFunctionPtr now_function, + openscreen::TaskRunner* task_runner); private: - // openscreen::platform::UdpSocket::Client implementation. - void OnError(openscreen::platform::UdpSocket* socket, - openscreen::Error error) final; - void OnSendError(openscreen::platform::UdpSocket* socket, + // openscreen::UdpSocket::Client implementation. + void OnError(openscreen::UdpSocket* socket, openscreen::Error error) final; + void OnSendError(openscreen::UdpSocket* socket, openscreen::Error error) final; - void OnRead(openscreen::platform::UdpSocket* socket, - openscreen::ErrorOr<openscreen::platform::UdpPacket> - packet_or_error) final; + void OnRead(openscreen::UdpSocket* socket, + openscreen::ErrorOr<openscreen::UdpPacket> packet_or_error) final; - const openscreen::platform::ClockNowFunctionPtr now_function_; - openscreen::platform::TaskRunner* const task_runner_; + const openscreen::ClockNowFunctionPtr now_function_; + openscreen::TaskRunner* const task_runner_; // The UDP socket bound to the local endpoint that was passed into the // constructor, or null if socket creation failed. - const std::unique_ptr<openscreen::platform::UdpSocket> socket_; + const std::unique_ptr<openscreen::UdpSocket> socket_; // These are externally set/cleared. Behaviors are described in getter/setter // method comments above. diff --git a/cast/streaming/mock_compound_rtcp_parser_client.h b/cast/streaming/mock_compound_rtcp_parser_client.h index 0b16e599..4411e98a 100644 --- a/cast/streaming/mock_compound_rtcp_parser_client.h +++ b/cast/streaming/mock_compound_rtcp_parser_client.h @@ -14,7 +14,7 @@ namespace streaming { class MockCompoundRtcpParserClient : public CompoundRtcpParser::Client { public: MOCK_METHOD1(OnReceiverReferenceTimeAdvanced, - void(openscreen::platform::Clock::time_point reference_time)); + void(openscreen::Clock::time_point reference_time)); MOCK_METHOD1(OnReceiverReport, void(const RtcpReportBlock& receiver_report)); MOCK_METHOD0(OnReceiverIndicatesPictureLoss, void()); MOCK_METHOD2(OnReceiverCheckpoint, diff --git a/cast/streaming/ntp_time.cc b/cast/streaming/ntp_time.cc index d7072baf..5bead4ba 100644 --- a/cast/streaming/ntp_time.cc +++ b/cast/streaming/ntp_time.cc @@ -6,7 +6,7 @@ #include "util/logging.h" -using openscreen::platform::Clock; +using openscreen::Clock; using std::chrono::duration_cast; namespace cast { diff --git a/cast/streaming/ntp_time.h b/cast/streaming/ntp_time.h index f76dae4a..7330148c 100644 --- a/cast/streaming/ntp_time.h +++ b/cast/streaming/ntp_time.h @@ -41,8 +41,8 @@ constexpr NtpTimestamp AssembleNtpTimestamp(NtpSeconds seconds, static_cast<uint32_t>(fraction.count()); } -// Converts between openscreen::platform::Clock::time_points and NtpTimestamps. -// The class is instantiated with the current openscreen::platform::Clock time +// Converts between openscreen::Clock::time_points and NtpTimestamps. +// The class is instantiated with the current openscreen::Clock time // and the current wall clock time, and these are used to determine a fixed // origin reference point for all conversions. Thus, to avoid introducing // unintended timing-related behaviors, only one NtpTimeConverter instance @@ -50,15 +50,13 @@ constexpr NtpTimestamp AssembleNtpTimestamp(NtpSeconds seconds, // session. class NtpTimeConverter { public: - NtpTimeConverter(openscreen::platform::Clock::time_point now, + NtpTimeConverter(openscreen::Clock::time_point now, std::chrono::seconds since_unix_epoch = - openscreen::platform::GetWallTimeSinceUnixEpoch()); + openscreen::GetWallTimeSinceUnixEpoch()); ~NtpTimeConverter(); - NtpTimestamp ToNtpTimestamp( - openscreen::platform::Clock::time_point time_point) const; - openscreen::platform::Clock::time_point ToLocalTime( - NtpTimestamp timestamp) const; + NtpTimestamp ToNtpTimestamp(openscreen::Clock::time_point time_point) const; + openscreen::Clock::time_point ToLocalTime(NtpTimestamp timestamp) const; private: // The time point on the platform clock's timeline that corresponds to @@ -68,7 +66,7 @@ class NtpTimeConverter { // can be off (with respect to each other) by even a large amount; and all // that matters is that time ticks forward at a reasonable pace from some // initial point. - const openscreen::platform::Clock::time_point start_time_; + const openscreen::Clock::time_point start_time_; const NtpSeconds since_ntp_epoch_; }; diff --git a/cast/streaming/ntp_time_unittest.cc b/cast/streaming/ntp_time_unittest.cc index 552673c0..6c72a187 100644 --- a/cast/streaming/ntp_time_unittest.cc +++ b/cast/streaming/ntp_time_unittest.cc @@ -6,7 +6,7 @@ #include "gtest/gtest.h" -using openscreen::platform::Clock; +using openscreen::Clock; using std::chrono::duration_cast; using std::chrono::microseconds; using std::chrono::milliseconds; @@ -74,7 +74,7 @@ TEST(NtpTimeConverterTest, ConvertsToNtpTimeAndBack) { // should be looked into! const Clock::time_point steady_clock_start = Clock::now(); const std::chrono::seconds wall_clock_start = - openscreen::platform::GetWallTimeSinceUnixEpoch(); + openscreen::GetWallTimeSinceUnixEpoch(); SCOPED_TRACE(::testing::Message() << "steady_clock_start.time_since_epoch().count() is " << steady_clock_start.time_since_epoch().count() diff --git a/cast/streaming/packet_receive_stats_tracker.cc b/cast/streaming/packet_receive_stats_tracker.cc index 0d7f268e..c00af536 100644 --- a/cast/streaming/packet_receive_stats_tracker.cc +++ b/cast/streaming/packet_receive_stats_tracker.cc @@ -6,7 +6,7 @@ #include <algorithm> -using openscreen::platform::Clock; +using openscreen::Clock; namespace cast { namespace streaming { diff --git a/cast/streaming/packet_receive_stats_tracker.h b/cast/streaming/packet_receive_stats_tracker.h index e579f76f..a13696bf 100644 --- a/cast/streaming/packet_receive_stats_tracker.h +++ b/cast/streaming/packet_receive_stats_tracker.h @@ -29,10 +29,9 @@ class PacketReceiveStatsTracker { // RtpPacketParser::ParseResult. |arrival_time| is when the packet was // received (i.e., right-off the network socket, before any // processing/parsing). - void OnReceivedValidRtpPacket( - uint16_t sequence_number, - RtpTimeTicks rtp_timestamp, - openscreen::platform::Clock::time_point arrival_time); + void OnReceivedValidRtpPacket(uint16_t sequence_number, + RtpTimeTicks rtp_timestamp, + openscreen::Clock::time_point arrival_time); // Populates *only* those fields in the given |report| that pertain to packet // loss, jitter, and the latest-known RTP packet sequence number. @@ -89,7 +88,7 @@ class PacketReceiveStatsTracker { // The time the last RTP packet was received. This is used in the computation // that updates |jitter_|. - openscreen::platform::Clock::time_point last_rtp_packet_arrival_time_; + openscreen::Clock::time_point last_rtp_packet_arrival_time_; // The RTP timestamp of the last RTP packet received. This is used in the // computation that updates |jitter_|. @@ -98,7 +97,7 @@ class PacketReceiveStatsTracker { // The interarrival jitter. See RFC 3550 spec, section 6.4.1. The Cast // Streaming spec diverges from the algorithm in the RFC spec in that it uses // different pieces of timing data to calculate this metric. - openscreen::platform::Clock::duration jitter_; + openscreen::Clock::duration jitter_; }; } // namespace streaming diff --git a/cast/streaming/packet_receive_stats_tracker_unittest.cc b/cast/streaming/packet_receive_stats_tracker_unittest.cc index 1532741f..c386a799 100644 --- a/cast/streaming/packet_receive_stats_tracker_unittest.cc +++ b/cast/streaming/packet_receive_stats_tracker_unittest.cc @@ -9,7 +9,7 @@ #include "cast/streaming/constants.h" #include "gtest/gtest.h" -using openscreen::platform::Clock; +using openscreen::Clock; namespace cast { namespace streaming { diff --git a/cast/streaming/receiver.cc b/cast/streaming/receiver.cc index 73a37eb2..b68ffd07 100644 --- a/cast/streaming/receiver.cc +++ b/cast/streaming/receiver.cc @@ -13,7 +13,7 @@ #include "util/logging.h" #include "util/std_util.h" -using openscreen::platform::Clock; +using openscreen::Clock; using std::chrono::duration_cast; using std::chrono::microseconds; diff --git a/cast/streaming/receiver.h b/cast/streaming/receiver.h index d1ea8b0c..5d786d94 100644 --- a/cast/streaming/receiver.h +++ b/cast/streaming/receiver.h @@ -143,8 +143,7 @@ class Receiver { // based on changing environmental conditions. // // Default setting: kDefaultPlayerProcessingTime - void SetPlayerProcessingTime( - openscreen::platform::Clock::duration needed_time); + void SetPlayerProcessingTime(openscreen::Clock::duration needed_time); // Propagates a "picture loss indicator" notification to the Sender, // requesting a key frame so that decode/playout can recover. It is safe to @@ -185,11 +184,10 @@ class Receiver { // Called by ReceiverPacketRouter to provide this Receiver with what looks // like a RTP/RTCP packet meant for it specifically (among other Receivers). - void OnReceivedRtpPacket(openscreen::platform::Clock::time_point arrival_time, + void OnReceivedRtpPacket(openscreen::Clock::time_point arrival_time, std::vector<uint8_t> packet); - void OnReceivedRtcpPacket( - openscreen::platform::Clock::time_point arrival_time, - std::vector<uint8_t> packet); + void OnReceivedRtcpPacket(openscreen::Clock::time_point arrival_time, + std::vector<uint8_t> packet); private: // An entry in the circular queue (see |pending_frames_|). @@ -200,8 +198,7 @@ class Receiver { // at the Sender. This is computed and assigned when the RTP packet with ID // 0 is processed. Add the target playout delay to this to get the target // playout time. - absl::optional<openscreen::platform::Clock::time_point> - estimated_capture_time; + absl::optional<openscreen::Clock::time_point> estimated_capture_time; PendingFrame(); ~PendingFrame(); @@ -256,10 +253,9 @@ class Receiver { // Sets the |consumption_alarm_| to check whether any frames are ready, // including possibly skipping over late frames in order to make not-yet-late // frames become ready. The default argument value means "without delay." - void ScheduleFrameReadyCheck( - openscreen::platform::Clock::time_point when = {}); + void ScheduleFrameReadyCheck(openscreen::Clock::time_point when = {}); - const openscreen::platform::ClockNowFunctionPtr now_; + const openscreen::ClockNowFunctionPtr now_; ReceiverPacketRouter* const packet_router_; RtcpSession rtcp_session_; SenderReportParser rtcp_parser_; @@ -277,8 +273,8 @@ class Receiver { // Not scheduled until after this Receiver has processed the first packet from // the Sender. openscreen::Alarm rtcp_alarm_; - openscreen::platform::Clock::time_point last_rtcp_send_time_ = - openscreen::platform::Clock::time_point::min(); + openscreen::Clock::time_point last_rtcp_send_time_ = + openscreen::Clock::time_point::min(); // The last Sender Report received and when the packet containing it had // arrived. This contains lip-sync timestamps used as part of the calculation @@ -286,7 +282,7 @@ class Receiver { // back to the Sender in the Receiver Reports. It is nullopt until the first // parseable Sender Report is received. absl::optional<SenderReportParser::SenderReportWithId> last_sender_report_; - openscreen::platform::Clock::time_point last_sender_report_arrival_time_; + openscreen::Clock::time_point last_sender_report_arrival_time_; // Tracks the offset between the Receiver's [local] clock and the Sender's // clock. This is invalid until the first Sender Report has been successfully @@ -333,7 +329,7 @@ class Receiver { // The additional time needed to decode/play-out each frame after being // consumed from this Receiver. - openscreen::platform::Clock::duration player_processing_time_ = + openscreen::Clock::duration player_processing_time_ = kDefaultPlayerProcessingTime; // Scheduled to check whether there are frames ready and, if there are, to diff --git a/cast/streaming/receiver_packet_router.cc b/cast/streaming/receiver_packet_router.cc index 5e3d17bd..456a2ce8 100644 --- a/cast/streaming/receiver_packet_router.cc +++ b/cast/streaming/receiver_packet_router.cc @@ -11,8 +11,8 @@ #include "cast/streaming/receiver.h" #include "util/logging.h" +using openscreen::Clock; using openscreen::IPEndpoint; -using openscreen::platform::Clock; namespace cast { namespace streaming { diff --git a/cast/streaming/receiver_packet_router.h b/cast/streaming/receiver_packet_router.h index 88db08a8..007f41f1 100644 --- a/cast/streaming/receiver_packet_router.h +++ b/cast/streaming/receiver_packet_router.h @@ -48,7 +48,7 @@ class ReceiverPacketRouter final : public Environment::PacketConsumer { // Environment::PacketConsumer implementation. void OnReceivedPacket(const openscreen::IPEndpoint& source, - openscreen::platform::Clock::time_point arrival_time, + openscreen::Clock::time_point arrival_time, std::vector<uint8_t> packet) final; // Helper to return an iterator pointing to the entry corresponding to the diff --git a/cast/streaming/receiver_session_unittest.cc b/cast/streaming/receiver_session_unittest.cc index e4e0eb43..5ce7c0a2 100644 --- a/cast/streaming/receiver_session_unittest.cc +++ b/cast/streaming/receiver_session_unittest.cc @@ -9,9 +9,9 @@ #include "platform/test/fake_clock.h" #include "platform/test/fake_task_runner.h" -using openscreen::platform::Clock; -using openscreen::platform::FakeClock; -using openscreen::platform::FakeTaskRunner; +using openscreen::Clock; +using openscreen::FakeClock; +using openscreen::FakeTaskRunner; using ::testing::_; using ::testing::Invoke; diff --git a/cast/streaming/receiver_unittest.cc b/cast/streaming/receiver_unittest.cc index 2426376a..e22d3a58 100644 --- a/cast/streaming/receiver_unittest.cc +++ b/cast/streaming/receiver_unittest.cc @@ -35,17 +35,17 @@ #include "platform/test/fake_task_runner.h" #include "util/logging.h" +using openscreen::Clock; +using openscreen::ClockNowFunctionPtr; using openscreen::Error; using openscreen::ErrorOr; +using openscreen::FakeClock; +using openscreen::FakeTaskRunner; using openscreen::IPAddress; using openscreen::IPEndpoint; -using openscreen::platform::Clock; -using openscreen::platform::ClockNowFunctionPtr; -using openscreen::platform::FakeClock; -using openscreen::platform::FakeTaskRunner; -using openscreen::platform::TaskRunner; -using openscreen::platform::UdpPacket; -using openscreen::platform::UdpSocket; +using openscreen::TaskRunner; +using openscreen::UdpPacket; +using openscreen::UdpSocket; using std::chrono::duration_cast; using std::chrono::microseconds; diff --git a/cast/streaming/rtcp_common.cc b/cast/streaming/rtcp_common.cc index 30d587a2..2a48ce51 100644 --- a/cast/streaming/rtcp_common.cc +++ b/cast/streaming/rtcp_common.cc @@ -9,8 +9,8 @@ #include "cast/streaming/packet_util.h" #include "util/saturate_cast.h" +using openscreen::Clock; using openscreen::saturate_cast; -using openscreen::platform::Clock; namespace cast { namespace streaming { diff --git a/cast/streaming/rtcp_common.h b/cast/streaming/rtcp_common.h index 3b6959c0..7e7cf963 100644 --- a/cast/streaming/rtcp_common.h +++ b/cast/streaming/rtcp_common.h @@ -116,8 +116,7 @@ struct RtcpReportBlock { // Convenience helper to convert the given |local_clock_delay| to the // RtcpReportBlock::Delay timebase, then clamp and assign it to // |delay_since_last_report|. - void SetDelaySinceLastReport( - openscreen::platform::Clock::duration local_clock_delay); + void SetDelaySinceLastReport(openscreen::Clock::duration local_clock_delay); // Serializes this report block in the first |kRtcpReportBlockSize| bytes of // the given |buffer| and adjusts |buffer| to point to the first byte after @@ -139,7 +138,7 @@ struct RtcpSenderReport { // common reference clock shared by all RTP streams; 2) the RTP timestamp on // the media capture/playout timeline. Together, these are used by a Receiver // to achieve A/V synchronization across RTP streams for playout. - openscreen::platform::Clock::time_point reference_time{}; + openscreen::Clock::time_point reference_time{}; RtpTimeTicks rtp_timestamp; // The total number of RTP packets transmitted since the start of the session diff --git a/cast/streaming/rtcp_common_unittest.cc b/cast/streaming/rtcp_common_unittest.cc index 8d088c2c..9cc6a3fe 100644 --- a/cast/streaming/rtcp_common_unittest.cc +++ b/cast/streaming/rtcp_common_unittest.cc @@ -11,7 +11,7 @@ #include "gtest/gtest.h" #include "platform/api/time.h" -using openscreen::platform::Clock; +using openscreen::Clock; namespace cast { namespace streaming { diff --git a/cast/streaming/rtcp_session.cc b/cast/streaming/rtcp_session.cc index a8b8ab6a..2b4af644 100644 --- a/cast/streaming/rtcp_session.cc +++ b/cast/streaming/rtcp_session.cc @@ -11,7 +11,7 @@ namespace streaming { RtcpSession::RtcpSession(Ssrc sender_ssrc, Ssrc receiver_ssrc, - openscreen::platform::Clock::time_point start_time) + openscreen::Clock::time_point start_time) : sender_ssrc_(sender_ssrc), receiver_ssrc_(receiver_ssrc), ntp_converter_(start_time) { diff --git a/cast/streaming/rtcp_session.h b/cast/streaming/rtcp_session.h index d896cb94..33a219cb 100644 --- a/cast/streaming/rtcp_session.h +++ b/cast/streaming/rtcp_session.h @@ -21,7 +21,7 @@ class RtcpSession { // world" wall time. RtcpSession(Ssrc sender_ssrc, Ssrc receiver_ssrc, - openscreen::platform::Clock::time_point start_time); + openscreen::Clock::time_point start_time); ~RtcpSession(); Ssrc sender_ssrc() const { return sender_ssrc_; } diff --git a/cast/streaming/rtp_packetizer.cc b/cast/streaming/rtp_packetizer.cc index 675a4a97..3e0bd506 100644 --- a/cast/streaming/rtp_packetizer.cc +++ b/cast/streaming/rtp_packetizer.cc @@ -14,7 +14,7 @@ #include "util/integer_division.h" #include "util/logging.h" -using openscreen::platform::Clock; +using openscreen::Clock; namespace cast { namespace streaming { diff --git a/cast/streaming/rtp_packetizer_unittest.cc b/cast/streaming/rtp_packetizer_unittest.cc index 52b460de..dc8bf8ac 100644 --- a/cast/streaming/rtp_packetizer_unittest.cc +++ b/cast/streaming/rtp_packetizer_unittest.cc @@ -42,7 +42,7 @@ class RtpPacketizerTest : public testing::Test { frame.frame_id = frame_id; frame.referenced_frame_id = is_key_frame ? frame_id : (frame_id - 1); frame.rtp_timestamp = RtpTimeTicks() + RtpTimeDelta::FromTicks(987); - frame.reference_time = openscreen::platform::Clock::now(); + frame.reference_time = openscreen::Clock::now(); frame.new_playout_delay = new_playout_delay; std::unique_ptr<uint8_t[]> buffer(new uint8_t[payload_size]); diff --git a/cast/streaming/sender_report_parser_fuzzer.cc b/cast/streaming/sender_report_parser_fuzzer.cc index 8b9d8e74..8c91a6d2 100644 --- a/cast/streaming/sender_report_parser_fuzzer.cc +++ b/cast/streaming/sender_report_parser_fuzzer.cc @@ -24,7 +24,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wexit-time-destructors" static RtcpSession session(kSenderSsrcInSeedCorpus, kReceiverSsrcInSeedCorpus, - openscreen::platform::Clock::now()); + openscreen::Clock::now()); static SenderReportParser parser(&session); #pragma clang diagnostic pop diff --git a/cast/streaming/sender_report_unittest.cc b/cast/streaming/sender_report_unittest.cc index bad2cf0a..4f757fc0 100644 --- a/cast/streaming/sender_report_unittest.cc +++ b/cast/streaming/sender_report_unittest.cc @@ -25,8 +25,7 @@ class SenderReportTest : public testing::Test { } private: - RtcpSession session_{kSenderSsrc, kReceiverSsrc, - openscreen::platform::Clock::now()}; + RtcpSession session_{kSenderSsrc, kReceiverSsrc, openscreen::Clock::now()}; SenderReportBuilder builder_{&session_}; SenderReportParser parser_{&session_}; }; @@ -120,7 +119,7 @@ TEST_F(SenderReportTest, BuildPackets) { const bool with_report_block = (i == 1); RtcpSenderReport original; - original.reference_time = openscreen::platform::Clock::now(); + original.reference_time = openscreen::Clock::now(); original.rtp_timestamp = RtpTimeTicks() + RtpTimeDelta::FromTicks(5); original.send_packet_count = 55; original.send_octet_count = 20044; diff --git a/cast/streaming/ssrc.cc b/cast/streaming/ssrc.cc index d3f24469..cb18a800 100644 --- a/cast/streaming/ssrc.cc +++ b/cast/streaming/ssrc.cc @@ -28,7 +28,7 @@ Ssrc GenerateSsrc(bool higher_priority) { // it is light-weight and does not need to produce unguessable (nor // crypto-secure) values. static std::minstd_rand generator(static_cast<std::minstd_rand::result_type>( - openscreen::platform::Clock::now().time_since_epoch().count())); + openscreen::Clock::now().time_since_epoch().count())); std::uniform_int_distribution<int> distribution( higher_priority ? kHigherPriorityMin : kNormalPriorityMin, diff --git a/discovery/dnssd/impl/service_impl.h b/discovery/dnssd/impl/service_impl.h index 829cceb9..1c4bea0d 100644 --- a/discovery/dnssd/impl/service_impl.h +++ b/discovery/dnssd/impl/service_impl.h @@ -12,12 +12,9 @@ #include "discovery/dnssd/public/dns_sd_service.h" namespace openscreen { -namespace platform { class TaskRunner; -} - namespace discovery { class MdnsService; diff --git a/discovery/mdns/mdns_publisher.cc b/discovery/mdns/mdns_publisher.cc index e1ebde80..052eb5b1 100644 --- a/discovery/mdns/mdns_publisher.cc +++ b/discovery/mdns/mdns_publisher.cc @@ -12,7 +12,7 @@ namespace discovery { MdnsPublisher::MdnsPublisher(MdnsQuerier* querier, MdnsSender* sender, - platform::TaskRunner* task_runner, + TaskRunner* task_runner, MdnsRandom* random_delay) : querier_(querier), sender_(sender), diff --git a/discovery/mdns/mdns_publisher.h b/discovery/mdns/mdns_publisher.h index 022a94df..91fc97ca 100644 --- a/discovery/mdns/mdns_publisher.h +++ b/discovery/mdns/mdns_publisher.h @@ -10,9 +10,7 @@ namespace openscreen { -namespace platform { class TaskRunner; -} // namespace platform namespace discovery { @@ -24,7 +22,7 @@ class MdnsPublisher : public MdnsResponder::RecordHandler { // the duration of this object's lifetime MdnsPublisher(MdnsQuerier* querier, MdnsSender* sender, - platform::TaskRunner* task_runner, + TaskRunner* task_runner, MdnsRandom* random_delay); ~MdnsPublisher(); @@ -57,7 +55,7 @@ class MdnsPublisher : public MdnsResponder::RecordHandler { MdnsQuerier* const querier_; MdnsSender* const sender_; - platform::TaskRunner* const task_runner_; + TaskRunner* const task_runner_; MdnsRandom* const random_delay_; }; diff --git a/discovery/mdns/mdns_querier.h b/discovery/mdns/mdns_querier.h index 2e50978f..a70cfa78 100644 --- a/discovery/mdns/mdns_querier.h +++ b/discovery/mdns/mdns_querier.h @@ -22,9 +22,6 @@ class MdnsRecordTracker; class MdnsQuerier { public: - using ClockNowFunctionPtr = openscreen::platform::ClockNowFunctionPtr; - using TaskRunner = openscreen::platform::TaskRunner; - MdnsQuerier(MdnsSender* sender, MdnsReceiver* receiver, TaskRunner* task_runner, diff --git a/discovery/mdns/mdns_querier_unittest.cc b/discovery/mdns/mdns_querier_unittest.cc index a2407822..43904578 100644 --- a/discovery/mdns/mdns_querier_unittest.cc +++ b/discovery/mdns/mdns_querier_unittest.cc @@ -18,13 +18,6 @@ namespace openscreen { namespace discovery { -using openscreen::platform::Clock; -using openscreen::platform::FakeClock; -using openscreen::platform::FakeTaskRunner; -using openscreen::platform::NetworkInterfaceIndex; -using openscreen::platform::TaskRunner; -using openscreen::platform::UdpPacket; -using openscreen::platform::UdpSocket; using testing::_; using testing::Args; using testing::Invoke; diff --git a/discovery/mdns/mdns_random.h b/discovery/mdns/mdns_random.h index b422f998..44a55a98 100644 --- a/discovery/mdns/mdns_random.h +++ b/discovery/mdns/mdns_random.h @@ -14,8 +14,6 @@ namespace discovery { class MdnsRandom { public: - using Clock = openscreen::platform::Clock; - // RFC 6762 Section 5.2 // https://tools.ietf.org/html/rfc6762#section-5.2 diff --git a/discovery/mdns/mdns_random_unittest.cc b/discovery/mdns/mdns_random_unittest.cc index 1ba58c90..e0ad2611 100644 --- a/discovery/mdns/mdns_random_unittest.cc +++ b/discovery/mdns/mdns_random_unittest.cc @@ -10,8 +10,6 @@ namespace openscreen { namespace discovery { -using openscreen::platform::Clock; - namespace { constexpr int kIterationCount = 100; } diff --git a/discovery/mdns/mdns_receiver.cc b/discovery/mdns/mdns_receiver.cc index 9245b8c1..2cb447b9 100644 --- a/discovery/mdns/mdns_receiver.cc +++ b/discovery/mdns/mdns_receiver.cc @@ -7,8 +7,6 @@ #include "discovery/mdns/mdns_reader.h" #include "util/trace_logging.h" -using openscreen::platform::TraceCategory; - namespace openscreen { namespace discovery { diff --git a/discovery/mdns/mdns_receiver.h b/discovery/mdns/mdns_receiver.h index ca02543e..15db8758 100644 --- a/discovery/mdns/mdns_receiver.h +++ b/discovery/mdns/mdns_receiver.h @@ -14,11 +14,8 @@ namespace discovery { class MdnsMessage; -class MdnsReceiver : openscreen::platform::UdpSocket::Client { +class MdnsReceiver : UdpSocket::Client { public: - using UdpPacket = openscreen::platform::UdpPacket; - using UdpSocket = openscreen::platform::UdpSocket; - // MdnsReceiver does not own |socket| and |delegate| // and expects that the lifetime of these objects exceeds the lifetime of // MdnsReceiver. diff --git a/discovery/mdns/mdns_receiver_unittest.cc b/discovery/mdns/mdns_receiver_unittest.cc index 5894abf8..383fa196 100644 --- a/discovery/mdns/mdns_receiver_unittest.cc +++ b/discovery/mdns/mdns_receiver_unittest.cc @@ -17,9 +17,6 @@ namespace openscreen { namespace discovery { -using openscreen::platform::FakeUdpSocket; -using openscreen::platform::TaskRunner; -using openscreen::platform::UdpPacket; using testing::_; using testing::Return; diff --git a/discovery/mdns/mdns_responder.cc b/discovery/mdns/mdns_responder.cc index ce3dd4be..881cb517 100644 --- a/discovery/mdns/mdns_responder.cc +++ b/discovery/mdns/mdns_responder.cc @@ -18,8 +18,8 @@ MdnsResponder::MdnsResponder(RecordHandler* record_handler, MdnsSender* sender, MdnsReceiver* receiver, MdnsQuerier* querier, - platform::TaskRunner* task_runner, - platform::ClockNowFunctionPtr now_function, + TaskRunner* task_runner, + ClockNowFunctionPtr now_function, MdnsRandom* random_delay) : record_handler_(record_handler), sender_(sender), diff --git a/discovery/mdns/mdns_responder.h b/discovery/mdns/mdns_responder.h index cde4518e..e7c5ffa0 100644 --- a/discovery/mdns/mdns_responder.h +++ b/discovery/mdns/mdns_responder.h @@ -12,11 +12,9 @@ #include "platform/base/macros.h" namespace openscreen { -struct IPEndpoint; -namespace platform { +struct IPEndpoint; class TaskRunner; -} // namespace platform namespace discovery { @@ -54,8 +52,8 @@ class MdnsResponder { MdnsSender* sender, MdnsReceiver* receiver, MdnsQuerier* querier, - platform::TaskRunner* task_runner, - platform::ClockNowFunctionPtr now_function, + TaskRunner* task_runner, + ClockNowFunctionPtr now_function, MdnsRandom* random_delay); ~MdnsResponder(); @@ -68,8 +66,8 @@ class MdnsResponder { MdnsSender* const sender_; MdnsReceiver* const receiver_; MdnsQuerier* const querier_; - platform::TaskRunner* const task_runner_; - const platform::ClockNowFunctionPtr now_function_; + TaskRunner* const task_runner_; + const ClockNowFunctionPtr now_function_; MdnsRandom* const random_delay_; }; diff --git a/discovery/mdns/mdns_sender.h b/discovery/mdns/mdns_sender.h index b51eb122..50f66ff8 100644 --- a/discovery/mdns/mdns_sender.h +++ b/discovery/mdns/mdns_sender.h @@ -16,8 +16,6 @@ class MdnsMessage; class MdnsSender { public: - using UdpSocket = openscreen::platform::UdpSocket; - // MdnsSender does not own |socket| and expects that its lifetime exceeds the // lifetime of MdnsSender. explicit MdnsSender(UdpSocket* socket); diff --git a/discovery/mdns/mdns_sender_unittest.cc b/discovery/mdns/mdns_sender_unittest.cc index 4e7669b2..6a21c364 100644 --- a/discovery/mdns/mdns_sender_unittest.cc +++ b/discovery/mdns/mdns_sender_unittest.cc @@ -15,7 +15,6 @@ namespace openscreen { namespace discovery { -using openscreen::platform::FakeUdpSocket; using testing::_; using testing::Args; using testing::Return; diff --git a/discovery/mdns/mdns_trackers.cc b/discovery/mdns/mdns_trackers.cc index 28b05b7f..f45c2148 100644 --- a/discovery/mdns/mdns_trackers.cc +++ b/discovery/mdns/mdns_trackers.cc @@ -101,7 +101,7 @@ ErrorOr<MdnsRecordTracker::UpdateType> MdnsRecordTracker::Update( // Goodbye records do not need to be requeried, set the attempt count to the // last item, which is 100% of TTL, i.e. record expiration. - attempt_count_ = openscreen::countof(kTtlFractions) - 1; + attempt_count_ = countof(kTtlFractions) - 1; } else { record_ = new_record; attempt_count_ = 0; @@ -123,7 +123,7 @@ void MdnsRecordTracker::ExpireSoon() { // Set the attempt count to the last item, which is 100% of TTL, i.e. record // expiration, to prevent any requeries - attempt_count_ = openscreen::countof(kTtlFractions) - 1; + attempt_count_ = countof(kTtlFractions) - 1; start_time_ = now_function_(); send_alarm_.Schedule([this] { SendQuery(); }, GetNextSendTime()); } @@ -144,13 +144,13 @@ void MdnsRecordTracker::SendQuery() { } } -openscreen::platform::Clock::time_point MdnsRecordTracker::GetNextSendTime() { - OSP_DCHECK(attempt_count_ < openscreen::countof(kTtlFractions)); +Clock::time_point MdnsRecordTracker::GetNextSendTime() { + OSP_DCHECK(attempt_count_ < countof(kTtlFractions)); double ttl_fraction = kTtlFractions[attempt_count_++]; // Do not add random variation to the expiration time (last fraction of TTL) - if (attempt_count_ != openscreen::countof(kTtlFractions)) { + if (attempt_count_ != countof(kTtlFractions)) { ttl_fraction += random_delay_->GetRecordTtlVariation(); } diff --git a/discovery/mdns/mdns_trackers.h b/discovery/mdns/mdns_trackers.h index 75556f2c..166b5f1d 100644 --- a/discovery/mdns/mdns_trackers.h +++ b/discovery/mdns/mdns_trackers.h @@ -25,9 +25,6 @@ class MdnsSender; // the purposes of common code sharing only class MdnsTracker { public: - using ClockNowFunctionPtr = openscreen::platform::ClockNowFunctionPtr; - using TaskRunner = openscreen::platform::TaskRunner; - // MdnsTracker does not own |sender|, |task_runner| and |random_delay| // and expects that the lifetime of these objects exceeds the lifetime of // MdnsTracker. @@ -53,8 +50,6 @@ class MdnsTracker { // refreshing records as they reach their expiration time. class MdnsRecordTracker : public MdnsTracker { public: - using Clock = openscreen::platform::Clock; - MdnsRecordTracker( MdnsRecord record, MdnsSender* sender, @@ -100,8 +95,6 @@ class MdnsRecordTracker : public MdnsTracker { // continuous monitoring with exponential back-off as described in RFC 6762 class MdnsQuestionTracker : public MdnsTracker { public: - using Clock = openscreen::platform::Clock; - MdnsQuestionTracker(MdnsQuestion question, MdnsSender* sender, TaskRunner* task_runner, diff --git a/discovery/mdns/mdns_trackers_unittest.cc b/discovery/mdns/mdns_trackers_unittest.cc index 91b33678..2f2603a6 100644 --- a/discovery/mdns/mdns_trackers_unittest.cc +++ b/discovery/mdns/mdns_trackers_unittest.cc @@ -15,12 +15,6 @@ namespace openscreen { namespace discovery { -using openscreen::platform::Clock; -using openscreen::platform::FakeClock; -using openscreen::platform::FakeTaskRunner; -using openscreen::platform::NetworkInterfaceIndex; -using openscreen::platform::TaskRunner; -using openscreen::platform::UdpSocket; using testing::_; using testing::Args; using testing::Invoke; diff --git a/discovery/mdns/mdns_writer.h b/discovery/mdns/mdns_writer.h index 66c1b036..a4a30b6d 100644 --- a/discovery/mdns/mdns_writer.h +++ b/discovery/mdns/mdns_writer.h @@ -13,7 +13,7 @@ namespace openscreen { namespace discovery { -class MdnsWriter : public openscreen::BigEndianWriter { +class MdnsWriter : public BigEndianWriter { public: using BigEndianWriter::BigEndianWriter; using BigEndianWriter::Write; diff --git a/docs/trace_logging.md b/docs/trace_logging.md index 0139b3f2..31b1c7de 100644 --- a/docs/trace_logging.md +++ b/docs/trace_logging.md @@ -229,7 +229,7 @@ For an embedder to create a custom TraceLogging implementation: called frequently (especially `IsLoggingEnabled(TraceCategory)`) and are often in the critical execution path of the library's code. -2. *Call `openscreen::platform::StartTracing()` and `StopTracing()`* +2. *Call `openscreen::StartTracing()` and `StopTracing()`* These activate/deactivate tracing by providing the TraceLoggingPlatform instance and later clearing references to it. diff --git a/osp/demo/osp_demo.cc b/osp/demo/osp_demo.cc index 37c6bb43..daa5fa0c 100644 --- a/osp/demo/osp_demo.cc +++ b/osp/demo/osp_demo.cc @@ -36,9 +36,6 @@ #include "third_party/tinycbor/src/src/cbor.h" #include "util/trace_logging.h" -using openscreen::platform::Clock; -using openscreen::platform::PlatformClientPosix; - namespace { const char* kReceiverLogFilename = "_recv_fifo"; @@ -431,8 +428,7 @@ void ListenerDemo() { listener_config, &listener_observer, PlatformClientPosix::GetInstance()->GetTaskRunner()); - MessageDemuxer demuxer(platform::Clock::now, - MessageDemuxer::kDefaultBufferLimit); + MessageDemuxer demuxer(Clock::now, MessageDemuxer::kDefaultBufferLimit); DemoConnectionClientObserver client_observer; auto connection_client = ProtocolConnectionClientFactory::Create( &demuxer, &client_observer, @@ -440,7 +436,7 @@ void ListenerDemo() { auto* network_service = NetworkServiceManager::Create( std::move(mdns_listener), nullptr, std::move(connection_client), nullptr); - auto controller = std::make_unique<Controller>(platform::Clock::now); + auto controller = std::make_unique<Controller>(Clock::now); network_service->GetMdnsServiceListener()->Start(); network_service->GetProtocolConnectionClient()->Start(); @@ -524,8 +520,7 @@ void PublisherDemo(absl::string_view friendly_name) { PlatformClientPosix::GetInstance()->GetTaskRunner()); ServerConfig server_config; - for (const platform::InterfaceInfo& interface : - platform::GetNetworkInterfaces()) { + for (const InterfaceInfo& interface : GetNetworkInterfaces()) { OSP_VLOG << "Found interface: " << interface; if (!interface.addresses.empty()) { server_config.connection_endpoints.push_back( @@ -535,8 +530,7 @@ void PublisherDemo(absl::string_view friendly_name) { OSP_LOG_IF(WARN, server_config.connection_endpoints.empty()) << "No network interfaces had usable addresses for mDNS publishing."; - MessageDemuxer demuxer(platform::Clock::now, - MessageDemuxer::kDefaultBufferLimit); + MessageDemuxer demuxer(Clock::now, MessageDemuxer::kDefaultBufferLimit); DemoConnectionServerObserver server_observer; auto connection_server = ProtocolConnectionServerFactory::Create( server_config, &demuxer, &server_observer, @@ -588,7 +582,9 @@ InputArgs GetInputArgs(int argc, char** argv) { } int main(int argc, char** argv) { - using openscreen::platform::LogLevel; + using openscreen::Clock; + using openscreen::LogLevel; + using openscreen::PlatformClientPosix; std::cout << "Usage: osp_demo [-v] [friendly_name]" << std::endl << "-v: enable more verbose logging" << std::endl @@ -602,11 +598,11 @@ int main(int argc, char** argv) { const bool is_receiver_demo = !args.friendly_server_name.empty(); const char* log_filename = is_receiver_demo ? kReceiverLogFilename : kControllerLogFilename; - openscreen::platform::SetLogFifoOrDie(log_filename); + openscreen::SetLogFifoOrDie(log_filename); LogLevel level = args.is_verbose ? LogLevel::kVerbose : LogLevel::kInfo; - openscreen::platform::SetLogLevel(level); - openscreen::platform::TextTraceLoggingPlatform text_logging_platform; + openscreen::SetLogLevel(level); + openscreen::TextTraceLoggingPlatform text_logging_platform; PlatformClientPosix::Create(Clock::duration{50}, Clock::duration{50}); diff --git a/osp/impl/discovery/mdns/mdns_demo.cc b/osp/impl/discovery/mdns/mdns_demo.cc index 691658e0..a6c0e508 100644 --- a/osp/impl/discovery/mdns/mdns_demo.cc +++ b/osp/impl/discovery/mdns/mdns_demo.cc @@ -37,9 +37,6 @@ // shouldn't be expected to be a source of truth, nor should it be expected to // be correct after running for a long time. -using openscreen::platform::Clock; -using openscreen::platform::PlatformClientPosix; - namespace openscreen { namespace osp { namespace { @@ -59,22 +56,21 @@ struct Service { std::vector<std::string> txt; }; -class DemoSocketClient : public platform::UdpSocket::Client { +class DemoSocketClient : public UdpSocket::Client { public: DemoSocketClient(MdnsResponderAdapterImpl* mdns) : mdns_(mdns) {} - void OnError(platform::UdpSocket* socket, Error error) override { + void OnError(UdpSocket* socket, Error error) override { // TODO(crbug.com/openscreen/66): Change to OSP_LOG_FATAL. OSP_LOG_ERROR << "configuration failed for interface " << error.message(); OSP_CHECK(false); } - void OnSendError(platform::UdpSocket* socket, Error error) override { + void OnSendError(UdpSocket* socket, Error error) override { OSP_UNIMPLEMENTED(); } - void OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet) override { + void OnRead(UdpSocket* socket, ErrorOr<UdpPacket> packet) override { mdns_->OnRead(socket, std::move(packet)); } @@ -128,20 +124,20 @@ void SignalThings() { OSP_LOG << "signal handlers setup" << std::endl << "pid: " << getpid(); } -std::vector<platform::UdpSocketUniquePtr> SetUpMulticastSockets( - platform::TaskRunner* task_runner, - const std::vector<platform::NetworkInterfaceIndex>& index_list, - platform::UdpSocket::Client* client) { - std::vector<platform::UdpSocketUniquePtr> sockets; +std::vector<std::unique_ptr<UdpSocket>> SetUpMulticastSockets( + TaskRunner* task_runner, + const std::vector<NetworkInterfaceIndex>& index_list, + UdpSocket::Client* client) { + std::vector<std::unique_ptr<UdpSocket>> sockets; for (const auto ifindex : index_list) { auto create_result = - platform::UdpSocket::Create(task_runner, client, IPEndpoint{{}, 5353}); + UdpSocket::Create(task_runner, client, IPEndpoint{{}, 5353}); if (!create_result) { OSP_LOG_ERROR << "failed to create IPv4 socket for interface " << ifindex << ": " << create_result.error().message(); continue; } - platform::UdpSocketUniquePtr socket = std::move(create_result.value()); + std::unique_ptr<UdpSocket> socket = std::move(create_result.value()); socket->JoinMulticastGroup(IPAddress{224, 0, 0, 251}, ifindex); socket->SetMulticastOutboundInterface(ifindex); @@ -250,7 +246,7 @@ void HandleEvents(MdnsResponderAdapterImpl* mdns_adapter) { } } -void BrowseDemo(platform::TaskRunner* task_runner, +void BrowseDemo(TaskRunner* task_runner, const std::string& service_name, const std::string& service_protocol, const std::string& service_instance) { @@ -269,9 +265,8 @@ void BrowseDemo(platform::TaskRunner* task_runner, auto mdns_adapter = std::make_unique<MdnsResponderAdapterImpl>(); mdns_adapter->Init(); mdns_adapter->SetHostLabel("gigliorononomicon"); - const std::vector<platform::InterfaceInfo> interfaces = - platform::GetNetworkInterfaces(); - std::vector<platform::NetworkInterfaceIndex> index_list; + const std::vector<InterfaceInfo> interfaces = GetNetworkInterfaces(); + std::vector<NetworkInterfaceIndex> index_list; for (const auto& interface : interfaces) { OSP_LOG << "Found interface: " << interface; if (!interface.addresses.empty()) { @@ -290,10 +285,10 @@ void BrowseDemo(platform::TaskRunner* task_runner, // Listen on all interfaces. auto socket_it = sockets.begin(); - for (platform::NetworkInterfaceIndex index : index_list) { + for (NetworkInterfaceIndex index : index_list) { const auto& interface = *std::find_if(interfaces.begin(), interfaces.end(), - [index](const openscreen::platform::InterfaceInfo& info) { + [index](const openscreen::InterfaceInfo& info) { return info.index == index; }); // Pick any address for the given interface. @@ -308,7 +303,7 @@ void BrowseDemo(platform::TaskRunner* task_runner, {{"k1", "yurtle"}, {"k2", "turtle"}}); } - for (const platform::UdpSocketUniquePtr& socket : sockets) { + for (const std::unique_ptr<UdpSocket>& socket : sockets) { mdns_adapter->StartPtrQuery(socket.get(), service_type.value()); } @@ -332,7 +327,7 @@ void BrowseDemo(platform::TaskRunner* task_runner, for (const auto& s : *g_services) { LogService(s.second); } - for (const platform::UdpSocketUniquePtr& socket : sockets) { + for (const std::unique_ptr<UdpSocket>& socket : sockets) { mdns_adapter->DeregisterInterface(socket.get()); } mdns_adapter->Close(); @@ -343,7 +338,10 @@ void BrowseDemo(platform::TaskRunner* task_runner, } // namespace openscreen int main(int argc, char** argv) { - openscreen::platform::SetLogLevel(openscreen::platform::LogLevel::kVerbose); + using openscreen::Clock; + using openscreen::PlatformClientPosix; + + openscreen::SetLogLevel(openscreen::LogLevel::kVerbose); std::string service_instance; std::string service_type("_openscreen._udp"); diff --git a/osp/impl/discovery/mdns/mdns_responder_adapter.cc b/osp/impl/discovery/mdns/mdns_responder_adapter.cc index 810c7bbd..edf25503 100644 --- a/osp/impl/discovery/mdns/mdns_responder_adapter.cc +++ b/osp/impl/discovery/mdns/mdns_responder_adapter.cc @@ -9,7 +9,7 @@ namespace osp { QueryEventHeader::QueryEventHeader() = default; QueryEventHeader::QueryEventHeader(QueryEventHeader::Type response_type, - platform::UdpSocket* socket) + UdpSocket* socket) : response_type(response_type), socket(socket) {} QueryEventHeader::QueryEventHeader(QueryEventHeader&&) noexcept = default; QueryEventHeader::~QueryEventHeader() = default; diff --git a/osp/impl/discovery/mdns/mdns_responder_adapter.h b/osp/impl/discovery/mdns/mdns_responder_adapter.h index 376a9899..66083d57 100644 --- a/osp/impl/discovery/mdns/mdns_responder_adapter.h +++ b/osp/impl/discovery/mdns/mdns_responder_adapter.h @@ -29,13 +29,13 @@ struct QueryEventHeader { }; QueryEventHeader(); - QueryEventHeader(Type response_type, platform::UdpSocket* socket); + QueryEventHeader(Type response_type, UdpSocket* socket); QueryEventHeader(QueryEventHeader&&) noexcept; ~QueryEventHeader(); QueryEventHeader& operator=(QueryEventHeader&&) noexcept; Type response_type; - platform::UdpSocket* socket; + UdpSocket* socket; }; struct PtrEvent { @@ -160,7 +160,7 @@ enum class MdnsResponderErrorCode { // called after any sequence of calls to mDNSResponder. It also returns a // timeout value, after which it must be called again (e.g. for maintaining its // cache). -class MdnsResponderAdapter : public platform::UdpSocket::Client { +class MdnsResponderAdapter : public UdpSocket::Client { public: MdnsResponderAdapter(); virtual ~MdnsResponderAdapter() = 0; @@ -184,14 +184,14 @@ class MdnsResponderAdapter : public platform::UdpSocket::Client { // mDNSResponder. |socket| will be used to identify which interface received // the data in OnDataReceived and will be used to send data via the platform // layer. - virtual Error RegisterInterface(const platform::InterfaceInfo& interface_info, - const platform::IPSubnet& interface_address, - platform::UdpSocket* socket) = 0; - virtual Error DeregisterInterface(platform::UdpSocket* socket) = 0; + virtual Error RegisterInterface(const InterfaceInfo& interface_info, + const IPSubnet& interface_address, + UdpSocket* socket) = 0; + virtual Error DeregisterInterface(UdpSocket* socket) = 0; // Returns the time period after which this method must be called again, if // any. - virtual platform::Clock::duration RunTasks() = 0; + virtual Clock::duration RunTasks() = 0; virtual std::vector<PtrEvent> TakePtrResponses() = 0; virtual std::vector<SrvEvent> TakeSrvResponses() = 0; @@ -200,33 +200,33 @@ class MdnsResponderAdapter : public platform::UdpSocket::Client { virtual std::vector<AaaaEvent> TakeAaaaResponses() = 0; virtual MdnsResponderErrorCode StartPtrQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_type) = 0; virtual MdnsResponderErrorCode StartSrvQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) = 0; virtual MdnsResponderErrorCode StartTxtQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) = 0; - virtual MdnsResponderErrorCode StartAQuery(platform::UdpSocket* socket, + virtual MdnsResponderErrorCode StartAQuery(UdpSocket* socket, const DomainName& domain_name) = 0; virtual MdnsResponderErrorCode StartAaaaQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& domain_name) = 0; virtual MdnsResponderErrorCode StopPtrQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_type) = 0; virtual MdnsResponderErrorCode StopSrvQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) = 0; virtual MdnsResponderErrorCode StopTxtQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) = 0; - virtual MdnsResponderErrorCode StopAQuery(platform::UdpSocket* socket, + virtual MdnsResponderErrorCode StopAQuery(UdpSocket* socket, const DomainName& domain_name) = 0; virtual MdnsResponderErrorCode StopAaaaQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& domain_name) = 0; // The following methods concern advertising a service via mDNS. The diff --git a/osp/impl/discovery/mdns/mdns_responder_adapter_impl.cc b/osp/impl/discovery/mdns/mdns_responder_adapter_impl.cc index 6b986ded..57fd0b2d 100644 --- a/osp/impl/discovery/mdns/mdns_responder_adapter_impl.cc +++ b/osp/impl/discovery/mdns/mdns_responder_adapter_impl.cc @@ -13,8 +13,6 @@ #include "util/logging.h" #include "util/trace_logging.h" -using openscreen::platform::TraceCategory; - namespace openscreen { namespace osp { namespace { @@ -242,9 +240,9 @@ Error MdnsResponderAdapterImpl::SetHostLabel(const std::string& host_label) { } Error MdnsResponderAdapterImpl::RegisterInterface( - const platform::InterfaceInfo& interface_info, - const platform::IPSubnet& interface_address, - platform::UdpSocket* socket) { + const InterfaceInfo& interface_info, + const IPSubnet& interface_address, + UdpSocket* socket) { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::RegisterInterface"); OSP_DCHECK(socket); @@ -284,8 +282,7 @@ Error MdnsResponderAdapterImpl::RegisterInterface( : Error::Code::kMdnsRegisterFailure; } -Error MdnsResponderAdapterImpl::DeregisterInterface( - platform::UdpSocket* socket) { +Error MdnsResponderAdapterImpl::DeregisterInterface(UdpSocket* socket) { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::DeregisterInterface"); const auto info_it = responder_interface_info_.find(socket); @@ -304,14 +301,13 @@ Error MdnsResponderAdapterImpl::DeregisterInterface( responder_interface_info_.erase(info_it); return Error::None(); } -void MdnsResponderAdapterImpl::OnRead( - platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet_or_error) { +void MdnsResponderAdapterImpl::OnRead(UdpSocket* socket, + ErrorOr<UdpPacket> packet_or_error) { if (packet_or_error.is_error()) { return; } - platform::UdpPacket packet = std::move(packet_or_error.value()); + UdpPacket packet = std::move(packet_or_error.value()); TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::OnRead"); mDNSAddr src; if (packet.source().address.IsV4()) { @@ -341,19 +337,17 @@ void MdnsResponderAdapterImpl::OnRead( reinterpret_cast<mDNSInterfaceID>(packet.socket())); } -void MdnsResponderAdapterImpl::OnSendError(platform::UdpSocket* socket, - Error error) { +void MdnsResponderAdapterImpl::OnSendError(UdpSocket* socket, Error error) { // TODO(crbug.com/openscreen/67): Implement this method. OSP_UNIMPLEMENTED(); } -void MdnsResponderAdapterImpl::OnError(platform::UdpSocket* socket, - Error error) { +void MdnsResponderAdapterImpl::OnError(UdpSocket* socket, Error error) { // TODO(crbug.com/openscreen/67): Implement this method. OSP_UNIMPLEMENTED(); } -platform::Clock::duration MdnsResponderAdapterImpl::RunTasks() { +Clock::duration MdnsResponderAdapterImpl::RunTasks() { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::RunTasks"); mDNS_Execute(&mdns_); @@ -409,7 +403,7 @@ std::vector<AaaaEvent> MdnsResponderAdapterImpl::TakeAaaaResponses() { } MdnsResponderErrorCode MdnsResponderAdapterImpl::StartPtrQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_type) { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::StartPtrQuery"); auto& ptr_questions = socket_to_questions_[socket].ptr; @@ -456,7 +450,7 @@ MdnsResponderErrorCode MdnsResponderAdapterImpl::StartPtrQuery( } MdnsResponderErrorCode MdnsResponderAdapterImpl::StartSrvQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::StartSrvQuery"); if (!service_instance.EndsWithLocalDomain()) @@ -494,7 +488,7 @@ MdnsResponderErrorCode MdnsResponderAdapterImpl::StartSrvQuery( } MdnsResponderErrorCode MdnsResponderAdapterImpl::StartTxtQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::StartTxtQuery"); if (!service_instance.EndsWithLocalDomain()) @@ -532,7 +526,7 @@ MdnsResponderErrorCode MdnsResponderAdapterImpl::StartTxtQuery( } MdnsResponderErrorCode MdnsResponderAdapterImpl::StartAQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& domain_name) { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::StartAQuery"); if (!domain_name.EndsWithLocalDomain()) @@ -570,7 +564,7 @@ MdnsResponderErrorCode MdnsResponderAdapterImpl::StartAQuery( } MdnsResponderErrorCode MdnsResponderAdapterImpl::StartAaaaQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& domain_name) { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::StartAaaaQuery"); if (!domain_name.EndsWithLocalDomain()) @@ -608,7 +602,7 @@ MdnsResponderErrorCode MdnsResponderAdapterImpl::StartAaaaQuery( } MdnsResponderErrorCode MdnsResponderAdapterImpl::StopPtrQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_type) { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::StopPtrQuery"); auto interface_entry = socket_to_questions_.find(socket); @@ -626,7 +620,7 @@ MdnsResponderErrorCode MdnsResponderAdapterImpl::StopPtrQuery( } MdnsResponderErrorCode MdnsResponderAdapterImpl::StopSrvQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::StopSrvQuery"); auto interface_entry = socket_to_questions_.find(socket); @@ -644,7 +638,7 @@ MdnsResponderErrorCode MdnsResponderAdapterImpl::StopSrvQuery( } MdnsResponderErrorCode MdnsResponderAdapterImpl::StopTxtQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::StopTxtQuery"); auto interface_entry = socket_to_questions_.find(socket); @@ -662,7 +656,7 @@ MdnsResponderErrorCode MdnsResponderAdapterImpl::StopTxtQuery( } MdnsResponderErrorCode MdnsResponderAdapterImpl::StopAQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& domain_name) { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::StopAQuery"); auto interface_entry = socket_to_questions_.find(socket); @@ -680,7 +674,7 @@ MdnsResponderErrorCode MdnsResponderAdapterImpl::StopAQuery( } MdnsResponderErrorCode MdnsResponderAdapterImpl::StopAaaaQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& domain_name) { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::StopAaaaQuery"); auto interface_entry = socket_to_questions_.find(socket); @@ -834,8 +828,8 @@ void MdnsResponderAdapterImpl::AQueryCallback(mDNS* m, OSP_DCHECK_EQ(added, QC_addnocache); } adapter->a_responses_.emplace_back( - QueryEventHeader{event_type, reinterpret_cast<platform::UdpSocket*>( - answer->InterfaceID)}, + QueryEventHeader{event_type, + reinterpret_cast<UdpSocket*>(answer->InterfaceID)}, std::move(domain), address); } @@ -866,8 +860,8 @@ void MdnsResponderAdapterImpl::AaaaQueryCallback(mDNS* m, OSP_DCHECK_EQ(added, QC_addnocache); } adapter->aaaa_responses_.emplace_back( - QueryEventHeader{event_type, reinterpret_cast<platform::UdpSocket*>( - answer->InterfaceID)}, + QueryEventHeader{event_type, + reinterpret_cast<UdpSocket*>(answer->InterfaceID)}, std::move(domain), address); } @@ -897,8 +891,8 @@ void MdnsResponderAdapterImpl::PtrQueryCallback(mDNS* m, OSP_DCHECK_EQ(added, QC_addnocache); } adapter->ptr_responses_.emplace_back( - QueryEventHeader{event_type, reinterpret_cast<platform::UdpSocket*>( - answer->InterfaceID)}, + QueryEventHeader{event_type, + reinterpret_cast<UdpSocket*>(answer->InterfaceID)}, std::move(result)); } @@ -932,8 +926,8 @@ void MdnsResponderAdapterImpl::SrvQueryCallback(mDNS* m, OSP_DCHECK_EQ(added, QC_addnocache); } adapter->srv_responses_.emplace_back( - QueryEventHeader{event_type, reinterpret_cast<platform::UdpSocket*>( - answer->InterfaceID)}, + QueryEventHeader{event_type, + reinterpret_cast<UdpSocket*>(answer->InterfaceID)}, std::move(service), std::move(result), GetNetworkOrderPort(answer->rdata->u.srv.port)); } @@ -963,8 +957,8 @@ void MdnsResponderAdapterImpl::TxtQueryCallback(mDNS* m, OSP_DCHECK_EQ(added, QC_addnocache); } adapter->txt_responses_.emplace_back( - QueryEventHeader{event_type, reinterpret_cast<platform::UdpSocket*>( - answer->InterfaceID)}, + QueryEventHeader{event_type, + reinterpret_cast<UdpSocket*>(answer->InterfaceID)}, std::move(service), std::move(lines)); } @@ -995,7 +989,7 @@ void MdnsResponderAdapterImpl::AdvertiseInterfaces() { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderAdapterImpl::AdvertiseInterfaces"); for (auto& info : responder_interface_info_) { - platform::UdpSocket* socket = info.first; + UdpSocket* socket = info.first; NetworkInterfaceInfo& interface_info = info.second; mDNS_SetupResourceRecord(&interface_info.RR_A, /** RDataStorage */ nullptr, reinterpret_cast<mDNSInterfaceID>(socket), @@ -1027,8 +1021,7 @@ void MdnsResponderAdapterImpl::DeadvertiseInterfaces() { } } -void MdnsResponderAdapterImpl::RemoveQuestionsIfEmpty( - platform::UdpSocket* socket) { +void MdnsResponderAdapterImpl::RemoveQuestionsIfEmpty(UdpSocket* socket) { auto entry = socket_to_questions_.find(socket); bool empty = entry->second.a.empty() || entry->second.aaaa.empty() || entry->second.ptr.empty() || entry->second.srv.empty() || diff --git a/osp/impl/discovery/mdns/mdns_responder_adapter_impl.h b/osp/impl/discovery/mdns/mdns_responder_adapter_impl.h index 1e5ddeb0..80669e57 100644 --- a/osp/impl/discovery/mdns/mdns_responder_adapter_impl.h +++ b/osp/impl/discovery/mdns/mdns_responder_adapter_impl.h @@ -29,17 +29,16 @@ class MdnsResponderAdapterImpl final : public MdnsResponderAdapter { Error SetHostLabel(const std::string& host_label) override; - Error RegisterInterface(const platform::InterfaceInfo& interface_info, - const platform::IPSubnet& interface_address, - platform::UdpSocket* socket) override; - Error DeregisterInterface(platform::UdpSocket* socket) override; + Error RegisterInterface(const InterfaceInfo& interface_info, + const IPSubnet& interface_address, + UdpSocket* socket) override; + Error DeregisterInterface(UdpSocket* socket) override; - void OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet) override; - void OnSendError(platform::UdpSocket* socket, Error error) override; - void OnError(platform::UdpSocket* socket, Error error) override; + void OnRead(UdpSocket* socket, ErrorOr<UdpPacket> packet) override; + void OnSendError(UdpSocket* socket, Error error) override; + void OnError(UdpSocket* socket, Error error) override; - platform::Clock::duration RunTasks() override; + Clock::duration RunTasks() override; std::vector<PtrEvent> TakePtrResponses() override; std::vector<SrvEvent> TakeSrvResponses() override; @@ -47,29 +46,29 @@ class MdnsResponderAdapterImpl final : public MdnsResponderAdapter { std::vector<AEvent> TakeAResponses() override; std::vector<AaaaEvent> TakeAaaaResponses() override; - MdnsResponderErrorCode StartPtrQuery(platform::UdpSocket* socket, + MdnsResponderErrorCode StartPtrQuery(UdpSocket* socket, const DomainName& service_type) override; MdnsResponderErrorCode StartSrvQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) override; MdnsResponderErrorCode StartTxtQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) override; - MdnsResponderErrorCode StartAQuery(platform::UdpSocket* socket, + MdnsResponderErrorCode StartAQuery(UdpSocket* socket, const DomainName& domain_name) override; - MdnsResponderErrorCode StartAaaaQuery(platform::UdpSocket* socket, + MdnsResponderErrorCode StartAaaaQuery(UdpSocket* socket, const DomainName& domain_name) override; - MdnsResponderErrorCode StopPtrQuery(platform::UdpSocket* socket, + MdnsResponderErrorCode StopPtrQuery(UdpSocket* socket, const DomainName& service_type) override; MdnsResponderErrorCode StopSrvQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) override; MdnsResponderErrorCode StopTxtQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) override; - MdnsResponderErrorCode StopAQuery(platform::UdpSocket* socket, + MdnsResponderErrorCode StopAQuery(UdpSocket* socket, const DomainName& domain_name) override; - MdnsResponderErrorCode StopAaaaQuery(platform::UdpSocket* socket, + MdnsResponderErrorCode StopAaaaQuery(UdpSocket* socket, const DomainName& domain_name) override; MdnsResponderErrorCode RegisterService( @@ -124,7 +123,7 @@ class MdnsResponderAdapterImpl final : public MdnsResponderAdapter { void AdvertiseInterfaces(); void DeadvertiseInterfaces(); - void RemoveQuestionsIfEmpty(platform::UdpSocket* socket); + void RemoveQuestionsIfEmpty(UdpSocket* socket); CacheEntity rr_cache_[kRrCacheSize]; @@ -136,10 +135,9 @@ class MdnsResponderAdapterImpl final : public MdnsResponderAdapter { // platform sockets. mDNS_PlatformSupport platform_storage_; - std::map<platform::UdpSocket*, Questions> socket_to_questions_; + std::map<UdpSocket*, Questions> socket_to_questions_; - std::map<platform::UdpSocket*, NetworkInterfaceInfo> - responder_interface_info_; + std::map<UdpSocket*, NetworkInterfaceInfo> responder_interface_info_; std::vector<AEvent> a_responses_; std::vector<AaaaEvent> aaaa_responses_; diff --git a/osp/impl/discovery/mdns/mdns_responder_adapter_impl_unittest.cc b/osp/impl/discovery/mdns/mdns_responder_adapter_impl_unittest.cc index 759fe44d..29b76679 100644 --- a/osp/impl/discovery/mdns/mdns_responder_adapter_impl_unittest.cc +++ b/osp/impl/discovery/mdns/mdns_responder_adapter_impl_unittest.cc @@ -49,7 +49,7 @@ TEST(MdnsResponderAdapterImplTest, ExampleData) { 'p', 5, 'l', 'o', 'c', 'a', 'l', 0}}; const IPEndpoint mdns_endpoint{{224, 0, 0, 251}, 5353}; - platform::UdpPacket packet(std::begin(data), std::end(data)); + UdpPacket packet(std::begin(data), std::end(data)); packet.set_source({{192, 168, 0, 2}, 6556}); packet.set_destination(mdns_endpoint); packet.set_socket(nullptr); diff --git a/osp/impl/discovery/mdns/mdns_responder_platform.cc b/osp/impl/discovery/mdns/mdns_responder_platform.cc index 01603be4..c3fe2d25 100644 --- a/osp/impl/discovery/mdns/mdns_responder_platform.cc +++ b/osp/impl/discovery/mdns/mdns_responder_platform.cc @@ -18,7 +18,6 @@ #include "third_party/mDNSResponder/src/mDNSCore/mDNSEmbeddedAPI.h" #include "util/logging.h" -using openscreen::platform::Clock; using std::chrono::duration_cast; using std::chrono::hours; using std::chrono::milliseconds; @@ -44,8 +43,7 @@ mStatus mDNSPlatformSendUDP(const mDNS* m, UDPSocket* src, const mDNSAddr* dst, mDNSIPPort dstport) { - auto* const socket = - reinterpret_cast<openscreen::platform::UdpSocket*>(InterfaceID); + auto* const socket = reinterpret_cast<openscreen::UdpSocket*>(InterfaceID); const auto socket_it = std::find(m->p->sockets.begin(), m->p->sockets.end(), socket); if (socket_it == m->p->sockets.end()) @@ -111,6 +109,8 @@ mStatus mDNSPlatformTimeInit() { } mDNSs32 mDNSPlatformRawTime() { + using openscreen::Clock; + const Clock::time_point now = Clock::now(); // A signed 32-bit integer counting milliseconds only gives ~24.8 days of @@ -129,8 +129,7 @@ mDNSs32 mDNSPlatformRawTime() { mDNSs32 mDNSPlatformUTC() { const auto seconds_since_epoch = - duration_cast<seconds>(openscreen::platform::GetWallTimeSinceUnixEpoch()) - .count(); + duration_cast<seconds>(openscreen::GetWallTimeSinceUnixEpoch()).count(); // The return type will cause overflow in early 2038. Warn future developers // a year ahead of time. diff --git a/osp/impl/discovery/mdns/mdns_responder_platform.h b/osp/impl/discovery/mdns/mdns_responder_platform.h index afe04cd8..342913fe 100644 --- a/osp/impl/discovery/mdns/mdns_responder_platform.h +++ b/osp/impl/discovery/mdns/mdns_responder_platform.h @@ -10,7 +10,7 @@ #include "platform/api/udp_socket.h" struct mDNS_PlatformSupport_struct { - std::vector<openscreen::platform::UdpSocket*> sockets; + std::vector<openscreen::UdpSocket*> sockets; }; #endif // OSP_IMPL_DISCOVERY_MDNS_MDNS_RESPONDER_PLATFORM_H_ diff --git a/osp/impl/internal_services.cc b/osp/impl/internal_services.cc index 8a11ccd5..5441472f 100644 --- a/osp/impl/internal_services.cc +++ b/osp/impl/internal_services.cc @@ -37,8 +37,7 @@ class MdnsResponderAdapterImplFactory final } }; -Error SetUpMulticastSocket(platform::UdpSocket* socket, - platform::NetworkInterfaceIndex ifindex) { +Error SetUpMulticastSocket(UdpSocket* socket, NetworkInterfaceIndex ifindex) { const IPAddress broadcast_address = socket->IsIPv6() ? kMulticastIPv6Address : kMulticastAddress; @@ -60,7 +59,7 @@ int g_instance_ref_count = 0; std::unique_ptr<ServiceListener> InternalServices::CreateListener( const MdnsServiceListenerConfig& config, ServiceListener::Observer* observer, - platform::TaskRunner* task_runner) { + TaskRunner* task_runner) { auto* services = ReferenceSingleton(task_runner); auto listener = std::make_unique<ServiceListenerImpl>(&services->mdns_service_); @@ -74,7 +73,7 @@ std::unique_ptr<ServiceListener> InternalServices::CreateListener( std::unique_ptr<ServicePublisher> InternalServices::CreatePublisher( const ServicePublisher::Config& config, ServicePublisher::Observer* observer, - platform::TaskRunner* task_runner) { + TaskRunner* task_runner) { auto* services = ReferenceSingleton(task_runner); services->mdns_service_.SetServiceConfig( config.hostname, config.service_instance_name, @@ -99,11 +98,10 @@ InternalServices::InternalPlatformLinkage::~InternalPlatformLinkage() { std::vector<MdnsPlatformService::BoundInterface> InternalServices::InternalPlatformLinkage::RegisterInterfaces( - const std::vector<platform::NetworkInterfaceIndex>& whitelist) { - const std::vector<platform::InterfaceInfo> interfaces = - platform::GetNetworkInterfaces(); + const std::vector<NetworkInterfaceIndex>& whitelist) { + const std::vector<InterfaceInfo> interfaces = GetNetworkInterfaces(); const bool do_filter_using_whitelist = !whitelist.empty(); - std::vector<platform::NetworkInterfaceIndex> index_list; + std::vector<NetworkInterfaceIndex> index_list; for (const auto& interface : interfaces) { OSP_VLOG << "Found interface: " << interface; if (do_filter_using_whitelist && @@ -121,28 +119,26 @@ InternalServices::InternalPlatformLinkage::RegisterInterfaces( // Set up sockets to send and listen to mDNS multicast traffic on all // interfaces. std::vector<BoundInterface> result; - for (platform::NetworkInterfaceIndex index : index_list) { - const auto& interface = - *std::find_if(interfaces.begin(), interfaces.end(), - [index](const platform::InterfaceInfo& info) { - return info.index == index; - }); + for (NetworkInterfaceIndex index : index_list) { + const auto& interface = *std::find_if( + interfaces.begin(), interfaces.end(), + [index](const InterfaceInfo& info) { return info.index == index; }); if (interface.addresses.empty()) { continue; } // Pick any address for the given interface. - const platform::IPSubnet& primary_subnet = interface.addresses.front(); + const IPSubnet& primary_subnet = interface.addresses.front(); auto create_result = - platform::UdpSocket::Create(parent_->task_runner_, parent_, - IPEndpoint{{}, kMulticastListeningPort}); + UdpSocket::Create(parent_->task_runner_, parent_, + IPEndpoint{{}, kMulticastListeningPort}); if (!create_result) { OSP_LOG_ERROR << "failed to create socket for interface " << index << ": " << create_result.error().message(); continue; } - platform::UdpSocketUniquePtr socket = std::move(create_result.value()); + std::unique_ptr<UdpSocket> socket = std::move(create_result.value()); if (!SetUpMulticastSocket(socket.get(), index).ok()) { continue; } @@ -158,21 +154,20 @@ InternalServices::InternalPlatformLinkage::RegisterInterfaces( void InternalServices::InternalPlatformLinkage::DeregisterInterfaces( const std::vector<BoundInterface>& registered_interfaces) { for (const auto& interface : registered_interfaces) { - platform::UdpSocket* const socket = interface.socket; + UdpSocket* const socket = interface.socket; parent_->DeregisterMdnsSocket(socket); - const auto it = - std::find_if(open_sockets_.begin(), open_sockets_.end(), - [socket](const platform::UdpSocketUniquePtr& s) { - return s.get() == socket; - }); + const auto it = std::find_if(open_sockets_.begin(), open_sockets_.end(), + [socket](const std::unique_ptr<UdpSocket>& s) { + return s.get() == socket; + }); OSP_DCHECK(it != open_sockets_.end()); open_sockets_.erase(it); } } -InternalServices::InternalServices(platform::ClockNowFunctionPtr now_function, - platform::TaskRunner* task_runner) +InternalServices::InternalServices(ClockNowFunctionPtr now_function, + TaskRunner* task_runner) : mdns_service_(now_function, task_runner, kServiceName, @@ -183,23 +178,23 @@ InternalServices::InternalServices(platform::ClockNowFunctionPtr now_function, InternalServices::~InternalServices() = default; -void InternalServices::RegisterMdnsSocket(platform::UdpSocket* socket) { +void InternalServices::RegisterMdnsSocket(UdpSocket* socket) { OSP_CHECK(g_instance) << "No listener or publisher is alive."; // TODO(rwkeane): Hook this up to the new mDNS library once we swap out the // mDNSResponder. } -void InternalServices::DeregisterMdnsSocket(platform::UdpSocket* socket) { +void InternalServices::DeregisterMdnsSocket(UdpSocket* socket) { // TODO(rwkeane): Hook this up to the new mDNS library once we swap out the // mDNSResponder. } // static InternalServices* InternalServices::ReferenceSingleton( - platform::TaskRunner* task_runner) { + TaskRunner* task_runner) { if (!g_instance) { OSP_CHECK_EQ(g_instance_ref_count, 0); - g_instance = new InternalServices(&platform::Clock::now, task_runner); + g_instance = new InternalServices(&Clock::now, task_runner); } ++g_instance_ref_count; return g_instance; @@ -216,18 +211,17 @@ void InternalServices::DereferenceSingleton(void* instance) { } } -void InternalServices::OnError(platform::UdpSocket* socket, Error error) { +void InternalServices::OnError(UdpSocket* socket, Error error) { OSP_LOG_ERROR << "failed to configure socket " << error.message(); this->DeregisterMdnsSocket(socket); } -void InternalServices::OnSendError(platform::UdpSocket* socket, Error error) { +void InternalServices::OnSendError(UdpSocket* socket, Error error) { // TODO(crbug.com/openscreen/67): Implement this method. OSP_UNIMPLEMENTED(); } -void InternalServices::OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet) { +void InternalServices::OnRead(UdpSocket* socket, ErrorOr<UdpPacket> packet) { g_instance->mdns_service_.OnRead(socket, std::move(packet)); } diff --git a/osp/impl/internal_services.h b/osp/impl/internal_services.h index 5a1f015a..364c5963 100644 --- a/osp/impl/internal_services.h +++ b/osp/impl/internal_services.h @@ -25,9 +25,7 @@ namespace openscreen { -namespace platform { class TaskRunner; -} // namespace platform namespace osp { @@ -36,22 +34,21 @@ namespace osp { // event loop. // TODO(btolsch): This may be renamed and/or split up once QUIC code lands and // this use case is more concrete. -class InternalServices : platform::UdpSocket::Client { +class InternalServices : UdpSocket::Client { public: static std::unique_ptr<ServiceListener> CreateListener( const MdnsServiceListenerConfig& config, ServiceListener::Observer* observer, - platform::TaskRunner* task_runner); + TaskRunner* task_runner); static std::unique_ptr<ServicePublisher> CreatePublisher( const ServicePublisher::Config& config, ServicePublisher::Observer* observer, - platform::TaskRunner* task_runner); + TaskRunner* task_runner); // UdpSocket::Client overrides. - void OnError(platform::UdpSocket* socket, Error error) override; - void OnSendError(platform::UdpSocket* socket, Error error) override; - void OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet) override; + void OnError(UdpSocket* socket, Error error) override; + void OnSendError(UdpSocket* socket, Error error) override; + void OnRead(UdpSocket* socket, ErrorOr<UdpPacket> packet) override; private: class InternalPlatformLinkage final : public MdnsPlatformService { @@ -60,31 +57,29 @@ class InternalServices : platform::UdpSocket::Client { ~InternalPlatformLinkage() override; std::vector<BoundInterface> RegisterInterfaces( - const std::vector<platform::NetworkInterfaceIndex>& whitelist) override; + const std::vector<NetworkInterfaceIndex>& whitelist) override; void DeregisterInterfaces( const std::vector<BoundInterface>& registered_interfaces) override; private: InternalServices* const parent_; - std::vector<platform::UdpSocketUniquePtr> open_sockets_; + std::vector<std::unique_ptr<UdpSocket>> open_sockets_; }; // The TaskRunner provided here should live for the duration of this // InternalService object's lifetime. - InternalServices(platform::ClockNowFunctionPtr now_function, - platform::TaskRunner* task_runner); + InternalServices(ClockNowFunctionPtr now_function, TaskRunner* task_runner); ~InternalServices() override; - void RegisterMdnsSocket(platform::UdpSocket* socket); - void DeregisterMdnsSocket(platform::UdpSocket* socket); + void RegisterMdnsSocket(UdpSocket* socket); + void DeregisterMdnsSocket(UdpSocket* socket); - static InternalServices* ReferenceSingleton( - platform::TaskRunner* task_runner); + static InternalServices* ReferenceSingleton(TaskRunner* task_runner); static void DereferenceSingleton(void* instance); MdnsResponderService mdns_service_; - platform::TaskRunner* const task_runner_; + TaskRunner* const task_runner_; OSP_DISALLOW_COPY_AND_ASSIGN(InternalServices); }; diff --git a/osp/impl/mdns_platform_service.cc b/osp/impl/mdns_platform_service.cc index b4e6d8b8..e46829b8 100644 --- a/osp/impl/mdns_platform_service.cc +++ b/osp/impl/mdns_platform_service.cc @@ -12,9 +12,9 @@ namespace openscreen { namespace osp { MdnsPlatformService::BoundInterface::BoundInterface( - const platform::InterfaceInfo& interface_info, - const platform::IPSubnet& subnet, - platform::UdpSocket* socket) + const InterfaceInfo& interface_info, + const IPSubnet& subnet, + UdpSocket* socket) : interface_info(interface_info), subnet(subnet), socket(socket) { OSP_DCHECK(socket); } diff --git a/osp/impl/mdns_platform_service.h b/osp/impl/mdns_platform_service.h index 7cb6271f..ec6ca31b 100644 --- a/osp/impl/mdns_platform_service.h +++ b/osp/impl/mdns_platform_service.h @@ -16,23 +16,23 @@ namespace osp { class MdnsPlatformService { public: struct BoundInterface { - BoundInterface(const platform::InterfaceInfo& interface_info, - const platform::IPSubnet& subnet, - platform::UdpSocket* socket); + BoundInterface(const InterfaceInfo& interface_info, + const IPSubnet& subnet, + UdpSocket* socket); ~BoundInterface(); bool operator==(const BoundInterface& other) const; bool operator!=(const BoundInterface& other) const; - platform::InterfaceInfo interface_info; - platform::IPSubnet subnet; - platform::UdpSocket* socket; + InterfaceInfo interface_info; + IPSubnet subnet; + UdpSocket* socket; }; virtual ~MdnsPlatformService() = default; virtual std::vector<BoundInterface> RegisterInterfaces( - const std::vector<platform::NetworkInterfaceIndex>& whitelist) = 0; + const std::vector<NetworkInterfaceIndex>& whitelist) = 0; virtual void DeregisterInterfaces( const std::vector<BoundInterface>& registered_interfaces) = 0; }; diff --git a/osp/impl/mdns_responder_service.cc b/osp/impl/mdns_responder_service.cc index 347f1254..aca15e18 100644 --- a/osp/impl/mdns_responder_service.cc +++ b/osp/impl/mdns_responder_service.cc @@ -13,8 +13,6 @@ #include "util/logging.h" #include "util/trace_logging.h" -using openscreen::platform::TraceCategory; - namespace openscreen { namespace osp { namespace { @@ -33,8 +31,8 @@ std::string ServiceIdFromServiceInstanceName( } // namespace MdnsResponderService::MdnsResponderService( - platform::ClockNowFunctionPtr now_function, - platform::TaskRunner* task_runner, + ClockNowFunctionPtr now_function, + TaskRunner* task_runner, const std::string& service_name, const std::string& service_protocol, std::unique_ptr<MdnsResponderAdapterFactory> mdns_responder_factory, @@ -51,7 +49,7 @@ void MdnsResponderService::SetServiceConfig( const std::string& hostname, const std::string& instance, uint16_t port, - const std::vector<platform::NetworkInterfaceIndex> whitelist, + const std::vector<NetworkInterfaceIndex> whitelist, const std::map<std::string, std::string>& txt_data) { OSP_DCHECK(!hostname.empty()); OSP_DCHECK(!instance.empty()); @@ -63,8 +61,8 @@ void MdnsResponderService::SetServiceConfig( service_txt_data_ = txt_data; } -void MdnsResponderService::OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet) { +void MdnsResponderService::OnRead(UdpSocket* socket, + ErrorOr<UdpPacket> packet) { TRACE_SCOPED(TraceCategory::mDNS, "MdnsResponderService::OnRead"); if (!mdns_responder_) { return; @@ -74,12 +72,11 @@ void MdnsResponderService::OnRead(platform::UdpSocket* socket, HandleMdnsEvents(); } -void MdnsResponderService::OnSendError(platform::UdpSocket* socket, - Error error) { +void MdnsResponderService::OnSendError(UdpSocket* socket, Error error) { mdns_responder_->OnSendError(socket, std::move(error)); } -void MdnsResponderService::OnError(platform::UdpSocket* socket, Error error) { +void MdnsResponderService::OnError(UdpSocket* socket, Error error) { mdns_responder_->OnError(socket, std::move(error)); } @@ -334,7 +331,7 @@ void MdnsResponderService::StopListening() { } network_scoped_domain_to_host_.clear(); for (const auto& service : service_by_name_) { - platform::UdpSocket* const socket = service.second->ptr_socket; + UdpSocket* const socket = service.second->ptr_socket; mdns_responder_->StopSrvQuery(socket, service.first); mdns_responder_->StopTxtQuery(socket, service.first); } @@ -429,7 +426,7 @@ bool MdnsResponderService::HandlePtrEvent( InstanceNameSet* modified_instance_names) { bool events_possible = false; const auto& instance_name = ptr_event.service_instance; - platform::UdpSocket* const socket = ptr_event.header.socket; + UdpSocket* const socket = ptr_event.header.socket; auto entry = service_by_name_.find(ptr_event.service_instance); switch (ptr_event.header.response_type) { case QueryEventHeader::Type::kAddedNoCache: @@ -481,7 +478,7 @@ bool MdnsResponderService::HandleSrvEvent( bool events_possible = false; auto& domain_name = srv_event.domain_name; const auto& instance_name = srv_event.service_instance; - platform::UdpSocket* const socket = srv_event.header.socket; + UdpSocket* const socket = srv_event.header.socket; auto entry = service_by_name_.find(srv_event.service_instance); if (entry == service_by_name_.end()) return events_possible; @@ -568,7 +565,7 @@ bool MdnsResponderService::HandleTxtEvent( } bool MdnsResponderService::HandleAddressEvent( - platform::UdpSocket* socket, + UdpSocket* socket, QueryEventHeader::Type response_type, const DomainName& domain_name, bool a_event, @@ -619,14 +616,14 @@ bool MdnsResponderService::HandleAaaaEvent( } MdnsResponderService::HostInfo* MdnsResponderService::AddOrGetHostInfo( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& domain_name) { return &network_scoped_domain_to_host_[NetworkScopedDomainName{socket, domain_name}]; } MdnsResponderService::HostInfo* MdnsResponderService::GetHostInfo( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& domain_name) { auto kv = network_scoped_domain_to_host_.find( NetworkScopedDomainName{socket, domain_name}); @@ -642,16 +639,15 @@ bool MdnsResponderService::IsServiceReady(const ServiceInstance& instance, !instance.txt_info.empty() && (host->v4_address || host->v6_address)); } -platform::NetworkInterfaceIndex -MdnsResponderService::GetNetworkInterfaceIndexFromSocket( - const platform::UdpSocket* socket) const { +NetworkInterfaceIndex MdnsResponderService::GetNetworkInterfaceIndexFromSocket( + const UdpSocket* socket) const { auto it = std::find_if( bound_interfaces_.begin(), bound_interfaces_.end(), [socket](const MdnsPlatformService::BoundInterface& interface) { return interface.socket == socket; }); if (it == bound_interfaces_.end()) - return platform::kInvalidNetworkInterfaceIndex; + return kInvalidNetworkInterfaceIndex; return it->interface_info.index; } diff --git a/osp/impl/mdns_responder_service.h b/osp/impl/mdns_responder_service.h index c6ec126f..a010f5a6 100644 --- a/osp/impl/mdns_responder_service.h +++ b/osp/impl/mdns_responder_service.h @@ -34,29 +34,27 @@ class MdnsResponderAdapterFactory { class MdnsResponderService : public ServiceListenerImpl::Delegate, public ServicePublisherImpl::Delegate, - public platform::UdpSocket::Client { + public UdpSocket::Client { public: MdnsResponderService( - platform::ClockNowFunctionPtr now_function, - platform::TaskRunner* task_runner, + ClockNowFunctionPtr now_function, + TaskRunner* task_runner, const std::string& service_name, const std::string& service_protocol, std::unique_ptr<MdnsResponderAdapterFactory> mdns_responder_factory, std::unique_ptr<MdnsPlatformService> platform); virtual ~MdnsResponderService() override; - void SetServiceConfig( - const std::string& hostname, - const std::string& instance, - uint16_t port, - const std::vector<platform::NetworkInterfaceIndex> whitelist, - const std::map<std::string, std::string>& txt_data); + void SetServiceConfig(const std::string& hostname, + const std::string& instance, + uint16_t port, + const std::vector<NetworkInterfaceIndex> whitelist, + const std::map<std::string, std::string>& txt_data); // UdpSocket::Client overrides. - void OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet) override; - void OnSendError(platform::UdpSocket* socket, Error error) override; - void OnError(platform::UdpSocket* socket, Error error) override; + void OnRead(UdpSocket* socket, ErrorOr<UdpPacket> packet) override; + void OnSendError(UdpSocket* socket, Error error) override; + void OnError(UdpSocket* socket, Error error) override; // ServiceListenerImpl::Delegate overrides. void StartListener() override; @@ -98,7 +96,7 @@ class MdnsResponderService : public ServiceListenerImpl::Delegate, // NOTE: service_instance implicit in map key. struct ServiceInstance { - platform::UdpSocket* ptr_socket = nullptr; + UdpSocket* ptr_socket = nullptr; DomainName domain_name; uint16_t port = 0; bool has_ptr_record = false; @@ -116,7 +114,7 @@ class MdnsResponderService : public ServiceListenerImpl::Delegate, }; struct NetworkScopedDomainName { - platform::UdpSocket* socket; + UdpSocket* socket; DomainName domain_name; }; @@ -144,7 +142,7 @@ class MdnsResponderService : public ServiceListenerImpl::Delegate, InstanceNameSet* modified_instance_names); bool HandleTxtEvent(const TxtEvent& txt_event, InstanceNameSet* modified_instance_names); - bool HandleAddressEvent(platform::UdpSocket* socket, + bool HandleAddressEvent(UdpSocket* socket, QueryEventHeader::Type response_type, const DomainName& domain_name, bool a_event, @@ -155,13 +153,11 @@ class MdnsResponderService : public ServiceListenerImpl::Delegate, bool HandleAaaaEvent(const AaaaEvent& aaaa_event, InstanceNameSet* modified_instance_names); - HostInfo* AddOrGetHostInfo(platform::UdpSocket* socket, - const DomainName& domain_name); - HostInfo* GetHostInfo(platform::UdpSocket* socket, - const DomainName& domain_name); + HostInfo* AddOrGetHostInfo(UdpSocket* socket, const DomainName& domain_name); + HostInfo* GetHostInfo(UdpSocket* socket, const DomainName& domain_name); bool IsServiceReady(const ServiceInstance& instance, HostInfo* host) const; - platform::NetworkInterfaceIndex GetNetworkInterfaceIndexFromSocket( - const platform::UdpSocket* socket) const; + NetworkInterfaceIndex GetNetworkInterfaceIndexFromSocket( + const UdpSocket* socket) const; // Runs background tasks to manage the internal mDNS state. void RunBackgroundTasks(); @@ -175,7 +171,7 @@ class MdnsResponderService : public ServiceListenerImpl::Delegate, std::string service_hostname_; std::string service_instance_name_; uint16_t service_port_; - std::vector<platform::NetworkInterfaceIndex> interface_index_whitelist_; + std::vector<NetworkInterfaceIndex> interface_index_whitelist_; std::map<std::string, std::string> service_txt_data_; std::unique_ptr<MdnsResponderAdapterFactory> mdns_responder_factory_; @@ -199,7 +195,7 @@ class MdnsResponderService : public ServiceListenerImpl::Delegate, std::map<std::string, ServiceInfo> receiver_info_; - platform::TaskRunner* const task_runner_; + TaskRunner* const task_runner_; // Scheduled to run periodic background tasks. Alarm background_tasks_alarm_; diff --git a/osp/impl/mdns_responder_service_unittest.cc b/osp/impl/mdns_responder_service_unittest.cc index fe8e1239..5a9891ac 100644 --- a/osp/impl/mdns_responder_service_unittest.cc +++ b/osp/impl/mdns_responder_service_unittest.cc @@ -24,12 +24,12 @@ namespace osp { class TestingMdnsResponderService final : public MdnsResponderService { public: TestingMdnsResponderService( - platform::FakeTaskRunner* task_runner, + FakeTaskRunner* task_runner, const std::string& service_name, const std::string& service_protocol, std::unique_ptr<MdnsResponderAdapterFactory> mdns_responder_factory, std::unique_ptr<MdnsPlatformService> platform_service) - : MdnsResponderService(&platform::FakeClock::now, + : MdnsResponderService(&FakeClock::now, task_runner, service_name, service_protocol, @@ -172,10 +172,10 @@ class MockServicePublisherObserver final : public ServicePublisher::Observer { MOCK_METHOD1(OnMetrics, void(ServicePublisher::Metrics)); }; -platform::UdpSocket* const kDefaultSocket = - reinterpret_cast<platform::UdpSocket*>(static_cast<uintptr_t>(16)); -platform::UdpSocket* const kSecondSocket = - reinterpret_cast<platform::UdpSocket*>(static_cast<uintptr_t>(24)); +UdpSocket* const kDefaultSocket = + reinterpret_cast<UdpSocket*>(static_cast<uintptr_t>(16)); +UdpSocket* const kSecondSocket = + reinterpret_cast<UdpSocket*>(static_cast<uintptr_t>(24)); class MdnsResponderServiceTest : public ::testing::Test { protected: @@ -184,8 +184,8 @@ class MdnsResponderServiceTest : public ::testing::Test { std::make_unique<FakeMdnsResponderAdapterFactory>(); auto wrapper_factory = std::make_unique<WrapperMdnsResponderAdapterFactory>( mdns_responder_factory_.get()); - clock_ = std::make_unique<platform::FakeClock>(platform::Clock::now()); - task_runner_ = std::make_unique<platform::FakeTaskRunner>(clock_.get()); + clock_ = std::make_unique<FakeClock>(Clock::now()); + task_runner_ = std::make_unique<FakeTaskRunner>(clock_.get()); auto platform_service = std::make_unique<FakeMdnsPlatformService>(); fake_platform_service_ = platform_service.get(); fake_platform_service_->set_interfaces(bound_interfaces_); @@ -202,8 +202,8 @@ class MdnsResponderServiceTest : public ::testing::Test { &publisher_observer_, mdns_service_.get()); } - std::unique_ptr<platform::FakeClock> clock_; - std::unique_ptr<platform::FakeTaskRunner> task_runner_; + std::unique_ptr<FakeClock> clock_; + std::unique_ptr<FakeTaskRunner> task_runner_; MockServiceListenerObserver observer_; FakeMdnsPlatformService* fake_platform_service_; std::unique_ptr<FakeMdnsResponderAdapterFactory> mdns_responder_factory_; @@ -213,22 +213,22 @@ class MdnsResponderServiceTest : public ::testing::Test { std::unique_ptr<ServicePublisherImpl> service_publisher_; const uint8_t default_mac_[6] = {0, 11, 22, 33, 44, 55}; const uint8_t second_mac_[6] = {55, 33, 22, 33, 44, 77}; - const platform::IPSubnet default_subnet_{IPAddress{192, 168, 3, 2}, 24}; - const platform::IPSubnet second_subnet_{IPAddress{10, 0, 0, 3}, 24}; + const IPSubnet default_subnet_{IPAddress{192, 168, 3, 2}, 24}; + const IPSubnet second_subnet_{IPAddress{10, 0, 0, 3}, 24}; std::vector<MdnsPlatformService::BoundInterface> bound_interfaces_{ MdnsPlatformService::BoundInterface{ - platform::InterfaceInfo{1, - default_mac_, - "eth0", - platform::InterfaceInfo::Type::kEthernet, - {default_subnet_}}, + InterfaceInfo{1, + default_mac_, + "eth0", + InterfaceInfo::Type::kEthernet, + {default_subnet_}}, default_subnet_, kDefaultSocket}, MdnsPlatformService::BoundInterface{ - platform::InterfaceInfo{2, - second_mac_, - "eth1", - platform::InterfaceInfo::Type::kEthernet, - {second_subnet_}}, + InterfaceInfo{2, + second_mac_, + "eth1", + InterfaceInfo::Type::kEthernet, + {second_subnet_}}, second_subnet_, kSecondSocket}, }; }; @@ -284,10 +284,9 @@ TEST_F(MdnsResponderServiceTest, BasicServiceStates) { TEST_F(MdnsResponderServiceTest, NetworkNetworkInterfaceIndex) { constexpr uint8_t mac[6] = {12, 34, 56, 78, 90}; - const platform::IPSubnet subnet{IPAddress{10, 0, 0, 2}, 24}; + const IPSubnet subnet{IPAddress{10, 0, 0, 2}, 24}; bound_interfaces_.emplace_back( - platform::InterfaceInfo{ - 2, mac, "wlan0", platform::InterfaceInfo::Type::kWifi, {subnet}}, + InterfaceInfo{2, mac, "wlan0", InterfaceInfo::Type::kWifi, {subnet}}, subnet, kSecondSocket); fake_platform_service_->set_interfaces(bound_interfaces_); EXPECT_CALL(observer_, OnStarted()); diff --git a/osp/impl/mdns_service_listener_factory.cc b/osp/impl/mdns_service_listener_factory.cc index a94d8108..cae4a341 100644 --- a/osp/impl/mdns_service_listener_factory.cc +++ b/osp/impl/mdns_service_listener_factory.cc @@ -8,9 +8,7 @@ namespace openscreen { -namespace platform { class TaskRunner; -} // namespace platform namespace osp { @@ -18,7 +16,7 @@ namespace osp { std::unique_ptr<ServiceListener> MdnsServiceListenerFactory::Create( const MdnsServiceListenerConfig& config, ServiceListener::Observer* observer, - platform::TaskRunner* task_runner) { + TaskRunner* task_runner) { return InternalServices::CreateListener(config, observer, task_runner); } diff --git a/osp/impl/mdns_service_publisher_factory.cc b/osp/impl/mdns_service_publisher_factory.cc index cbd8d122..f055e772 100644 --- a/osp/impl/mdns_service_publisher_factory.cc +++ b/osp/impl/mdns_service_publisher_factory.cc @@ -8,9 +8,7 @@ namespace openscreen { -namespace platform { class TaskRunner; -} // namespace platform namespace osp { @@ -18,7 +16,7 @@ namespace osp { std::unique_ptr<ServicePublisher> MdnsServicePublisherFactory::Create( const ServicePublisher::Config& config, ServicePublisher::Observer* observer, - platform::TaskRunner* task_runner) { + TaskRunner* task_runner) { return InternalServices::CreatePublisher(config, observer, task_runner); } diff --git a/osp/impl/presentation/presentation_connection.cc b/osp/impl/presentation/presentation_connection.cc index 1bd6f408..9220b63b 100644 --- a/osp/impl/presentation/presentation_connection.cc +++ b/osp/impl/presentation/presentation_connection.cc @@ -181,13 +181,12 @@ void ConnectionManager::RemoveConnection(Connection* connection) { // TODO(jophba): refine the RegisterWatch/OnStreamMessage API. We // should add a layer between the message logic and the parse/dispatch // logic, and remove the CBOR information from ConnectionManager. -ErrorOr<size_t> ConnectionManager::OnStreamMessage( - uint64_t endpoint_id, - uint64_t connection_id, - msgs::Type message_type, - const uint8_t* buffer, - size_t buffer_size, - platform::Clock::time_point now) { +ErrorOr<size_t> ConnectionManager::OnStreamMessage(uint64_t endpoint_id, + uint64_t connection_id, + msgs::Type message_type, + const uint8_t* buffer, + size_t buffer_size, + Clock::time_point now) { switch (message_type) { case msgs::Type::kPresentationConnectionMessage: { msgs::PresentationConnectionMessage message; diff --git a/osp/impl/presentation/presentation_connection_unittest.cc b/osp/impl/presentation/presentation_connection_unittest.cc index 6f611dda..f4c829a4 100644 --- a/osp/impl/presentation/presentation_connection_unittest.cc +++ b/osp/impl/presentation/presentation_connection_unittest.cc @@ -58,12 +58,11 @@ class MockConnectRequest final class ConnectionTest : public ::testing::Test { public: ConnectionTest() { - fake_clock_ = std::make_unique<platform::FakeClock>( - platform::Clock::time_point(std::chrono::milliseconds(1298424))); - task_runner_ = - std::make_unique<platform::FakeTaskRunner>(fake_clock_.get()); - quic_bridge_ = std::make_unique<FakeQuicBridge>(task_runner_.get(), - platform::FakeClock::now); + fake_clock_ = std::make_unique<FakeClock>( + Clock::time_point(std::chrono::milliseconds(1298424))); + task_runner_ = std::make_unique<FakeTaskRunner>(fake_clock_.get()); + quic_bridge_ = + std::make_unique<FakeQuicBridge>(task_runner_.get(), FakeClock::now); controller_connection_manager_ = std::make_unique<ConnectionManager>( quic_bridge_->controller_demuxer.get()); receiver_connection_manager_ = std::make_unique<ConnectionManager>( @@ -89,8 +88,8 @@ class ConnectionTest : public ::testing::Test { return response; } - std::unique_ptr<platform::FakeClock> fake_clock_; - std::unique_ptr<platform::FakeTaskRunner> task_runner_; + std::unique_ptr<FakeClock> fake_clock_; + std::unique_ptr<FakeTaskRunner> task_runner_; std::unique_ptr<FakeQuicBridge> quic_bridge_; std::unique_ptr<ConnectionManager> controller_connection_manager_; std::unique_ptr<ConnectionManager> receiver_connection_manager_; diff --git a/osp/impl/presentation/presentation_controller.cc b/osp/impl/presentation/presentation_controller.cc index 5a54cb2b..94ee4e2d 100644 --- a/osp/impl/presentation/presentation_controller.cc +++ b/osp/impl/presentation/presentation_controller.cc @@ -418,7 +418,7 @@ void swap(Controller::ConnectRequest& a, Controller::ConnectRequest& b) { swap(a.controller_, b.controller_); } -Controller::Controller(platform::ClockNowFunctionPtr now_function) { +Controller::Controller(ClockNowFunctionPtr now_function) { availability_requester_ = std::make_unique<UrlAvailabilityRequester>(now_function); connection_manager_ = @@ -621,7 +621,7 @@ class Controller::TerminationListener final msgs::Type message_type, const uint8_t* buffer, size_t buffer_size, - platform::Clock::time_point now) override; + Clock::time_point now) override; private: Controller* const controller_; @@ -650,7 +650,7 @@ ErrorOr<size_t> Controller::TerminationListener::OnStreamMessage( msgs::Type message_type, const uint8_t* buffer, size_t buffer_size, - platform::Clock::time_point now) { + Clock::time_point now) { OSP_CHECK_EQ(static_cast<int>(msgs::Type::kPresentationTerminationEvent), static_cast<int>(message_type)); msgs::PresentationTerminationEvent event; diff --git a/osp/impl/presentation/presentation_controller_unittest.cc b/osp/impl/presentation/presentation_controller_unittest.cc index 5b32c12f..bad4c666 100644 --- a/osp/impl/presentation/presentation_controller_unittest.cc +++ b/osp/impl/presentation/presentation_controller_unittest.cc @@ -77,12 +77,11 @@ class MockRequestDelegate final : public RequestDelegate { class ControllerTest : public ::testing::Test { public: ControllerTest() { - fake_clock_ = std::make_unique<platform::FakeClock>( - platform::Clock::time_point(seconds(11111))); - task_runner_ = - std::make_unique<platform::FakeTaskRunner>(fake_clock_.get()); - quic_bridge_ = std::make_unique<FakeQuicBridge>(task_runner_.get(), - platform::FakeClock::now); + fake_clock_ = + std::make_unique<FakeClock>(Clock::time_point(seconds(11111))); + task_runner_ = std::make_unique<FakeTaskRunner>(fake_clock_.get()); + quic_bridge_ = + std::make_unique<FakeQuicBridge>(task_runner_.get(), FakeClock::now); receiver_info1 = { "service-id1", "lucas-auer", 1, quic_bridge_->kReceiverEndpoint, {}}; } @@ -94,7 +93,7 @@ class ControllerTest : public ::testing::Test { NetworkServiceManager::Create(std::move(service_listener), nullptr, std::move(quic_bridge_->quic_client), std::move(quic_bridge_->quic_server)); - controller_ = std::make_unique<Controller>(platform::FakeClock::now); + controller_ = std::make_unique<Controller>(FakeClock::now); ON_CALL(quic_bridge_->mock_server_observer, OnIncomingConnectionMock(_)) .WillByDefault( Invoke([this](std::unique_ptr<ProtocolConnection>& connection) { @@ -117,16 +116,15 @@ class ControllerTest : public ::testing::Test { ssize_t decode_result = -1; msgs::Type msg_type; EXPECT_CALL(mock_callback_, OnStreamMessage(_, _, _, _, _, _)) - .WillOnce( - Invoke([request, &msg_type, &decode_result]( - uint64_t endpoint_id, uint64_t cid, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - msg_type = message_type; - decode_result = msgs::DecodePresentationUrlAvailabilityRequest( - buffer, buffer_size, request); - return decode_result; - })); + .WillOnce(Invoke([request, &msg_type, &decode_result]( + uint64_t endpoint_id, uint64_t cid, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + msg_type = message_type; + decode_result = msgs::DecodePresentationUrlAvailabilityRequest( + buffer, buffer_size, request); + return decode_result; + })); quic_bridge_->RunTasksUntilIdle(); ASSERT_EQ(msg_type, msgs::Type::kPresentationUrlAvailabilityRequest); ASSERT_GT(decode_result, 0); @@ -206,16 +204,15 @@ class ControllerTest : public ::testing::Test { ssize_t decode_result = -1; msgs::Type msg_type; EXPECT_CALL(*mock_callback, OnStreamMessage(_, _, _, _, _, _)) - .WillOnce( - Invoke([request, &msg_type, &decode_result]( - uint64_t endpoint_id, uint64_t cid, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - msg_type = message_type; - decode_result = msgs::DecodePresentationConnectionCloseRequest( - buffer, buffer_size, request); - return decode_result; - })); + .WillOnce(Invoke([request, &msg_type, &decode_result]( + uint64_t endpoint_id, uint64_t cid, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + msg_type = message_type; + decode_result = msgs::DecodePresentationConnectionCloseRequest( + buffer, buffer_size, request); + return decode_result; + })); connection->Close(Connection::CloseReason::kClosed); EXPECT_EQ(connection->state(), Connection::State::kClosed); quic_bridge_->RunTasksUntilIdle(); @@ -264,16 +261,15 @@ class ControllerTest : public ::testing::Test { msgs::PresentationStartRequest request; msgs::Type msg_type; EXPECT_CALL(*mock_callback, OnStreamMessage(_, _, _, _, _, _)) - .WillOnce( - Invoke([&request, &msg_type]( - uint64_t endpoint_id, uint64_t cid, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - msg_type = message_type; - ssize_t result = msgs::DecodePresentationStartRequest( - buffer, buffer_size, &request); - return result; - })); + .WillOnce(Invoke([&request, &msg_type]( + uint64_t endpoint_id, uint64_t cid, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + msg_type = message_type; + ssize_t result = msgs::DecodePresentationStartRequest( + buffer, buffer_size, &request); + return result; + })); Controller::ConnectRequest connect_request = controller_->StartPresentation( "https://example.com/receiver.html", receiver_info1.service_id, &mock_request_delegate, mock_connection_delegate); @@ -297,8 +293,8 @@ class ControllerTest : public ::testing::Test { ASSERT_TRUE(*connection); } - std::unique_ptr<platform::FakeClock> fake_clock_; - std::unique_ptr<platform::FakeTaskRunner> task_runner_; + std::unique_ptr<FakeClock> fake_clock_; + std::unique_ptr<FakeTaskRunner> task_runner_; MessageDemuxer::MessageWatch availability_watch_; MockMessageCallback mock_callback_; std::unique_ptr<FakeQuicBridge> quic_bridge_; @@ -413,16 +409,15 @@ TEST_F(ControllerTest, TerminatePresentationFromController) { msgs::PresentationTerminationRequest termination_request; msgs::Type msg_type; EXPECT_CALL(mock_callback, OnStreamMessage(_, _, _, _, _, _)) - .WillOnce( - Invoke([&termination_request, &msg_type]( - uint64_t endpoint_id, uint64_t cid, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - msg_type = message_type; - ssize_t result = msgs::DecodePresentationTerminationRequest( - buffer, buffer_size, &termination_request); - return result; - })); + .WillOnce(Invoke([&termination_request, &msg_type]( + uint64_t endpoint_id, uint64_t cid, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + msg_type = message_type; + ssize_t result = msgs::DecodePresentationTerminationRequest( + buffer, buffer_size, &termination_request); + return result; + })); connection->Terminate(TerminationReason::kControllerTerminateCalled); quic_bridge_->RunTasksUntilIdle(); @@ -505,16 +500,15 @@ TEST_F(ControllerTest, Reconnect) { ssize_t decode_result = -1; msgs::Type msg_type; EXPECT_CALL(mock_callback, OnStreamMessage(_, _, _, _, _, _)) - .WillOnce( - Invoke([&open_request, &msg_type, &decode_result]( - uint64_t endpoint_id, uint64_t cid, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - msg_type = message_type; - decode_result = msgs::DecodePresentationConnectionOpenRequest( - buffer, buffer_size, &open_request); - return decode_result; - })); + .WillOnce(Invoke([&open_request, &msg_type, &decode_result]( + uint64_t endpoint_id, uint64_t cid, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + msg_type = message_type; + decode_result = msgs::DecodePresentationConnectionOpenRequest( + buffer, buffer_size, &open_request); + return decode_result; + })); quic_bridge_->RunTasksUntilIdle(); ASSERT_FALSE(connection); diff --git a/osp/impl/presentation/presentation_receiver.cc b/osp/impl/presentation/presentation_receiver.cc index 17babae0..162642c0 100644 --- a/osp/impl/presentation/presentation_receiver.cc +++ b/osp/impl/presentation/presentation_receiver.cc @@ -16,8 +16,6 @@ #include "util/logging.h" #include "util/trace_logging.h" -using openscreen::platform::TraceCategory; - namespace openscreen { namespace osp { namespace { @@ -107,7 +105,7 @@ ErrorOr<size_t> Receiver::OnStreamMessage(uint64_t endpoint_id, msgs::Type message_type, const uint8_t* buffer, size_t buffer_size, - platform::Clock::time_point now) { + Clock::time_point now) { TRACE_SCOPED(TraceCategory::Presentation, "Receiver::OnStreamMessage"); switch (message_type) { case msgs::Type::kPresentationUrlAvailabilityRequest: { diff --git a/osp/impl/presentation/presentation_receiver_unittest.cc b/osp/impl/presentation/presentation_receiver_unittest.cc index 098df0d3..173b9fd5 100644 --- a/osp/impl/presentation/presentation_receiver_unittest.cc +++ b/osp/impl/presentation/presentation_receiver_unittest.cc @@ -69,12 +69,11 @@ class MockReceiverDelegate final : public ReceiverDelegate { class PresentationReceiverTest : public ::testing::Test { public: PresentationReceiverTest() { - fake_clock_ = std::make_unique<platform::FakeClock>( - platform::Clock::time_point(std::chrono::milliseconds(1298424))); - task_runner_ = - std::make_unique<platform::FakeTaskRunner>(fake_clock_.get()); - quic_bridge_ = std::make_unique<FakeQuicBridge>(task_runner_.get(), - platform::FakeClock::now); + fake_clock_ = std::make_unique<FakeClock>( + Clock::time_point(std::chrono::milliseconds(1298424))); + task_runner_ = std::make_unique<FakeTaskRunner>(fake_clock_.get()); + quic_bridge_ = + std::make_unique<FakeQuicBridge>(task_runner_.get(), FakeClock::now); } protected: @@ -103,8 +102,8 @@ class PresentationReceiverTest : public ::testing::Test { NetworkServiceManager::Dispose(); } - std::unique_ptr<platform::FakeClock> fake_clock_; - std::unique_ptr<platform::FakeTaskRunner> task_runner_; + std::unique_ptr<FakeClock> fake_clock_; + std::unique_ptr<FakeTaskRunner> task_runner_; const std::string url1_{"https://www.example.com/receiver.html"}; std::unique_ptr<FakeQuicBridge> quic_bridge_; MockReceiverDelegate mock_receiver_delegate_; @@ -142,14 +141,14 @@ TEST_F(PresentationReceiverTest, QueryAvailability) { msgs::PresentationUrlAvailabilityResponse response; EXPECT_CALL(mock_callback, OnStreamMessage(_, _, _, _, _, _)) - .WillOnce(Invoke([&response](uint64_t endpoint_id, uint64_t cid, - msgs::Type message_type, - const uint8_t* buffer, size_t buffer_size, - platform::Clock::time_point now) { - ssize_t result = msgs::DecodePresentationUrlAvailabilityResponse( - buffer, buffer_size, &response); - return result; - })); + .WillOnce( + Invoke([&response](uint64_t endpoint_id, uint64_t cid, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + ssize_t result = msgs::DecodePresentationUrlAvailabilityResponse( + buffer, buffer_size, &response); + return result; + })); quic_bridge_->RunTasksUntilIdle(); EXPECT_EQ(request.request_id, response.request_id); EXPECT_EQ( @@ -190,14 +189,14 @@ TEST_F(PresentationReceiverTest, StartPresentation) { ResponseResult::kSuccess); msgs::PresentationStartResponse response; EXPECT_CALL(mock_callback, OnStreamMessage(_, _, _, _, _, _)) - .WillOnce(Invoke([&response](uint64_t endpoint_id, uint64_t cid, - msgs::Type message_type, - const uint8_t* buffer, size_t buffer_size, - platform::Clock::time_point now) { - ssize_t result = msgs::DecodePresentationStartResponse( - buffer, buffer_size, &response); - return result; - })); + .WillOnce( + Invoke([&response](uint64_t endpoint_id, uint64_t cid, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + ssize_t result = msgs::DecodePresentationStartResponse( + buffer, buffer_size, &response); + return result; + })); quic_bridge_->RunTasksUntilIdle(); EXPECT_EQ(msgs::Result::kSuccess, response.result); EXPECT_EQ(connection.connection_id(), response.connection_id); diff --git a/osp/impl/presentation/url_availability_requester.cc b/osp/impl/presentation/url_availability_requester.cc index 9213447c..b5e3bae7 100644 --- a/osp/impl/presentation/url_availability_requester.cc +++ b/osp/impl/presentation/url_availability_requester.cc @@ -12,7 +12,6 @@ #include "osp/public/network_service_manager.h" #include "util/logging.h" -using openscreen::platform::Clock; using std::chrono::seconds; namespace openscreen { @@ -48,7 +47,7 @@ uint64_t GetNextRequestId(const uint64_t endpoint_id) { } // namespace UrlAvailabilityRequester::UrlAvailabilityRequester( - platform::ClockNowFunctionPtr now_function) + ClockNowFunctionPtr now_function) : now_function_(now_function) { OSP_DCHECK(now_function_); } diff --git a/osp/impl/presentation/url_availability_requester.h b/osp/impl/presentation/url_availability_requester.h index 82f5bb6b..dd0309a5 100644 --- a/osp/impl/presentation/url_availability_requester.h +++ b/osp/impl/presentation/url_availability_requester.h @@ -29,7 +29,7 @@ namespace osp { // given URL. class UrlAvailabilityRequester { public: - explicit UrlAvailabilityRequester(platform::ClockNowFunctionPtr now_function); + explicit UrlAvailabilityRequester(ClockNowFunctionPtr now_function); ~UrlAvailabilityRequester(); // Adds a persistent availability request for |urls| to all known receivers. @@ -63,7 +63,7 @@ class UrlAvailabilityRequester { // Ensures that all open availability watches (to all receivers) that are // about to expire are refreshed by sending a new request with the same URLs. // Returns the time point at which this should next be scheduled to run. - platform::Clock::time_point RefreshWatches(); + Clock::time_point RefreshWatches(); private: // Handles Presentation API URL availability requests and watches for one @@ -82,7 +82,7 @@ class UrlAvailabilityRequester { }; struct Watch { - platform::Clock::time_point deadline; + Clock::time_point deadline; std::vector<std::string> urls; }; @@ -97,7 +97,7 @@ class UrlAvailabilityRequester { void RequestUrlAvailabilities(std::vector<std::string> urls); ErrorOr<uint64_t> SendRequest(uint64_t request_id, const std::vector<std::string>& urls); - platform::Clock::time_point RefreshWatches(platform::Clock::time_point now); + Clock::time_point RefreshWatches(Clock::time_point now); Error::Code UpdateAvailabilities( const std::vector<std::string>& urls, const std::vector<msgs::UrlAvailability>& availabilities); @@ -117,7 +117,7 @@ class UrlAvailabilityRequester { msgs::Type message_type, const uint8_t* buffer, size_t buffer_size, - platform::Clock::time_point now) override; + Clock::time_point now) override; UrlAvailabilityRequester* const listener; @@ -138,7 +138,7 @@ class UrlAvailabilityRequester { std::map<std::string, msgs::UrlAvailability> known_availability_by_url; }; - const platform::ClockNowFunctionPtr now_function_; + const ClockNowFunctionPtr now_function_; std::map<std::string, std::vector<ReceiverObserver*>> observers_by_url_; diff --git a/osp/impl/presentation/url_availability_requester_unittest.cc b/osp/impl/presentation/url_availability_requester_unittest.cc index a0e19639..578c8612 100644 --- a/osp/impl/presentation/url_availability_requester_unittest.cc +++ b/osp/impl/presentation/url_availability_requester_unittest.cc @@ -46,12 +46,11 @@ class MockReceiverObserver : public ReceiverObserver { class UrlAvailabilityRequesterTest : public Test { public: UrlAvailabilityRequesterTest() { - fake_clock_ = std::make_unique<platform::FakeClock>( - platform::Clock::time_point(milliseconds(1298424))); - task_runner_ = - std::make_unique<platform::FakeTaskRunner>(fake_clock_.get()); - quic_bridge_ = std::make_unique<FakeQuicBridge>(task_runner_.get(), - platform::FakeClock::now); + fake_clock_ = + std::make_unique<FakeClock>(Clock::time_point(milliseconds(1298424))); + task_runner_ = std::make_unique<FakeTaskRunner>(fake_clock_.get()); + quic_bridge_ = + std::make_unique<FakeQuicBridge>(task_runner_.get(), FakeClock::now); info1_ = {service_id_, friendly_name_, 1, quic_bridge_->kReceiverEndpoint}; } @@ -86,16 +85,16 @@ class UrlAvailabilityRequesterTest : public Test { void ExpectStreamMessage(MockMessageCallback* mock_callback, msgs::PresentationUrlAvailabilityRequest* request) { EXPECT_CALL(*mock_callback, OnStreamMessage(_, _, _, _, _, _)) - .WillOnce(Invoke([request](uint64_t endpoint_id, uint64_t cid, - msgs::Type message_type, - const uint8_t* buffer, size_t buffer_size, - platform::Clock::time_point now) { - ssize_t request_result_size = - msgs::DecodePresentationUrlAvailabilityRequest( - buffer, buffer_size, request); - OSP_DCHECK_GT(request_result_size, 0); - return request_result_size; - })); + .WillOnce( + Invoke([request](uint64_t endpoint_id, uint64_t cid, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + ssize_t request_result_size = + msgs::DecodePresentationUrlAvailabilityRequest( + buffer, buffer_size, request); + OSP_DCHECK_GT(request_result_size, 0); + return request_result_size; + })); } void SendAvailabilityResponse( @@ -126,12 +125,12 @@ class UrlAvailabilityRequesterTest : public Test { stream->Write(buffer.data(), buffer.size()); } - std::unique_ptr<platform::FakeClock> fake_clock_; - std::unique_ptr<platform::FakeTaskRunner> task_runner_; + std::unique_ptr<FakeClock> fake_clock_; + std::unique_ptr<FakeTaskRunner> task_runner_; MockMessageCallback mock_callback_; MessageDemuxer::MessageWatch availability_watch_; std::unique_ptr<FakeQuicBridge> quic_bridge_; - UrlAvailabilityRequester listener_{platform::FakeClock::now}; + UrlAvailabilityRequester listener_{FakeClock::now}; std::string url1_{"https://example.com/foo.html"}; std::string url2_{"https://example.com/bar.html"}; diff --git a/osp/impl/protocol_connection_client_factory.cc b/osp/impl/protocol_connection_client_factory.cc index 90b14590..c4a72b79 100644 --- a/osp/impl/protocol_connection_client_factory.cc +++ b/osp/impl/protocol_connection_client_factory.cc @@ -20,10 +20,10 @@ std::unique_ptr<ProtocolConnectionClient> ProtocolConnectionClientFactory::Create( MessageDemuxer* demuxer, ProtocolConnectionServiceObserver* observer, - platform::TaskRunner* task_runner) { + TaskRunner* task_runner) { return std::make_unique<QuicClient>( demuxer, std::make_unique<QuicConnectionFactoryImpl>(task_runner), - observer, &platform::Clock::now, task_runner); + observer, &Clock::now, task_runner); } } // namespace osp diff --git a/osp/impl/protocol_connection_server_factory.cc b/osp/impl/protocol_connection_server_factory.cc index e0a3b034..2984429c 100644 --- a/osp/impl/protocol_connection_server_factory.cc +++ b/osp/impl/protocol_connection_server_factory.cc @@ -21,10 +21,10 @@ ProtocolConnectionServerFactory::Create( const ServerConfig& config, MessageDemuxer* demuxer, ProtocolConnectionServer::Observer* observer, - platform::TaskRunner* task_runner) { + TaskRunner* task_runner) { return std::make_unique<QuicServer>( config, demuxer, std::make_unique<QuicConnectionFactoryImpl>(task_runner), - observer, &platform::Clock::now, task_runner); + observer, &Clock::now, task_runner); } } // namespace osp diff --git a/osp/impl/quic/quic_client.cc b/osp/impl/quic/quic_client.cc index 41303ad7..7d0a3103 100644 --- a/osp/impl/quic/quic_client.cc +++ b/osp/impl/quic/quic_client.cc @@ -19,8 +19,8 @@ QuicClient::QuicClient( MessageDemuxer* demuxer, std::unique_ptr<QuicConnectionFactory> connection_factory, ProtocolConnectionServiceObserver* observer, - platform::ClockNowFunctionPtr now_function, - platform::TaskRunner* task_runner) + ClockNowFunctionPtr now_function, + TaskRunner* task_runner) : ProtocolConnectionClient(demuxer, observer), connection_factory_(std::move(connection_factory)), cleanup_alarm_(now_function, task_runner) {} @@ -63,8 +63,7 @@ void QuicClient::Cleanup() { } delete_connections_.clear(); - constexpr platform::Clock::duration kQuicCleanupPeriod = - std::chrono::milliseconds(500); + constexpr Clock::duration kQuicCleanupPeriod = std::chrono::milliseconds(500); if (state_ != State::kStopped) { cleanup_alarm_.ScheduleFromNow([this] { Cleanup(); }, kQuicCleanupPeriod); } diff --git a/osp/impl/quic/quic_client.h b/osp/impl/quic/quic_client.h index 50fb5503..7e37267d 100644 --- a/osp/impl/quic/quic_client.h +++ b/osp/impl/quic/quic_client.h @@ -43,8 +43,8 @@ class QuicClient final : public ProtocolConnectionClient, QuicClient(MessageDemuxer* demuxer, std::unique_ptr<QuicConnectionFactory> connection_factory, ProtocolConnectionServiceObserver* observer, - platform::ClockNowFunctionPtr now_function, - platform::TaskRunner* task_runner); + ClockNowFunctionPtr now_function, + TaskRunner* task_runner); ~QuicClient() override; // ProtocolConnectionClient overrides. diff --git a/osp/impl/quic/quic_client_unittest.cc b/osp/impl/quic/quic_client_unittest.cc index 954fa11c..71a74ab4 100644 --- a/osp/impl/quic/quic_client_unittest.cc +++ b/osp/impl/quic/quic_client_unittest.cc @@ -60,12 +60,11 @@ class ConnectionCallback final class QuicClientTest : public ::testing::Test { public: QuicClientTest() { - fake_clock_ = std::make_unique<platform::FakeClock>( - platform::Clock::time_point(std::chrono::milliseconds(1298424))); - task_runner_ = - std::make_unique<platform::FakeTaskRunner>(fake_clock_.get()); - quic_bridge_ = std::make_unique<FakeQuicBridge>(task_runner_.get(), - platform::FakeClock::now); + fake_clock_ = std::make_unique<FakeClock>( + Clock::time_point(std::chrono::milliseconds(1298424))); + task_runner_ = std::make_unique<FakeTaskRunner>(fake_clock_.get()); + quic_bridge_ = + std::make_unique<FakeQuicBridge>(task_runner_.get(), FakeClock::now); } protected: @@ -100,17 +99,16 @@ class QuicClientTest : public ::testing::Test { mock_message_callback, OnStreamMessage(0, connection->id(), msgs::Type::kPresentationConnectionMessage, _, _, _)) - .WillOnce( - Invoke([&decode_result, &received_message]( - uint64_t endpoint_id, uint64_t connection_id, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - decode_result = msgs::DecodePresentationConnectionMessage( - buffer, buffer_size, &received_message); - if (decode_result < 0) - return ErrorOr<size_t>(Error::Code::kCborParsing); - return ErrorOr<size_t>(decode_result); - })); + .WillOnce(Invoke([&decode_result, &received_message]( + uint64_t endpoint_id, uint64_t connection_id, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + decode_result = msgs::DecodePresentationConnectionMessage( + buffer, buffer_size, &received_message); + if (decode_result < 0) + return ErrorOr<size_t>(Error::Code::kCborParsing); + return ErrorOr<size_t>(decode_result); + })); quic_bridge_->RunTasksUntilIdle(); ASSERT_GT(decode_result, 0); @@ -121,8 +119,8 @@ class QuicClientTest : public ::testing::Test { EXPECT_EQ(received_message.message.str, message.message.str); } - std::unique_ptr<platform::FakeClock> fake_clock_; - std::unique_ptr<platform::FakeTaskRunner> task_runner_; + std::unique_ptr<FakeClock> fake_clock_; + std::unique_ptr<FakeTaskRunner> task_runner_; std::unique_ptr<FakeQuicBridge> quic_bridge_; QuicClient* client_; }; diff --git a/osp/impl/quic/quic_connection.h b/osp/impl/quic/quic_connection.h index 2f1cb936..e00e25a0 100644 --- a/osp/impl/quic/quic_connection.h +++ b/osp/impl/quic/quic_connection.h @@ -37,7 +37,7 @@ class QuicStream { uint64_t id_; }; -class QuicConnection : public platform::UdpSocket::Client { +class QuicConnection : public UdpSocket::Client { public: class Delegate { public: diff --git a/osp/impl/quic/quic_connection_factory.h b/osp/impl/quic/quic_connection_factory.h index 2e3e10b3..f396419d 100644 --- a/osp/impl/quic/quic_connection_factory.h +++ b/osp/impl/quic/quic_connection_factory.h @@ -18,7 +18,7 @@ namespace osp { // This interface provides a way to make new QUIC connections to endpoints. It // also provides a way to receive incoming QUIC connections (as a server). -class QuicConnectionFactory : public platform::UdpSocket::Client { +class QuicConnectionFactory : public UdpSocket::Client { public: class ServerDelegate { public: diff --git a/osp/impl/quic/quic_connection_factory_impl.cc b/osp/impl/quic/quic_connection_factory_impl.cc index 0ecc17e2..264ebd85 100644 --- a/osp/impl/quic/quic_connection_factory_impl.cc +++ b/osp/impl/quic/quic_connection_factory_impl.cc @@ -18,13 +18,12 @@ #include "util/logging.h" #include "util/trace_logging.h" -using openscreen::platform::TraceCategory; - namespace openscreen { namespace osp { + class QuicTaskRunner final : public ::base::TaskRunner { public: - explicit QuicTaskRunner(platform::TaskRunner* task_runner); + explicit QuicTaskRunner(openscreen::TaskRunner* task_runner); ~QuicTaskRunner() override; void RunTasks(); @@ -37,11 +36,12 @@ class QuicTaskRunner final : public ::base::TaskRunner { bool RunsTasksInCurrentSequence() const override; private: - platform::TaskRunner* const task_runner_; + openscreen::TaskRunner* const task_runner_; }; -QuicTaskRunner::QuicTaskRunner(platform::TaskRunner* task_runner) +QuicTaskRunner::QuicTaskRunner(openscreen::TaskRunner* task_runner) : task_runner_(task_runner) {} + QuicTaskRunner::~QuicTaskRunner() = default; void QuicTaskRunner::RunTasks() {} @@ -49,8 +49,7 @@ void QuicTaskRunner::RunTasks() {} bool QuicTaskRunner::PostDelayedTask(const ::base::Location& whence, ::base::OnceClosure task, ::base::TimeDelta delay) { - platform::Clock::duration wait = - platform::Clock::duration(delay.InMilliseconds()); + Clock::duration wait = Clock::duration(delay.InMilliseconds()); task_runner_->PostTaskWithDelay( [closure = std::move(task)]() mutable { std::move(closure).Run(); }, wait); @@ -61,8 +60,7 @@ bool QuicTaskRunner::RunsTasksInCurrentSequence() const { return true; } -QuicConnectionFactoryImpl::QuicConnectionFactoryImpl( - platform::TaskRunner* task_runner) +QuicConnectionFactoryImpl::QuicConnectionFactoryImpl(TaskRunner* task_runner) : task_runner_(task_runner) { quic_task_runner_ = ::base::MakeRefCounted<QuicTaskRunner>(task_runner); alarm_factory_ = std::make_unique<::net::QuicChromiumAlarmFactory>( @@ -90,34 +88,31 @@ void QuicConnectionFactoryImpl::SetServerDelegate( // create/bind errors occur. Maybe return an Error immediately, and undo // partial progress (i.e. "unwatch" all the sockets and call // sockets_.clear() to close the sockets)? - auto create_result = - platform::UdpSocket::Create(task_runner_, this, endpoint); + auto create_result = UdpSocket::Create(task_runner_, this, endpoint); if (!create_result) { OSP_LOG_ERROR << "failed to create socket (for " << endpoint << "): " << create_result.error().message(); continue; } - platform::UdpSocketUniquePtr server_socket = - std::move(create_result.value()); + std::unique_ptr<UdpSocket> server_socket = std::move(create_result.value()); server_socket->Bind(); sockets_.emplace_back(std::move(server_socket)); } } -void QuicConnectionFactoryImpl::OnRead( - platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet_or_error) { +void QuicConnectionFactoryImpl::OnRead(UdpSocket* socket, + ErrorOr<UdpPacket> packet_or_error) { TRACE_SCOPED(TraceCategory::Quic, "QuicConnectionFactoryImpl::OnRead"); if (packet_or_error.is_error()) { return; } - platform::UdpPacket packet = std::move(packet_or_error.value()); + UdpPacket packet = std::move(packet_or_error.value()); // Ensure that |packet.socket| is one of the instances owned by // QuicConnectionFactoryImpl. auto packet_ptr = &packet; OSP_DCHECK(std::find_if(sockets_.begin(), sockets_.end(), - [packet_ptr](const platform::UdpSocketUniquePtr& s) { + [packet_ptr](const std::unique_ptr<UdpSocket>& s) { return s.get() == packet_ptr->socket(); }) != sockets_.end()); @@ -153,15 +148,14 @@ void QuicConnectionFactoryImpl::OnRead( std::unique_ptr<QuicConnection> QuicConnectionFactoryImpl::Connect( const IPEndpoint& endpoint, QuicConnection::Delegate* connection_delegate) { - auto create_result = - platform::UdpSocket::Create(task_runner_, this, endpoint); + auto create_result = UdpSocket::Create(task_runner_, this, endpoint); if (!create_result) { OSP_LOG_ERROR << "failed to create socket: " << create_result.error().message(); // TODO(mfoltz): This method should return ErrorOr<uni_ptr<QuicConnection>>. return nullptr; } - platform::UdpSocketUniquePtr socket = std::move(create_result.value()); + std::unique_ptr<UdpSocket> socket = std::move(create_result.value()); auto transport = std::make_unique<UdpTransport>(socket.get(), endpoint); ::quic::QuartcSessionConfig session_config; @@ -192,7 +186,7 @@ void QuicConnectionFactoryImpl::OnConnectionClosed(QuicConnection* connection) { return entry.second.connection == connection; }); OSP_DCHECK(entry != connections_.end()); - platform::UdpSocket* const socket = entry->second.socket; + UdpSocket* const socket = entry->second.socket; connections_.erase(entry); // If none of the remaining |connections_| reference the socket, close/destroy @@ -203,7 +197,7 @@ void QuicConnectionFactoryImpl::OnConnectionClosed(QuicConnection* connection) { }) == connections_.end()) { auto socket_it = std::find_if(sockets_.begin(), sockets_.end(), - [socket](const platform::UdpSocketUniquePtr& s) { + [socket](const std::unique_ptr<UdpSocket>& s) { return s.get() == socket; }); OSP_DCHECK(socket_it != sockets_.end()); @@ -211,13 +205,11 @@ void QuicConnectionFactoryImpl::OnConnectionClosed(QuicConnection* connection) { } } -void QuicConnectionFactoryImpl::OnError(platform::UdpSocket* socket, - Error error) { +void QuicConnectionFactoryImpl::OnError(UdpSocket* socket, Error error) { OSP_LOG_ERROR << "failed to configure socket " << error.message(); } -void QuicConnectionFactoryImpl::OnSendError(platform::UdpSocket* socket, - Error error) { +void QuicConnectionFactoryImpl::OnSendError(UdpSocket* socket, Error error) { // TODO(crbug.com/openscreen/67): Implement this method. OSP_UNIMPLEMENTED(); } diff --git a/osp/impl/quic/quic_connection_factory_impl.h b/osp/impl/quic/quic_connection_factory_impl.h index 8e29579d..0bfa242f 100644 --- a/osp/impl/quic/quic_connection_factory_impl.h +++ b/osp/impl/quic/quic_connection_factory_impl.h @@ -22,14 +22,13 @@ class QuicTaskRunner; class QuicConnectionFactoryImpl final : public QuicConnectionFactory { public: - QuicConnectionFactoryImpl(platform::TaskRunner* task_runner); + QuicConnectionFactoryImpl(TaskRunner* task_runner); ~QuicConnectionFactoryImpl() override; // UdpSocket::Client overrides. - void OnError(platform::UdpSocket* socket, Error error) override; - void OnSendError(platform::UdpSocket* socket, Error error) override; - void OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet) override; + void OnError(UdpSocket* socket, Error error) override; + void OnSendError(UdpSocket* socket, Error error) override; + void OnRead(UdpSocket* socket, ErrorOr<UdpPacket> packet) override; // QuicConnectionFactory overrides. void SetServerDelegate(ServerDelegate* delegate, @@ -48,18 +47,18 @@ class QuicConnectionFactoryImpl final : public QuicConnectionFactory { ServerDelegate* server_delegate_ = nullptr; - std::vector<platform::UdpSocketUniquePtr> sockets_; + std::vector<std::unique_ptr<UdpSocket>> sockets_; struct OpenConnection { QuicConnection* connection; - platform::UdpSocket* socket; // References one of the owned |sockets_|. + UdpSocket* socket; // References one of the owned |sockets_|. }; std::map<IPEndpoint, OpenConnection, IPEndpointComparator> connections_; // NOTE: Must be provided in constructor and stored as an instance variable // rather than using the static accessor method to allow for UTs to mock this // layer. - platform::TaskRunner* const task_runner_; + TaskRunner* const task_runner_; }; } // namespace osp diff --git a/osp/impl/quic/quic_connection_impl.cc b/osp/impl/quic/quic_connection_impl.cc index 8ee43c33..e3b36fcf 100644 --- a/osp/impl/quic/quic_connection_impl.cc +++ b/osp/impl/quic/quic_connection_impl.cc @@ -14,13 +14,10 @@ #include "util/logging.h" #include "util/trace_logging.h" -using openscreen::platform::TraceCategory; - namespace openscreen { namespace osp { -UdpTransport::UdpTransport(platform::UdpSocket* socket, - const IPEndpoint& destination) +UdpTransport::UdpTransport(UdpSocket* socket, const IPEndpoint& destination) : socket_(socket), destination_(destination) { OSP_DCHECK(socket_); } @@ -79,8 +76,7 @@ void QuicStreamImpl::OnBufferChanged(::quic::QuartcStream* stream) {} // Passes a received UDP packet to the QUIC implementation. If this contains // any stream data, it will be passed automatically to the relevant // QuicStream::Delegate objects. -void QuicConnectionImpl::OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> data) { +void QuicConnectionImpl::OnRead(UdpSocket* socket, ErrorOr<UdpPacket> data) { TRACE_SCOPED(TraceCategory::Quic, "QuicConnectionImpl::OnRead"); if (data.is_error()) { TRACE_SET_RESULT(data.error()); @@ -91,12 +87,12 @@ void QuicConnectionImpl::OnRead(platform::UdpSocket* socket, reinterpret_cast<const char*>(data.value().data()), data.value().size()); } -void QuicConnectionImpl::OnSendError(platform::UdpSocket* socket, Error error) { +void QuicConnectionImpl::OnSendError(UdpSocket* socket, Error error) { // TODO(crbug.com/openscreen/67): Implement this method. OSP_UNIMPLEMENTED(); } -void QuicConnectionImpl::OnError(platform::UdpSocket* socket, Error error) { +void QuicConnectionImpl::OnError(UdpSocket* socket, Error error) { // TODO(crbug.com/openscreen/67): Implement this method. OSP_UNIMPLEMENTED(); } diff --git a/osp/impl/quic/quic_connection_impl.h b/osp/impl/quic/quic_connection_impl.h index c7697ec1..e2609deb 100644 --- a/osp/impl/quic/quic_connection_impl.h +++ b/osp/impl/quic/quic_connection_impl.h @@ -26,7 +26,7 @@ class QuicConnectionFactoryImpl; class UdpTransport final : public ::quic::QuartcPacketTransport { public: - UdpTransport(platform::UdpSocket* socket, const IPEndpoint& destination); + UdpTransport(UdpSocket* socket, const IPEndpoint& destination); UdpTransport(UdpTransport&&) noexcept; ~UdpTransport() override; @@ -37,10 +37,10 @@ class UdpTransport final : public ::quic::QuartcPacketTransport { size_t buffer_length, const PacketInfo& info) override; - platform::UdpSocket* socket() const { return socket_; } + UdpSocket* socket() const { return socket_; } private: - platform::UdpSocket* socket_; + UdpSocket* socket_; IPEndpoint destination_; }; @@ -76,10 +76,9 @@ class QuicConnectionImpl final : public QuicConnection, ~QuicConnectionImpl() override; // UdpSocket::Client overrides. - void OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> data) override; - void OnError(platform::UdpSocket* socket, Error error) override; - void OnSendError(platform::UdpSocket* socket, Error error) override; + void OnRead(UdpSocket* socket, ErrorOr<UdpPacket> data) override; + void OnError(UdpSocket* socket, Error error) override; + void OnSendError(UdpSocket* socket, Error error) override; // QuicConnection overrides. std::unique_ptr<QuicStream> MakeOutgoingStream( diff --git a/osp/impl/quic/quic_server.cc b/osp/impl/quic/quic_server.cc index 17a90973..e1afc58c 100644 --- a/osp/impl/quic/quic_server.cc +++ b/osp/impl/quic/quic_server.cc @@ -19,8 +19,8 @@ QuicServer::QuicServer( MessageDemuxer* demuxer, std::unique_ptr<QuicConnectionFactory> connection_factory, ProtocolConnectionServer::Observer* observer, - platform::ClockNowFunctionPtr now_function, - platform::TaskRunner* task_runner) + ClockNowFunctionPtr now_function, + TaskRunner* task_runner) : ProtocolConnectionServer(demuxer, observer), connection_endpoints_(config.connection_endpoints), connection_factory_(std::move(connection_factory)), @@ -80,8 +80,7 @@ void QuicServer::Cleanup() { } delete_connections_.clear(); - constexpr platform::Clock::duration kQuicCleanupPeriod = - std::chrono::milliseconds(500); + constexpr Clock::duration kQuicCleanupPeriod = std::chrono::milliseconds(500); if (state_ != State::kStopped) { cleanup_alarm_.ScheduleFromNow([this] { Cleanup(); }, kQuicCleanupPeriod); } diff --git a/osp/impl/quic/quic_server.h b/osp/impl/quic/quic_server.h index 48652d53..31a3bbe8 100644 --- a/osp/impl/quic/quic_server.h +++ b/osp/impl/quic/quic_server.h @@ -37,8 +37,8 @@ class QuicServer final : public ProtocolConnectionServer, MessageDemuxer* demuxer, std::unique_ptr<QuicConnectionFactory> connection_factory, ProtocolConnectionServer::Observer* observer, - platform::ClockNowFunctionPtr now_function, - platform::TaskRunner* task_runner); + ClockNowFunctionPtr now_function, + TaskRunner* task_runner); ~QuicServer() override; // ProtocolConnectionServer overrides. diff --git a/osp/impl/quic/quic_server_unittest.cc b/osp/impl/quic/quic_server_unittest.cc index ed1c3362..12ad8c33 100644 --- a/osp/impl/quic/quic_server_unittest.cc +++ b/osp/impl/quic/quic_server_unittest.cc @@ -49,12 +49,11 @@ class MockConnectionObserver final : public ProtocolConnection::Observer { class QuicServerTest : public Test { public: QuicServerTest() { - fake_clock_ = std::make_unique<platform::FakeClock>( - platform::Clock::time_point(std::chrono::milliseconds(1298424))); - task_runner_ = - std::make_unique<platform::FakeTaskRunner>(fake_clock_.get()); - quic_bridge_ = std::make_unique<FakeQuicBridge>(task_runner_.get(), - platform::FakeClock::now); + fake_clock_ = std::make_unique<FakeClock>( + Clock::time_point(std::chrono::milliseconds(1298424))); + task_runner_ = std::make_unique<FakeTaskRunner>(fake_clock_.get()); + quic_bridge_ = + std::make_unique<FakeQuicBridge>(task_runner_.get(), FakeClock::now); } protected: @@ -103,17 +102,16 @@ class QuicServerTest : public Test { EXPECT_CALL(mock_message_callback, OnStreamMessage( 0, _, msgs::Type::kPresentationConnectionMessage, _, _, _)) - .WillOnce( - Invoke([&decode_result, &received_message]( - uint64_t endpoint_id, uint64_t connection_id, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - decode_result = msgs::DecodePresentationConnectionMessage( - buffer, buffer_size, &received_message); - if (decode_result < 0) - return ErrorOr<size_t>(Error::Code::kCborParsing); - return ErrorOr<size_t>(decode_result); - })); + .WillOnce(Invoke([&decode_result, &received_message]( + uint64_t endpoint_id, uint64_t connection_id, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + decode_result = msgs::DecodePresentationConnectionMessage( + buffer, buffer_size, &received_message); + if (decode_result < 0) + return ErrorOr<size_t>(Error::Code::kCborParsing); + return ErrorOr<size_t>(decode_result); + })); quic_bridge_->RunTasksUntilIdle(); ASSERT_GT(decode_result, 0); @@ -124,8 +122,8 @@ class QuicServerTest : public Test { EXPECT_EQ(received_message.message.str, message.message.str); } - std::unique_ptr<platform::FakeClock> fake_clock_; - std::unique_ptr<platform::FakeTaskRunner> task_runner_; + std::unique_ptr<FakeClock> fake_clock_; + std::unique_ptr<FakeTaskRunner> task_runner_; std::unique_ptr<FakeQuicBridge> quic_bridge_; QuicServer* server_; }; diff --git a/osp/impl/quic/testing/fake_quic_connection.cc b/osp/impl/quic/testing/fake_quic_connection.cc index c04ef433..52f7241c 100644 --- a/osp/impl/quic/testing/fake_quic_connection.cc +++ b/osp/impl/quic/testing/fake_quic_connection.cc @@ -61,16 +61,15 @@ std::unique_ptr<FakeQuicStream> FakeQuicConnection::MakeIncomingStream() { return result; } -void FakeQuicConnection::OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> data) { +void FakeQuicConnection::OnRead(UdpSocket* socket, ErrorOr<UdpPacket> data) { OSP_NOTREACHED() << "data should go directly to fake streams"; } -void FakeQuicConnection::OnSendError(platform::UdpSocket* socket, Error error) { +void FakeQuicConnection::OnSendError(UdpSocket* socket, Error error) { OSP_NOTREACHED() << "data should go directly to fake streams"; } -void FakeQuicConnection::OnError(platform::UdpSocket* socket, Error error) { +void FakeQuicConnection::OnError(UdpSocket* socket, Error error) { OSP_NOTREACHED() << "data should go directly to fake streams"; } diff --git a/osp/impl/quic/testing/fake_quic_connection.h b/osp/impl/quic/testing/fake_quic_connection.h index 47943f0b..9b11d7b4 100644 --- a/osp/impl/quic/testing/fake_quic_connection.h +++ b/osp/impl/quic/testing/fake_quic_connection.h @@ -58,10 +58,9 @@ class FakeQuicConnection final : public QuicConnection { std::unique_ptr<FakeQuicStream> MakeIncomingStream(); // UdpSocket::Client overrides. - void OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> data) override; - void OnSendError(platform::UdpSocket* socket, Error error) override; - void OnError(platform::UdpSocket* socket, Error error) override; + void OnRead(UdpSocket* socket, ErrorOr<UdpPacket> data) override; + void OnSendError(UdpSocket* socket, Error error) override; + void OnError(UdpSocket* socket, Error error) override; // QuicConnection overrides. std::unique_ptr<QuicStream> MakeOutgoingStream( diff --git a/osp/impl/quic/testing/fake_quic_connection_factory.cc b/osp/impl/quic/testing/fake_quic_connection_factory.cc index c68d256c..47f3ab87 100644 --- a/osp/impl/quic/testing/fake_quic_connection_factory.cc +++ b/osp/impl/quic/testing/fake_quic_connection_factory.cc @@ -167,19 +167,17 @@ std::unique_ptr<QuicConnection> FakeClientQuicConnectionFactory::Connect( return bridge_->Connect(endpoint, connection_delegate); } -void FakeClientQuicConnectionFactory::OnError(platform::UdpSocket* socket, - Error error) { +void FakeClientQuicConnectionFactory::OnError(UdpSocket* socket, Error error) { OSP_UNIMPLEMENTED(); } -void FakeClientQuicConnectionFactory::OnSendError(platform::UdpSocket* socket, +void FakeClientQuicConnectionFactory::OnSendError(UdpSocket* socket, Error error) { OSP_UNIMPLEMENTED(); } -void FakeClientQuicConnectionFactory::OnRead( - platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet) { +void FakeClientQuicConnectionFactory::OnRead(UdpSocket* socket, + ErrorOr<UdpPacket> packet) { bridge_->RunTasks(true); idle_ = bridge_->client_idle(); } @@ -207,19 +205,17 @@ std::unique_ptr<QuicConnection> FakeServerQuicConnectionFactory::Connect( return nullptr; } -void FakeServerQuicConnectionFactory::OnError(platform::UdpSocket* socket, - Error error) { +void FakeServerQuicConnectionFactory::OnError(UdpSocket* socket, Error error) { OSP_UNIMPLEMENTED(); } -void FakeServerQuicConnectionFactory::OnSendError(platform::UdpSocket* socket, +void FakeServerQuicConnectionFactory::OnSendError(UdpSocket* socket, Error error) { OSP_UNIMPLEMENTED(); } -void FakeServerQuicConnectionFactory::OnRead( - platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet) { +void FakeServerQuicConnectionFactory::OnRead(UdpSocket* socket, + ErrorOr<UdpPacket> packet) { bridge_->RunTasks(false); idle_ = bridge_->server_idle(); } diff --git a/osp/impl/quic/testing/fake_quic_connection_factory.h b/osp/impl/quic/testing/fake_quic_connection_factory.h index 128e6372..2aac1145 100644 --- a/osp/impl/quic/testing/fake_quic_connection_factory.h +++ b/osp/impl/quic/testing/fake_quic_connection_factory.h @@ -55,10 +55,9 @@ class FakeClientQuicConnectionFactory final : public QuicConnectionFactory { ~FakeClientQuicConnectionFactory() override; // UdpSocket::Client overrides. - void OnError(platform::UdpSocket* socket, Error error) override; - void OnSendError(platform::UdpSocket* socket, Error error) override; - void OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet) override; + void OnError(UdpSocket* socket, Error error) override; + void OnSendError(UdpSocket* socket, Error error) override; + void OnRead(UdpSocket* socket, ErrorOr<UdpPacket> packet) override; // QuicConnectionFactory overrides. void SetServerDelegate(ServerDelegate* delegate, @@ -69,7 +68,7 @@ class FakeClientQuicConnectionFactory final : public QuicConnectionFactory { bool idle() const { return idle_; } - std::unique_ptr<platform::UdpSocket> socket_; + std::unique_ptr<UdpSocket> socket_; private: FakeQuicConnectionFactoryBridge* bridge_; @@ -83,10 +82,9 @@ class FakeServerQuicConnectionFactory final : public QuicConnectionFactory { ~FakeServerQuicConnectionFactory() override; // UdpSocket::Client overrides. - void OnError(platform::UdpSocket* socket, Error error) override; - void OnSendError(platform::UdpSocket* socket, Error error) override; - void OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet) override; + void OnError(UdpSocket* socket, Error error) override; + void OnSendError(UdpSocket* socket, Error error) override; + void OnRead(UdpSocket* socket, ErrorOr<UdpPacket> packet) override; // QuicConnectionFactory overrides. void SetServerDelegate(ServerDelegate* delegate, diff --git a/osp/impl/quic/testing/quic_test_support.cc b/osp/impl/quic/testing/quic_test_support.cc index ed5a7007..2ca32713 100644 --- a/osp/impl/quic/testing/quic_test_support.cc +++ b/osp/impl/quic/testing/quic_test_support.cc @@ -14,8 +14,8 @@ namespace openscreen { namespace osp { -FakeQuicBridge::FakeQuicBridge(platform::FakeTaskRunner* task_runner, - platform::ClockNowFunctionPtr now_function) +FakeQuicBridge::FakeQuicBridge(FakeTaskRunner* task_runner, + ClockNowFunctionPtr now_function) : task_runner_(task_runner) { fake_bridge = std::make_unique<FakeQuicConnectionFactoryBridge>(kControllerEndpoint); @@ -27,8 +27,8 @@ FakeQuicBridge::FakeQuicBridge(platform::FakeTaskRunner* task_runner, auto fake_client_factory = std::make_unique<FakeClientQuicConnectionFactory>(fake_bridge.get()); - client_socket_ = std::make_unique<platform::FakeUdpSocket>( - task_runner_, fake_client_factory.get()); + client_socket_ = + std::make_unique<FakeUdpSocket>(task_runner_, fake_client_factory.get()); quic_client = std::make_unique<QuicClient>( controller_demuxer.get(), std::move(fake_client_factory), @@ -36,8 +36,8 @@ FakeQuicBridge::FakeQuicBridge(platform::FakeTaskRunner* task_runner, auto fake_server_factory = std::make_unique<FakeServerQuicConnectionFactory>(fake_bridge.get()); - server_socket_ = std::make_unique<platform::FakeUdpSocket>( - task_runner_, fake_server_factory.get()); + server_socket_ = + std::make_unique<FakeUdpSocket>(task_runner_, fake_server_factory.get()); ServerConfig config; config.connection_endpoints.push_back(kReceiverEndpoint); quic_server = std::make_unique<QuicServer>( @@ -51,13 +51,13 @@ FakeQuicBridge::FakeQuicBridge(platform::FakeTaskRunner* task_runner, FakeQuicBridge::~FakeQuicBridge() = default; void FakeQuicBridge::PostClientPacket() { - platform::UdpPacket packet; + UdpPacket packet; packet.set_socket(client_socket_.get()); client_socket_->MockReceivePacket(std::move(packet)); } void FakeQuicBridge::PostServerPacket() { - platform::UdpPacket packet; + UdpPacket packet; packet.set_socket(server_socket_.get()); server_socket_->MockReceivePacket(std::move(packet)); } diff --git a/osp/impl/quic/testing/quic_test_support.h b/osp/impl/quic/testing/quic_test_support.h index 3e8719aa..a7ae7c33 100644 --- a/osp/impl/quic/testing/quic_test_support.h +++ b/osp/impl/quic/testing/quic_test_support.h @@ -56,8 +56,7 @@ class MockServerObserver : public ProtocolConnectionServer::Observer { class FakeQuicBridge { public: - FakeQuicBridge(platform::FakeTaskRunner* task_runner, - platform::ClockNowFunctionPtr now_function); + FakeQuicBridge(FakeTaskRunner* task_runner, ClockNowFunctionPtr now_function); ~FakeQuicBridge(); const IPEndpoint kControllerEndpoint{{192, 168, 1, 3}, 4321}; @@ -79,10 +78,10 @@ class FakeQuicBridge { void PostPacketsUntilIdle(); FakeClientQuicConnectionFactory* GetClientFactory(); FakeServerQuicConnectionFactory* GetServerFactory(); - platform::FakeTaskRunner* task_runner_; + FakeTaskRunner* task_runner_; - std::unique_ptr<platform::FakeUdpSocket> client_socket_; - std::unique_ptr<platform::FakeUdpSocket> server_socket_; + std::unique_ptr<FakeUdpSocket> client_socket_; + std::unique_ptr<FakeUdpSocket> server_socket_; }; } // namespace osp diff --git a/osp/impl/testing/fake_mdns_platform_service.cc b/osp/impl/testing/fake_mdns_platform_service.cc index 7930eedf..371e8789 100644 --- a/osp/impl/testing/fake_mdns_platform_service.cc +++ b/osp/impl/testing/fake_mdns_platform_service.cc @@ -16,7 +16,7 @@ FakeMdnsPlatformService::~FakeMdnsPlatformService() = default; std::vector<MdnsPlatformService::BoundInterface> FakeMdnsPlatformService::RegisterInterfaces( - const std::vector<platform::NetworkInterfaceIndex>& whitelist) { + const std::vector<NetworkInterfaceIndex>& whitelist) { OSP_CHECK(registered_interfaces_.empty()); if (whitelist.empty()) { registered_interfaces_ = interfaces_; diff --git a/osp/impl/testing/fake_mdns_platform_service.h b/osp/impl/testing/fake_mdns_platform_service.h index 81e148c1..2c5d6b88 100644 --- a/osp/impl/testing/fake_mdns_platform_service.h +++ b/osp/impl/testing/fake_mdns_platform_service.h @@ -23,8 +23,8 @@ class FakeMdnsPlatformService final : public MdnsPlatformService { // PlatformService overrides. std::vector<BoundInterface> RegisterInterfaces( - const std::vector<platform::NetworkInterfaceIndex>& - interface_index_whitelist) override; + const std::vector<NetworkInterfaceIndex>& interface_index_whitelist) + override; void DeregisterInterfaces( const std::vector<BoundInterface>& registered_interfaces) override; diff --git a/osp/impl/testing/fake_mdns_platform_service_unittest.cc b/osp/impl/testing/fake_mdns_platform_service_unittest.cc index c8ec0a95..c2058d4d 100644 --- a/osp/impl/testing/fake_mdns_platform_service_unittest.cc +++ b/osp/impl/testing/fake_mdns_platform_service_unittest.cc @@ -12,33 +12,33 @@ namespace openscreen { namespace osp { namespace { -platform::UdpSocket* const kDefaultSocket = - reinterpret_cast<platform::UdpSocket*>(static_cast<uintptr_t>(16)); -platform::UdpSocket* const kSecondSocket = - reinterpret_cast<platform::UdpSocket*>(static_cast<uintptr_t>(24)); +UdpSocket* const kDefaultSocket = + reinterpret_cast<UdpSocket*>(static_cast<uintptr_t>(16)); +UdpSocket* const kSecondSocket = + reinterpret_cast<UdpSocket*>(static_cast<uintptr_t>(24)); class FakeMdnsPlatformServiceTest : public ::testing::Test { protected: const uint8_t mac1_[6] = {11, 22, 33, 44, 55, 66}; const uint8_t mac2_[6] = {12, 23, 34, 45, 56, 67}; - const platform::IPSubnet subnet1_{IPAddress{192, 168, 3, 2}, 24}; - const platform::IPSubnet subnet2_{ + const IPSubnet subnet1_{IPAddress{192, 168, 3, 2}, 24}; + const IPSubnet subnet2_{ IPAddress{0x0102, 0x0304, 0x0504, 0x0302, 0x0102, 0x0304, 0x0506, 0x0708}, 24}; std::vector<MdnsPlatformService::BoundInterface> bound_interfaces_{ MdnsPlatformService::BoundInterface{ - platform::InterfaceInfo{1, - mac1_, - "eth0", - platform::InterfaceInfo::Type::kEthernet, - {subnet1_}}, + InterfaceInfo{1, + mac1_, + "eth0", + InterfaceInfo::Type::kEthernet, + {subnet1_}}, subnet1_, kDefaultSocket}, MdnsPlatformService::BoundInterface{ - platform::InterfaceInfo{2, - mac2_, - "eth1", - platform::InterfaceInfo::Type::kEthernet, - {subnet2_}}, + InterfaceInfo{2, + mac2_, + "eth1", + InterfaceInfo::Type::kEthernet, + {subnet2_}}, subnet2_, kSecondSocket}}; }; diff --git a/osp/impl/testing/fake_mdns_responder_adapter.cc b/osp/impl/testing/fake_mdns_responder_adapter.cc index 37e74434..fad1c125 100644 --- a/osp/impl/testing/fake_mdns_responder_adapter.cc +++ b/osp/impl/testing/fake_mdns_responder_adapter.cc @@ -17,7 +17,7 @@ constexpr char kLocalDomain[] = "local"; PtrEvent MakePtrEvent(const std::string& service_instance, const std::string& service_type, const std::string& service_protocol, - platform::UdpSocket* socket) { + UdpSocket* socket) { const auto labels = std::vector<std::string>{service_instance, service_type, service_protocol, kLocalDomain}; ErrorOr<DomainName> full_instance_name = @@ -33,7 +33,7 @@ SrvEvent MakeSrvEvent(const std::string& service_instance, const std::string& service_protocol, const std::string& hostname, uint16_t port, - platform::UdpSocket* socket) { + UdpSocket* socket) { const auto instance_labels = std::vector<std::string>{ service_instance, service_type, service_protocol, kLocalDomain}; ErrorOr<DomainName> full_instance_name = @@ -54,7 +54,7 @@ TxtEvent MakeTxtEvent(const std::string& service_instance, const std::string& service_type, const std::string& service_protocol, const std::vector<std::string>& txt_lines, - platform::UdpSocket* socket) { + UdpSocket* socket) { const auto labels = std::vector<std::string>{service_instance, service_type, service_protocol, kLocalDomain}; ErrorOr<DomainName> domain_name = @@ -67,7 +67,7 @@ TxtEvent MakeTxtEvent(const std::string& service_instance, AEvent MakeAEvent(const std::string& hostname, IPAddress address, - platform::UdpSocket* socket) { + UdpSocket* socket) { const auto labels = std::vector<std::string>{hostname, kLocalDomain}; ErrorOr<DomainName> domain_name = DomainName::FromLabels(labels.begin(), labels.end()); @@ -79,7 +79,7 @@ AEvent MakeAEvent(const std::string& hostname, AaaaEvent MakeAaaaEvent(const std::string& hostname, IPAddress address, - platform::UdpSocket* socket) { + UdpSocket* socket) { const auto labels = std::vector<std::string>{hostname, kLocalDomain}; ErrorOr<DomainName> domain_name = DomainName::FromLabels(labels.begin(), labels.end()); @@ -97,7 +97,7 @@ void AddEventsForNewService(FakeMdnsResponderAdapter* mdns_responder, uint16_t port, const std::vector<std::string>& txt_lines, const IPAddress& address, - platform::UdpSocket* socket) { + UdpSocket* socket) { mdns_responder->AddPtrEvent( MakePtrEvent(service_instance, service_name, service_protocol, socket)); mdns_responder->AddSrvEvent(MakeSrvEvent(service_instance, service_name, @@ -202,9 +202,9 @@ Error FakeMdnsResponderAdapter::SetHostLabel(const std::string& host_label) { } Error FakeMdnsResponderAdapter::RegisterInterface( - const platform::InterfaceInfo& interface_info, - const platform::IPSubnet& interface_address, - platform::UdpSocket* socket) { + const InterfaceInfo& interface_info, + const IPSubnet& interface_address, + UdpSocket* socket) { if (!running_) return Error::Code::kOperationInvalid; @@ -218,8 +218,7 @@ Error FakeMdnsResponderAdapter::RegisterInterface( return Error::None(); } -Error FakeMdnsResponderAdapter::DeregisterInterface( - platform::UdpSocket* socket) { +Error FakeMdnsResponderAdapter::DeregisterInterface(UdpSocket* socket) { auto it = std::find_if(registered_interfaces_.begin(), registered_interfaces_.end(), [&socket](const RegisteredInterface& interface) { @@ -232,22 +231,20 @@ Error FakeMdnsResponderAdapter::DeregisterInterface( return Error::None(); } -void FakeMdnsResponderAdapter::OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet) { +void FakeMdnsResponderAdapter::OnRead(UdpSocket* socket, + ErrorOr<UdpPacket> packet) { OSP_NOTREACHED() << "Tests should not drive this class with packets"; } -void FakeMdnsResponderAdapter::OnSendError(platform::UdpSocket* socket, - Error error) { +void FakeMdnsResponderAdapter::OnSendError(UdpSocket* socket, Error error) { OSP_NOTREACHED() << "Tests should not drive this class with packets"; } -void FakeMdnsResponderAdapter::OnError(platform::UdpSocket* socket, - Error error) { +void FakeMdnsResponderAdapter::OnError(UdpSocket* socket, Error error) { OSP_NOTREACHED() << "Tests should not drive this class with packets"; } -platform::Clock::duration FakeMdnsResponderAdapter::RunTasks() { +Clock::duration FakeMdnsResponderAdapter::RunTasks() { return std::chrono::seconds(1); } @@ -369,7 +366,7 @@ std::vector<AaaaEvent> FakeMdnsResponderAdapter::TakeAaaaResponses() { } MdnsResponderErrorCode FakeMdnsResponderAdapter::StartPtrQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_type) { if (!running_) return MdnsResponderErrorCode::kUnknownError; @@ -388,7 +385,7 @@ MdnsResponderErrorCode FakeMdnsResponderAdapter::StartPtrQuery( } MdnsResponderErrorCode FakeMdnsResponderAdapter::StartSrvQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) { if (!running_) return MdnsResponderErrorCode::kUnknownError; @@ -402,7 +399,7 @@ MdnsResponderErrorCode FakeMdnsResponderAdapter::StartSrvQuery( } MdnsResponderErrorCode FakeMdnsResponderAdapter::StartTxtQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) { if (!running_) return MdnsResponderErrorCode::kUnknownError; @@ -416,7 +413,7 @@ MdnsResponderErrorCode FakeMdnsResponderAdapter::StartTxtQuery( } MdnsResponderErrorCode FakeMdnsResponderAdapter::StartAQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& domain_name) { if (!running_) return MdnsResponderErrorCode::kUnknownError; @@ -430,7 +427,7 @@ MdnsResponderErrorCode FakeMdnsResponderAdapter::StartAQuery( } MdnsResponderErrorCode FakeMdnsResponderAdapter::StartAaaaQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& domain_name) { if (!running_) return MdnsResponderErrorCode::kUnknownError; @@ -444,7 +441,7 @@ MdnsResponderErrorCode FakeMdnsResponderAdapter::StartAaaaQuery( } MdnsResponderErrorCode FakeMdnsResponderAdapter::StopPtrQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_type) { auto interface_entry = queries_.find(socket); if (interface_entry == queries_.end()) @@ -463,7 +460,7 @@ MdnsResponderErrorCode FakeMdnsResponderAdapter::StopPtrQuery( } MdnsResponderErrorCode FakeMdnsResponderAdapter::StopSrvQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) { auto interface_entry = queries_.find(socket); if (interface_entry == queries_.end()) @@ -478,7 +475,7 @@ MdnsResponderErrorCode FakeMdnsResponderAdapter::StopSrvQuery( } MdnsResponderErrorCode FakeMdnsResponderAdapter::StopTxtQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) { auto interface_entry = queries_.find(socket); if (interface_entry == queries_.end()) @@ -493,7 +490,7 @@ MdnsResponderErrorCode FakeMdnsResponderAdapter::StopTxtQuery( } MdnsResponderErrorCode FakeMdnsResponderAdapter::StopAQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& domain_name) { auto interface_entry = queries_.find(socket); if (interface_entry == queries_.end()) @@ -508,7 +505,7 @@ MdnsResponderErrorCode FakeMdnsResponderAdapter::StopAQuery( } MdnsResponderErrorCode FakeMdnsResponderAdapter::StopAaaaQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& domain_name) { auto interface_entry = queries_.find(socket); if (interface_entry == queries_.end()) diff --git a/osp/impl/testing/fake_mdns_responder_adapter.h b/osp/impl/testing/fake_mdns_responder_adapter.h index a7287e45..d4fdad1f 100644 --- a/osp/impl/testing/fake_mdns_responder_adapter.h +++ b/osp/impl/testing/fake_mdns_responder_adapter.h @@ -18,28 +18,28 @@ class FakeMdnsResponderAdapter; PtrEvent MakePtrEvent(const std::string& service_instance, const std::string& service_type, const std::string& service_protocol, - platform::UdpSocket* socket); + UdpSocket* socket); SrvEvent MakeSrvEvent(const std::string& service_instance, const std::string& service_type, const std::string& service_protocol, const std::string& hostname, uint16_t port, - platform::UdpSocket* socket); + UdpSocket* socket); TxtEvent MakeTxtEvent(const std::string& service_instance, const std::string& service_type, const std::string& service_protocol, const std::vector<std::string>& txt_lines, - platform::UdpSocket* socket); + UdpSocket* socket); AEvent MakeAEvent(const std::string& hostname, IPAddress address, - platform::UdpSocket* socket); + UdpSocket* socket); AaaaEvent MakeAaaaEvent(const std::string& hostname, IPAddress address, - platform::UdpSocket* socket); + UdpSocket* socket); void AddEventsForNewService(FakeMdnsResponderAdapter* mdns_responder, const std::string& service_instance, @@ -49,14 +49,14 @@ void AddEventsForNewService(FakeMdnsResponderAdapter* mdns_responder, uint16_t port, const std::vector<std::string>& txt_lines, const IPAddress& address, - platform::UdpSocket* socket); + UdpSocket* socket); class FakeMdnsResponderAdapter final : public MdnsResponderAdapter { public: struct RegisteredInterface { - platform::InterfaceInfo interface_info; - platform::IPSubnet interface_address; - platform::UdpSocket* socket; + InterfaceInfo interface_info; + IPSubnet interface_address; + UdpSocket* socket; }; struct RegisteredService { @@ -99,10 +99,9 @@ class FakeMdnsResponderAdapter final : public MdnsResponderAdapter { bool running() const { return running_; } // UdpSocket::Client overrides. - void OnRead(platform::UdpSocket* socket, - ErrorOr<platform::UdpPacket> packet) override; - void OnSendError(platform::UdpSocket* socket, Error error) override; - void OnError(platform::UdpSocket* socket, Error error) override; + void OnRead(UdpSocket* socket, ErrorOr<UdpPacket> packet) override; + void OnSendError(UdpSocket* socket, Error error) override; + void OnError(UdpSocket* socket, Error error) override; // MdnsResponderAdapter overrides. Error Init() override; @@ -112,12 +111,12 @@ class FakeMdnsResponderAdapter final : public MdnsResponderAdapter { // TODO(btolsch): Reject/OSP_CHECK events that don't match any registered // interface? - Error RegisterInterface(const platform::InterfaceInfo& interface_info, - const platform::IPSubnet& interface_address, - platform::UdpSocket* socket) override; - Error DeregisterInterface(platform::UdpSocket* socket) override; + Error RegisterInterface(const InterfaceInfo& interface_info, + const IPSubnet& interface_address, + UdpSocket* socket) override; + Error DeregisterInterface(UdpSocket* socket) override; - platform::Clock::duration RunTasks() override; + Clock::duration RunTasks() override; std::vector<PtrEvent> TakePtrResponses() override; std::vector<SrvEvent> TakeSrvResponses() override; @@ -125,30 +124,30 @@ class FakeMdnsResponderAdapter final : public MdnsResponderAdapter { std::vector<AEvent> TakeAResponses() override; std::vector<AaaaEvent> TakeAaaaResponses() override; - MdnsResponderErrorCode StartPtrQuery(platform::UdpSocket* socket, + MdnsResponderErrorCode StartPtrQuery(UdpSocket* socket, const DomainName& service_type) override; MdnsResponderErrorCode StartSrvQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) override; MdnsResponderErrorCode StartTxtQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) override; - MdnsResponderErrorCode StartAQuery(platform::UdpSocket* socket, + MdnsResponderErrorCode StartAQuery(UdpSocket* socket, const DomainName& domain_name) override; - MdnsResponderErrorCode StartAaaaQuery(platform::UdpSocket* socket, + MdnsResponderErrorCode StartAaaaQuery(UdpSocket* socket, const DomainName& domain_name) override; - MdnsResponderErrorCode StopPtrQuery(platform::UdpSocket* socket, + MdnsResponderErrorCode StopPtrQuery(UdpSocket* socket, const DomainName& service_type) override; MdnsResponderErrorCode StopSrvQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) override; MdnsResponderErrorCode StopTxtQuery( - platform::UdpSocket* socket, + UdpSocket* socket, const DomainName& service_instance) override; - MdnsResponderErrorCode StopAQuery(platform::UdpSocket* socket, + MdnsResponderErrorCode StopAQuery(UdpSocket* socket, const DomainName& domain_name) override; - MdnsResponderErrorCode StopAaaaQuery(platform::UdpSocket* socket, + MdnsResponderErrorCode StopAaaaQuery(UdpSocket* socket, const DomainName& domain_name) override; MdnsResponderErrorCode RegisterService( @@ -180,7 +179,7 @@ class FakeMdnsResponderAdapter final : public MdnsResponderAdapter { bool running_ = false; LifetimeObserver* observer_ = nullptr; - std::map<platform::UdpSocket*, InterfaceQueries> queries_; + std::map<UdpSocket*, InterfaceQueries> queries_; // NOTE: One of many simplifications here is that there is no cache. This // means that calling StartQuery, StopQuery, StartQuery will only return an // event the first time, unless the test also adds the event a second time. diff --git a/osp/impl/testing/fake_mdns_responder_adapter_unittest.cc b/osp/impl/testing/fake_mdns_responder_adapter_unittest.cc index f11ef33b..06cec89a 100644 --- a/osp/impl/testing/fake_mdns_responder_adapter_unittest.cc +++ b/osp/impl/testing/fake_mdns_responder_adapter_unittest.cc @@ -15,10 +15,10 @@ constexpr char kTestServiceInstance[] = "turtle"; constexpr char kTestServiceName[] = "_foo"; constexpr char kTestServiceProtocol[] = "_udp"; -platform::UdpSocket* const kDefaultSocket = - reinterpret_cast<platform::UdpSocket*>(static_cast<uintptr_t>(8)); -platform::UdpSocket* const kSecondSocket = - reinterpret_cast<platform::UdpSocket*>(static_cast<uintptr_t>(32)); +UdpSocket* const kDefaultSocket = + reinterpret_cast<UdpSocket*>(static_cast<uintptr_t>(8)); +UdpSocket* const kSecondSocket = + reinterpret_cast<UdpSocket*>(static_cast<uintptr_t>(32)); } // namespace @@ -260,18 +260,18 @@ TEST(FakeMdnsResponderAdapterTest, RegisterInterfaces) { ASSERT_TRUE(mdns_responder.running()); EXPECT_EQ(0u, mdns_responder.registered_interfaces().size()); - Error result = mdns_responder.RegisterInterface( - platform::InterfaceInfo{}, platform::IPSubnet{}, kDefaultSocket); + Error result = mdns_responder.RegisterInterface(InterfaceInfo{}, IPSubnet{}, + kDefaultSocket); EXPECT_TRUE(result.ok()); EXPECT_EQ(1u, mdns_responder.registered_interfaces().size()); - result = mdns_responder.RegisterInterface( - platform::InterfaceInfo{}, platform::IPSubnet{}, kDefaultSocket); + result = mdns_responder.RegisterInterface(InterfaceInfo{}, IPSubnet{}, + kDefaultSocket); EXPECT_FALSE(result.ok()); EXPECT_EQ(1u, mdns_responder.registered_interfaces().size()); - result = mdns_responder.RegisterInterface( - platform::InterfaceInfo{}, platform::IPSubnet{}, kSecondSocket); + result = mdns_responder.RegisterInterface(InterfaceInfo{}, IPSubnet{}, + kSecondSocket); EXPECT_TRUE(result.ok()); EXPECT_EQ(2u, mdns_responder.registered_interfaces().size()); @@ -286,8 +286,8 @@ TEST(FakeMdnsResponderAdapterTest, RegisterInterfaces) { ASSERT_FALSE(mdns_responder.running()); EXPECT_EQ(0u, mdns_responder.registered_interfaces().size()); - result = mdns_responder.RegisterInterface( - platform::InterfaceInfo{}, platform::IPSubnet{}, kDefaultSocket); + result = mdns_responder.RegisterInterface(InterfaceInfo{}, IPSubnet{}, + kDefaultSocket); EXPECT_FALSE(result.ok()); EXPECT_EQ(0u, mdns_responder.registered_interfaces().size()); } diff --git a/osp/msgs/request_response_handler.h b/osp/msgs/request_response_handler.h index 579739c7..82874420 100644 --- a/osp/msgs/request_response_handler.h +++ b/osp/msgs/request_response_handler.h @@ -160,7 +160,7 @@ class RequestResponseHandler : public MessageDemuxer::MessageCallback { msgs::Type message_type, const uint8_t* buffer, size_t buffer_size, - platform::Clock::time_point now) override { + Clock::time_point now) override { if (message_type != RequestT::kResponseType) { return 0; } diff --git a/osp/public/client_config.h b/osp/public/client_config.h index 732b52b6..ae172377 100644 --- a/osp/public/client_config.h +++ b/osp/public/client_config.h @@ -19,8 +19,8 @@ struct ClientConfig { // The indexes of network interfaces that should be used by the Open Screen // Library. The indexes derive from the values of - // openscreen::platform::InterfaceInfo::index. - std::vector<platform::NetworkInterfaceIndex> interface_indexes; + // openscreen::InterfaceInfo::index. + std::vector<NetworkInterfaceIndex> interface_indexes; }; } // namespace osp diff --git a/osp/public/mdns_service_listener_factory.h b/osp/public/mdns_service_listener_factory.h index 73118bda..663d060f 100644 --- a/osp/public/mdns_service_listener_factory.h +++ b/osp/public/mdns_service_listener_factory.h @@ -11,9 +11,7 @@ namespace openscreen { -namespace platform { class TaskRunner; -} // namespace platform namespace osp { @@ -27,7 +25,7 @@ class MdnsServiceListenerFactory { static std::unique_ptr<ServiceListener> Create( const MdnsServiceListenerConfig& config, ServiceListener::Observer* observer, - platform::TaskRunner* task_runner); + TaskRunner* task_runner); }; } // namespace osp diff --git a/osp/public/mdns_service_publisher_factory.h b/osp/public/mdns_service_publisher_factory.h index 4710d0fb..075137a7 100644 --- a/osp/public/mdns_service_publisher_factory.h +++ b/osp/public/mdns_service_publisher_factory.h @@ -11,9 +11,7 @@ namespace openscreen { -namespace platform { class TaskRunner; -} // namespace platform namespace osp { @@ -22,7 +20,7 @@ class MdnsServicePublisherFactory { static std::unique_ptr<ServicePublisher> Create( const ServicePublisher::Config& config, ServicePublisher::Observer* observer, - platform::TaskRunner* task_runner); + TaskRunner* task_runner); }; } // namespace osp diff --git a/osp/public/message_demuxer.cc b/osp/public/message_demuxer.cc index cabc910f..d67f848a 100644 --- a/osp/public/message_demuxer.cc +++ b/osp/public/message_demuxer.cc @@ -116,7 +116,7 @@ MessageDemuxer::MessageWatch& MessageDemuxer::MessageWatch::operator=( return *this; } -MessageDemuxer::MessageDemuxer(platform::ClockNowFunctionPtr now_function, +MessageDemuxer::MessageDemuxer(ClockNowFunctionPtr now_function, size_t buffer_limit = kDefaultBufferLimit) : now_function_(now_function), buffer_limit_(buffer_limit) { OSP_DCHECK(now_function_); diff --git a/osp/public/message_demuxer.h b/osp/public/message_demuxer.h index 5592ee8d..284e43ba 100644 --- a/osp/public/message_demuxer.h +++ b/osp/public/message_demuxer.h @@ -33,13 +33,12 @@ class MessageDemuxer { // error code of Error::Code::kCborIncompleteMessage. This way, // the MessageDemuxer knows to neither consume the data nor discard it as // bad. - virtual ErrorOr<size_t> OnStreamMessage( - uint64_t endpoint_id, - uint64_t connection_id, - msgs::Type message_type, - const uint8_t* buffer, - size_t buffer_size, - platform::Clock::time_point now) = 0; + virtual ErrorOr<size_t> OnStreamMessage(uint64_t endpoint_id, + uint64_t connection_id, + msgs::Type message_type, + const uint8_t* buffer, + size_t buffer_size, + Clock::time_point now) = 0; }; class MessageWatch { @@ -64,8 +63,7 @@ class MessageDemuxer { static constexpr size_t kDefaultBufferLimit = 1 << 16; - MessageDemuxer(platform::ClockNowFunctionPtr now_function, - size_t buffer_limit); + MessageDemuxer(ClockNowFunctionPtr now_function, size_t buffer_limit); ~MessageDemuxer(); // Starts watching for messages of type |message_type| from the endpoint @@ -110,7 +108,7 @@ class MessageDemuxer { std::map<msgs::Type, MessageCallback*>* message_callbacks, std::vector<uint8_t>* buffer); - const platform::ClockNowFunctionPtr now_function_; + const ClockNowFunctionPtr now_function_; const size_t buffer_limit_; std::map<uint64_t, std::map<msgs::Type, MessageCallback*>> message_callbacks_; std::map<msgs::Type, MessageCallback*> default_callbacks_; diff --git a/osp/public/message_demuxer_unittest.cc b/osp/public/message_demuxer_unittest.cc index 7e830815..63a03735 100644 --- a/osp/public/message_demuxer_unittest.cc +++ b/osp/public/message_demuxer_unittest.cc @@ -48,14 +48,12 @@ class MessageDemuxerTest : public ::testing::Test { const uint64_t endpoint_id_ = 13; const uint64_t connection_id_ = 45; - platform::FakeClock fake_clock_{ - platform::Clock::time_point(std::chrono::milliseconds(1298424))}; + FakeClock fake_clock_{Clock::time_point(std::chrono::milliseconds(1298424))}; msgs::CborEncodeBuffer buffer_; msgs::PresentationConnectionOpenRequest request_{1, "fry-am-the-egg-man", "url"}; MockMessageCallback mock_callback_; - MessageDemuxer demuxer_{platform::FakeClock::now, - MessageDemuxer::kDefaultBufferLimit}; + MessageDemuxer demuxer_{FakeClock::now, MessageDemuxer::kDefaultBufferLimit}; }; } // namespace @@ -75,15 +73,14 @@ TEST_F(MessageDemuxerTest, WatchStartStop) { mock_callback_, OnStreamMessage(endpoint_id_, connection_id_, msgs::Type::kPresentationConnectionOpenRequest, _, _, _)) - .WillOnce( - Invoke([&decode_result, &received_request]( - uint64_t endpoint_id, uint64_t connection_id, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - decode_result = msgs::DecodePresentationConnectionOpenRequest( - buffer, buffer_size, &received_request); - return ConvertDecodeResult(decode_result); - })); + .WillOnce(Invoke([&decode_result, &received_request]( + uint64_t endpoint_id, uint64_t connection_id, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + decode_result = msgs::DecodePresentationConnectionOpenRequest( + buffer, buffer_size, &received_request); + return ConvertDecodeResult(decode_result); + })); demuxer_.OnStreamData(endpoint_id_, connection_id_, buffer_.data(), buffer_.size()); ExpectDecodedRequest(decode_result, received_request); @@ -110,15 +107,14 @@ TEST_F(MessageDemuxerTest, BufferPartialMessage) { OnStreamMessage(endpoint_id_, connection_id_, msgs::Type::kPresentationConnectionOpenRequest, _, _, _)) .Times(2) - .WillRepeatedly( - Invoke([&decode_result, &received_request]( - uint64_t endpoint_id, uint64_t connection_id, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - decode_result = msgs::DecodePresentationConnectionOpenRequest( - buffer, buffer_size, &received_request); - return ConvertDecodeResult(decode_result); - })); + .WillRepeatedly(Invoke([&decode_result, &received_request]( + uint64_t endpoint_id, uint64_t connection_id, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + decode_result = msgs::DecodePresentationConnectionOpenRequest( + buffer, buffer_size, &received_request); + return ConvertDecodeResult(decode_result); + })); demuxer_.OnStreamData(endpoint_id_, connection_id_, buffer_.data(), buffer_.size() - 3); demuxer_.OnStreamData(endpoint_id_, connection_id_, @@ -140,15 +136,14 @@ TEST_F(MessageDemuxerTest, DefaultWatch) { mock_callback_, OnStreamMessage(endpoint_id_, connection_id_, msgs::Type::kPresentationConnectionOpenRequest, _, _, _)) - .WillOnce( - Invoke([&decode_result, &received_request]( - uint64_t endpoint_id, uint64_t connection_id, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - decode_result = msgs::DecodePresentationConnectionOpenRequest( - buffer, buffer_size, &received_request); - return ConvertDecodeResult(decode_result); - })); + .WillOnce(Invoke([&decode_result, &received_request]( + uint64_t endpoint_id, uint64_t connection_id, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + decode_result = msgs::DecodePresentationConnectionOpenRequest( + buffer, buffer_size, &received_request); + return ConvertDecodeResult(decode_result); + })); demuxer_.OnStreamData(endpoint_id_, connection_id_, buffer_.data(), buffer_.size()); ExpectDecodedRequest(decode_result, received_request); @@ -176,15 +171,14 @@ TEST_F(MessageDemuxerTest, DefaultWatchOverridden) { mock_callback_global, OnStreamMessage(endpoint_id_ + 1, 14, msgs::Type::kPresentationConnectionOpenRequest, _, _, _)) - .WillOnce( - Invoke([&decode_result, &received_request]( - uint64_t endpoint_id, uint64_t connection_id, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - decode_result = msgs::DecodePresentationConnectionOpenRequest( - buffer, buffer_size, &received_request); - return ConvertDecodeResult(decode_result); - })); + .WillOnce(Invoke([&decode_result, &received_request]( + uint64_t endpoint_id, uint64_t connection_id, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + decode_result = msgs::DecodePresentationConnectionOpenRequest( + buffer, buffer_size, &received_request); + return ConvertDecodeResult(decode_result); + })); demuxer_.OnStreamData(endpoint_id_ + 1, 14, buffer_.data(), buffer_.size()); ExpectDecodedRequest(decode_result, received_request); @@ -193,15 +187,14 @@ TEST_F(MessageDemuxerTest, DefaultWatchOverridden) { mock_callback_, OnStreamMessage(endpoint_id_, connection_id_, msgs::Type::kPresentationConnectionOpenRequest, _, _, _)) - .WillOnce( - Invoke([&decode_result, &received_request]( - uint64_t endpoint_id, uint64_t connection_id, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - decode_result = msgs::DecodePresentationConnectionOpenRequest( - buffer, buffer_size, &received_request); - return ConvertDecodeResult(decode_result); - })); + .WillOnce(Invoke([&decode_result, &received_request]( + uint64_t endpoint_id, uint64_t connection_id, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + decode_result = msgs::DecodePresentationConnectionOpenRequest( + buffer, buffer_size, &received_request); + return ConvertDecodeResult(decode_result); + })); demuxer_.OnStreamData(endpoint_id_, connection_id_, buffer_.data(), buffer_.size()); ExpectDecodedRequest(decode_result, received_request); @@ -214,15 +207,14 @@ TEST_F(MessageDemuxerTest, WatchAfterData) { mock_callback_, OnStreamMessage(endpoint_id_, connection_id_, msgs::Type::kPresentationConnectionOpenRequest, _, _, _)) - .WillOnce( - Invoke([&decode_result, &received_request]( - uint64_t endpoint_id, uint64_t connection_id, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - decode_result = msgs::DecodePresentationConnectionOpenRequest( - buffer, buffer_size, &received_request); - return ConvertDecodeResult(decode_result); - })); + .WillOnce(Invoke([&decode_result, &received_request]( + uint64_t endpoint_id, uint64_t connection_id, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + decode_result = msgs::DecodePresentationConnectionOpenRequest( + buffer, buffer_size, &received_request); + return ConvertDecodeResult(decode_result); + })); MessageDemuxer::MessageWatch watch = demuxer_.WatchMessageType( endpoint_id_, msgs::Type::kPresentationConnectionOpenRequest, &mock_callback_); @@ -245,27 +237,25 @@ TEST_F(MessageDemuxerTest, WatchAfterMultipleData) { mock_callback_, OnStreamMessage(endpoint_id_, connection_id_, msgs::Type::kPresentationConnectionOpenRequest, _, _, _)) - .WillOnce( - Invoke([&decode_result1, &received_request]( - uint64_t endpoint_id, uint64_t connection_id, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - decode_result1 = msgs::DecodePresentationConnectionOpenRequest( - buffer, buffer_size, &received_request); - return ConvertDecodeResult(decode_result1); - })); + .WillOnce(Invoke([&decode_result1, &received_request]( + uint64_t endpoint_id, uint64_t connection_id, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + decode_result1 = msgs::DecodePresentationConnectionOpenRequest( + buffer, buffer_size, &received_request); + return ConvertDecodeResult(decode_result1); + })); EXPECT_CALL(mock_init_callback, OnStreamMessage(endpoint_id_, connection_id_, msgs::Type::kPresentationStartRequest, _, _, _)) - .WillOnce( - Invoke([&decode_result2, &received_init_request]( - uint64_t endpoint_id, uint64_t connection_id, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - decode_result2 = msgs::DecodePresentationStartRequest( - buffer, buffer_size, &received_init_request); - return ConvertDecodeResult(decode_result2); - })); + .WillOnce(Invoke([&decode_result2, &received_init_request]( + uint64_t endpoint_id, uint64_t connection_id, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + decode_result2 = msgs::DecodePresentationStartRequest( + buffer, buffer_size, &received_init_request); + return ConvertDecodeResult(decode_result2); + })); MessageDemuxer::MessageWatch watch = demuxer_.WatchMessageType( endpoint_id_, msgs::Type::kPresentationConnectionOpenRequest, &mock_callback_); @@ -296,15 +286,14 @@ TEST_F(MessageDemuxerTest, GlobalWatchAfterData) { mock_callback_, OnStreamMessage(endpoint_id_, connection_id_, msgs::Type::kPresentationConnectionOpenRequest, _, _, _)) - .WillOnce( - Invoke([&decode_result, &received_request]( - uint64_t endpoint_id, uint64_t connection_id, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - decode_result = msgs::DecodePresentationConnectionOpenRequest( - buffer, buffer_size, &received_request); - return ConvertDecodeResult(decode_result); - })); + .WillOnce(Invoke([&decode_result, &received_request]( + uint64_t endpoint_id, uint64_t connection_id, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + decode_result = msgs::DecodePresentationConnectionOpenRequest( + buffer, buffer_size, &received_request); + return ConvertDecodeResult(decode_result); + })); MessageDemuxer::MessageWatch watch = demuxer_.SetDefaultMessageTypeWatch( msgs::Type::kPresentationConnectionOpenRequest, &mock_callback_); ASSERT_TRUE(watch); @@ -314,7 +303,7 @@ TEST_F(MessageDemuxerTest, GlobalWatchAfterData) { } TEST_F(MessageDemuxerTest, BufferLimit) { - MessageDemuxer demuxer(platform::FakeClock::now, 10); + MessageDemuxer demuxer(FakeClock::now, 10); demuxer.OnStreamData(endpoint_id_, connection_id_, buffer_.data(), buffer_.size()); @@ -329,15 +318,14 @@ TEST_F(MessageDemuxerTest, BufferLimit) { mock_callback_, OnStreamMessage(endpoint_id_, connection_id_, msgs::Type::kPresentationConnectionOpenRequest, _, _, _)) - .WillOnce( - Invoke([&decode_result, &received_request]( - uint64_t endpoint_id, uint64_t connection_id, - msgs::Type message_type, const uint8_t* buffer, - size_t buffer_size, platform::Clock::time_point now) { - decode_result = msgs::DecodePresentationConnectionOpenRequest( - buffer, buffer_size, &received_request); - return ConvertDecodeResult(decode_result); - })); + .WillOnce(Invoke([&decode_result, &received_request]( + uint64_t endpoint_id, uint64_t connection_id, + msgs::Type message_type, const uint8_t* buffer, + size_t buffer_size, Clock::time_point now) { + decode_result = msgs::DecodePresentationConnectionOpenRequest( + buffer, buffer_size, &received_request); + return ConvertDecodeResult(decode_result); + })); demuxer.OnStreamData(endpoint_id_, connection_id_, buffer_.data(), buffer_.size()); ExpectDecodedRequest(decode_result, received_request); diff --git a/osp/public/presentation/presentation_connection.h b/osp/public/presentation/presentation_connection.h index 5382fec3..293e942f 100644 --- a/osp/public/presentation/presentation_connection.h +++ b/osp/public/presentation/presentation_connection.h @@ -196,7 +196,7 @@ class ConnectionManager final : public MessageDemuxer::MessageCallback { msgs::Type message_type, const uint8_t* buffer, size_t buffer_size, - platform::Clock::time_point now) override; + Clock::time_point now) override; Connection* GetConnection(uint64_t connection_id); diff --git a/osp/public/presentation/presentation_controller.h b/osp/public/presentation/presentation_controller.h index 6d51329d..d0a5ee81 100644 --- a/osp/public/presentation/presentation_controller.h +++ b/osp/public/presentation/presentation_controller.h @@ -96,7 +96,7 @@ class Controller final : public ServiceListener::Observer, Controller* controller_; }; - explicit Controller(platform::ClockNowFunctionPtr now_function); + explicit Controller(ClockNowFunctionPtr now_function); ~Controller(); // Requests receivers compatible with all urls in |urls| and registers diff --git a/osp/public/presentation/presentation_receiver.h b/osp/public/presentation/presentation_receiver.h index 3f87c0c5..4eb4a04c 100644 --- a/osp/public/presentation/presentation_receiver.h +++ b/osp/public/presentation/presentation_receiver.h @@ -97,7 +97,7 @@ class Receiver final : public MessageDemuxer::MessageCallback, msgs::Type message_type, const uint8_t* buffer, size_t buffer_size, - platform::Clock::time_point now) override; + Clock::time_point now) override; private: struct QueuedResponse { diff --git a/osp/public/protocol_connection_client_factory.h b/osp/public/protocol_connection_client_factory.h index 8672c16b..e30d6216 100644 --- a/osp/public/protocol_connection_client_factory.h +++ b/osp/public/protocol_connection_client_factory.h @@ -11,9 +11,7 @@ namespace openscreen { -namespace platform { class TaskRunner; -} // namespace platform namespace osp { @@ -22,7 +20,7 @@ class ProtocolConnectionClientFactory { static std::unique_ptr<ProtocolConnectionClient> Create( MessageDemuxer* demuxer, ProtocolConnectionServiceObserver* observer, - platform::TaskRunner* task_runner); + TaskRunner* task_runner); }; } // namespace osp diff --git a/osp/public/protocol_connection_server_factory.h b/osp/public/protocol_connection_server_factory.h index 0f11b8a2..0e55eedd 100644 --- a/osp/public/protocol_connection_server_factory.h +++ b/osp/public/protocol_connection_server_factory.h @@ -12,9 +12,7 @@ namespace openscreen { -namespace platform { class TaskRunner; -} namespace osp { @@ -24,7 +22,7 @@ class ProtocolConnectionServerFactory { const ServerConfig& config, MessageDemuxer* demuxer, ProtocolConnectionServer::Observer* observer, - platform::TaskRunner* task_runner); + TaskRunner* task_runner); }; } // namespace osp diff --git a/osp/public/server_config.h b/osp/public/server_config.h index 579fe361..e4f95d8a 100644 --- a/osp/public/server_config.h +++ b/osp/public/server_config.h @@ -20,8 +20,8 @@ struct ServerConfig { // The indexes of network interfaces that should be used by the Open Screen // Library. The indexes derive from the values of - // openscreen::platform::InterfaceInfo::index. - std::vector<platform::NetworkInterfaceIndex> interface_indexes; + // openscreen::InterfaceInfo::index. + std::vector<NetworkInterfaceIndex> interface_indexes; // The list of connection endpoints that are advertised for Open Screen // protocol connections. These must be reachable via one interface in diff --git a/osp/public/service_info.cc b/osp/public/service_info.cc index ebd41b27..77943ca4 100644 --- a/osp/public/service_info.cc +++ b/osp/public/service_info.cc @@ -23,11 +23,10 @@ bool ServiceInfo::operator!=(const ServiceInfo& other) const { return !(*this == other); } -bool ServiceInfo::Update( - std::string new_friendly_name, - platform::NetworkInterfaceIndex new_network_interface_index, - const IPEndpoint& new_v4_endpoint, - const IPEndpoint& new_v6_endpoint) { +bool ServiceInfo::Update(std::string new_friendly_name, + NetworkInterfaceIndex new_network_interface_index, + const IPEndpoint& new_v4_endpoint, + const IPEndpoint& new_v6_endpoint) { OSP_DCHECK(!new_v4_endpoint.address || IPAddress::Version::kV4 == new_v4_endpoint.address.version()); OSP_DCHECK(!new_v6_endpoint.address || diff --git a/osp/public/service_info.h b/osp/public/service_info.h index df9d8e36..73e43eb6 100644 --- a/osp/public/service_info.h +++ b/osp/public/service_info.h @@ -29,7 +29,7 @@ struct ServiceInfo { bool operator!=(const ServiceInfo& other) const; bool Update(std::string friendly_name, - platform::NetworkInterfaceIndex network_interface_index, + NetworkInterfaceIndex network_interface_index, const IPEndpoint& v4_endpoint, const IPEndpoint& v6_endpoint); @@ -40,8 +40,7 @@ struct ServiceInfo { std::string friendly_name; // The index of the network interface that the screen was discovered on. - platform::NetworkInterfaceIndex network_interface_index = - platform::kInvalidNetworkInterfaceIndex; + NetworkInterfaceIndex network_interface_index = kInvalidNetworkInterfaceIndex; // The network endpoints to create a new connection to the Open Screen // service. diff --git a/osp/public/service_publisher.h b/osp/public/service_publisher.h index a5fac6a2..ef94042d 100644 --- a/osp/public/service_publisher.h +++ b/osp/public/service_publisher.h @@ -108,7 +108,7 @@ class ServicePublisher { // By default, all enabled Ethernet and WiFi interfaces are used. // This configuration must be identical to the interfaces configured // in the ScreenConnectionServer. - std::vector<platform::NetworkInterfaceIndex> network_interface_indices; + std::vector<NetworkInterfaceIndex> network_interface_indices; }; virtual ~ServicePublisher(); diff --git a/osp/public/testing/message_demuxer_test_support.h b/osp/public/testing/message_demuxer_test_support.h index 7ba1e36b..cde458c2 100644 --- a/osp/public/testing/message_demuxer_test_support.h +++ b/osp/public/testing/message_demuxer_test_support.h @@ -22,7 +22,7 @@ class MockMessageCallback final : public MessageDemuxer::MessageCallback { msgs::Type message_type, const uint8_t* buffer, size_t buffer_size, - platform::Clock::time_point now)); + Clock::time_point now)); }; } // namespace osp diff --git a/platform/api/logging.h b/platform/api/logging.h index 0dea6d4b..6080b77c 100644 --- a/platform/api/logging.h +++ b/platform/api/logging.h @@ -8,7 +8,6 @@ #include <sstream> namespace openscreen { -namespace platform { enum class LogLevel { // Very detailed information, often used for evaluating performance or @@ -58,7 +57,6 @@ void LogWithLevel(LogLevel level, // aborting the process. void Break(); -} // namespace platform } // namespace openscreen #endif // PLATFORM_API_LOGGING_H_ diff --git a/platform/api/network_interface.h b/platform/api/network_interface.h index f0e53e17..28ebd2fe 100644 --- a/platform/api/network_interface.h +++ b/platform/api/network_interface.h @@ -10,7 +10,6 @@ #include "platform/base/interface_info.h" namespace openscreen { -namespace platform { // Returns an InterfaceInfo for each currently active network interface on the // system. No two entries in this vector can have the same NetworkInterfaceIndex @@ -22,7 +21,6 @@ namespace platform { // discovery) are not being used. std::vector<InterfaceInfo> GetNetworkInterfaces(); -} // namespace platform } // namespace openscreen #endif // PLATFORM_API_NETWORK_INTERFACE_H_ diff --git a/platform/api/scoped_wake_lock.cc b/platform/api/scoped_wake_lock.cc index ad8442e0..73a946e1 100644 --- a/platform/api/scoped_wake_lock.cc +++ b/platform/api/scoped_wake_lock.cc @@ -5,10 +5,8 @@ #include "platform/api/scoped_wake_lock.h" namespace openscreen { -namespace platform { ScopedWakeLock::ScopedWakeLock() = default; ScopedWakeLock::~ScopedWakeLock() = default; -} // namespace platform } // namespace openscreen diff --git a/platform/api/scoped_wake_lock.h b/platform/api/scoped_wake_lock.h index 64d69ecb..2843be4e 100644 --- a/platform/api/scoped_wake_lock.h +++ b/platform/api/scoped_wake_lock.h @@ -8,7 +8,6 @@ #include <memory> namespace openscreen { -namespace platform { // Ensures that the device does not got to sleep. This is used, for example, // while Open Screen is communicating with peers over the network for things @@ -33,7 +32,6 @@ class ScopedWakeLock { virtual ~ScopedWakeLock(); }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_API_SCOPED_WAKE_LOCK_H_ diff --git a/platform/api/socket_integration_unittest.cc b/platform/api/socket_integration_unittest.cc index 3014507f..3704dbcb 100644 --- a/platform/api/socket_integration_unittest.cc +++ b/platform/api/socket_integration_unittest.cc @@ -9,7 +9,6 @@ #include "platform/test/fake_udp_socket.h" namespace openscreen { -namespace platform { using testing::_; @@ -21,7 +20,7 @@ TEST(SocketIntegrationTest, ResolvesLocalEndpoint_IPv4) { FakeClock clock(Clock::now()); FakeTaskRunner task_runner(&clock); FakeUdpSocket::MockClient client; - ErrorOr<UdpSocketUniquePtr> create_result = UdpSocket::Create( + ErrorOr<std::unique_ptr<UdpSocket>> create_result = UdpSocket::Create( &task_runner, &client, IPEndpoint{IPAddress(kIpV4AddrAny), 0}); ASSERT_TRUE(create_result) << create_result.error(); const auto socket = std::move(create_result.value()); @@ -39,7 +38,7 @@ TEST(SocketIntegrationTest, ResolvesLocalEndpoint_IPv6) { FakeClock clock(Clock::now()); FakeTaskRunner task_runner(&clock); FakeUdpSocket::MockClient client; - ErrorOr<UdpSocketUniquePtr> create_result = UdpSocket::Create( + ErrorOr<std::unique_ptr<UdpSocket>> create_result = UdpSocket::Create( &task_runner, &client, IPEndpoint{IPAddress(kIpV6AddrAny), 0}); ASSERT_TRUE(create_result) << create_result.error(); const auto socket = std::move(create_result.value()); @@ -49,5 +48,4 @@ TEST(SocketIntegrationTest, ResolvesLocalEndpoint_IPv6) { EXPECT_NE(local_endpoint.port, 0) << local_endpoint; } -} // namespace platform } // namespace openscreen diff --git a/platform/api/task_runner.h b/platform/api/task_runner.h index 4f3526d5..b10e5ec7 100644 --- a/platform/api/task_runner.h +++ b/platform/api/task_runner.h @@ -11,7 +11,6 @@ #include "platform/api/time.h" namespace openscreen { -namespace platform { // A thread-safe API surface that allows for posting tasks. The underlying // implementation may be single or multi-threaded, and all complication should @@ -53,7 +52,6 @@ class TaskRunner { virtual bool IsRunningOnTaskRunner() { return true; } }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_API_TASK_RUNNER_H_ diff --git a/platform/api/time.h b/platform/api/time.h index af0dda75..dcf24acc 100644 --- a/platform/api/time.h +++ b/platform/api/time.h @@ -10,7 +10,6 @@ #include "platform/base/trivial_clock_traits.h" namespace openscreen { -namespace platform { // The "reasonably high-resolution" source of monotonic time from the embedder, // exhibiting the traits described in TrivialClockTraits. This class is not @@ -33,7 +32,6 @@ class Clock : public TrivialClockTraits { // time." std::chrono::seconds GetWallTimeSinceUnixEpoch() noexcept; -} // namespace platform } // namespace openscreen #endif // PLATFORM_API_TIME_H_ diff --git a/platform/api/time_unittest.cc b/platform/api/time_unittest.cc index 9a4f40cb..2bef8250 100644 --- a/platform/api/time_unittest.cc +++ b/platform/api/time_unittest.cc @@ -12,7 +12,6 @@ using std::chrono::microseconds; using std::chrono::milliseconds; namespace openscreen { -namespace platform { namespace { // Tests that the clock always seems to tick forward. If this test is broken, or @@ -56,5 +55,4 @@ TEST(TimeTest, PlatformClockHasSufficientResolution) { } } // namespace -} // namespace platform } // namespace openscreen diff --git a/platform/api/tls_connection.cc b/platform/api/tls_connection.cc index fc3a8c8e..9668c114 100644 --- a/platform/api/tls_connection.cc +++ b/platform/api/tls_connection.cc @@ -5,10 +5,8 @@ #include "platform/api/tls_connection.h" namespace openscreen { -namespace platform { TlsConnection::TlsConnection() = default; TlsConnection::~TlsConnection() = default; -} // namespace platform } // namespace openscreen diff --git a/platform/api/tls_connection.h b/platform/api/tls_connection.h index 7c2777fb..82825ab9 100644 --- a/platform/api/tls_connection.h +++ b/platform/api/tls_connection.h @@ -12,7 +12,6 @@ #include "platform/base/ip_address.h" namespace openscreen { -namespace platform { class TlsConnection { public: @@ -58,7 +57,6 @@ class TlsConnection { TlsConnection(); }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_API_TLS_CONNECTION_H_ diff --git a/platform/api/tls_connection_factory.cc b/platform/api/tls_connection_factory.cc index a3bfb287..e64078f1 100644 --- a/platform/api/tls_connection_factory.cc +++ b/platform/api/tls_connection_factory.cc @@ -5,10 +5,8 @@ #include "platform/api/tls_connection_factory.h" namespace openscreen { -namespace platform { TlsConnectionFactory::TlsConnectionFactory() = default; TlsConnectionFactory::~TlsConnectionFactory() = default; -} // namespace platform } // namespace openscreen diff --git a/platform/api/tls_connection_factory.h b/platform/api/tls_connection_factory.h index eed6893f..3f8a65db 100644 --- a/platform/api/tls_connection_factory.h +++ b/platform/api/tls_connection_factory.h @@ -13,7 +13,6 @@ #include "platform/base/ip_address.h" namespace openscreen { -namespace platform { class TaskRunner; class TlsConnection; @@ -75,7 +74,6 @@ class TlsConnectionFactory { TlsConnectionFactory(); }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_API_TLS_CONNECTION_FACTORY_H_ diff --git a/platform/api/trace_logging_platform.cc b/platform/api/trace_logging_platform.cc index 2725b404..35be2bf3 100644 --- a/platform/api/trace_logging_platform.cc +++ b/platform/api/trace_logging_platform.cc @@ -5,9 +5,7 @@ #include "platform/api/trace_logging_platform.h" namespace openscreen { -namespace platform { TraceLoggingPlatform::~TraceLoggingPlatform() = default; -} // namespace platform } // namespace openscreen diff --git a/platform/api/trace_logging_platform.h b/platform/api/trace_logging_platform.h index 76c7e7a9..7d4e0d6e 100644 --- a/platform/api/trace_logging_platform.h +++ b/platform/api/trace_logging_platform.h @@ -11,7 +11,6 @@ #include "platform/base/trace_logging_types.h" namespace openscreen { -namespace platform { // Optional platform API to support logging trace events from Open Screen. To // use this, implement the TraceLoggingPlatform interface and call @@ -48,7 +47,6 @@ class TraceLoggingPlatform { Error::Code error) = 0; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_API_TRACE_LOGGING_PLATFORM_H_ diff --git a/platform/api/udp_socket.cc b/platform/api/udp_socket.cc index 60262cab..2da7a73f 100644 --- a/platform/api/udp_socket.cc +++ b/platform/api/udp_socket.cc @@ -5,10 +5,8 @@ #include "platform/api/udp_socket.h" namespace openscreen { -namespace platform { UdpSocket::UdpSocket() = default; UdpSocket::~UdpSocket() = default; -} // namespace platform } // namespace openscreen diff --git a/platform/api/udp_socket.h b/platform/api/udp_socket.h index e76b9eb8..0bc8aff8 100644 --- a/platform/api/udp_socket.h +++ b/platform/api/udp_socket.h @@ -17,13 +17,10 @@ #include "platform/base/udp_packet.h" namespace openscreen { -namespace platform { class TaskRunner; class UdpSocket; -using UdpSocketUniquePtr = std::unique_ptr<UdpSocket>; - // An open UDP socket for sending/receiving datagrams to/from either specific // endpoints or over IP multicast. // @@ -75,9 +72,10 @@ class UdpSocket { // will be queued on the provided |task_runner|. For this reason, the provided // TaskRunner and Client must exist for the duration of the created socket's // lifetime. - static ErrorOr<UdpSocketUniquePtr> Create(TaskRunner* task_runner, - Client* client, - const IPEndpoint& local_endpoint); + static ErrorOr<std::unique_ptr<UdpSocket>> Create( + TaskRunner* task_runner, + Client* client, + const IPEndpoint& local_endpoint); virtual ~UdpSocket(); @@ -119,7 +117,6 @@ class UdpSocket { UdpSocket(); }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_API_UDP_SOCKET_H_ diff --git a/platform/base/interface_info.cc b/platform/base/interface_info.cc index b8baff97..a71833a9 100644 --- a/platform/base/interface_info.cc +++ b/platform/base/interface_info.cc @@ -5,7 +5,6 @@ #include "platform/base/interface_info.h" namespace openscreen { -namespace platform { InterfaceInfo::InterfaceInfo() = default; InterfaceInfo::InterfaceInfo(NetworkInterfaceIndex index, @@ -63,5 +62,4 @@ std::ostream& operator<<(std::ostream& out, const InterfaceInfo& info) { return out << '}'; } -} // namespace platform } // namespace openscreen diff --git a/platform/base/interface_info.h b/platform/base/interface_info.h index af0c35b6..cc01ccdb 100644 --- a/platform/base/interface_info.h +++ b/platform/base/interface_info.h @@ -13,7 +13,6 @@ #include "platform/base/ip_address.h" namespace openscreen { -namespace platform { // Unique identifier, usually provided by the operating system, for identifying // a specific network interface. This value is used with UdpSocket to join @@ -75,7 +74,6 @@ struct InterfaceInfo { std::ostream& operator<<(std::ostream& out, const IPSubnet& subnet); std::ostream& operator<<(std::ostream& out, const InterfaceInfo& info); -} // namespace platform } // namespace openscreen #endif // PLATFORM_BASE_INTERFACE_INFO_H_ diff --git a/platform/base/socket_state.h b/platform/base/socket_state.h index bd82dd29..7672c4f5 100644 --- a/platform/base/socket_state.h +++ b/platform/base/socket_state.h @@ -10,7 +10,6 @@ #include <string> namespace openscreen { -namespace platform { // SocketState should be used by TCP and TLS sockets for indicating // current state. NOTE: socket state transitions should only happen in @@ -30,7 +29,6 @@ enum class SocketState { kClosed }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_BASE_SOCKET_STATE_H_ diff --git a/platform/base/tls_connect_options.h b/platform/base/tls_connect_options.h index 12a0cd26..dcaebe0a 100644 --- a/platform/base/tls_connect_options.h +++ b/platform/base/tls_connect_options.h @@ -8,7 +8,6 @@ #include "platform/base/macros.h" namespace openscreen { -namespace platform { struct TlsConnectOptions { // This option allows TLS connections to devices without @@ -17,7 +16,6 @@ struct TlsConnectOptions { bool unsafely_skip_certificate_validation; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_BASE_TLS_CONNECT_OPTIONS_H_ diff --git a/platform/base/tls_credentials.cc b/platform/base/tls_credentials.cc index 9493f597..7f7af41e 100644 --- a/platform/base/tls_credentials.cc +++ b/platform/base/tls_credentials.cc @@ -5,7 +5,6 @@ #include "platform/base/tls_credentials.h" namespace openscreen { -namespace platform { TlsCredentials::TlsCredentials() = default; @@ -18,5 +17,4 @@ TlsCredentials::TlsCredentials(std::vector<uint8_t> der_rsa_private_key, TlsCredentials::~TlsCredentials() = default; -} // namespace platform } // namespace openscreen diff --git a/platform/base/tls_credentials.h b/platform/base/tls_credentials.h index 8c5162dc..285e2705 100644 --- a/platform/base/tls_credentials.h +++ b/platform/base/tls_credentials.h @@ -10,7 +10,6 @@ #include <vector> namespace openscreen { -namespace platform { struct TlsCredentials { TlsCredentials(); @@ -29,7 +28,6 @@ struct TlsCredentials { std::vector<uint8_t> der_x509_cert; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_BASE_TLS_CREDENTIALS_H_ diff --git a/platform/base/tls_listen_options.h b/platform/base/tls_listen_options.h index 32cab160..da47b661 100644 --- a/platform/base/tls_listen_options.h +++ b/platform/base/tls_listen_options.h @@ -10,13 +10,11 @@ #include "platform/base/macros.h" namespace openscreen { -namespace platform { struct TlsListenOptions { uint32_t backlog_size; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_BASE_TLS_LISTEN_OPTIONS_H_ diff --git a/platform/base/trace_logging_activation.cc b/platform/base/trace_logging_activation.cc index dd7ac6c3..3645fe36 100644 --- a/platform/base/trace_logging_activation.cc +++ b/platform/base/trace_logging_activation.cc @@ -7,7 +7,6 @@ #include <cassert> namespace openscreen { -namespace platform { namespace { TraceLoggingPlatform* g_current_destination = nullptr; @@ -28,5 +27,4 @@ void StopTracing() { g_current_destination = nullptr; } -} // namespace platform } // namespace openscreen diff --git a/platform/base/trace_logging_activation.h b/platform/base/trace_logging_activation.h index 05be7343..239eaffb 100644 --- a/platform/base/trace_logging_activation.h +++ b/platform/base/trace_logging_activation.h @@ -6,7 +6,6 @@ #define PLATFORM_BASE_TRACE_LOGGING_ACTIVATION_H_ namespace openscreen { -namespace platform { class TraceLoggingPlatform; @@ -19,7 +18,6 @@ void StopTracing(); // nullptr. TraceLoggingPlatform* GetTracingDestination(); -} // namespace platform } // namespace openscreen #endif // PLATFORM_BASE_TRACE_LOGGING_ACTIVATION_H_ diff --git a/platform/base/trace_logging_types.h b/platform/base/trace_logging_types.h index b27fb74d..25b31331 100644 --- a/platform/base/trace_logging_types.h +++ b/platform/base/trace_logging_types.h @@ -10,7 +10,6 @@ #include <limits> namespace openscreen { -namespace platform { // Define TraceId type here since other TraceLogging files import it. using TraceId = uint64_t; @@ -64,7 +63,6 @@ struct TraceCategory { }; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_BASE_TRACE_LOGGING_TYPES_H_ diff --git a/platform/base/trivial_clock_traits.cc b/platform/base/trivial_clock_traits.cc index 3be1c783..2694adb1 100644 --- a/platform/base/trivial_clock_traits.cc +++ b/platform/base/trivial_clock_traits.cc @@ -7,13 +7,13 @@ namespace openscreen { std::ostream& operator<<(std::ostream& os, - const platform::TrivialClockTraits::duration& d) { + const TrivialClockTraits::duration& d) { constexpr char kUnits[] = "\u03BCs"; // Greek Mu + "s" return os << d.count() << kUnits; } std::ostream& operator<<(std::ostream& os, - const platform::TrivialClockTraits::time_point& tp) { + const TrivialClockTraits::time_point& tp) { constexpr char kUnits[] = "\u03BCs-ticks"; // Greek Mu + "s-ticks" return os << tp.time_since_epoch().count() << kUnits; } diff --git a/platform/base/trivial_clock_traits.h b/platform/base/trivial_clock_traits.h index b5392c43..b78eadd7 100644 --- a/platform/base/trivial_clock_traits.h +++ b/platform/base/trivial_clock_traits.h @@ -9,7 +9,6 @@ #include <ostream> namespace openscreen { -namespace platform { // The Open Screen monotonic clock traits description, providing all the C++14 // requirements of a TrivialClock, for use with STL <chrono>. @@ -44,16 +43,14 @@ class TrivialClockTraits { // &Clock::now versus something else for testing). using ClockNowFunctionPtr = TrivialClockTraits::time_point (*)(); -} // namespace platform - // Logging convenience for durations. Outputs a string of the form "123µs". std::ostream& operator<<(std::ostream& os, - const platform::TrivialClockTraits::duration& d); + const TrivialClockTraits::duration& d); // Logging convenience for time points. Outputs a string of the form // "123µs-ticks". std::ostream& operator<<(std::ostream& os, - const platform::TrivialClockTraits::time_point& tp); + const TrivialClockTraits::time_point& tp); } // namespace openscreen diff --git a/platform/base/udp_packet.cc b/platform/base/udp_packet.cc index d8ad75e4..2eb906df 100644 --- a/platform/base/udp_packet.cc +++ b/platform/base/udp_packet.cc @@ -7,7 +7,6 @@ #include <cassert> namespace openscreen { -namespace platform { UdpPacket::UdpPacket() : std::vector<uint8_t>() {} @@ -31,5 +30,4 @@ UdpPacket::~UdpPacket() = default; UdpPacket& UdpPacket::operator=(UdpPacket&& other) = default; -} // namespace platform } // namespace openscreen diff --git a/platform/base/udp_packet.h b/platform/base/udp_packet.h index 479cee59..b25cb8c1 100644 --- a/platform/base/udp_packet.h +++ b/platform/base/udp_packet.h @@ -14,7 +14,6 @@ #include "platform/base/ip_address.h" namespace openscreen { -namespace platform { class UdpSocket; @@ -60,7 +59,6 @@ class UdpPacket : public std::vector<uint8_t> { OSP_DISALLOW_COPY_AND_ASSIGN(UdpPacket); }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_BASE_UDP_PACKET_H_ diff --git a/platform/impl/logging.h b/platform/impl/logging.h index 033691f8..85d6abcd 100644 --- a/platform/impl/logging.h +++ b/platform/impl/logging.h @@ -8,7 +8,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { // Direct all logging output to a named FIFO having the given |filename|. If the // file does not exist, an attempt is made to auto-create it. If unsuccessful, @@ -20,7 +19,6 @@ void SetLogFifoOrDie(const char* filename); // default. void SetLogLevel(LogLevel level); -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_LOGGING_H_ diff --git a/platform/impl/logging_posix.cc b/platform/impl/logging_posix.cc index 5d1d7388..412876ce 100644 --- a/platform/impl/logging_posix.cc +++ b/platform/impl/logging_posix.cc @@ -16,7 +16,6 @@ #include "util/trace_logging.h" namespace openscreen { -namespace platform { namespace { int g_log_fd = STDERR_FILENO; @@ -109,5 +108,4 @@ void Break() { #endif } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/network_interface_linux.cc b/platform/impl/network_interface_linux.cc index 5f432265..4e4cf426 100644 --- a/platform/impl/network_interface_linux.cc +++ b/platform/impl/network_interface_linux.cc @@ -29,7 +29,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { namespace { constexpr int kNetlinkRecvmsgBufSize = 8192; @@ -357,5 +356,4 @@ std::vector<InterfaceInfo> GetNetworkInterfaces() { return interfaces; } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/network_interface_mac.cc b/platform/impl/network_interface_mac.cc index 138d4918..fcefbf39 100644 --- a/platform/impl/network_interface_mac.cc +++ b/platform/impl/network_interface_mac.cc @@ -23,7 +23,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { namespace { @@ -173,5 +172,4 @@ std::vector<InterfaceInfo> GetNetworkInterfaces() { return results; } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/platform_client_posix.cc b/platform/impl/platform_client_posix.cc index f31f19aa..a6dec968 100644 --- a/platform/impl/platform_client_posix.cc +++ b/platform/impl/platform_client_posix.cc @@ -9,7 +9,6 @@ #include "platform/impl/udp_socket_reader_posix.h" namespace openscreen { -namespace platform { // static PlatformClientPosix* PlatformClientPosix::instance_ = nullptr; @@ -125,5 +124,4 @@ PlatformClientPosix::networking_operations() { }}; } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/platform_client_posix.h b/platform/impl/platform_client_posix.h index 57b0cf75..af1e71d3 100644 --- a/platform/impl/platform_client_posix.h +++ b/platform/impl/platform_client_posix.h @@ -18,7 +18,6 @@ #include "util/operation_loop.h" namespace openscreen { -namespace platform { class UdpSocketReaderPosix; @@ -125,7 +124,6 @@ class PlatformClientPosix { OSP_DISALLOW_COPY_AND_ASSIGN(PlatformClientPosix); }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_PLATFORM_CLIENT_POSIX_H_ diff --git a/platform/impl/scoped_wake_lock_mac.cc b/platform/impl/scoped_wake_lock_mac.cc index 70b9e2dd..3cd7f11a 100644 --- a/platform/impl/scoped_wake_lock_mac.cc +++ b/platform/impl/scoped_wake_lock_mac.cc @@ -11,7 +11,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { ScopedWakeLockMac::LockState ScopedWakeLockMac::lock_state_{}; @@ -70,5 +69,4 @@ void ScopedWakeLockMac::ReleaseWakeLock() { OSP_DCHECK_EQ(result, kIOReturnSuccess); } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/scoped_wake_lock_mac.h b/platform/impl/scoped_wake_lock_mac.h index 4e7d2031..1d1a2f41 100644 --- a/platform/impl/scoped_wake_lock_mac.h +++ b/platform/impl/scoped_wake_lock_mac.h @@ -10,7 +10,6 @@ #include "platform/api/scoped_wake_lock.h" namespace openscreen { -namespace platform { class ScopedWakeLockMac : public ScopedWakeLock { public: @@ -29,7 +28,6 @@ class ScopedWakeLockMac : public ScopedWakeLock { static LockState lock_state_; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_SCOPED_WAKE_LOCK_MAC_H_ diff --git a/platform/impl/socket_address_posix.cc b/platform/impl/socket_address_posix.cc index 36dc21f2..ebe70242 100644 --- a/platform/impl/socket_address_posix.cc +++ b/platform/impl/socket_address_posix.cc @@ -10,7 +10,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { SocketAddressPosix::SocketAddressPosix(const struct sockaddr& address) { if (address.sa_family == AF_INET) { @@ -83,5 +82,4 @@ socklen_t SocketAddressPosix::size() const { return 0; } } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/socket_address_posix.h b/platform/impl/socket_address_posix.h index 17f0e82a..4fde6831 100644 --- a/platform/impl/socket_address_posix.h +++ b/platform/impl/socket_address_posix.h @@ -17,7 +17,6 @@ #include "platform/base/ip_address.h" namespace openscreen { -namespace platform { class SocketAddressPosix { public: @@ -50,7 +49,6 @@ class SocketAddressPosix { IPEndpoint endpoint_; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_SOCKET_ADDRESS_POSIX_H_ diff --git a/platform/impl/socket_address_posix_unittest.cc b/platform/impl/socket_address_posix_unittest.cc index 12868971..e8b81c09 100644 --- a/platform/impl/socket_address_posix_unittest.cc +++ b/platform/impl/socket_address_posix_unittest.cc @@ -8,7 +8,6 @@ #include "gtest/gtest.h" namespace openscreen { -namespace platform { TEST(SocketAddressPosixTest, IPv4SocketAddressConvertsSuccessfully) { const SocketAddressPosix address(IPEndpoint{{1, 2, 3, 4}, 80}); @@ -89,5 +88,4 @@ TEST(SocketAddressPosixTest, IPv6ConvertsSuccessfully) { EXPECT_EQ(address_posix.endpoint(), expected_address); } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/socket_handle.h b/platform/impl/socket_handle.h index 6a775f1a..fca8192e 100644 --- a/platform/impl/socket_handle.h +++ b/platform/impl/socket_handle.h @@ -8,7 +8,6 @@ #include <cstdlib> namespace openscreen { -namespace platform { // A SocketHandle is the handle used to access a Socket by the underlying // platform. @@ -23,7 +22,6 @@ inline bool operator!=(const SocketHandle& lhs, const SocketHandle& rhs) { return !(lhs == rhs); } -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_SOCKET_HANDLE_H_ diff --git a/platform/impl/socket_handle_posix.cc b/platform/impl/socket_handle_posix.cc index 7d99ca32..dfc9c5bb 100644 --- a/platform/impl/socket_handle_posix.cc +++ b/platform/impl/socket_handle_posix.cc @@ -8,7 +8,6 @@ #include <functional> namespace openscreen { -namespace platform { SocketHandle::SocketHandle(int descriptor) : fd(descriptor) {} @@ -20,5 +19,4 @@ size_t SocketHandleHash::operator()(const SocketHandle& handle) const { return std::hash<int>()(handle.fd); } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/socket_handle_posix.h b/platform/impl/socket_handle_posix.h index 59ff670d..13f977c3 100644 --- a/platform/impl/socket_handle_posix.h +++ b/platform/impl/socket_handle_posix.h @@ -8,14 +8,12 @@ #include "platform/impl/socket_handle.h" namespace openscreen { -namespace platform { struct SocketHandle { explicit SocketHandle(int descriptor); int fd; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_SOCKET_HANDLE_POSIX_H_ diff --git a/platform/impl/socket_handle_waiter.cc b/platform/impl/socket_handle_waiter.cc index e3731b34..8feebe00 100644 --- a/platform/impl/socket_handle_waiter.cc +++ b/platform/impl/socket_handle_waiter.cc @@ -11,7 +11,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { void SocketHandleWaiter::Subscribe(Subscriber* subscriber, SocketHandleRef handle) { @@ -107,5 +106,4 @@ Error SocketHandleWaiter::ProcessHandles(Clock::duration timeout) { return Error::None(); } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/socket_handle_waiter.h b/platform/impl/socket_handle_waiter.h index 1b97abd4..5cfbfef4 100644 --- a/platform/impl/socket_handle_waiter.h +++ b/platform/impl/socket_handle_waiter.h @@ -18,7 +18,6 @@ #include "platform/impl/socket_handle.h" namespace openscreen { -namespace platform { // The class responsible for calling platform-level method to watch UDP sockets // for available read data. Reading from these sockets is handled at a higher @@ -92,7 +91,6 @@ class SocketHandleWaiter { handle_mappings_; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_SOCKET_HANDLE_WAITER_H_ diff --git a/platform/impl/socket_handle_waiter_posix.cc b/platform/impl/socket_handle_waiter_posix.cc index 0cfca99b..2a4cedd8 100644 --- a/platform/impl/socket_handle_waiter_posix.cc +++ b/platform/impl/socket_handle_waiter_posix.cc @@ -16,7 +16,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { SocketHandleWaiterPosix::SocketHandleWaiterPosix() = default; @@ -74,5 +73,4 @@ void SocketHandleWaiterPosix::RequestStopSoon() { is_running_.store(false); } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/socket_handle_waiter_posix.h b/platform/impl/socket_handle_waiter_posix.h index 2a8b8683..7a124898 100644 --- a/platform/impl/socket_handle_waiter_posix.h +++ b/platform/impl/socket_handle_waiter_posix.h @@ -13,7 +13,6 @@ #include "platform/impl/socket_handle_waiter.h" namespace openscreen { -namespace platform { class SocketHandleWaiterPosix : public SocketHandleWaiter { public: @@ -41,7 +40,6 @@ class SocketHandleWaiterPosix : public SocketHandleWaiter { std::atomic_bool is_running_; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_SOCKET_HANDLE_WAITER_POSIX_H_ diff --git a/platform/impl/socket_handle_waiter_posix_unittest.cc b/platform/impl/socket_handle_waiter_posix_unittest.cc index fcc249e5..2bea7c5d 100644 --- a/platform/impl/socket_handle_waiter_posix_unittest.cc +++ b/platform/impl/socket_handle_waiter_posix_unittest.cc @@ -16,7 +16,6 @@ #include "platform/impl/timeval_posix.h" namespace openscreen { -namespace platform { namespace { using namespace ::testing; @@ -88,5 +87,4 @@ TEST(SocketHandleWaiterTest, WatchedSocketsReturnedToCorrectSubscribers) { waiter.ProcessHandles(Clock::duration{0}); } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/stream_socket.h b/platform/impl/stream_socket.h index 7278e05b..b4536e27 100644 --- a/platform/impl/stream_socket.h +++ b/platform/impl/stream_socket.h @@ -17,7 +17,6 @@ #include "platform/impl/socket_handle.h" namespace openscreen { -namespace platform { // StreamSocket is an incomplete abstraction of synchronous platform methods for // creating, initializing, and closing stream sockets. Callers can use this @@ -68,7 +67,6 @@ class StreamSocket { virtual IPAddress::Version version() const = 0; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_STREAM_SOCKET_H_ diff --git a/platform/impl/stream_socket_posix.cc b/platform/impl/stream_socket_posix.cc index b60e82ae..f477eb56 100644 --- a/platform/impl/stream_socket_posix.cc +++ b/platform/impl/stream_socket_posix.cc @@ -12,7 +12,6 @@ #include <unistd.h> namespace openscreen { -namespace platform { namespace { constexpr int kDefaultMaxBacklogSize = 64; @@ -251,5 +250,4 @@ Error StreamSocketPosix::ReportSocketClosedError() { last_error_code_ = Error::Code::kSocketClosedFailure; return Error::Code::kSocketClosedFailure; } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/stream_socket_posix.h b/platform/impl/stream_socket_posix.h index a990ca2b..0e23fcba 100644 --- a/platform/impl/stream_socket_posix.h +++ b/platform/impl/stream_socket_posix.h @@ -18,7 +18,6 @@ #include "platform/impl/weak_ptr.h" namespace openscreen { -namespace platform { class StreamSocketPosix : public StreamSocket { public: @@ -81,7 +80,6 @@ class StreamSocketPosix : public StreamSocket { WeakPtrFactory<StreamSocketPosix> weak_factory_{this}; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_STREAM_SOCKET_POSIX_H_ diff --git a/platform/impl/task_runner.cc b/platform/impl/task_runner.cc index 8ff92b34..dae79c4c 100644 --- a/platform/impl/task_runner.cc +++ b/platform/impl/task_runner.cc @@ -9,9 +9,8 @@ #include "util/logging.h" namespace openscreen { -namespace platform { -TaskRunnerImpl::TaskRunnerImpl(platform::ClockNowFunctionPtr now_function, +TaskRunnerImpl::TaskRunnerImpl(ClockNowFunctionPtr now_function, TaskWaiter* event_waiter, Clock::duration waiter_timeout) : now_function_(now_function), @@ -143,5 +142,4 @@ bool TaskRunnerImpl::GrabMoreRunnableTasks() { return false; } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/task_runner.h b/platform/impl/task_runner.h index 35da181b..bbdd1ccd 100644 --- a/platform/impl/task_runner.h +++ b/platform/impl/task_runner.h @@ -22,7 +22,6 @@ #include "util/trace_logging.h" namespace openscreen { -namespace platform { class TaskRunnerImpl final : public TaskRunner { public: @@ -49,7 +48,7 @@ class TaskRunnerImpl final : public TaskRunner { }; explicit TaskRunnerImpl( - platform::ClockNowFunctionPtr now_function, + ClockNowFunctionPtr now_function, TaskWaiter* event_waiter = nullptr, Clock::duration waiter_timeout = std::chrono::milliseconds(100)); @@ -111,7 +110,7 @@ class TaskRunnerImpl final : public TaskRunner { // transferred. bool GrabMoreRunnableTasks(); - const platform::ClockNowFunctionPtr now_function_; + const ClockNowFunctionPtr now_function_; // Flag that indicates whether the task runner loop should continue. This is // only meant to be read/written on the thread executing RunUntilStopped(). @@ -141,7 +140,6 @@ class TaskRunnerImpl final : public TaskRunner { OSP_DISALLOW_COPY_AND_ASSIGN(TaskRunnerImpl); }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_TASK_RUNNER_H_ diff --git a/platform/impl/task_runner_unittest.cc b/platform/impl/task_runner_unittest.cc index ac433196..d7535cf3 100644 --- a/platform/impl/task_runner_unittest.cc +++ b/platform/impl/task_runner_unittest.cc @@ -13,7 +13,6 @@ #include "platform/test/fake_clock.h" namespace openscreen { -namespace platform { namespace { using namespace ::testing; @@ -31,7 +30,7 @@ void WaitUntilCondition(std::function<bool()> predicate) { class FakeTaskWaiter final : public TaskRunnerImpl::TaskWaiter { public: - explicit FakeTaskWaiter(platform::ClockNowFunctionPtr now_function) + explicit FakeTaskWaiter(ClockNowFunctionPtr now_function) : now_function_(now_function) {} ~FakeTaskWaiter() override = default; @@ -60,7 +59,7 @@ class FakeTaskWaiter final : public TaskRunnerImpl::TaskWaiter { } private: - const platform::ClockNowFunctionPtr now_function_; + const ClockNowFunctionPtr now_function_; TaskRunnerImpl* task_runner_; std::atomic<bool> has_event_{false}; std::atomic<bool> waiting_{false}; @@ -69,7 +68,7 @@ class FakeTaskWaiter final : public TaskRunnerImpl::TaskWaiter { class TaskRunnerWithWaiterFactory { public: static std::unique_ptr<TaskRunnerImpl> Create( - platform::ClockNowFunctionPtr now_function) { + ClockNowFunctionPtr now_function) { fake_waiter = std::make_unique<FakeTaskWaiter>(now_function); auto runner = std::make_unique<TaskRunnerImpl>( now_function, fake_waiter.get(), std::chrono::hours(1)); @@ -86,7 +85,7 @@ std::unique_ptr<FakeTaskWaiter> TaskRunnerWithWaiterFactory::fake_waiter; } // anonymous namespace TEST(TaskRunnerImplTest, TaskRunnerExecutesTaskAndStops) { - FakeClock fake_clock{platform::Clock::time_point(milliseconds(1337))}; + FakeClock fake_clock{Clock::time_point(milliseconds(1337))}; TaskRunnerImpl runner(&fake_clock.now); std::string ran_tasks = ""; @@ -98,7 +97,7 @@ TEST(TaskRunnerImplTest, TaskRunnerExecutesTaskAndStops) { } TEST(TaskRunnerImplTest, TaskRunnerRunsDelayedTasksInOrder) { - FakeClock fake_clock{platform::Clock::time_point(milliseconds(1337))}; + FakeClock fake_clock{Clock::time_point(milliseconds(1337))}; TaskRunnerImpl runner(&fake_clock.now); std::thread t([&runner] { runner.RunUntilStopped(); }); @@ -126,7 +125,7 @@ TEST(TaskRunnerImplTest, TaskRunnerRunsDelayedTasksInOrder) { } TEST(TaskRunnerImplTest, SingleThreadedTaskRunnerRunsSequentially) { - FakeClock fake_clock{platform::Clock::time_point(milliseconds(1337))}; + FakeClock fake_clock{Clock::time_point(milliseconds(1337))}; TaskRunnerImpl runner(&fake_clock.now); std::string ran_tasks; @@ -149,7 +148,7 @@ TEST(TaskRunnerImplTest, SingleThreadedTaskRunnerRunsSequentially) { } TEST(TaskRunnerImplTest, RunsAllImmediateTasksBeforeStopping) { - FakeClock fake_clock{platform::Clock::time_point(milliseconds(1337))}; + FakeClock fake_clock{Clock::time_point(milliseconds(1337))}; TaskRunnerImpl runner(&fake_clock.now); std::string result; @@ -181,7 +180,7 @@ TEST(TaskRunnerImplTest, RunsAllImmediateTasksBeforeStopping) { } TEST(TaskRunnerImplTest, TaskRunnerIsStableWithLotsOfTasks) { - FakeClock fake_clock{platform::Clock::time_point(milliseconds(1337))}; + FakeClock fake_clock{Clock::time_point(milliseconds(1337))}; TaskRunnerImpl runner(&fake_clock.now); const int kNumberOfTasks = 500; @@ -200,7 +199,7 @@ TEST(TaskRunnerImplTest, TaskRunnerIsStableWithLotsOfTasks) { } TEST(TaskRunnerImplTest, TaskRunnerDelayedTasksDontBlockImmediateTasks) { - TaskRunnerImpl runner(platform::Clock::now); + TaskRunnerImpl runner(Clock::now); std::string ran_tasks; const auto task = [&ran_tasks] { ran_tasks += "1"; }; @@ -282,5 +281,4 @@ class RepeatedClass { std::atomic<int> execution_count{0}; }; -} // namespace platform } // namespace openscreen diff --git a/platform/impl/text_trace_logging_platform.cc b/platform/impl/text_trace_logging_platform.cc index 573369a6..6ef50fb8 100644 --- a/platform/impl/text_trace_logging_platform.cc +++ b/platform/impl/text_trace_logging_platform.cc @@ -9,7 +9,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { bool TextTraceLoggingPlatform::IsTraceLoggingEnabled( TraceCategory::Value category) { @@ -69,5 +68,4 @@ void TextTraceLoggingPlatform::LogAsyncEnd(const uint32_t line, << timestamp << ") " << error; } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/text_trace_logging_platform.h b/platform/impl/text_trace_logging_platform.h index 3d2a93c6..c9155b6b 100644 --- a/platform/impl/text_trace_logging_platform.h +++ b/platform/impl/text_trace_logging_platform.h @@ -8,7 +8,6 @@ #include "platform/api/trace_logging_platform.h" namespace openscreen { -namespace platform { class TextTraceLoggingPlatform : public TraceLoggingPlatform { public: @@ -38,7 +37,6 @@ class TextTraceLoggingPlatform : public TraceLoggingPlatform { Error::Code error) override; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_TEXT_TRACE_LOGGING_PLATFORM_H_ diff --git a/platform/impl/time.cc b/platform/impl/time.cc index 5604b84a..6ad93145 100644 --- a/platform/impl/time.cc +++ b/platform/impl/time.cc @@ -17,7 +17,6 @@ using std::chrono::steady_clock; using std::chrono::system_clock; namespace openscreen { -namespace platform { Clock::time_point Clock::now() noexcept { constexpr bool can_use_steady_clock = @@ -66,5 +65,4 @@ std::chrono::seconds GetWallTimeSinceUnixEpoch() noexcept { return std::chrono::seconds(since_epoch); } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/time_unittest.cc b/platform/impl/time_unittest.cc index d784dc59..321bb7b3 100644 --- a/platform/impl/time_unittest.cc +++ b/platform/impl/time_unittest.cc @@ -11,7 +11,6 @@ using std::chrono::seconds; namespace openscreen { -namespace platform { #if __cplusplus < 202000L // Before C++20, the standard does not guarantee that time_t is the number of @@ -51,5 +50,4 @@ TEST(TimeTest, TimeTMeetsTheCpp20Standard) { } #endif -} // namespace platform } // namespace openscreen diff --git a/platform/impl/timeval_posix.cc b/platform/impl/timeval_posix.cc index dd165324..28c25ffe 100644 --- a/platform/impl/timeval_posix.cc +++ b/platform/impl/timeval_posix.cc @@ -7,7 +7,6 @@ #include <chrono> namespace openscreen { -namespace platform { struct timeval ToTimeval(const Clock::duration& timeout) { struct timeval tv; @@ -21,5 +20,4 @@ struct timeval ToTimeval(const Clock::duration& timeout) { return tv; } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/timeval_posix.h b/platform/impl/timeval_posix.h index 3679682d..8f42129a 100644 --- a/platform/impl/timeval_posix.h +++ b/platform/impl/timeval_posix.h @@ -10,11 +10,9 @@ #include "platform/api/time.h" namespace openscreen { -namespace platform { struct timeval ToTimeval(const Clock::duration& timeout); -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_TIMEVAL_POSIX_H_ diff --git a/platform/impl/timeval_posix_unittest.cc b/platform/impl/timeval_posix_unittest.cc index 3b679366..db82d7ad 100644 --- a/platform/impl/timeval_posix_unittest.cc +++ b/platform/impl/timeval_posix_unittest.cc @@ -7,7 +7,6 @@ #include "gtest/gtest.h" namespace openscreen { -namespace platform { TEST(TimevalPosixTest, ToTimeval) { auto timespan = Clock::duration::zero(); @@ -36,5 +35,4 @@ TEST(TimevalPosixTest, ToTimeval) { EXPECT_EQ(timeval.tv_usec, 10); } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/tls_connection_factory_posix.cc b/platform/impl/tls_connection_factory_posix.cc index 8b270dab..bf85ec88 100644 --- a/platform/impl/tls_connection_factory_posix.cc +++ b/platform/impl/tls_connection_factory_posix.cc @@ -29,7 +29,6 @@ #include "util/trace_logging.h" namespace openscreen { -namespace platform { namespace { @@ -277,5 +276,4 @@ void TlsConnectionFactoryPosix::DispatchError(Error error) { }); } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/tls_connection_factory_posix.h b/platform/impl/tls_connection_factory_posix.h index 46ba6e25..f9cc1612 100644 --- a/platform/impl/tls_connection_factory_posix.h +++ b/platform/impl/tls_connection_factory_posix.h @@ -17,7 +17,6 @@ #include "platform/impl/weak_ptr.h" namespace openscreen { -namespace platform { class StreamSocket; @@ -86,7 +85,6 @@ class TlsConnectionFactoryPosix : public TlsConnectionFactory, OSP_DISALLOW_COPY_AND_ASSIGN(TlsConnectionFactoryPosix); }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_TLS_CONNECTION_FACTORY_POSIX_H_ diff --git a/platform/impl/tls_connection_posix.cc b/platform/impl/tls_connection_posix.cc index 3fa39037..11195773 100644 --- a/platform/impl/tls_connection_posix.cc +++ b/platform/impl/tls_connection_posix.cc @@ -27,7 +27,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { // TODO(jophba, rwkeane): implement write blocking/unblocking TlsConnectionPosix::TlsConnectionPosix(IPEndpoint local_address, @@ -222,5 +221,4 @@ void TlsConnectionPosix::NotifyClientOfWriteBlockStatusSequentially( } } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/tls_connection_posix.h b/platform/impl/tls_connection_posix.h index c0089844..6ada2e75 100644 --- a/platform/impl/tls_connection_posix.h +++ b/platform/impl/tls_connection_posix.h @@ -17,7 +17,6 @@ #include "platform/impl/weak_ptr.h" namespace openscreen { -namespace platform { class TaskRunner; class TlsConnectionFactoryPosix; @@ -86,7 +85,6 @@ class TlsConnectionPosix : public TlsConnection, OSP_DISALLOW_COPY_AND_ASSIGN(TlsConnectionPosix); }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_TLS_CONNECTION_POSIX_H_ diff --git a/platform/impl/tls_data_router_posix.cc b/platform/impl/tls_data_router_posix.cc index 642d4a93..f2a92560 100644 --- a/platform/impl/tls_data_router_posix.cc +++ b/platform/impl/tls_data_router_posix.cc @@ -9,7 +9,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { TlsDataRouterPosix::TlsDataRouterPosix( SocketHandleWaiter* waiter, @@ -171,5 +170,4 @@ std::vector<TlsConnectionPosix*>::iterator TlsDataRouterPosix::GetConnection( return current_pos; } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/tls_data_router_posix.h b/platform/impl/tls_data_router_posix.h index fb8ac45c..a9f6dbb1 100644 --- a/platform/impl/tls_data_router_posix.h +++ b/platform/impl/tls_data_router_posix.h @@ -14,7 +14,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { class StreamSocketPosix; class TlsConnectionPosix; @@ -132,7 +131,6 @@ class TlsDataRouterPosix : public SocketHandleWaiter::Subscriber { GUARDED_BY(connections_mutex_); }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_TLS_DATA_ROUTER_POSIX_H_ diff --git a/platform/impl/tls_data_router_posix_unittest.cc b/platform/impl/tls_data_router_posix_unittest.cc index 257ad08b..8d911086 100644 --- a/platform/impl/tls_data_router_posix_unittest.cc +++ b/platform/impl/tls_data_router_posix_unittest.cc @@ -13,7 +13,6 @@ #include "platform/test/fake_task_runner.h" namespace openscreen { -namespace platform { using testing::_; using testing::Return; @@ -192,5 +191,4 @@ TEST(TlsNetworkingManagerPosixTest, HitsAllCallsOnceStartedInMiddle) { network_manager.PerformNetworkingOperations(Clock::duration{0}); } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/tls_write_buffer.cc b/platform/impl/tls_write_buffer.cc index f0370868..1f4db57e 100644 --- a/platform/impl/tls_write_buffer.cc +++ b/platform/impl/tls_write_buffer.cc @@ -11,7 +11,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { TlsWriteBuffer::~TlsWriteBuffer() = default; @@ -96,5 +95,4 @@ void TlsWriteBuffer::NotifyWriteBufferFill(size_t write_index, observer_->NotifyWriteBufferFill(fraction); } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/tls_write_buffer.h b/platform/impl/tls_write_buffer.h index 308b882d..fadc5753 100644 --- a/platform/impl/tls_write_buffer.h +++ b/platform/impl/tls_write_buffer.h @@ -12,7 +12,6 @@ #include "platform/base/macros.h" namespace openscreen { -namespace platform { // This class is responsible for buffering TLS Write data. The approach taken by // this class is to allow for a single thread to act as a publisher of data and @@ -68,7 +67,6 @@ class TlsWriteBuffer { OSP_DISALLOW_COPY_AND_ASSIGN(TlsWriteBuffer); }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_TLS_WRITE_BUFFER_H_ diff --git a/platform/impl/tls_write_buffer_unittest.cc b/platform/impl/tls_write_buffer_unittest.cc index 9e815433..ceb3c509 100644 --- a/platform/impl/tls_write_buffer_unittest.cc +++ b/platform/impl/tls_write_buffer_unittest.cc @@ -10,7 +10,6 @@ #include "gtest/gtest.h" namespace openscreen { -namespace platform { namespace { class MockObserver : public TlsWriteBuffer::Observer { @@ -80,5 +79,4 @@ TEST(TlsWriteBufferTest, TestWrapAround) { buffer.Consume(write_size / 4); } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/udp_socket_posix.cc b/platform/impl/udp_socket_posix.cc index 234c43fd..1be7c79a 100644 --- a/platform/impl/udp_socket_posix.cc +++ b/platform/impl/udp_socket_posix.cc @@ -27,7 +27,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { namespace { constexpr bool IsPowerOf2(uint32_t x) { @@ -85,9 +84,10 @@ const SocketHandle& UdpSocketPosix::GetHandle() const { } // static -ErrorOr<UdpSocketUniquePtr> UdpSocket::Create(TaskRunner* task_runner, - Client* client, - const IPEndpoint& endpoint) { +ErrorOr<std::unique_ptr<UdpSocket>> UdpSocket::Create( + TaskRunner* task_runner, + Client* client, + const IPEndpoint& endpoint) { static std::atomic_bool in_create{false}; const bool in_create_local = in_create.exchange(true); OSP_DCHECK_EQ(in_create_local, false) @@ -113,8 +113,8 @@ ErrorOr<UdpSocketUniquePtr> UdpSocket::Create(TaskRunner* task_runner, return fd.error(); } - auto socket = UdpSocketUniquePtr(static_cast<UdpSocket*>(new UdpSocketPosix( - task_runner, client, SocketHandle(fd.value()), endpoint))); + std::unique_ptr<UdpSocket> socket = std::make_unique<UdpSocketPosix>( + task_runner, client, SocketHandle(fd.value()), endpoint); in_create = false; return socket; } @@ -619,5 +619,4 @@ void UdpSocketPosix::Close() { handle_.fd = -1; } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/udp_socket_posix.h b/platform/impl/udp_socket_posix.h index ba44d61a..fddc40a2 100644 --- a/platform/impl/udp_socket_posix.h +++ b/platform/impl/udp_socket_posix.h @@ -13,7 +13,6 @@ #include "platform/impl/weak_ptr.h" namespace openscreen { -namespace platform { class UdpSocketReaderPosix; @@ -87,7 +86,6 @@ class UdpSocketPosix : public UdpSocket { OSP_DISALLOW_COPY_AND_ASSIGN(UdpSocketPosix); }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_UDP_SOCKET_POSIX_H_ diff --git a/platform/impl/udp_socket_reader_posix.cc b/platform/impl/udp_socket_reader_posix.cc index 3892081b..1e318af9 100644 --- a/platform/impl/udp_socket_reader_posix.cc +++ b/platform/impl/udp_socket_reader_posix.cc @@ -12,7 +12,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { UdpSocketReaderPosix::UdpSocketReaderPosix(SocketHandleWaiter* waiter) : waiter_(waiter) {} @@ -64,5 +63,4 @@ bool UdpSocketReaderPosix::IsMappedReadForTesting( return std::find(sockets_.begin(), sockets_.end(), socket) != sockets_.end(); } -} // namespace platform } // namespace openscreen diff --git a/platform/impl/udp_socket_reader_posix.h b/platform/impl/udp_socket_reader_posix.h index 5b1f615b..d9e065d9 100644 --- a/platform/impl/udp_socket_reader_posix.h +++ b/platform/impl/udp_socket_reader_posix.h @@ -16,7 +16,6 @@ #include "platform/impl/udp_socket_posix.h" namespace openscreen { -namespace platform { // This is the class responsible for watching sockets for readable data, then // calling the function associated with these sockets once that data is read. @@ -72,7 +71,6 @@ class UdpSocketReaderPosix : public SocketHandleWaiter::Subscriber { friend class TestingUdpSocketReader; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_IMPL_UDP_SOCKET_READER_POSIX_H_ diff --git a/platform/impl/udp_socket_reader_posix_unittest.cc b/platform/impl/udp_socket_reader_posix_unittest.cc index a09fe29e..b96c259b 100644 --- a/platform/impl/udp_socket_reader_posix_unittest.cc +++ b/platform/impl/udp_socket_reader_posix_unittest.cc @@ -14,7 +14,6 @@ #include "platform/test/fake_udp_socket.h" namespace openscreen { -namespace platform { using namespace ::testing; using ::testing::_; @@ -129,5 +128,4 @@ TEST(UdpSocketReaderTest, UnwatchReadableSucceeds) { EXPECT_FALSE(network_waiter.IsMappedRead(socket.get())); } -} // namespace platform } // namespace openscreen diff --git a/platform/test/fake_clock.cc b/platform/test/fake_clock.cc index 78977ad2..350e8fe7 100644 --- a/platform/test/fake_clock.cc +++ b/platform/test/fake_clock.cc @@ -8,7 +8,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { FakeClock::FakeClock(Clock::time_point start_time) { now_ = start_time; @@ -48,5 +47,4 @@ void FakeClock::UnsubscribeFromTimeChanges(FakeTaskRunner* task_runner) { // static std::atomic<Clock::time_point> FakeClock::now_{Clock::time_point{}}; -} // namespace platform } // namespace openscreen diff --git a/platform/test/fake_clock.h b/platform/test/fake_clock.h index 8847a687..766206fc 100644 --- a/platform/test/fake_clock.h +++ b/platform/test/fake_clock.h @@ -11,7 +11,6 @@ #include "platform/api/time.h" namespace openscreen { -namespace platform { class FakeTaskRunner; @@ -36,7 +35,6 @@ class FakeClock { static std::atomic<Clock::time_point> now_; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_TEST_FAKE_CLOCK_H_ diff --git a/platform/test/fake_task_runner.cc b/platform/test/fake_task_runner.cc index f906da34..19942cd4 100644 --- a/platform/test/fake_task_runner.cc +++ b/platform/test/fake_task_runner.cc @@ -7,7 +7,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { FakeTaskRunner::FakeTaskRunner(FakeClock* clock) : clock_(clock) { OSP_CHECK(clock_); @@ -62,5 +61,4 @@ bool FakeTaskRunner::IsRunningOnTaskRunner() { return true; } -} // namespace platform } // namespace openscreen diff --git a/platform/test/fake_task_runner.h b/platform/test/fake_task_runner.h index 83e8bbe1..87b3ceb0 100644 --- a/platform/test/fake_task_runner.h +++ b/platform/test/fake_task_runner.h @@ -14,7 +14,6 @@ #include "platform/test/fake_clock.h" namespace openscreen { -namespace platform { // Usage: // @@ -26,7 +25,7 @@ namespace platform { // FakeTaskRunner* task_runner() { return &task_runner_; } // // private: -// FakeClock clock_{platform::Clock::now()}; +// FakeClock clock_{Clock::now()}; // FakeTaskRunner task_runner_{&clock_}; // }; // @@ -63,7 +62,6 @@ class FakeTaskRunner : public TaskRunner { std::multimap<Clock::time_point, Task> delayed_tasks_; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_TEST_FAKE_TASK_RUNNER_H_ diff --git a/platform/test/fake_udp_socket.cc b/platform/test/fake_udp_socket.cc index 993ee4b8..760c70c6 100644 --- a/platform/test/fake_udp_socket.cc +++ b/platform/test/fake_udp_socket.cc @@ -5,7 +5,6 @@ #include "platform/test/fake_udp_socket.h" namespace openscreen { -namespace platform { FakeUdpSocket::FakeUdpSocket(TaskRunner* task_runner, Client* client, @@ -97,5 +96,4 @@ std::unique_ptr<FakeUdpSocket> FakeUdpSocket::CreateDefault( return socket; } -} // namespace platform } // namespace openscreen diff --git a/platform/test/fake_udp_socket.h b/platform/test/fake_udp_socket.h index 78736c4e..dc9b4c96 100644 --- a/platform/test/fake_udp_socket.h +++ b/platform/test/fake_udp_socket.h @@ -17,7 +17,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { class FakeUdpSocket : public UdpSocket { public: @@ -101,7 +100,6 @@ class FakeUdpSocket : public UdpSocket { std::unique_ptr<FakeClock> fake_clock_; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_TEST_FAKE_UDP_SOCKET_H_ diff --git a/platform/test/mock_tls_connection.h b/platform/test/mock_tls_connection.h index bec8b9cc..a2ccf0c9 100644 --- a/platform/test/mock_tls_connection.h +++ b/platform/test/mock_tls_connection.h @@ -9,7 +9,6 @@ #include "platform/api/tls_connection.h" namespace openscreen { -namespace platform { class TaskRunner; @@ -55,7 +54,6 @@ class MockTlsConnection : public TlsConnection { const IPEndpoint remote_address_; }; -} // namespace platform } // namespace openscreen #endif // PLATFORM_TEST_MOCK_TLS_CONNECTION_H_ diff --git a/platform/test/trace_logging_helpers.h b/platform/test/trace_logging_helpers.h index e9d4f3f6..8d0f0680 100644 --- a/platform/test/trace_logging_helpers.h +++ b/platform/test/trace_logging_helpers.h @@ -12,7 +12,6 @@ #include "util/logging.h" namespace openscreen { -namespace platform { enum TraceHierarchyParts { kRoot = 0x1, kParent = 0x2, kCurrent = 0x4 }; @@ -123,7 +122,6 @@ void ValidateTraceIdHierarchyOnAsyncTrace(const char* name, } } -} // namespace platform } // namespace openscreen #endif // PLATFORM_TEST_TRACE_LOGGING_HELPERS_H_ diff --git a/util/alarm.cc b/util/alarm.cc index c72815a1..16f099e2 100644 --- a/util/alarm.cc +++ b/util/alarm.cc @@ -58,8 +58,7 @@ class Alarm::CancelableFunctor { Alarm* alarm_; }; -Alarm::Alarm(platform::ClockNowFunctionPtr now_function, - platform::TaskRunner* task_runner) +Alarm::Alarm(ClockNowFunctionPtr now_function, TaskRunner* task_runner) : now_function_(now_function), task_runner_(task_runner) { OSP_DCHECK(now_function_); OSP_DCHECK(task_runner_); @@ -73,11 +72,11 @@ Alarm::~Alarm() { } void Alarm::Cancel() { - scheduled_task_ = platform::TaskRunner::Task(); + scheduled_task_ = TaskRunner::Task(); } -void Alarm::ScheduleWithTask(platform::TaskRunner::Task task, - platform::Clock::time_point alarm_time) { +void Alarm::ScheduleWithTask(TaskRunner::Task task, + Clock::time_point alarm_time) { OSP_DCHECK(task.valid()); scheduled_task_ = std::move(task); @@ -94,8 +93,7 @@ void Alarm::ScheduleWithTask(platform::TaskRunner::Task task, InvokeLater(now_function_(), alarm_time); } -void Alarm::InvokeLater(platform::Clock::time_point now, - platform::Clock::time_point fire_time) { +void Alarm::InvokeLater(Clock::time_point now, Clock::time_point fire_time) { OSP_DCHECK(!queued_fire_); next_fire_time_ = fire_time; // Note: Instantiating the CancelableFunctor below sets |this->queued_fire_|. @@ -109,7 +107,7 @@ void Alarm::TryInvoke() { // If this is an early firing, re-schedule for later. This happens if // Schedule() was called again before this firing had occurred. - const platform::Clock::time_point now = now_function_(); + const Clock::time_point now = now_function_(); if (now < alarm_time_) { InvokeLater(now, alarm_time_); return; @@ -119,7 +117,7 @@ void Alarm::TryInvoke() { // itself: a) calls any Alarm methods re-entrantly, or b) causes the // destruction of this Alarm instance. // WARNING: |this| is not valid after here! - platform::TaskRunner::Task task = std::move(scheduled_task_); + TaskRunner::Task task = std::move(scheduled_task_); task(); } diff --git a/util/alarm.h b/util/alarm.h index dbf75714..f87127d8 100644 --- a/util/alarm.h +++ b/util/alarm.h @@ -31,8 +31,7 @@ namespace openscreen { // running the client's Task later; or c) runs the client's Task. class Alarm { public: - Alarm(platform::ClockNowFunctionPtr now_function, - platform::TaskRunner* task_runner); + Alarm(ClockNowFunctionPtr now_function, TaskRunner* task_runner); ~Alarm(); // The design requires that Alarm instances not be copied or moved. @@ -46,18 +45,15 @@ class Alarm { // callable target (e.g., function, lambda-expression, std::bind result, // etc.). template <typename Functor> - inline void Schedule(Functor functor, - platform::Clock::time_point alarm_time) { - ScheduleWithTask(platform::TaskRunner::Task(std::move(functor)), - alarm_time); + inline void Schedule(Functor functor, Clock::time_point alarm_time) { + ScheduleWithTask(TaskRunner::Task(std::move(functor)), alarm_time); } // Same as Schedule(), but invoke the functor at the given |delay| after right // now. template <typename Functor> - inline void ScheduleFromNow(Functor functor, - platform::Clock::duration delay) { - ScheduleWithTask(platform::TaskRunner::Task(std::move(functor)), + inline void ScheduleFromNow(Functor functor, Clock::duration delay) { + ScheduleWithTask(TaskRunner::Task(std::move(functor)), now_function_() + delay); } @@ -67,8 +63,7 @@ class Alarm { // See comments for Schedule(). Generally, callers will want to call // Schedule() instead of this, for more-convenient caller-side syntax, unless // they already have a Task to pass-in. - void ScheduleWithTask(platform::TaskRunner::Task task, - platform::Clock::time_point alarm_time); + void ScheduleWithTask(TaskRunner::Task task, Clock::time_point alarm_time); private: // A move-only functor that holds a raw pointer back to |this| and can be @@ -77,20 +72,19 @@ class Alarm { class CancelableFunctor; // Posts a delayed call to TryInvoke() to the TaskRunner. - void InvokeLater(platform::Clock::time_point now, - platform::Clock::time_point fire_time); + void InvokeLater(Clock::time_point now, Clock::time_point fire_time); // Examines whether to invoke the client's Task now; or try again later; or // just do nothing. See class-level design comments. void TryInvoke(); - const platform::ClockNowFunctionPtr now_function_; - platform::TaskRunner* const task_runner_; + const ClockNowFunctionPtr now_function_; + TaskRunner* const task_runner_; // This is the task the client wants to have run at a specific point-in-time. // This is NOT the task that Alarm provides to the TaskRunner. - platform::TaskRunner::Task scheduled_task_; - platform::Clock::time_point alarm_time_{}; + TaskRunner::Task scheduled_task_; + Clock::time_point alarm_time_{}; // When non-null, there is a task in the TaskRunner's queue that will call // TryInvoke() some time in the future. This member is exclusively maintained @@ -99,7 +93,7 @@ class Alarm { // When the CancelableFunctor is scheduled to run. It may possibly execute // later than this, if the TaskRunner is falling behind. - platform::Clock::time_point next_fire_time_{}; + Clock::time_point next_fire_time_{}; }; } // namespace openscreen diff --git a/util/alarm_unittest.cc b/util/alarm_unittest.cc index 71f570a0..6df85f16 100644 --- a/util/alarm_unittest.cc +++ b/util/alarm_unittest.cc @@ -15,30 +15,28 @@ namespace { class AlarmTest : public testing::Test { public: - platform::FakeClock* clock() { return &clock_; } - platform::TaskRunner* task_runner() { return &task_runner_; } + FakeClock* clock() { return &clock_; } + TaskRunner* task_runner() { return &task_runner_; } Alarm* alarm() { return &alarm_; } private: - platform::FakeClock clock_{platform::Clock::now()}; - platform::FakeTaskRunner task_runner_{&clock_}; - Alarm alarm_{&platform::FakeClock::now, &task_runner_}; + FakeClock clock_{Clock::now()}; + FakeTaskRunner task_runner_{&clock_}; + Alarm alarm_{&FakeClock::now, &task_runner_}; }; TEST_F(AlarmTest, RunsTaskAsClockAdvances) { - constexpr platform::Clock::duration kDelay = std::chrono::milliseconds(20); + constexpr Clock::duration kDelay = std::chrono::milliseconds(20); - const platform::Clock::time_point alarm_time = - platform::FakeClock::now() + kDelay; - platform::Clock::time_point actual_run_time{}; - alarm()->Schedule([&]() { actual_run_time = platform::FakeClock::now(); }, - alarm_time); + const Clock::time_point alarm_time = FakeClock::now() + kDelay; + Clock::time_point actual_run_time{}; + alarm()->Schedule([&]() { actual_run_time = FakeClock::now(); }, alarm_time); // Confirm the lambda did not run immediately. - ASSERT_EQ(platform::Clock::time_point{}, actual_run_time); + ASSERT_EQ(Clock::time_point{}, actual_run_time); // Confirm the lambda does not run until the necessary delay has elapsed. clock()->Advance(kDelay / 2); - ASSERT_EQ(platform::Clock::time_point{}, actual_run_time); + ASSERT_EQ(Clock::time_point{}, actual_run_time); // Confirm the lambda is called when the necessary delay has elapsed. clock()->Advance(kDelay / 2); @@ -50,16 +48,15 @@ TEST_F(AlarmTest, RunsTaskAsClockAdvances) { } TEST_F(AlarmTest, CancelsTaskWhenGoingOutOfScope) { - constexpr platform::Clock::duration kDelay = std::chrono::milliseconds(20); - constexpr platform::Clock::time_point kNever{}; + constexpr Clock::duration kDelay = std::chrono::milliseconds(20); + constexpr Clock::time_point kNever{}; - platform::Clock::time_point actual_run_time{}; + Clock::time_point actual_run_time{}; { - Alarm scoped_alarm(&platform::FakeClock::now, task_runner()); - const platform::Clock::time_point alarm_time = - platform::FakeClock::now() + kDelay; - scoped_alarm.Schedule( - [&]() { actual_run_time = platform::FakeClock::now(); }, alarm_time); + Alarm scoped_alarm(&FakeClock::now, task_runner()); + const Clock::time_point alarm_time = FakeClock::now() + kDelay; + scoped_alarm.Schedule([&]() { actual_run_time = FakeClock::now(); }, + alarm_time); // |scoped_alarm| is destroyed. } @@ -70,31 +67,27 @@ TEST_F(AlarmTest, CancelsTaskWhenGoingOutOfScope) { } TEST_F(AlarmTest, Cancels) { - constexpr platform::Clock::duration kDelay = std::chrono::milliseconds(20); + constexpr Clock::duration kDelay = std::chrono::milliseconds(20); - const platform::Clock::time_point alarm_time = - platform::FakeClock::now() + kDelay; - platform::Clock::time_point actual_run_time{}; - alarm()->Schedule([&]() { actual_run_time = platform::FakeClock::now(); }, - alarm_time); + const Clock::time_point alarm_time = FakeClock::now() + kDelay; + Clock::time_point actual_run_time{}; + alarm()->Schedule([&]() { actual_run_time = FakeClock::now(); }, alarm_time); // Advance the clock for half the delay, and confirm the lambda has not run // yet. clock()->Advance(kDelay / 2); - ASSERT_EQ(platform::Clock::time_point{}, actual_run_time); + ASSERT_EQ(Clock::time_point{}, actual_run_time); // Cancel and then advance the clock well past the delay, and confirm the // lambda has never run. alarm()->Cancel(); clock()->Advance(kDelay * 100); - ASSERT_EQ(platform::Clock::time_point{}, actual_run_time); + ASSERT_EQ(Clock::time_point{}, actual_run_time); } TEST_F(AlarmTest, CancelsAndRearms) { - constexpr platform::Clock::duration kShorterDelay = - std::chrono::milliseconds(10); - constexpr platform::Clock::duration kLongerDelay = - std::chrono::milliseconds(100); + constexpr Clock::duration kShorterDelay = std::chrono::milliseconds(10); + constexpr Clock::duration kLongerDelay = std::chrono::milliseconds(100); // Run the test twice: Once when scheduling first with a long delay, then a // shorter delay; and once when scheduling first with a short delay, then a @@ -105,7 +98,7 @@ TEST_F(AlarmTest, CancelsAndRearms) { const auto delay2 = do_longer_then_shorter ? kShorterDelay : kLongerDelay; int count1 = 0; - alarm()->Schedule([&]() { ++count1; }, platform::FakeClock::now() + delay1); + alarm()->Schedule([&]() { ++count1; }, FakeClock::now() + delay1); // Advance the clock for half of |delay1|, and confirm the lambda that // increments the variable does not run. @@ -116,7 +109,7 @@ TEST_F(AlarmTest, CancelsAndRearms) { // Schedule a different lambda, that increments a different variable, to run // after |delay2|. int count2 = 0; - alarm()->Schedule([&]() { ++count2; }, platform::FakeClock::now() + delay2); + alarm()->Schedule([&]() { ++count2; }, FakeClock::now() + delay2); // Confirm the second scheduling will fire at the right moment. clock()->Advance(delay2 / 2); diff --git a/util/crypto/certificate_utils.h b/util/crypto/certificate_utils.h index 4bfe6e37..2a5149cd 100644 --- a/util/crypto/certificate_utils.h +++ b/util/crypto/certificate_utils.h @@ -25,8 +25,7 @@ ErrorOr<bssl::UniquePtr<X509>> CreateCertificate( absl::string_view name, std::chrono::seconds duration, const EVP_PKEY& key_pair, - std::chrono::seconds time_since_unix_epoch = - platform::GetWallTimeSinceUnixEpoch()); + std::chrono::seconds time_since_unix_epoch = GetWallTimeSinceUnixEpoch()); // Exports the given X509 certificate as its DER-encoded binary form. ErrorOr<std::vector<uint8_t>> ExportCertificate(const X509& certificate); diff --git a/util/logging.h b/util/logging.h index a38e817e..4c76040e 100644 --- a/util/logging.h +++ b/util/logging.h @@ -11,7 +11,6 @@ #include "platform/api/logging.h" namespace openscreen { -namespace platform { namespace internal { // The stream-based logging macros below are adapted from Chromium's @@ -49,17 +48,15 @@ class Voidify { }; } // namespace internal -} // namespace platform } // namespace openscreen #define OSP_LAZY_STREAM(condition, stream) \ - !(condition) ? (void)0 : openscreen::platform::internal::Voidify() & (stream) -#define OSP_LOG_IS_ON(level_enum) \ - openscreen::platform::IsLoggingOn( \ - openscreen::platform::LogLevel::level_enum, __FILE__) -#define OSP_LOG_STREAM(level_enum) \ - openscreen::platform::internal::LogMessage( \ - openscreen::platform::LogLevel::level_enum, __FILE__, __LINE__) \ + !(condition) ? (void)0 : openscreen::internal::Voidify() & (stream) +#define OSP_LOG_IS_ON(level_enum) \ + openscreen::IsLoggingOn(openscreen::LogLevel::level_enum, __FILE__) +#define OSP_LOG_STREAM(level_enum) \ + openscreen::internal::LogMessage(openscreen::LogLevel::level_enum, __FILE__, \ + __LINE__) \ .stream() #define OSP_VLOG \ diff --git a/util/operation_loop.h b/util/operation_loop.h index 155fe078..ddb7846f 100644 --- a/util/operation_loop.h +++ b/util/operation_loop.h @@ -15,8 +15,6 @@ namespace openscreen { -using Clock = platform::Clock; - class OperationLoop { public: using OperationWithTimeout = std::function<void(Clock::duration)>; diff --git a/util/serial_delete_ptr.h b/util/serial_delete_ptr.h index d33781ee..08bf7b96 100644 --- a/util/serial_delete_ptr.h +++ b/util/serial_delete_ptr.h @@ -19,13 +19,13 @@ namespace openscreen { template <typename Type, typename DeleterType> class SerialDelete { public: - explicit SerialDelete(platform::TaskRunner* task_runner) + explicit SerialDelete(TaskRunner* task_runner) : task_runner_(task_runner), deleter_() { assert(task_runner); } template <typename DT> - SerialDelete(platform::TaskRunner* task_runner, DT&& deleter) + SerialDelete(TaskRunner* task_runner, DT&& deleter) : task_runner_(task_runner), deleter_(std::forward<DT>(deleter)) { assert(task_runner); } @@ -36,7 +36,7 @@ class SerialDelete { } private: - platform::TaskRunner* task_runner_; + TaskRunner* task_runner_; DeleterType deleter_; }; @@ -46,21 +46,21 @@ template <typename Type, typename DeleterType = std::default_delete<Type>> class SerialDeletePtr : public std::unique_ptr<Type, SerialDelete<Type, DeleterType>> { public: - explicit SerialDeletePtr(platform::TaskRunner* task_runner) noexcept + explicit SerialDeletePtr(TaskRunner* task_runner) noexcept : std::unique_ptr<Type, SerialDelete<Type, DeleterType>>( nullptr, SerialDelete<Type, DeleterType>(task_runner)) { assert(task_runner); } - SerialDeletePtr(platform::TaskRunner* task_runner, std::nullptr_t) noexcept + SerialDeletePtr(TaskRunner* task_runner, std::nullptr_t) noexcept : std::unique_ptr<Type, SerialDelete<Type, DeleterType>>( nullptr, SerialDelete<Type, DeleterType>(task_runner)) { assert(task_runner); } - SerialDeletePtr(platform::TaskRunner* task_runner, Type* pointer) noexcept + SerialDeletePtr(TaskRunner* task_runner, Type* pointer) noexcept : std::unique_ptr<Type, SerialDelete<Type, DeleterType>>( pointer, SerialDelete<Type, DeleterType>(task_runner)) { @@ -68,7 +68,7 @@ class SerialDeletePtr } SerialDeletePtr( - platform::TaskRunner* task_runner, + TaskRunner* task_runner, Type* pointer, typename std::conditional<std::is_reference<DeleterType>::value, DeleterType, @@ -80,7 +80,7 @@ class SerialDeletePtr } SerialDeletePtr( - platform::TaskRunner* task_runner, + TaskRunner* task_runner, Type* pointer, typename std::remove_reference<DeleterType>::type&& deleter) noexcept : std::unique_ptr<Type, SerialDelete<Type, DeleterType>>( @@ -91,7 +91,7 @@ class SerialDeletePtr }; template <typename Type, typename... Args> -SerialDeletePtr<Type> MakeSerialDelete(platform::TaskRunner* task_runner, +SerialDeletePtr<Type> MakeSerialDelete(TaskRunner* task_runner, Args&&... args) { return SerialDeletePtr<Type>(task_runner, new Type(std::forward<Args>(args)...)); diff --git a/util/serial_delete_ptr_unittest.cc b/util/serial_delete_ptr_unittest.cc index 4713814c..c8b899c5 100644 --- a/util/serial_delete_ptr_unittest.cc +++ b/util/serial_delete_ptr_unittest.cc @@ -10,10 +10,6 @@ namespace openscreen { -using openscreen::platform::Clock; -using openscreen::platform::FakeClock; -using openscreen::platform::FakeTaskRunner; - class SerialDeletePtrTest : public ::testing::Test { public: SerialDeletePtrTest() : clock_(Clock::now()), task_runner_(&clock_) {} diff --git a/util/trace_logging.h b/util/trace_logging.h index cb454e1b..f3aa7bce 100644 --- a/util/trace_logging.h +++ b/util/trace_logging.h @@ -28,24 +28,24 @@ #include "util/trace_logging/macro_support.h" #undef INCLUDING_FROM_UTIL_TRACE_LOGGING_H_ -#define TRACE_SET_RESULT(result) \ - do { \ - if (TRACE_IS_ENABLED(openscreen::platform::TraceCategory::Value::Any)) { \ - openscreen::internal::ScopedTraceOperation::set_result(result); \ - } \ +#define TRACE_SET_RESULT(result) \ + do { \ + if (TRACE_IS_ENABLED(openscreen::TraceCategory::Value::Any)) { \ + openscreen::internal::ScopedTraceOperation::set_result(result); \ + } \ } while (false) #define TRACE_SET_HIERARCHY(ids) TRACE_SET_HIERARCHY_INTERNAL(__LINE__, ids) -#define TRACE_HIERARCHY \ - (TRACE_IS_ENABLED(openscreen::platform::TraceCategory::Value::Any) \ - ? openscreen::internal::ScopedTraceOperation::hierarchy() \ - : openscreen::platform::TraceIdHierarchy::Empty()) -#define TRACE_CURRENT_ID \ - (TRACE_IS_ENABLED(openscreen::platform::TraceCategory::Value::Any) \ - ? openscreen::internal::ScopedTraceOperation::current_id() \ +#define TRACE_HIERARCHY \ + (TRACE_IS_ENABLED(openscreen::TraceCategory::Value::Any) \ + ? openscreen::internal::ScopedTraceOperation::hierarchy() \ + : openscreen::TraceIdHierarchy::Empty()) +#define TRACE_CURRENT_ID \ + (TRACE_IS_ENABLED(openscreen::TraceCategory::Value::Any) \ + ? openscreen::internal::ScopedTraceOperation::current_id() \ : kEmptyTraceId) -#define TRACE_ROOT_ID \ - (TRACE_IS_ENABLED(openscreen::platform::TraceCategory::Value::Any) \ - ? openscreen::internal::ScopedTraceOperation::root_id() \ +#define TRACE_ROOT_ID \ + (TRACE_IS_ENABLED(openscreen::TraceCategory::Value::Any) \ + ? openscreen::internal::ScopedTraceOperation::root_id() \ : kEmptyTraceId) // Synchronous Trace Macro. @@ -76,9 +76,9 @@ inline void DoNothingForTracing(Args... args) {} #define TRACE_SET_RESULT(result) \ openscreen::internal::DoNothingForTracing(result) #define TRACE_SET_HIERARCHY(ids) openscreen::internal::DoNothingForTracing(ids) -#define TRACE_HIERARCHY openscreen::platform::TraceIdHierarchy::Empty() -#define TRACE_CURRENT_ID openscreen::platform::kEmptyTraceId -#define TRACE_ROOT_ID openscreen::platform::kEmptyTraceId +#define TRACE_HIERARCHY openscreen::TraceIdHierarchy::Empty() +#define TRACE_CURRENT_ID openscreen::kEmptyTraceId +#define TRACE_ROOT_ID openscreen::kEmptyTraceId #define TRACE_SCOPED(category, name, ...) \ openscreen::internal::DoNothingForTracing(category, name, ##__VA_ARGS__) #define TRACE_ASYNC_START(category, name, ...) \ diff --git a/util/trace_logging/macro_support.h b/util/trace_logging/macro_support.h index 30865f4c..7516dab8 100644 --- a/util/trace_logging/macro_support.h +++ b/util/trace_logging/macro_support.h @@ -42,8 +42,8 @@ namespace openscreen { namespace internal { -inline bool IsTraceLoggingEnabled(platform::TraceCategory::Value category) { - auto* const destination = platform::GetTracingDestination(); +inline bool IsTraceLoggingEnabled(TraceCategory::Value category) { + auto* const destination = GetTracingDestination(); return destination && destination->IsTraceLoggingEnabled(category); } @@ -59,7 +59,7 @@ inline bool IsTraceLoggingEnabled(platform::TraceCategory::Value category) { tracing_storage, line)[sizeof(openscreen::internal::TraceIdSetter)]; \ TRACE_INTERNAL_IGNORE_UNUSED_VAR \ const auto TRACE_INTERNAL_UNIQUE_VAR_NAME(trace_ref_) = \ - TRACE_IS_ENABLED(openscreen::platform::TraceCategory::Value::Any) \ + TRACE_IS_ENABLED(openscreen::TraceCategory::Value::Any) \ ? openscreen::internal::TraceInstanceHelper< \ openscreen::internal::TraceIdSetter>:: \ Create(TRACE_INTERNAL_CONCAT_CONST(tracing_storage, line), \ diff --git a/util/trace_logging/scoped_trace_operations.cc b/util/trace_logging/scoped_trace_operations.cc index 7b19b74d..e2e7cb22 100644 --- a/util/trace_logging/scoped_trace_operations.cc +++ b/util/trace_logging/scoped_trace_operations.cc @@ -12,11 +12,6 @@ #if defined(ENABLE_TRACE_LOGGING) -using openscreen::platform::kUnsetTraceId; -using openscreen::platform::TraceCategory; -using openscreen::platform::TraceId; -using openscreen::platform::TraceIdHierarchy; - namespace openscreen { namespace internal { @@ -25,8 +20,8 @@ bool ScopedTraceOperation::TraceAsyncEnd(const uint32_t line, const char* file, TraceId id, Error::Code e) { - auto end_time = platform::Clock::now(); - auto* const current_platform = platform::GetTracingDestination(); + auto end_time = Clock::now(); + auto* const current_platform = GetTracingDestination(); if (current_platform == nullptr) { return false; } @@ -95,7 +90,7 @@ TraceLoggerBase::TraceLoggerBase(TraceCategory::Value category, TraceId parent, TraceId root) : ScopedTraceOperation(current, parent, root), - start_time_(platform::Clock::now()), + start_time_(Clock::now()), result_(Error::Code::kNone), name_(name), file_name_(file), @@ -116,18 +111,18 @@ TraceLoggerBase::TraceLoggerBase(TraceCategory::Value category, ids.root) {} SynchronousTraceLogger::~SynchronousTraceLogger() { - auto* const current_platform = platform::GetTracingDestination(); + auto* const current_platform = GetTracingDestination(); if (current_platform == nullptr) { return; } - auto end_time = platform::Clock::now(); + auto end_time = Clock::now(); current_platform->LogTrace(this->name_, this->line_number_, this->file_name_, this->start_time_, end_time, this->to_hierarchy(), this->result_); } AsynchronousTraceLogger::~AsynchronousTraceLogger() { - auto* const current_platform = platform::GetTracingDestination(); + auto* const current_platform = GetTracingDestination(); if (current_platform == nullptr) { return; } diff --git a/util/trace_logging/scoped_trace_operations.h b/util/trace_logging/scoped_trace_operations.h index b01e3210..7b088f61 100644 --- a/util/trace_logging/scoped_trace_operations.h +++ b/util/trace_logging/scoped_trace_operations.h @@ -36,19 +36,17 @@ class ScopedTraceOperation { // Getters the current Trace Hierarchy. If the traces_ stack hasn't been // created yet, return as if the empty root node is there. - static platform::TraceId current_id() { - return traces_ == nullptr ? platform::kEmptyTraceId - : traces_->top()->trace_id_; + static TraceId current_id() { + return traces_ == nullptr ? kEmptyTraceId : traces_->top()->trace_id_; } - static platform::TraceId root_id() { - return traces_ == nullptr ? platform::kEmptyTraceId - : traces_->top()->root_id_; + static TraceId root_id() { + return traces_ == nullptr ? kEmptyTraceId : traces_->top()->root_id_; } - static platform::TraceIdHierarchy hierarchy() { + static TraceIdHierarchy hierarchy() { if (traces_ == nullptr) { - return platform::TraceIdHierarchy::Empty(); + return TraceIdHierarchy::Empty(); } return traces_->top()->to_hierarchy(); @@ -68,7 +66,7 @@ class ScopedTraceOperation { // the ternary operator in the macros simpler. static bool TraceAsyncEnd(const uint32_t line, const char* file, - platform::TraceId id, + TraceId id, Error::Code e); protected: @@ -79,18 +77,16 @@ class ScopedTraceOperation { virtual void SetTraceResult(Error::Code error) = 0; // Constructor to set all trace id information. - ScopedTraceOperation(platform::TraceId current_id = platform::kUnsetTraceId, - platform::TraceId parent_id = platform::kUnsetTraceId, - platform::TraceId root_id = platform::kUnsetTraceId); + ScopedTraceOperation(TraceId current_id = kUnsetTraceId, + TraceId parent_id = kUnsetTraceId, + TraceId root_id = kUnsetTraceId); // Current TraceId information. - platform::TraceId trace_id_; - platform::TraceId parent_id_; - platform::TraceId root_id_; + TraceId trace_id_; + TraceId parent_id_; + TraceId root_id_; - platform::TraceIdHierarchy to_hierarchy() { - return {trace_id_, parent_id_, root_id_}; - } + TraceIdHierarchy to_hierarchy() { return {trace_id_, parent_id_, root_id_}; } private: // NOTE: A std::vector is used for backing the stack because it provides the @@ -115,26 +111,26 @@ class ScopedTraceOperation { // The class which does actual trace logging. class TraceLoggerBase : public ScopedTraceOperation { public: - TraceLoggerBase(platform::TraceCategory::Value category, + TraceLoggerBase(TraceCategory::Value category, const char* name, const char* file, uint32_t line, - platform::TraceId current = platform::kUnsetTraceId, - platform::TraceId parent = platform::kUnsetTraceId, - platform::TraceId root = platform::kUnsetTraceId); + TraceId current = kUnsetTraceId, + TraceId parent = kUnsetTraceId, + TraceId root = kUnsetTraceId); - TraceLoggerBase(platform::TraceCategory::Value category, + TraceLoggerBase(TraceCategory::Value category, const char* name, const char* file, uint32_t line, - platform::TraceIdHierarchy ids); + TraceIdHierarchy ids); protected: // Set the result. void SetTraceResult(Error::Code error) override { result_ = error; } // Timestamp for when the object was created. - platform::Clock::time_point start_time_; + Clock::time_point start_time_; // Result of this operation. Error::Code result_; @@ -149,7 +145,7 @@ class TraceLoggerBase : public ScopedTraceOperation { uint32_t line_number_; // Category of this trace log. - platform::TraceCategory::Value category_; + TraceCategory::Value category_; private: OSP_DISALLOW_COPY_AND_ASSIGN(TraceLoggerBase); @@ -179,7 +175,7 @@ class AsynchronousTraceLogger : public TraceLoggerBase { // the current TraceId Hierarchy manually. class TraceIdSetter : public ScopedTraceOperation { public: - explicit TraceIdSetter(platform::TraceIdHierarchy ids) + explicit TraceIdSetter(TraceIdHierarchy ids) : ScopedTraceOperation(ids.current, ids.parent, ids.root) {} ~TraceIdSetter() final; diff --git a/util/trace_logging/scoped_trace_operations_unittest.cc b/util/trace_logging/scoped_trace_operations_unittest.cc index 63fa1cba..a1eba626 100644 --- a/util/trace_logging/scoped_trace_operations_unittest.cc +++ b/util/trace_logging/scoped_trace_operations_unittest.cc @@ -21,12 +21,9 @@ using ::testing::_; using ::testing::DoAll; using ::testing::Invoke; -using platform::kEmptyTraceId; -using platform::MockLoggingPlatform; - // These tests validate that parameters are passed correctly by using the Trace // Internals. -constexpr auto category = platform::TraceCategory::mDNS; +constexpr auto category = TraceCategory::mDNS; constexpr uint32_t line = 10; TEST(TraceLoggingInternalTest, CreatingNoTraceObjectValid) { @@ -38,9 +35,8 @@ TEST(TraceLoggingInternalTest, TestMacroStyleInitializationTrue) { MockLoggingPlatform platform; EXPECT_CALL(platform, LogTrace(_, _, _, _, _, _, _)) .Times(1) - .WillOnce( - DoAll(Invoke(platform::ValidateTraceTimestampDiff<delay_in_ms>), - Invoke(platform::ValidateTraceErrorCode<Error::Code::kNone>))); + .WillOnce(DoAll(Invoke(ValidateTraceTimestampDiff<delay_in_ms>), + Invoke(ValidateTraceErrorCode<Error::Code::kNone>))); { uint8_t temp[sizeof(SynchronousTraceLogger)]; @@ -81,7 +77,7 @@ TEST(TraceLoggingInternalTest, ExpectParametersPassedToResult) { MockLoggingPlatform platform; EXPECT_CALL(platform, LogTrace(testing::StrEq("Name"), line, testing::StrEq(__FILE__), _, _, _, _)) - .WillOnce(Invoke(platform::ValidateTraceErrorCode<Error::Code::kNone>)); + .WillOnce(Invoke(ValidateTraceErrorCode<Error::Code::kNone>)); { SynchronousTraceLogger{category, "Name", __FILE__, line}; } } diff --git a/util/trace_logging_unittest.cc b/util/trace_logging_unittest.cc index d34ed303..db755d68 100644 --- a/util/trace_logging_unittest.cc +++ b/util/trace_logging_unittest.cc @@ -13,7 +13,6 @@ #include "platform/test/trace_logging_helpers.h" namespace openscreen { -namespace platform { namespace { #if defined(ENABLE_TRACE_LOGGING) @@ -368,5 +367,4 @@ TEST(TraceLoggingTest, CheckTraceAsyncEndLogsCorrectly) { } } // namespace -} // namespace platform } // namespace openscreen |