Rename CastSocket::SendMessage to Send

This change renames both CastSocket::SendMessage and the wrapper
VirtualConnectionRouter::SendMessage to Send.  On Windows, translation
units compiled with windows.h will accidentally rename this to
SendMessageA or SendMessageW due Microsoft's macro-ing.  This means that
libcast code compiled without windows.h won't link with anything
compiled with windows.h.

Bug: 1050913
Change-Id: I24faa8895a921c4a17a7dafc442a0cbcc980de8e
Reviewed-on: https://chromium-review.googlesource.com/c/openscreen/+/2152217
Reviewed-by: Ryan Keane <rwkeane@google.com>
Commit-Queue: Brandon Tolsch <btolsch@chromium.org>

15 files changed, 49 insertions, 56 deletions

diff --git a/cast/common/channel/cast_socket.cc b/cast/common/channel/cast_socket.cc
index ba799658..86880e23 100644
--- a/cast/common/channel/cast_socket.cc
+++ b/cast/common/channel/cast_socket.cc
@@ -26,7 +26,7 @@ CastSocket::~CastSocket() {
   connection_->SetClient(nullptr);
 }
 
-Error CastSocket::SendMessage(const CastMessage& message) {
+Error CastSocket::Send(const CastMessage& message) {
   if (state_ == State::kError) {
     return Error::Code::kSocketClosedFailure;
   }
diff --git a/cast/common/channel/cast_socket.h b/cast/common/channel/cast_socket.h
index 550aa76e..5923166f 100644
--- a/cast/common/channel/cast_socket.h
+++ b/cast/common/channel/cast_socket.h
@@ -38,7 +38,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.
-  [[nodiscard]] Error SendMessage(const ::cast::channel::CastMessage& message);
+  [[nodiscard]] Error Send(const ::cast::channel::CastMessage& message);
 
   void SetClient(Client* client);
 
diff --git a/cast/common/channel/cast_socket_unittest.cc b/cast/common/channel/cast_socket_unittest.cc
index 44776384..decfb041 100644
--- a/cast/common/channel/cast_socket_unittest.cc
+++ b/cast/common/channel/cast_socket_unittest.cc
@@ -57,7 +57,7 @@ TEST_F(CastSocketTest, SendMessage) {
                                  reinterpret_cast<const uint8_t*>(data) + len));
         return true;
       }));
-  ASSERT_TRUE(socket().SendMessage(message_).ok());
+  ASSERT_TRUE(socket().Send(message_).ok());
 }
 
 TEST_F(CastSocketTest, SendMessageEventuallyBlocks) {
@@ -71,12 +71,12 @@ TEST_F(CastSocketTest, SendMessageEventuallyBlocks) {
         return true;
       }))
       .RetiresOnSaturation();
-  ASSERT_TRUE(socket().SendMessage(message_).ok());
-  ASSERT_TRUE(socket().SendMessage(message_).ok());
-  ASSERT_TRUE(socket().SendMessage(message_).ok());
+  ASSERT_TRUE(socket().Send(message_).ok());
+  ASSERT_TRUE(socket().Send(message_).ok());
+  ASSERT_TRUE(socket().Send(message_).ok());
 
   EXPECT_CALL(connection(), Send(_, _)).WillOnce(Return(false));
