Moves create message functions into tcp library

Bug: 120027270
Test: run pie vnc_server
Change-Id: Ib8cb905cf942cf864aa978e72d2e4197de32b842
diff --git a/common/libs/tcp_socket/tcp_socket.cpp b/common/libs/tcp_socket/tcp_socket.cpp
index dc244b5..0c152eb 100644
--- a/common/libs/tcp_socket/tcp_socket.cpp
+++ b/common/libs/tcp_socket/tcp_socket.cpp
@@ -28,9 +28,9 @@
 using cvd::ServerSocket;
 
 ClientSocket::ClientSocket(int port)
-  : fd_(SharedFD::SocketLocalClient(port, SOCK_STREAM)) {}
+    : fd_(SharedFD::SocketLocalClient(port, SOCK_STREAM)) {}
 
-cvd::Message ClientSocket::RecvAny(size_t length) {
+cvd::Message ClientSocket::RecvAny(std::size_t length) {
   Message buf(length);
   auto read_count = fd_->Read(buf.data(), buf.size());
   if (read_count < 0) {
@@ -45,7 +45,7 @@
   return other_side_closed_;
 }
 
-cvd::Message ClientSocket::Recv(size_t length) {
+cvd::Message ClientSocket::Recv(std::size_t length) {
   Message buf(length);
   ssize_t total_read = 0;
   while (total_read < static_cast<ssize_t>(length)) {
@@ -70,7 +70,9 @@
   std::lock_guard<std::mutex> lock(send_lock_);
   ssize_t written{};
   while (written < static_cast<ssize_t>(size)) {
-    if (!fd_->IsOpen()) { LOG(ERROR) << "fd_ is closed"; }
+    if (!fd_->IsOpen()) {
+      LOG(ERROR) << "fd_ is closed";
+    }
     auto just_written = fd_->Write(data + written, size - written);
     if (just_written <= 0) {
       LOG(INFO) << "Couldn't write to client: " << strerror(errno);
@@ -103,3 +105,29 @@
   }
   return ClientSocket{client};
 }
+
+void cvd::AppendInNetworkByteOrder(Message* msg, const std::uint8_t b) {
+  msg->push_back(b);
+}
+
+void cvd::AppendInNetworkByteOrder(Message* msg, const std::uint16_t s) {
+  const std::uint16_t n = htons(s);
+  auto p = reinterpret_cast<const std::uint8_t*>(&n);
+  msg->insert(msg->end(), p, p + sizeof n);
+}
+
+void cvd::AppendInNetworkByteOrder(Message* msg, const std::uint32_t w) {
+  const std::uint32_t n = htonl(w);
+  auto p = reinterpret_cast<const std::uint8_t*>(&n);
+  msg->insert(msg->end(), p, p + sizeof n);
+}
+
+void cvd::AppendInNetworkByteOrder(Message* msg, const std::int32_t w) {
+  std::uint32_t u{};
+  std::memcpy(&u, &w, sizeof u);
+  AppendInNetworkByteOrder(msg, u);
+}
+
+void cvd::AppendInNetworkByteOrder(Message* msg, const std::string& str) {
+  msg->insert(msg->end(), str.begin(), str.end());
+}
diff --git a/common/libs/tcp_socket/tcp_socket.h b/common/libs/tcp_socket/tcp_socket.h
index 889d09b..dc78c94 100644
--- a/common/libs/tcp_socket/tcp_socket.h
+++ b/common/libs/tcp_socket/tcp_socket.h
@@ -49,7 +49,7 @@
   Message Recv(std::size_t length);
   // RecvAny will receive whatever is available.
   // An empty message returned indicates error or close.
-  Message RecvAny(size_t length);
+  Message RecvAny(std::size_t length);
   ssize_t Send(const std::uint8_t* data, std::size_t size);
   ssize_t Send(const Message& message);
 
@@ -83,4 +83,25 @@
   cvd::SharedFD fd_;
 };
 
+void AppendInNetworkByteOrder(Message* msg, const std::uint8_t b);
+void AppendInNetworkByteOrder(Message* msg, const std::uint16_t s);
+void AppendInNetworkByteOrder(Message* msg, const std::uint32_t w);
+void AppendInNetworkByteOrder(Message* msg, const std::int32_t w);
+void AppendInNetworkByteOrder(Message* msg, const std::string& str);
+
+inline void AppendToMessage(Message*) {}
+
+template <typename T, typename... Ts>
+void AppendToMessage(Message* msg, T v, Ts... vals) {
+  AppendInNetworkByteOrder(msg, v);
+  AppendToMessage(msg, vals...);
+}
+
+template <typename... Ts>
+Message CreateMessage(Ts... vals) {
+  Message m;
+  AppendToMessage(&m, vals...);
+  return m;
+}
+
 }  // namespace cvd
diff --git a/host/frontend/vnc_server/vnc_client_connection.cpp b/host/frontend/vnc_server/vnc_client_connection.cpp
index 25b007d..98920ac 100644
--- a/host/frontend/vnc_server/vnc_client_connection.cpp
+++ b/host/frontend/vnc_server/vnc_client_connection.cpp
@@ -76,47 +76,6 @@
 constexpr size_t kPointerEventLength = 5;
 constexpr size_t kClientCutTextLength = 7;  // more bytes follow
 
-void AppendInNetworkByteOrder(Message* msg, const std::uint8_t b) {
-  msg->push_back(b);
-}
-
-void AppendInNetworkByteOrder(Message* msg, const std::uint16_t s) {
-  const std::uint16_t n = htons(s);
-  auto p = reinterpret_cast<const std::uint8_t*>(&n);
-  msg->insert(msg->end(), p, p + sizeof n);
-}
-
-void AppendInNetworkByteOrder(Message* msg, const std::uint32_t w) {
-  const std::uint32_t n = htonl(w);
-  auto p = reinterpret_cast<const std::uint8_t*>(&n);
-  msg->insert(msg->end(), p, p + sizeof n);
-}
-
-void AppendInNetworkByteOrder(Message* msg, const int32_t w) {
-  std::uint32_t u{};
-  std::memcpy(&u, &w, sizeof u);
-  AppendInNetworkByteOrder(msg, u);
-}
-
-void AppendInNetworkByteOrder(Message* msg, const std::string& str) {
-  msg->insert(msg->end(), str.begin(), str.end());
-}
-
-void AppendToMessage(Message*) {}
-
-template <typename T, typename... Ts>
-void AppendToMessage(Message* msg, T v, Ts... vals) {
-  AppendInNetworkByteOrder(msg, v);
-  AppendToMessage(msg, vals...);
-}
-
-template <typename... Ts>
-Message CreateMessage(Ts... vals) {
-  Message m;
-  AppendToMessage(&m, vals...);
-  return m;
-}
-
 std::string HostName() {
   auto config = vsoc::CuttlefishConfig::Get();
   return !config || config->device_title().empty() ? std::string{"localhost"}
@@ -259,7 +218,7 @@
 void VncClientConnection::SendServerInit() {
   const std::string server_name = HostName();
   std::lock_guard<std::mutex> guard(m_);
-  auto server_init = CreateMessage(
+  auto server_init = cvd::CreateMessage(
       static_cast<std::uint16_t>(ScreenWidth()),
       static_cast<std::uint16_t>(ScreenHeight()), pixel_format_.bits_per_pixel,
       pixel_format_.depth, pixel_format_.big_endian, pixel_format_.true_color,
@@ -273,17 +232,17 @@
 
 Message VncClientConnection::MakeFrameBufferUpdateHeader(
     std::uint16_t num_stripes) {
-  return CreateMessage(std::uint8_t{0},  // message-type
-                       std::uint8_t{},   // padding
-                       std::uint16_t{num_stripes});
+  return cvd::CreateMessage(std::uint8_t{0},  // message-type
+                            std::uint8_t{},   // padding
+                            std::uint16_t{num_stripes});
 }
 
 void VncClientConnection::AppendRawStripeHeader(Message* frame_buffer_update,
                                                 const Stripe& stripe) {
   static constexpr int32_t kRawEncoding = 0;
-  AppendToMessage(frame_buffer_update, std::uint16_t{stripe.x},
-                  std::uint16_t{stripe.y}, std::uint16_t{stripe.width},
-                  std::uint16_t{stripe.height}, kRawEncoding);
+  cvd::AppendToMessage(frame_buffer_update, std::uint16_t{stripe.x},
+                       std::uint16_t{stripe.y}, std::uint16_t{stripe.width},
+                       std::uint16_t{stripe.height}, kRawEncoding);
 }
 
 void VncClientConnection::AppendJpegSize(Message* frame_buffer_update,
@@ -293,22 +252,23 @@
   constexpr size_t kJpegSizeThreeByteMax = 4194303;
 
   if (jpeg_size <= kJpegSizeOneByteMax) {
-    AppendToMessage(frame_buffer_update, static_cast<std::uint8_t>(jpeg_size));
+    cvd::AppendToMessage(frame_buffer_update,
+                         static_cast<std::uint8_t>(jpeg_size));
   } else if (jpeg_size <= kJpegSizeTwoByteMax) {
     auto sz = static_cast<std::uint32_t>(jpeg_size);
-    AppendToMessage(frame_buffer_update,
-                    static_cast<std::uint8_t>((sz & 0x7F) | 0x80),
-                    static_cast<std::uint8_t>((sz >> 7) & 0xFF));
+    cvd::AppendToMessage(frame_buffer_update,
+                         static_cast<std::uint8_t>((sz & 0x7F) | 0x80),
+                         static_cast<std::uint8_t>((sz >> 7) & 0xFF));
   } else {
     if (jpeg_size > kJpegSizeThreeByteMax) {
       LOG(FATAL) << "jpeg size is too big: " << jpeg_size << " must be under "
                  << kJpegSizeThreeByteMax;
     }
     const auto sz = static_cast<std::uint32_t>(jpeg_size);
-    AppendToMessage(frame_buffer_update,
-                    static_cast<std::uint8_t>((sz & 0x7F) | 0x80),
-                    static_cast<std::uint8_t>(((sz >> 7) & 0x7F) | 0x80),
-                    static_cast<std::uint8_t>((sz >> 14) & 0xFF));
+    cvd::AppendToMessage(frame_buffer_update,
+                         static_cast<std::uint8_t>((sz & 0x7F) | 0x80),
+                         static_cast<std::uint8_t>(((sz >> 7) & 0x7F) | 0x80),
+                         static_cast<std::uint8_t>((sz >> 14) & 0xFF));
   }
 }
 
@@ -353,8 +313,8 @@
 void VncClientConnection::AppendJpegStripeHeader(Message* frame_buffer_update,
                                                  const Stripe& stripe) {
   static constexpr std::uint8_t kJpegEncoding = 0x90;
-  AppendToMessage(frame_buffer_update, stripe.x, stripe.y, stripe.width,
-                  stripe.height, kTightEncoding, kJpegEncoding);
+  cvd::AppendToMessage(frame_buffer_update, stripe.x, stripe.y, stripe.width,
+                       stripe.height, kTightEncoding, kJpegEncoding);
   AppendJpegSize(frame_buffer_update, stripe.jpeg_data.size());
 }
 
@@ -411,13 +371,13 @@
 
 void VncClientConnection::SendDesktopSizeUpdate() {
   static constexpr int32_t kDesktopSizeEncoding = -223;
-  client_.Send(CreateMessage(std::uint8_t{0},   // message-type,
-                             std::uint8_t{},    // padding
-                             std::uint16_t{1},  // one pseudo rectangle
-                             std::uint16_t{0}, std::uint16_t{0},
-                             static_cast<std::uint16_t>(ScreenWidth()),
-                             static_cast<std::uint16_t>(ScreenHeight()),
-                             kDesktopSizeEncoding));
+  client_.Send(cvd::CreateMessage(std::uint8_t{0},   // message-type,
+                                  std::uint8_t{},    // padding
+                                  std::uint16_t{1},  // one pseudo rectangle
+                                  std::uint16_t{0}, std::uint16_t{0},
+                                  static_cast<std::uint16_t>(ScreenWidth()),
+                                  static_cast<std::uint16_t>(ScreenHeight()),
+                                  kDesktopSizeEncoding));
 }
 
 bool VncClientConnection::IsUrgent(