diff options
author | Jordan Bayles <jophba@chromium.org> | 2021-06-10 08:11:22 -0700 |
---|---|---|
committer | Openscreen LUCI CQ <openscreen-scoped@luci-project-accounts.iam.gserviceaccount.com> | 2021-06-10 17:26:53 +0000 |
commit | 1a4e533d57c2b879704759cdffb2a00f71266346 (patch) | |
tree | 8e98f4417665fae38e86f3cd9e120e2e09204910 /cast | |
parent | 94090603e69d7c63f3383038b0689bde6f968459 (diff) | |
download | openscreen-1a4e533d57c2b879704759cdffb2a00f71266346.tar.gz |
[Cast Streaming] Messager -> Messenger
Messager, while being proper English, is archaic and generally not in
use. This patch updates SessionMessager and its related types to be
named SessionMessenger.
Change-Id: I8d9caa685f86fa5863db56b4514a4d16ed5f1a33
Reviewed-on: https://chromium-review.googlesource.com/c/openscreen/+/2950433
Reviewed-by: Ryan Keane <rwkeane@google.com>
Commit-Queue: Jordan Bayles <jophba@chromium.org>
Diffstat (limited to 'cast')
-rw-r--r-- | cast/streaming/BUILD.gn | 6 | ||||
-rw-r--r-- | cast/streaming/receiver_session.cc | 28 | ||||
-rw-r--r-- | cast/streaming/receiver_session.h | 6 | ||||
-rw-r--r-- | cast/streaming/rpc_broker.h | 4 | ||||
-rw-r--r-- | cast/streaming/rpc_broker_unittest.cc | 46 | ||||
-rw-r--r-- | cast/streaming/sender_session.cc | 16 | ||||
-rw-r--r-- | cast/streaming/sender_session.h | 6 | ||||
-rw-r--r-- | cast/streaming/session_messenger.cc (renamed from cast/streaming/session_messager.cc) | 86 | ||||
-rw-r--r-- | cast/streaming/session_messenger.h (renamed from cast/streaming/session_messager.h) | 40 | ||||
-rw-r--r-- | cast/streaming/session_messenger_unittest.cc (renamed from cast/streaming/session_messager_unittest.cc) | 144 |
10 files changed, 191 insertions, 191 deletions
diff --git a/cast/streaming/BUILD.gn b/cast/streaming/BUILD.gn index 85867a95..baacb905 100644 --- a/cast/streaming/BUILD.gn +++ b/cast/streaming/BUILD.gn @@ -73,8 +73,8 @@ source_set("common") { "sender_message.h", "session_config.cc", "session_config.h", - "session_messager.cc", - "session_messager.h", + "session_messenger.cc", + "session_messenger.h", "ssrc.cc", "ssrc.h", ] @@ -202,7 +202,7 @@ source_set("unittests") { "sender_report_unittest.cc", "sender_session_unittest.cc", "sender_unittest.cc", - "session_messager_unittest.cc", + "session_messenger_unittest.cc", "ssrc_unittest.cc", ] diff --git a/cast/streaming/receiver_session.cc b/cast/streaming/receiver_session.cc index a9203734..c2a06d01 100644 --- a/cast/streaming/receiver_session.cc +++ b/cast/streaming/receiver_session.cc @@ -104,23 +104,23 @@ ReceiverSession::ReceiverSession(Client* const client, environment_(environment), preferences_(std::move(preferences)), session_id_(MakeUniqueSessionId("streaming_receiver")), - messager_(message_port, - session_id_, - [this](Error error) { - OSP_DLOG_WARN << "Got a session messager error: " << error; - client_->OnError(this, error); - }), + messenger_(message_port, + session_id_, + [this](Error error) { + OSP_DLOG_WARN << "Got a session messenger error: " << error; + client_->OnError(this, error); + }), packet_router_(environment_) { OSP_DCHECK(client_); OSP_DCHECK(environment_); - messager_.SetHandler( + messenger_.SetHandler( SenderMessage::Type::kOffer, [this](SenderMessage message) { OnOffer(std::move(message)); }); - messager_.SetHandler(SenderMessage::Type::kGetCapabilities, - [this](SenderMessage message) { - OnCapabilitiesRequest(std::move(message)); - }); + messenger_.SetHandler(SenderMessage::Type::kGetCapabilities, + [this](SenderMessage message) { + OnCapabilitiesRequest(std::move(message)); + }); environment_->SetSocketSubscriber(this); } @@ -237,7 +237,7 @@ void ReceiverSession::OnCapabilitiesRequest(SenderMessage message) { "Remoting is not supported"}; } - const Error result = messager_.SendMessage(std::move(response)); + const Error result = messenger_.SendMessage(std::move(response)); if (!result.ok()) { client_->OnError(this, std::move(result)); } @@ -256,7 +256,7 @@ void ReceiverSession::InitializeSession(const SessionProperties& properties) { // Only spawn receivers if we know we have a valid answer message. ConfiguredReceivers receivers = SpawnReceivers(properties); client_->OnNegotiated(this, std::move(receivers)); - const Error result = messager_.SendMessage(ReceiverMessage{ + const Error result = messenger_.SendMessage(ReceiverMessage{ ReceiverMessage::Type::kAnswer, properties.sequence_number, true /* valid */, std::move(answer)}); if (!result.ok()) { @@ -403,7 +403,7 @@ void ReceiverSession::SendErrorAnswerReply(int sequence_number, const char* message) { const Error error(Error::Code::kParseError, message); OSP_DLOG_WARN << message; - const Error result = messager_.SendMessage(ReceiverMessage{ + const Error result = messenger_.SendMessage(ReceiverMessage{ ReceiverMessage::Type::kAnswer, sequence_number, false /* valid */, ReceiverError{static_cast<int>(Error::Code::kParseError), message}}); if (!result.ok()) { diff --git a/cast/streaming/receiver_session.h b/cast/streaming/receiver_session.h index bb6e4493..3c341279 100644 --- a/cast/streaming/receiver_session.h +++ b/cast/streaming/receiver_session.h @@ -18,7 +18,7 @@ #include "cast/streaming/resolution.h" #include "cast/streaming/sender_message.h" #include "cast/streaming/session_config.h" -#include "cast/streaming/session_messager.h" +#include "cast/streaming/session_messenger.h" namespace openscreen { namespace cast { @@ -294,8 +294,8 @@ class ReceiverSession final : public Environment::SocketSubscriber { // The sender_id of this session. const std::string session_id_; - // The session messager used for the lifetime of this session. - ReceiverSessionMessager messager_; + // The session messenger used for the lifetime of this session. + ReceiverSessionMessenger messenger_; // The packet router to be used for all Receivers spawned by this session. ReceiverPacketRouter packet_router_; diff --git a/cast/streaming/rpc_broker.h b/cast/streaming/rpc_broker.h index 5865a86b..3cccec83 100644 --- a/cast/streaming/rpc_broker.h +++ b/cast/streaming/rpc_broker.h @@ -17,7 +17,7 @@ namespace openscreen { namespace cast { // Processes incoming and outgoing RPC messages and links them to desired -// components on both end points. For outgoing messages, the messager +// components on both end points. For outgoing messages, the messenger // must send an RPC message with associated handle value. On the messagee side, // the message is sent to a pre-registered component using that handle. // Before RPC communication starts, both sides need to negotiate the handle @@ -25,7 +25,7 @@ namespace cast { // |kAcquire*Handle|. // // NOTE: RpcBroker doesn't actually send RPC messages to the remote. The session -// messager needs to set SendMessageCallback, and call ProcessMessageFromRemote +// messenger needs to set SendMessageCallback, and call ProcessMessageFromRemote // as appropriate. The RpcBroker then distributes each RPC message to the // subscribed component. class RpcBroker { diff --git a/cast/streaming/rpc_broker_unittest.cc b/cast/streaming/rpc_broker_unittest.cc index 3f13f9ea..a837285c 100644 --- a/cast/streaming/rpc_broker_unittest.cc +++ b/cast/streaming/rpc_broker_unittest.cc @@ -21,7 +21,7 @@ namespace openscreen { namespace cast { namespace { -class FakeMessager { +class FakeMessenger { public: void OnReceivedRpc(std::unique_ptr<RpcMessage> message) { received_rpc_ = std::move(message); @@ -57,19 +57,19 @@ class FakeMessager { class RpcBrokerTest : public testing::Test { protected: void SetUp() override { - fake_messager_ = std::make_unique<FakeMessager>(); - ASSERT_FALSE(fake_messager_->received_count()); + fake_messenger_ = std::make_unique<FakeMessenger>(); + ASSERT_FALSE(fake_messenger_->received_count()); rpc_broker_ = std::make_unique<RpcBroker>( - [p = fake_messager_.get()](std::vector<uint8_t> message) { + [p = fake_messenger_.get()](std::vector<uint8_t> message) { p->OnSentRpc(message); }); const auto handle = rpc_broker_->GetUniqueHandle(); - fake_messager_->set_handle(handle); + fake_messenger_->set_handle(handle); rpc_broker_->RegisterMessageReceiverCallback( handle, - [p = fake_messager_.get()](std::unique_ptr<RpcMessage> message) { + [p = fake_messenger_.get()](std::unique_ptr<RpcMessage> message) { p->OnReceivedRpc(std::move(message)); }); } @@ -80,43 +80,43 @@ class RpcBrokerTest : public testing::Test { rpc_broker_->ProcessMessageFromRemote(message.data(), message.size()); } - std::unique_ptr<FakeMessager> fake_messager_; + std::unique_ptr<FakeMessenger> fake_messenger_; std::unique_ptr<RpcBroker> rpc_broker_; }; TEST_F(RpcBrokerTest, TestProcessMessageFromRemoteRegistered) { RpcMessage rpc; - rpc.set_handle(fake_messager_->handle()); + rpc.set_handle(fake_messenger_->handle()); ProcessMessage(rpc); - ASSERT_EQ(1, fake_messager_->received_count()); + ASSERT_EQ(1, fake_messenger_->received_count()); } TEST_F(RpcBrokerTest, TestProcessMessageFromRemoteUnregistered) { RpcMessage rpc; - rpc_broker_->UnregisterMessageReceiverCallback(fake_messager_->handle()); + rpc_broker_->UnregisterMessageReceiverCallback(fake_messenger_->handle()); ProcessMessage(rpc); - ASSERT_EQ(0, fake_messager_->received_count()); + ASSERT_EQ(0, fake_messenger_->received_count()); } TEST_F(RpcBrokerTest, CanSendMultipleMessages) { for (int i = 0; i < 10; ++i) { rpc_broker_->SendMessageToRemote(RpcMessage{}); } - EXPECT_EQ(10, fake_messager_->sent_count()); + EXPECT_EQ(10, fake_messenger_->sent_count()); } TEST_F(RpcBrokerTest, SendMessageCallback) { // Send message for RPC broker to process. RpcMessage sent_rpc; - sent_rpc.set_handle(fake_messager_->handle()); + sent_rpc.set_handle(fake_messenger_->handle()); sent_rpc.set_proc(RpcMessage::RPC_R_SETVOLUME); sent_rpc.set_double_value(2.3); rpc_broker_->SendMessageToRemote(sent_rpc); // Check if received message is identical to the one sent earlier. - ASSERT_EQ(1, fake_messager_->sent_count()); - const RpcMessage& message = fake_messager_->sent_rpc(); - ASSERT_EQ(fake_messager_->handle(), message.handle()); + ASSERT_EQ(1, fake_messenger_->sent_count()); + const RpcMessage& message = fake_messenger_->sent_rpc(); + ASSERT_EQ(fake_messenger_->handle(), message.handle()); ASSERT_EQ(RpcMessage::RPC_R_SETVOLUME, message.proc()); ASSERT_EQ(2.3, message.double_value()); } @@ -124,15 +124,15 @@ TEST_F(RpcBrokerTest, SendMessageCallback) { TEST_F(RpcBrokerTest, ProcessMessageWithRegisteredHandle) { // Send message for RPC broker to process. RpcMessage sent_rpc; - sent_rpc.set_handle(fake_messager_->handle()); + sent_rpc.set_handle(fake_messenger_->handle()); sent_rpc.set_proc(RpcMessage::RPC_R_SETVOLUME); sent_rpc.set_double_value(3.4); ProcessMessage(sent_rpc); // Checks if received message is identical to the one sent earlier. - ASSERT_EQ(1, fake_messager_->received_count()); - const RpcMessage& received_rpc = fake_messager_->received_rpc(); - ASSERT_EQ(fake_messager_->handle(), received_rpc.handle()); + ASSERT_EQ(1, fake_messenger_->received_count()); + const RpcMessage& received_rpc = fake_messenger_->received_rpc(); + ASSERT_EQ(fake_messenger_->handle(), received_rpc.handle()); ASSERT_EQ(RpcMessage::RPC_R_SETVOLUME, received_rpc.proc()); ASSERT_EQ(3.4, received_rpc.double_value()); } @@ -140,18 +140,18 @@ TEST_F(RpcBrokerTest, ProcessMessageWithRegisteredHandle) { TEST_F(RpcBrokerTest, ProcessMessageWithUnregisteredHandle) { // Send message for RPC broker to process. RpcMessage sent_rpc; - RpcBroker::Handle different_handle = fake_messager_->handle() + 1; + RpcBroker::Handle different_handle = fake_messenger_->handle() + 1; sent_rpc.set_handle(different_handle); sent_rpc.set_proc(RpcMessage::RPC_R_SETVOLUME); sent_rpc.set_double_value(4.5); ProcessMessage(sent_rpc); // We shouldn't have gotten the message since the handle is different. - ASSERT_EQ(0, fake_messager_->received_count()); + ASSERT_EQ(0, fake_messenger_->received_count()); } TEST_F(RpcBrokerTest, Registration) { - const auto handle = fake_messager_->handle(); + const auto handle = fake_messenger_->handle(); ASSERT_TRUE(rpc_broker_->IsRegisteredForTesting(handle)); rpc_broker_->UnregisterMessageReceiverCallback(handle); diff --git a/cast/streaming/sender_session.cc b/cast/streaming/sender_session.cc index 866afe5a..ca5ce027 100644 --- a/cast/streaming/sender_session.cc +++ b/cast/streaming/sender_session.cc @@ -201,7 +201,7 @@ SenderSession::Client::~Client() = default; SenderSession::SenderSession(Configuration config) : config_(config), - messager_( + messenger_( config_.message_port, config_.message_source_id, config_.message_destination_id, @@ -217,10 +217,10 @@ SenderSession::SenderSession(Configuration config) // We may or may not do remoting this session, however our RPC handler // is not negotiation-specific and registering on construction here allows us // to record any unexpected RPC messages. - messager_.SetHandler(ReceiverMessage::Type::kRpc, - [this](ReceiverMessage message) { - this->OnRpcMessage(std::move(message)); - }); + messenger_.SetHandler(ReceiverMessage::Type::kRpc, + [this](ReceiverMessage message) { + this->OnRpcMessage(std::move(message)); + }); } SenderSession::~SenderSession() = default; @@ -276,7 +276,7 @@ Error SenderSession::StartNegotiation( std::unique_ptr<InProcessNegotiation>(new InProcessNegotiation{ offer, std::move(audio_configs), std::move(video_configs)}); - return messager_.SendRequest( + return messenger_.SendRequest( SenderMessage{SenderMessage::Type::kOffer, ++current_sequence_number_, true, std::move(offer)}, ReceiverMessage::Type::kAnswer, @@ -310,7 +310,7 @@ void SenderSession::OnAnswer(ReceiverMessage message) { // receiver's capabilities are. So, we cache the Answer until the // capabilites request is completed. current_negotiation_->answer = answer; - const Error result = messager_.SendRequest( + const Error result = messenger_.SendRequest( SenderMessage{SenderMessage::Type::kGetCapabilities, ++current_sequence_number_, true}, ReceiverMessage::Type::kCapabilitiesResponse, @@ -362,7 +362,7 @@ void SenderSession::OnCapabilitiesResponse(ReceiverMessage message) { return; } broker_ = std::make_unique<RpcBroker>([this](std::vector<uint8_t> message) { - Error error = this->messager_.SendOutboundMessage(SenderMessage{ + Error error = this->messenger_.SendOutboundMessage(SenderMessage{ SenderMessage::Type::kRpc, ++(this->current_sequence_number_), true, std::move(message)}); diff --git a/cast/streaming/sender_session.h b/cast/streaming/sender_session.h index dce7ce2a..7702b490 100644 --- a/cast/streaming/sender_session.h +++ b/cast/streaming/sender_session.h @@ -20,7 +20,7 @@ #include "cast/streaming/sender.h" #include "cast/streaming/sender_packet_router.h" #include "cast/streaming/session_config.h" -#include "cast/streaming/session_messager.h" +#include "cast/streaming/session_messenger.h" #include "json/value.h" #include "util/json/json_serialization.h" @@ -230,10 +230,10 @@ class SenderSession final { // This session's configuration. Configuration config_; - // The session messager, which uses the message port for sending control + // The session messenger, which uses the message port for sending control // messages. For message formats, see // cast/protocol/castv2/streaming_schema.json. - SenderSessionMessager messager_; + SenderSessionMessenger messenger_; // The packet router used for RTP/RTCP messaging across all senders. SenderPacketRouter packet_router_; diff --git a/cast/streaming/session_messager.cc b/cast/streaming/session_messenger.cc index e66e984f..34c4c02f 100644 --- a/cast/streaming/session_messager.cc +++ b/cast/streaming/session_messenger.cc @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "cast/streaming/session_messager.h" +#include "cast/streaming/session_messenger.h" #include "absl/strings/ascii.h" #include "cast/common/public/message_port.h" @@ -19,7 +19,7 @@ namespace { void ReplyIfTimedOut( int sequence_number, ReceiverMessage::Type reply_type, - std::vector<std::pair<int, SenderSessionMessager::ReplyCallback>>* + std::vector<std::pair<int, SenderSessionMessenger::ReplyCallback>>* replies) { for (auto it = replies->begin(); it != replies->end(); ++it) { if (it->first == sequence_number) { @@ -35,22 +35,22 @@ void ReplyIfTimedOut( } // namespace -SessionMessager::SessionMessager(MessagePort* message_port, - std::string source_id, - ErrorCallback cb) +SessionMessenger::SessionMessenger(MessagePort* message_port, + std::string source_id, + ErrorCallback cb) : message_port_(message_port), error_callback_(std::move(cb)) { OSP_DCHECK(message_port_); OSP_DCHECK(!source_id.empty()); message_port_->SetClient(this, source_id); } -SessionMessager::~SessionMessager() { +SessionMessenger::~SessionMessenger() { message_port_->ResetClient(); } -Error SessionMessager::SendMessage(const std::string& destination_id, - const std::string& namespace_, - const Json::Value& message_root) { +Error SessionMessenger::SendMessage(const std::string& destination_id, + const std::string& namespace_, + const Json::Value& message_root) { OSP_DCHECK(namespace_ == kCastRemotingNamespace || namespace_ == kCastWebrtcNamespace); auto body_or_error = json::Stringify(message_root); @@ -64,40 +64,40 @@ Error SessionMessager::SendMessage(const std::string& destination_id, return Error::None(); } -void SessionMessager::ReportError(Error error) { +void SessionMessenger::ReportError(Error error) { error_callback_(std::move(error)); } -SenderSessionMessager::SenderSessionMessager(MessagePort* message_port, - std::string source_id, - std::string receiver_id, - ErrorCallback cb, - TaskRunner* task_runner) - : SessionMessager(message_port, std::move(source_id), std::move(cb)), +SenderSessionMessenger::SenderSessionMessenger(MessagePort* message_port, + std::string source_id, + std::string receiver_id, + ErrorCallback cb, + TaskRunner* task_runner) + : SessionMessenger(message_port, std::move(source_id), std::move(cb)), task_runner_(task_runner), receiver_id_(std::move(receiver_id)) {} -void SenderSessionMessager::SetHandler(ReceiverMessage::Type type, - ReplyCallback cb) { +void SenderSessionMessenger::SetHandler(ReceiverMessage::Type type, + ReplyCallback cb) { // Currently the only handler allowed is for RPC messages. OSP_DCHECK(type == ReceiverMessage::Type::kRpc); rpc_callback_ = std::move(cb); } -Error SenderSessionMessager::SendOutboundMessage(SenderMessage message) { +Error SenderSessionMessenger::SendOutboundMessage(SenderMessage message) { const auto namespace_ = (message.type == SenderMessage::Type::kRpc) ? kCastRemotingNamespace : kCastWebrtcNamespace; ErrorOr<Json::Value> jsonified = message.ToJson(); OSP_CHECK(jsonified.is_value()) << "Tried to send an invalid message"; - return SessionMessager::SendMessage(receiver_id_, namespace_, - jsonified.value()); + return SessionMessenger::SendMessage(receiver_id_, namespace_, + jsonified.value()); } -Error SenderSessionMessager::SendRequest(SenderMessage message, - ReceiverMessage::Type reply_type, - ReplyCallback cb) { +Error SenderSessionMessenger::SendRequest(SenderMessage message, + ReceiverMessage::Type reply_type, + ReplyCallback cb) { static constexpr std::chrono::milliseconds kReplyTimeout{4000}; // RPC messages are not meant to be request/reply. OSP_DCHECK(reply_type != ReceiverMessage::Type::kRpc); @@ -122,9 +122,9 @@ Error SenderSessionMessager::SendRequest(SenderMessage message, return Error::None(); } -void SenderSessionMessager::OnMessage(const std::string& source_id, - const std::string& message_namespace, - const std::string& message) { +void SenderSessionMessenger::OnMessage(const std::string& source_id, + const std::string& message_namespace, + const std::string& message) { if (source_id != receiver_id_) { OSP_DLOG_WARN << "Received message from unknown/incorrect Cast Receiver, " "expected id \"" @@ -191,22 +191,22 @@ void SenderSessionMessager::OnMessage(const std::string& source_id, } } -void SenderSessionMessager::OnError(Error error) { - OSP_DLOG_WARN << "Received an error in the session messager: " << error; +void SenderSessionMessenger::OnError(Error error) { + OSP_DLOG_WARN << "Received an error in the session messenger: " << error; } -ReceiverSessionMessager::ReceiverSessionMessager(MessagePort* message_port, - std::string source_id, - ErrorCallback cb) - : SessionMessager(message_port, std::move(source_id), std::move(cb)) {} +ReceiverSessionMessenger::ReceiverSessionMessenger(MessagePort* message_port, + std::string source_id, + ErrorCallback cb) + : SessionMessenger(message_port, std::move(source_id), std::move(cb)) {} -void ReceiverSessionMessager::SetHandler(SenderMessage::Type type, - RequestCallback cb) { +void ReceiverSessionMessenger::SetHandler(SenderMessage::Type type, + RequestCallback cb) { OSP_DCHECK(callbacks_.find(type) == callbacks_.end()); callbacks_.emplace_back(type, std::move(cb)); } -Error ReceiverSessionMessager::SendMessage(ReceiverMessage message) { +Error ReceiverSessionMessenger::SendMessage(ReceiverMessage message) { if (sender_session_id_.empty()) { return Error(Error::Code::kInitializationFailure, "Tried to send a message without receiving one first"); @@ -218,13 +218,13 @@ Error ReceiverSessionMessager::SendMessage(ReceiverMessage message) { ErrorOr<Json::Value> message_json = message.ToJson(); OSP_CHECK(message_json.is_value()) << "Tried to send an invalid message"; - return SessionMessager::SendMessage(sender_session_id_, namespace_, - message_json.value()); + return SessionMessenger::SendMessage(sender_session_id_, namespace_, + message_json.value()); } -void ReceiverSessionMessager::OnMessage(const std::string& source_id, - const std::string& message_namespace, - const std::string& message) { +void ReceiverSessionMessenger::OnMessage(const std::string& source_id, + const std::string& message_namespace, + const std::string& message) { // We assume we are connected to the first sender_id we receive. if (sender_session_id_.empty()) { sender_session_id_ = source_id; @@ -274,8 +274,8 @@ void ReceiverSessionMessager::OnMessage(const std::string& source_id, } } -void ReceiverSessionMessager::OnError(Error error) { - OSP_DLOG_WARN << "Received an error in the session messager: " << error; +void ReceiverSessionMessenger::OnError(Error error) { + OSP_DLOG_WARN << "Received an error in the session messenger: " << error; } } // namespace cast diff --git a/cast/streaming/session_messager.h b/cast/streaming/session_messenger.h index 044ff794..97a2564a 100644 --- a/cast/streaming/session_messager.h +++ b/cast/streaming/session_messenger.h @@ -2,8 +2,8 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CAST_STREAMING_SESSION_MESSAGER_H_ -#define CAST_STREAMING_SESSION_MESSAGER_H_ +#ifndef CAST_STREAMING_SESSION_MESSENGER_H_ +#define CAST_STREAMING_SESSION_MESSENGER_H_ #include <functional> #include <string> @@ -27,14 +27,14 @@ namespace cast { // A message port interface designed specifically for use by the Receiver // and Sender session classes. -class SessionMessager : public MessagePort::Client { +class SessionMessenger : public MessagePort::Client { public: using ErrorCallback = std::function<void(Error)>; - SessionMessager(MessagePort* message_port, - std::string source_id, - ErrorCallback cb); - ~SessionMessager() override; + SessionMessenger(MessagePort* message_port, + std::string source_id, + ErrorCallback cb); + ~SessionMessenger() override; protected: // Barebones message sending method shared by both children. @@ -50,15 +50,15 @@ class SessionMessager : public MessagePort::Client { ErrorCallback error_callback_; }; -class SenderSessionMessager final : public SessionMessager { +class SenderSessionMessenger final : public SessionMessenger { public: using ReplyCallback = std::function<void(ReceiverMessage)>; - SenderSessionMessager(MessagePort* message_port, - std::string source_id, - std::string receiver_id, - ErrorCallback cb, - TaskRunner* task_runner); + SenderSessionMessenger(MessagePort* message_port, + std::string source_id, + std::string receiver_id, + ErrorCallback cb, + TaskRunner* task_runner); // Set receiver message handler. Note that this should only be // applied for messages that don't have sequence numbers, like RPC @@ -80,7 +80,7 @@ class SenderSessionMessager final : public SessionMessager { private: TaskRunner* const task_runner_; - // This messager should only be connected to one receiver, so |receiver_id_| + // This messenger should only be connected to one receiver, so |receiver_id_| // should not change. const std::string receiver_id_; @@ -93,15 +93,15 @@ class SenderSessionMessager final : public SessionMessager { // a flatmap here. ReplyCallback rpc_callback_; - WeakPtrFactory<SenderSessionMessager> weak_factory_{this}; + WeakPtrFactory<SenderSessionMessenger> weak_factory_{this}; }; -class ReceiverSessionMessager final : public SessionMessager { +class ReceiverSessionMessenger final : public SessionMessenger { public: using RequestCallback = std::function<void(SenderMessage)>; - ReceiverSessionMessager(MessagePort* message_port, - std::string source_id, - ErrorCallback cb); + ReceiverSessionMessenger(MessagePort* message_port, + std::string source_id, + ErrorCallback cb); // Set sender message handler. void SetHandler(SenderMessage::Type type, RequestCallback cb); @@ -125,4 +125,4 @@ class ReceiverSessionMessager final : public SessionMessager { } // namespace cast } // namespace openscreen -#endif // CAST_STREAMING_SESSION_MESSAGER_H_ +#endif // CAST_STREAMING_SESSION_MESSENGER_H_ diff --git a/cast/streaming/session_messager_unittest.cc b/cast/streaming/session_messenger_unittest.cc index c06c64bb..ce2f1655 100644 --- a/cast/streaming/session_messager_unittest.cc +++ b/cast/streaming/session_messenger_unittest.cc @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "cast/streaming/session_messager.h" +#include "cast/streaming/session_messenger.h" #include "cast/streaming/testing/message_pipe.h" #include "cast/streaming/testing/simple_message_port.h" @@ -58,19 +58,19 @@ Offer kExampleOffer{ struct SessionMessageStore { public: - SenderSessionMessager::ReplyCallback GetReplyCallback() { + SenderSessionMessenger::ReplyCallback GetReplyCallback() { return [this](ReceiverMessage message) { receiver_messages.push_back(std::move(message)); }; } - ReceiverSessionMessager::RequestCallback GetRequestCallback() { + ReceiverSessionMessenger::RequestCallback GetRequestCallback() { return [this](SenderMessage message) { sender_messages.push_back(std::move(message)); }; } - SessionMessager::ErrorCallback GetErrorCallback() { + SessionMessenger::ErrorCallback GetErrorCallback() { return [this](Error error) { errors.push_back(std::move(error)); }; } @@ -80,33 +80,33 @@ struct SessionMessageStore { }; } // namespace -class SessionMessagerTest : public ::testing::Test { +class SessionMessengerTest : public ::testing::Test { public: - SessionMessagerTest() + SessionMessengerTest() : clock_{Clock::now()}, task_runner_(&clock_), message_store_(), pipe_(kSenderId, kReceiverId), - receiver_messager_(pipe_.right(), - kReceiverId, - message_store_.GetErrorCallback()), - sender_messager_(pipe_.left(), - kSenderId, - kReceiverId, - message_store_.GetErrorCallback(), - &task_runner_) + receiver_messenger_(pipe_.right(), + kReceiverId, + message_store_.GetErrorCallback()), + sender_messenger_(pipe_.left(), + kSenderId, + kReceiverId, + message_store_.GetErrorCallback(), + &task_runner_) {} void SetUp() override { - sender_messager_.SetHandler(ReceiverMessage::Type::kRpc, - message_store_.GetReplyCallback()); - receiver_messager_.SetHandler(SenderMessage::Type::kOffer, - message_store_.GetRequestCallback()); - receiver_messager_.SetHandler(SenderMessage::Type::kGetCapabilities, - message_store_.GetRequestCallback()); - receiver_messager_.SetHandler(SenderMessage::Type::kRpc, - message_store_.GetRequestCallback()); + sender_messenger_.SetHandler(ReceiverMessage::Type::kRpc, + message_store_.GetReplyCallback()); + receiver_messenger_.SetHandler(SenderMessage::Type::kOffer, + message_store_.GetRequestCallback()); + receiver_messenger_.SetHandler(SenderMessage::Type::kGetCapabilities, + message_store_.GetRequestCallback()); + receiver_messenger_.SetHandler(SenderMessage::Type::kRpc, + message_store_.GetRequestCallback()); } protected: @@ -114,18 +114,18 @@ class SessionMessagerTest : public ::testing::Test { FakeTaskRunner task_runner_; SessionMessageStore message_store_; MessagePipe pipe_; - ReceiverSessionMessager receiver_messager_; - SenderSessionMessager sender_messager_; + ReceiverSessionMessenger receiver_messenger_; + SenderSessionMessenger sender_messenger_; std::vector<Error> receiver_errors_; std::vector<Error> sender_errors_; }; -TEST_F(SessionMessagerTest, RpcMessaging) { +TEST_F(SessionMessengerTest, RpcMessaging) { static const std::vector<uint8_t> kSenderMessage{1, 2, 3, 4, 5}; static const std::vector<uint8_t> kReceiverResponse{6, 7, 8, 9}; ASSERT_TRUE( - sender_messager_ + sender_messenger_ .SendOutboundMessage(SenderMessage{SenderMessage::Type::kRpc, 123, true /* valid */, kSenderMessage}) .ok()); @@ -139,7 +139,7 @@ TEST_F(SessionMessagerTest, RpcMessaging) { message_store_.sender_messages.clear(); ASSERT_TRUE( - receiver_messager_ + receiver_messenger_ .SendMessage(ReceiverMessage{ReceiverMessage::Type::kRpc, 123, true /* valid */, kReceiverResponse}) .ok()); @@ -153,9 +153,9 @@ TEST_F(SessionMessagerTest, RpcMessaging) { message_store_.receiver_messages[0].body)); } -TEST_F(SessionMessagerTest, CapabilitiesMessaging) { +TEST_F(SessionMessengerTest, CapabilitiesMessaging) { ASSERT_TRUE( - sender_messager_ + sender_messenger_ .SendRequest(SenderMessage{SenderMessage::Type::kGetCapabilities, 1337, true /* valid */}, ReceiverMessage::Type::kCapabilitiesResponse, @@ -169,7 +169,7 @@ TEST_F(SessionMessagerTest, CapabilitiesMessaging) { EXPECT_TRUE(message_store_.sender_messages[0].valid); message_store_.sender_messages.clear(); - ASSERT_TRUE(receiver_messager_ + ASSERT_TRUE(receiver_messenger_ .SendMessage(ReceiverMessage{ ReceiverMessage::Type::kCapabilitiesResponse, 1337, true /* valid */, @@ -190,8 +190,8 @@ TEST_F(SessionMessagerTest, CapabilitiesMessaging) { ElementsAre(MediaCapability::kAac, MediaCapability::k4k)); } -TEST_F(SessionMessagerTest, OfferAnswerMessaging) { - ASSERT_TRUE(sender_messager_ +TEST_F(SessionMessengerTest, OfferAnswerMessaging) { + ASSERT_TRUE(sender_messenger_ .SendRequest(SenderMessage{SenderMessage::Type::kOffer, 42, true /* valid */, kExampleOffer}, ReceiverMessage::Type::kAnswer, @@ -205,7 +205,7 @@ TEST_F(SessionMessagerTest, OfferAnswerMessaging) { EXPECT_TRUE(message_store_.sender_messages[0].valid); message_store_.sender_messages.clear(); - EXPECT_TRUE(receiver_messager_ + EXPECT_TRUE(receiver_messenger_ .SendMessage(ReceiverMessage{ ReceiverMessage::Type::kAnswer, 41, true /* valid */, Answer{1234, {0, 1}, {12344443, 12344445}}}) @@ -214,7 +214,7 @@ TEST_F(SessionMessagerTest, OfferAnswerMessaging) { ASSERT_TRUE(message_store_.sender_messages.empty()); ASSERT_TRUE(message_store_.receiver_messages.empty()); - ASSERT_TRUE(receiver_messager_ + ASSERT_TRUE(receiver_messenger_ .SendMessage(ReceiverMessage{ ReceiverMessage::Type::kAnswer, 42, true /* valid */, Answer{1234, {0, 1}, {12344443, 12344445}}}) @@ -233,8 +233,8 @@ TEST_F(SessionMessagerTest, OfferAnswerMessaging) { EXPECT_THAT(answer.ssrcs, ElementsAre(12344443, 12344445)); } -TEST_F(SessionMessagerTest, OfferAndReceiverError) { - ASSERT_TRUE(sender_messager_ +TEST_F(SessionMessengerTest, OfferAndReceiverError) { + ASSERT_TRUE(sender_messenger_ .SendRequest(SenderMessage{SenderMessage::Type::kOffer, 42, true /* valid */, kExampleOffer}, ReceiverMessage::Type::kAnswer, @@ -248,7 +248,7 @@ TEST_F(SessionMessagerTest, OfferAndReceiverError) { EXPECT_TRUE(message_store_.sender_messages[0].valid); message_store_.sender_messages.clear(); - EXPECT_TRUE(receiver_messager_ + EXPECT_TRUE(receiver_messenger_ .SendMessage(ReceiverMessage{ ReceiverMessage::Type::kAnswer, 42, false /* valid */, ReceiverError{123, "Something real bad happened"}}) @@ -266,8 +266,8 @@ TEST_F(SessionMessagerTest, OfferAndReceiverError) { EXPECT_EQ("Something real bad happened", error.description); } -TEST_F(SessionMessagerTest, UnexpectedMessagesAreIgnored) { - EXPECT_FALSE(receiver_messager_ +TEST_F(SessionMessengerTest, UnexpectedMessagesAreIgnored) { + EXPECT_FALSE(receiver_messenger_ .SendMessage(ReceiverMessage{ ReceiverMessage::Type::kCapabilitiesResponse, 3123, true /* valid */, @@ -279,30 +279,30 @@ TEST_F(SessionMessagerTest, UnexpectedMessagesAreIgnored) { EXPECT_TRUE(message_store_.receiver_messages.empty()); } -TEST_F(SessionMessagerTest, UnknownSenderMessageTypesDontGetSent) { - EXPECT_DEATH(sender_messager_ +TEST_F(SessionMessengerTest, UnknownSenderMessageTypesDontGetSent) { + EXPECT_DEATH(sender_messenger_ .SendOutboundMessage(SenderMessage{ SenderMessage::Type::kUnknown, 123, true /* valid */}) .ok(), ".*Trying to send an unknown message is a developer error.*"); } -TEST_F(SessionMessagerTest, UnknownReceiverMessageTypesDontGetSent) { - ASSERT_TRUE(sender_messager_ +TEST_F(SessionMessengerTest, UnknownReceiverMessageTypesDontGetSent) { + ASSERT_TRUE(sender_messenger_ .SendRequest(SenderMessage{SenderMessage::Type::kOffer, 42, true /* valid */, kExampleOffer}, ReceiverMessage::Type::kAnswer, message_store_.GetReplyCallback()) .ok()); - EXPECT_DEATH(receiver_messager_ + EXPECT_DEATH(receiver_messenger_ .SendMessage(ReceiverMessage{ReceiverMessage::Type::kUnknown, 3123, true /* valid */}) .ok(), ".*Trying to send an unknown message is a developer error.*"); } -TEST_F(SessionMessagerTest, ReceiverHandlesUnknownMessageType) { +TEST_F(SessionMessengerTest, ReceiverHandlesUnknownMessageType) { pipe_.right()->ReceiveMessage(kCastWebrtcNamespace, R"({ "type": "GET_VIRTUAL_REALITY", "seqNum": 31337 @@ -310,12 +310,12 @@ TEST_F(SessionMessagerTest, ReceiverHandlesUnknownMessageType) { ASSERT_TRUE(message_store_.errors.empty()); } -TEST_F(SessionMessagerTest, SenderHandlesUnknownMessageType) { +TEST_F(SessionMessengerTest, SenderHandlesUnknownMessageType) { // The behavior on the sender side is a little more interesting: we // test elsewhere that messages with the wrong sequence number are ignored, // here if the type is unknown but the message contains a valid sequence // number we just treat it as a bad response/same as a timeout. - ASSERT_TRUE(sender_messager_ + ASSERT_TRUE(sender_messenger_ .SendRequest(SenderMessage{SenderMessage::Type::kOffer, 42, true /* valid */, kExampleOffer}, ReceiverMessage::Type::kAnswer, @@ -333,9 +333,9 @@ TEST_F(SessionMessagerTest, SenderHandlesUnknownMessageType) { ASSERT_EQ(false, message_store_.receiver_messages[0].valid); } -TEST_F(SessionMessagerTest, SenderHandlesMessageMissingSequenceNumber) { +TEST_F(SessionMessengerTest, SenderHandlesMessageMissingSequenceNumber) { ASSERT_TRUE( - sender_messager_ + sender_messenger_ .SendRequest(SenderMessage{SenderMessage::Type::kGetCapabilities, 42, true /* valid */}, ReceiverMessage::Type::kCapabilitiesResponse, @@ -354,17 +354,17 @@ TEST_F(SessionMessagerTest, SenderHandlesMessageMissingSequenceNumber) { ASSERT_TRUE(message_store_.receiver_messages.empty()); } -TEST_F(SessionMessagerTest, ReceiverCannotSendFirst) { - const Error error = receiver_messager_.SendMessage(ReceiverMessage{ +TEST_F(SessionMessengerTest, ReceiverCannotSendFirst) { + const Error error = receiver_messenger_.SendMessage(ReceiverMessage{ ReceiverMessage::Type::kCapabilitiesResponse, 3123, true /* valid */, ReceiverCapability{2, {MediaCapability::kAudio}}}); EXPECT_EQ(Error::Code::kInitializationFailure, error.code()); } -TEST_F(SessionMessagerTest, ErrorMessageLoggedIfTimeout) { +TEST_F(SessionMessengerTest, ErrorMessageLoggedIfTimeout) { ASSERT_TRUE( - sender_messager_ + sender_messenger_ .SendRequest(SenderMessage{SenderMessage::Type::kGetCapabilities, 3123, true /* valid */}, ReceiverMessage::Type::kCapabilitiesResponse, @@ -383,12 +383,12 @@ TEST_F(SessionMessagerTest, ErrorMessageLoggedIfTimeout) { EXPECT_FALSE(message_store_.receiver_messages[0].valid); } -TEST_F(SessionMessagerTest, ReceiverRejectsMessageFromWrongSender) { +TEST_F(SessionMessengerTest, ReceiverRejectsMessageFromWrongSender) { SimpleMessagePort port(kReceiverId); - ReceiverSessionMessager messager(&port, kReceiverId, - message_store_.GetErrorCallback()); - messager.SetHandler(SenderMessage::Type::kGetCapabilities, - message_store_.GetRequestCallback()); + ReceiverSessionMessenger messenger(&port, kReceiverId, + message_store_.GetErrorCallback()); + messenger.SetHandler(SenderMessage::Type::kGetCapabilities, + message_store_.GetRequestCallback()); // The first message should be accepted since we don't have a set sender_id // yet. @@ -418,11 +418,11 @@ TEST_F(SessionMessagerTest, ReceiverRejectsMessageFromWrongSender) { ASSERT_EQ(1u, message_store_.sender_messages.size()); } -TEST_F(SessionMessagerTest, SenderRejectsMessageFromWrongSender) { +TEST_F(SessionMessengerTest, SenderRejectsMessageFromWrongSender) { SimpleMessagePort port(kReceiverId); - SenderSessionMessager messager(&port, kSenderId, kReceiverId, - message_store_.GetErrorCallback(), - &task_runner_); + SenderSessionMessenger messenger(&port, kSenderId, kReceiverId, + message_store_.GetErrorCallback(), + &task_runner_); port.ReceiveMessage("receiver-31337", kCastWebrtcNamespace, R"({ "seqNum": 12345, @@ -438,12 +438,12 @@ TEST_F(SessionMessagerTest, SenderRejectsMessageFromWrongSender) { ASSERT_TRUE(message_store_.receiver_messages.empty()); } -TEST_F(SessionMessagerTest, ReceiverRejectsMessagesWithoutHandler) { +TEST_F(SessionMessengerTest, ReceiverRejectsMessagesWithoutHandler) { SimpleMessagePort port(kReceiverId); - ReceiverSessionMessager messager(&port, kReceiverId, - message_store_.GetErrorCallback()); - messager.SetHandler(SenderMessage::Type::kGetCapabilities, - message_store_.GetRequestCallback()); + ReceiverSessionMessenger messenger(&port, kReceiverId, + message_store_.GetErrorCallback()); + messenger.SetHandler(SenderMessage::Type::kGetCapabilities, + message_store_.GetRequestCallback()); // The first message should be accepted since we don't have a set sender_id // yet. @@ -464,11 +464,11 @@ TEST_F(SessionMessagerTest, ReceiverRejectsMessagesWithoutHandler) { ASSERT_TRUE(message_store_.sender_messages.empty()); } -TEST_F(SessionMessagerTest, SenderRejectsMessagesWithoutHandler) { +TEST_F(SessionMessengerTest, SenderRejectsMessagesWithoutHandler) { SimpleMessagePort port(kReceiverId); - SenderSessionMessager messager(&port, kSenderId, kReceiverId, - message_store_.GetErrorCallback(), - &task_runner_); + SenderSessionMessenger messenger(&port, kSenderId, kReceiverId, + message_store_.GetErrorCallback(), + &task_runner_); port.ReceiveMessage(kReceiverId, kCastWebrtcNamespace, R"({ "seqNum": 12345, @@ -484,7 +484,7 @@ TEST_F(SessionMessagerTest, SenderRejectsMessagesWithoutHandler) { ASSERT_TRUE(message_store_.receiver_messages.empty()); } -TEST_F(SessionMessagerTest, UnknownNamespaceMessagesGetDropped) { +TEST_F(SessionMessengerTest, UnknownNamespaceMessagesGetDropped) { pipe_.right()->ReceiveMessage("urn:x-cast:com.google.cast.virtualreality", R"({ "seqNum": 12345, |