-  ASSERT_EQ(socket().SendMessage(message_).code(), Error::Code::kAgain);
+  ASSERT_EQ(socket().Send(message_).code(), Error::Code::kAgain);
 }
 
 TEST_F(CastSocketTest, ReadCompleteMessage) {
diff --git a/cast/common/channel/connection_namespace_handler.cc b/cast/common/channel/connection_namespace_handler.cc
index 40b2b840..23febfb0 100644
--- a/cast/common/channel/connection_namespace_handler.cc
+++ b/cast/common/channel/connection_namespace_handler.cc
@@ -231,7 +231,7 @@ void ConnectionNamespaceHandler::SendClose(VirtualConnectionRouter* router,
     return;
   }
 
-  router->SendMessage(
+  router->Send(
       std::move(virtual_conn),
       MakeSimpleUTF8Message(kConnectionNamespace, std::move(result.value())));
 }
@@ -250,9 +250,8 @@ void ConnectionNamespaceHandler::SendConnectedResponse(
     return;
   }
 
-  router->SendMessage(
-      virtual_conn,
-      MakeSimpleUTF8Message(kConnectionNamespace, std::move(result.value())));
+  router->Send(virtual_conn, MakeSimpleUTF8Message(kConnectionNamespace,
+                                                   std::move(result.value())));
 }
 
 }  // namespace cast
diff --git a/cast/common/channel/virtual_connection_router.cc b/cast/common/channel/virtual_connection_router.cc
index 7ceace60..c5bc8e36 100644
--- a/cast/common/channel/virtual_connection_router.cc
+++ b/cast/common/channel/virtual_connection_router.cc
@@ -54,8 +54,8 @@ void VirtualConnectionRouter::CloseSocket(int id) {
   }
 }
 
