[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>

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,