feat: Move string_padder utilities to common repo

Bug: b/398920134
Change-Id: Ie45e9925ad1b357f18cf2de5ac2af62fa418e43a
GitOrigin-RevId: f456cb3e65948e78b73b1868b07ba0f28f315f49

Author: Privacy Sandbox Team

src/communication/BUILD.bazel

@@ -92,6 +92,35 @@ cc_test(
     ],
 )
 
+cc_library(
+    name = "string_padder",
+    srcs = [
+        "string_padder.cc",
+    ],
+    hdrs = [
+        "string_padder.h",
+    ],
+    deps = [
+        "@com_github_google_quiche//quiche:quiche_unstable_api",
+        "@com_google_absl//absl/log",
+        "@com_google_absl//absl/status",
+        "@com_google_absl//absl/status:statusor",
+        "@com_google_absl//absl/strings",
+    ],
+)
+
+cc_test(
+    name = "string_padder_test",
+    size = "small",
+    srcs = [
+        "string_padder_test.cc",
+    ],
+    deps = [
+        ":string_padder",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
 cc_library(
     name = "compression",
     srcs = [

src/communication/string_padder.cc

@@ -0,0 +1,49 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "src/communication/string_padder.h"
+
+#include <string>
+
+#include "absl/log/log.h"
+#include "quiche/common/quiche_data_reader.h"
+#include "quiche/common/quiche_data_writer.h"
+
+namespace privacy_sandbox::server_common {
+
+std::string Pad(std::string_view string_to_pad, int32_t extra_padding) {
+  int output_size = sizeof(u_int32_t) + string_to_pad.size() + extra_padding;
+  std::string output(output_size, '0');
+
+  quiche::QuicheDataWriter data_writer(output.size(), output.data());
+  data_writer.WriteUInt32(string_to_pad.size());
+  data_writer.WriteStringPiece(string_to_pad);
+  return output;
+}
+
+absl::StatusOr<std::string> Unpad(std::string_view padded_string) {
+  auto data_reader = quiche::QuicheDataReader(padded_string);
+  uint32_t string_size = 0;
+  if (!data_reader.ReadUInt32(&string_size)) {
+    return absl::InvalidArgumentError("Failed to read string size");
+  }
+  VLOG(9) << "string size: " << string_size;
+  std::string_view output;
+  if (!data_reader.ReadStringPiece(&output, string_size)) {
+    return absl::InvalidArgumentError("Failed to read a string");
+  }
+  VLOG(9) << "string: " << output;
+  return std::string(output);
+}
+
+}  // namespace privacy_sandbox::server_common

src/communication/string_padder.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef COMMUNICATION_STRING_PADDER_H_
+#define COMMUNICATION_STRING_PADDER_H_
+
+#include <string>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
+namespace privacy_sandbox::server_common {
+// Returns the string of the following format:
+// [32 bit unsigned int][string_to_pad][padding]
+//  length               data           filler
+// filler.size() == extra_padding
+std::string Pad(std::string_view string_to_pad, int32_t extra_padding);
+// Takes the string padded with the method above OR in the same format
+// and returns the string.
+absl::StatusOr<std::string> Unpad(std::string_view padded_string);
+}  // namespace privacy_sandbox::server_common
+
+#endif  // COMMUNICATION_STRING_PADDER_H_

src/communication/string_padder_test.cc

@@ -0,0 +1,66 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/communication/string_padder.h"
+
+#include <string_view>
+
+#include "gtest/gtest.h"
+
+namespace privacy_sandbox::server_common {
+namespace {
+
+TEST(PadUnpad, Success) {
+  const std::string_view kTestString = "string to pad";
+  const int32_t padding_size = 100;
+  auto padded_string = Pad(kTestString, padding_size);
+  int32_t expected_length =
+      sizeof(u_int32_t) + kTestString.size() + padding_size;
+  EXPECT_EQ(expected_length, padded_string.size());
+  auto original_string_status = Unpad(padded_string);
+  ASSERT_TRUE(original_string_status.ok());
+  EXPECT_EQ(*original_string_status, kTestString);
+}
+
+TEST(PadUnpadZeroPadding, Success) {
+  const std::string_view kTestString = "string to pad";
+  const int32_t padding_size = 0;
+  auto padded_string = Pad(kTestString, padding_size);
+  int32_t expected_length =
+      sizeof(u_int32_t) + kTestString.size() + padding_size;
+  EXPECT_EQ(expected_length, padded_string.size());
+  auto original_string_status = Unpad(padded_string);
+  ASSERT_TRUE(original_string_status.ok());
+  EXPECT_EQ(*original_string_status, kTestString);
+}
+
+TEST(PadUnpadEmtpyString, Success) {
+  const std::string_view kTestString = "";
+  const int32_t padding_size = 100;
+  auto padded_string = Pad(kTestString, padding_size);
+  int32_t expected_length =
+      sizeof(u_int32_t) + kTestString.size() + padding_size;
+  EXPECT_EQ(expected_length, padded_string.size());
+  auto original_string_status = Unpad(padded_string);
+  ASSERT_TRUE(original_string_status.ok());
+  EXPECT_EQ(*original_string_status, kTestString);
+}
+
+TEST(UnpadFailure, Success) {
+  auto original_string_status = Unpad("garbage");
+  ASSERT_FALSE(original_string_status.ok());
+}
+
+}  // namespace
+}  // namespace privacy_sandbox::server_common