-Error VirtualConnectionRouter::SendMessage(VirtualConnection virtual_conn,
-                                           CastMessage message) {
+Error VirtualConnectionRouter::Send(VirtualConnection virtual_conn,
+                                    CastMessage message) {
   // TODO(btolsch): Check for broadcast message.
   if (!IsTransportNamespace(message.namespace_()) &&
       !vc_manager_->GetConnectionData(virtual_conn)) {
@@ -67,7 +67,7 @@ Error VirtualConnectionRouter::SendMessage(VirtualConnection virtual_conn,
   }
   message.set_source_id(std::move(virtual_conn.local_id));
   message.set_destination_id(std::move(virtual_conn.peer_id));
-  return it->second.socket->SendMessage(message);
+  return it->second.socket->Send(message);
 }
 
 void VirtualConnectionRouter::OnError(CastSocket* socket, Error error) {
diff --git a/cast/common/channel/virtual_connection_router.h b/cast/common/channel/virtual_connection_router.h
index 375c24ff..c43a2de8 100644
--- a/cast/common/channel/virtual_connection_router.h
+++ b/cast/common/channel/virtual_connection_router.h
@@ -36,9 +36,9 @@ class VirtualConnectionManager;
 //    VCRouter::TakeSocket.
 //
 // 4. Anything Foo wants to send (launch, app availability, etc.) goes through
-//    VCRouter::SendMessage via an appropriate VC.  The virtual connection is
-//    not created automatically, so Foo should either ensure its existence via
-//    logic or check with the VirtualConnectionManager first.
+//    VCRouter::Send via an appropriate VC.  The virtual connection is not
+//    created automatically, so Foo should either ensure its existence via logic
+//    or check with the VirtualConnectionManager first.
 class VirtualConnectionRouter final : public CastSocket::Client {
  public:
   class SocketErrorHandler {
@@ -59,8 +59,8 @@ class VirtualConnectionRouter final : public CastSocket::Client {
                   std::unique_ptr<CastSocket> socket);
   void CloseSocket(int id);
 
-  Error SendMessage(VirtualConnection virtual_conn,
-                    ::cast::channel::CastMessage message);
+  Error Send(VirtualConnection virtual_conn,
+             ::cast::channel::CastMessage message);
 
   // CastSocket::Client overrides.
   void OnError(CastSocket* socket, Error error) override;
diff --git a/cast/common/channel/virtual_connection_router_unittest.cc b/cast/common/channel/virtual_connection_router_unittest.cc
index 57e9fa1b..04c0c244 100644
--- a/cast/common/channel/virtual_connection_router_unittest.cc
+++ b/cast/common/channel/virtual_connection_router_unittest.cc
@@ -58,14 +58,14 @@ TEST_F(VirtualConnectionRouterTest, LocalIdHandler) {
   message.set_payload_type(CastMessage::STRING);
   message.set_payload_utf8("cnlybnq");
   EXPECT_CALL(mock_message_handler_, OnMessage(_, socket_, _));
-  EXPECT_TRUE(peer_socket().SendMessage(message).ok());
+  EXPECT_TRUE(peer_socket().Send(message).ok());
 
   EXPECT_CALL(mock_message_handler_, OnMessage(_, socket_, _));
-  EXPECT_TRUE(peer_socket().SendMessage(message).ok());
+  EXPECT_TRUE(peer_socket().Send(message).ok());
 
   message.set_destination_id("receiver-4321");
   EXPECT_CALL(mock_message_handler_, OnMessage(_, _, _)).Times(0);
-  EXPECT_TRUE(peer_socket().SendMessage(message).ok());
+  EXPECT_TRUE(peer_socket().Send(message).ok());
 }
 
 TEST_F(VirtualConnectionRouterTest, RemoveLocalIdHandler) {
@@ -83,12 +83,12 @@ TEST_F(VirtualConnectionRouterTest, RemoveLocalIdHandler) {
   message.set_payload_type(CastMessage::STRING);
   message.set_payload_utf8("cnlybnq");
   EXPECT_CALL(mock_message_handler_, OnMessage(_, socket_, _));
-  EXPECT_TRUE(peer_socket().SendMessage(message).ok());
+  EXPECT_TRUE(peer_socket().Send(message).ok());
 
   router_.RemoveHandlerForLocalId("receiver-1234");
 
   EXPECT_CALL(mock_message_handler_, OnMessage(_, socket_, _)).Times(0);
-  EXPECT_TRUE(peer_socket().SendMessage(message).ok());
+  EXPECT_TRUE(peer_socket().Send(message).ok());
 }
 
 TEST_F(VirtualConnectionRouterTest, SendMessage) {
@@ -113,7 +113,7 @@ TEST_F(VirtualConnectionRouterTest, SendMessage) {
                   ::cast::channel::CastMessage_PayloadType_STRING);
         EXPECT_EQ(message.payload_utf8(), "cnlybnq");
       }));
-  router_.SendMessage(
+  router_.Send(
       VirtualConnection{"receiver-1234", "sender-4321", socket_->socket_id()},
       std::move(message));
 }
diff --git a/cast/receiver/channel/device_auth_namespace_handler.cc b/cast/receiver/channel/device_auth_namespace_handler.cc
index 9e9d5e3f..239459a0 100644
--- a/cast/receiver/channel/device_auth_namespace_handler.cc
+++ b/cast/receiver/channel/device_auth_namespace_handler.cc
@@ -85,9 +85,8 @@ void DeviceAuthNamespaceHandler::OnMessage(VirtualConnectionRouter* router,
        sig_alg != ::cast::channel::RSASSA_PKCS1v15) ||
       (hash_alg != ::cast::channel::SHA1 &&
        hash_alg != ::cast::channel::SHA256)) {
-    router->SendMessage(
-        virtual_conn,
-        GenerateErrorMessage(AuthError::SIGNATURE_ALGORITHM_UNAVAILABLE));
+    router->Send(virtual_conn, GenerateErrorMessage(
+                                   AuthError::SIGNATURE_ALGORITHM_UNAVAILABLE));
     return;
   }
   const EVP_MD* digest =
@@ -100,8 +99,7 @@ void DeviceAuthNamespaceHandler::OnMessage(VirtualConnectionRouter* router,
   if (tls_cert_der.empty() || device_creds.certs.empty() ||
       !device_creds.private_key) {
     // TODO(btolsch): Add this to future error reporting.
-    router->SendMessage(virtual_conn,
-                        GenerateErrorMessage(AuthError::INTERNAL_ERROR));
+    router->Send(virtual_conn, GenerateErrorMessage(AuthError::INTERNAL_ERROR));
     return;
   }
 
@@ -131,8 +129,7 @@ void DeviceAuthNamespaceHandler::OnMessage(VirtualConnectionRouter* router,
   ErrorOr<std::string> signature =
       SignData(digest, device_creds.private_key.get(), to_be_signed);
   if (!signature) {
-    router->SendMessage(virtual_conn,
-                        GenerateErrorMessage(AuthError::INTERNAL_ERROR));
+    router->Send(virtual_conn, GenerateErrorMessage(AuthError::INTERNAL_ERROR));
     return;
   }
   auth_response->set_signature(std::move(signature.value()));
@@ -148,7 +145,7 @@ void DeviceAuthNamespaceHandler::OnMessage(VirtualConnectionRouter* router,
   response.set_namespace_(kAuthNamespace);
   response.set_payload_type(::cast::channel::CastMessage_PayloadType_BINARY);
   response.set_payload_binary(std::move(response_string));
-  router->SendMessage(virtual_conn, std::move(response));
+  router->Send(virtual_conn, std::move(response));
 }
 
 }  // namespace cast
diff --git a/cast/receiver/channel/device_auth_namespace_handler_unittest.cc b/cast/receiver/channel/device_auth_namespace_handler_unittest.cc
index bbd5f5fa..c264cb0e 100644
--- a/cast/receiver/channel/device_auth_namespace_handler_unittest.cc
+++ b/cast/receiver/channel/device_auth_namespace_handler_unittest.cc
@@ -91,8 +91,7 @@ TEST_F(DeviceAuthNamespaceHandlerTest, AuthResponse) {
             challenge_reply = std::move(message);
           }));
   ASSERT_TRUE(
-      fake_cast_socket_pair_.peer_socket->SendMessage(std::move(auth_challenge))
-          .ok());
+      fake_cast_socket_pair_.peer_socket->Send(std::move(auth_challenge)).ok());
 
   const std::string auth_response_string =
       ReadEntireFileToString(data_path_ + "auth_response.pb");
@@ -155,8 +154,7 @@ TEST_F(DeviceAuthNamespaceHandlerTest, BadNonce) {
             challenge_reply = std::move(message);
           }));
   ASSERT_TRUE(
-      fake_cast_socket_pair_.peer_socket->SendMessage(std::move(auth_challenge))
-          .ok());
+      fake_cast_socket_pair_.peer_socket->Send(std::move(auth_challenge)).ok());
 
   const std::string auth_response_string =
       ReadEntireFileToString(data_path_ + "auth_response.pb");
@@ -207,8 +205,7 @@ TEST_F(DeviceAuthNamespaceHandlerTest, UnsupportedSignatureAlgorithm) {
             challenge_reply = std::move(message);
           }));
   ASSERT_TRUE(
-      fake_cast_socket_pair_.peer_socket->SendMessage(std::move(auth_challenge))
-          .ok());
+      fake_cast_socket_pair_.peer_socket->Send(std::move(auth_challenge)).ok());
 
   DeviceAuthMessage auth_message;
   ASSERT_EQ(challenge_reply.payload_type(),
diff --git a/cast/sender/cast_app_discovery_service_impl_unittest.cc b/cast/sender/cast_app_discovery_service_impl_unittest.cc
index 863eb347..008b1a74 100644
--- a/cast/sender/cast_app_discovery_service_impl_unittest.cc
+++ b/cast/sender/cast_app_discovery_service_impl_unittest.cc
@@ -108,7 +108,7 @@ TEST_F(CastAppDiscoveryServiceImplTest, StartObservingAvailability) {
 
   CastMessage availability_response =
       CreateAppAvailableResponseChecked(request_id, sender_id, "AAA");
-  EXPECT_TRUE(peer_socket().SendMessage(availability_response).ok());
+  EXPECT_TRUE(peer_socket().Send(availability_response).ok());
   ASSERT_EQ(receivers1.size(), 1u);
   ASSERT_EQ(receivers2.size(), 1u);
   EXPECT_EQ(receivers1[0].unique_id, "deviceId1");
@@ -131,7 +131,7 @@ TEST_F(CastAppDiscoveryServiceImplTest, ReAddAvailQueryUsesCachedValue) {
 
   CastMessage availability_response =
       CreateAppAvailableResponseChecked(request_id, sender_id, "AAA");
-  EXPECT_TRUE(peer_socket().SendMessage(availability_response).ok());
+  EXPECT_TRUE(peer_socket().Send(availability_response).ok());
   ASSERT_EQ(receivers1.size(), 1u);
   EXPECT_EQ(receivers1[0].unique_id, "deviceId1");
 
@@ -154,7 +154,7 @@ TEST_F(CastAppDiscoveryServiceImplTest, AvailQueryUpdatedOnReceiverUpdate) {
   // Result set now includes |receiver_|.
   CastMessage availability_response =
       CreateAppAvailableResponseChecked(request_id, sender_id, "AAA");
-  EXPECT_TRUE(peer_socket().SendMessage(availability_response).ok());
+  EXPECT_TRUE(peer_socket().Send(availability_response).ok());
   ASSERT_EQ(receivers1.size(), 1u);
   EXPECT_EQ(receivers1[0].unique_id, "deviceId1");
 
@@ -202,10 +202,10 @@ TEST_F(CastAppDiscoveryServiceImplTest, Refresh) {
 
   CastMessage availability_response =
       CreateAppAvailableResponseChecked(request_idA, sender_id, "AAA");
-  EXPECT_TRUE(peer_socket().SendMessage(availability_response).ok());
+  EXPECT_TRUE(peer_socket().Send(availability_response).ok());
   availability_response =
       CreateAppUnavailableResponseChecked(request_idB, sender_id, "BBB");
-  EXPECT_TRUE(peer_socket().SendMessage(availability_response).ok());
+  EXPECT_TRUE(peer_socket().Send(availability_response).ok());
   ASSERT_EQ(receivers1.size(), 1u);
   ASSERT_EQ(receivers2.size(), 0u);
   EXPECT_EQ(receivers1[0].unique_id, "deviceId1");
@@ -291,7 +291,7 @@ TEST_F(CastAppDiscoveryServiceImplTest, StartObservingAvailabilityCachedValue) {
 
   CastMessage availability_response =
       CreateAppAvailableResponseChecked(request_id, sender_id, "AAA");
-  EXPECT_TRUE(peer_socket().SendMessage(availability_response).ok());
+  EXPECT_TRUE(peer_socket().Send(availability_response).ok());
   ASSERT_EQ(receivers1.size(), 1u);
   EXPECT_EQ(receivers1[0].unique_id, "deviceId1");
 
@@ -326,7 +326,7 @@ TEST_F(CastAppDiscoveryServiceImplTest, AvailabilityUnknownOrUnavailable) {
 
   CastMessage availability_response =
       CreateAppUnavailableResponseChecked(request_id, sender_id, "AAA");
-  EXPECT_TRUE(peer_socket().SendMessage(availability_response).ok());
+  EXPECT_TRUE(peer_socket().Send(availability_response).ok());
 
   // Known availability so no request sent.
   EXPECT_CALL(peer_client(), OnMessage(_, _)).Times(0);
diff --git a/cast/sender/cast_platform_client.cc b/cast/sender/cast_platform_client.cc
index 6e3d13da..7f7dde66 100644
--- a/cast/sender/cast_platform_client.cc
+++ b/cast/sender/cast_platform_client.cc
@@ -87,8 +87,8 @@ absl::optional<int> CastPlatformClient::RequestAppAvailability(
                                          VirtualConnection::AssociatedData{});
   }
 
-  virtual_conn_router_->SendMessage(std::move(virtual_conn),
-                                    std::move(message.value()));
+  virtual_conn_router_->Send(std::move(virtual_conn),
+                             std::move(message.value()));
 
   return request_id;
 }
diff --git a/cast/sender/cast_platform_client_unittest.cc b/cast/sender/cast_platform_client_unittest.cc
index 44e99660..eaaf5c6e 100644
--- a/cast/sender/cast_platform_client_unittest.cc
+++ b/cast/sender/cast_platform_client_unittest.cc
@@ -74,12 +74,12 @@ TEST_F(CastPlatformClientTest, AppAvailability) {
 
   CastMessage availability_response =
       CreateAppAvailableResponseChecked(request_id, sender_id, "AAA");
-  EXPECT_TRUE(peer_socket().SendMessage(availability_response).ok());
+  EXPECT_TRUE(peer_socket().Send(availability_response).ok());
   EXPECT_TRUE(ran);
 
   // NOTE: Callback should only fire once, so it should not fire again here.
   ran = false;
-  EXPECT_TRUE(peer_socket().SendMessage(availability_response).ok());
+  EXPECT_TRUE(peer_socket().Send(availability_response).ok());
   EXPECT_FALSE(ran);
 }
 
@@ -103,7 +103,7 @@ TEST_F(CastPlatformClientTest, CancelRequest) {
 
   CastMessage availability_response =
       CreateAppAvailableResponseChecked(request_id, sender_id, "AAA");
-  EXPECT_TRUE(peer_socket().SendMessage(availability_response).ok());
+  EXPECT_TRUE(peer_socket().Send(availability_response).ok());
 }
 
 }  // namespace cast
diff --git a/cast/sender/channel/sender_socket_factory.cc b/cast/sender/channel/sender_socket_factory.cc
index bf89de88..84826bdc 100644
--- a/cast/sender/channel/sender_socket_factory.cc
+++ b/cast/sender/channel/sender_socket_factory.cc
@@ -92,7 +92,7 @@ void SenderSocketFactory::OnConnected(
   PendingAuth& pending = *pending_auth_.back();
 
   CastMessage auth_challenge = CreateAuthChallengeMessage(pending.auth_context);
-  Error error = pending.socket->SendMessage(auth_challenge);
+  Error error = pending.socket->Send(auth_challenge);
   if (!error.ok()) {
     pending_auth_.pop_back();
     client_->OnError(this, endpoint, error);
diff --git a/cast/standalone_receiver/cast_socket_message_port.cc b/cast/standalone_receiver/cast_socket_message_port.cc
index 706fd58f..e73de786 100644
--- a/cast/standalone_receiver/cast_socket_message_port.cc
+++ b/cast/standalone_receiver/cast_socket_message_port.cc
@@ -49,7 +49,7 @@ void CastSocketMessagePort::PostMessage(absl::string_view sender_id,
                               message_namespace.size());
   cast_message.set_payload_utf8(message.data(), message.size());
 
-  Error error = socket_->SendMessage(cast_message);
+  Error error = socket_->Send(cast_message);
   if (!error.ok()) {
     client_->OnError(error);
   }
diff --git a/cast/test/device_auth_test.cc b/cast/test/device_auth_test.cc
index e1259308..e10a87b9 100644
--- a/cast/test/device_auth_test.cc
+++ b/cast/test/device_auth_test.cc
@@ -83,9 +83,9 @@ class DeviceAuthTest : public ::testing::Test {
             Invoke([&challenge_reply](CastSocket* socket, CastMessage message) {
               challenge_reply = std::move(message);
             }));
-    ASSERT_TRUE(fake_cast_socket_pair_.peer_socket
-                    ->SendMessage(std::move(auth_challenge))
-                    .ok());
+    ASSERT_TRUE(
+        fake_cast_socket_pair_.peer_socket->Send(std::move(auth_challenge))
+            .ok());
 
     if (record_this_test) {
       std::string output;