feat: Copy doubly_linked_list.h from B&A to common repo

This is part of a series of CLs to copy
the KV BYOS clients from B&A to common repo.

Bug: 411430242
Change-Id: Ibf5948d67d95908041848e9290a881af505e61a9
GitOrigin-RevId: 73cc5961241d7f0970b151e6dee0b8017caf430f

Author: Privacy Sandbox Team

src/util/containers/BUILD.bazel

@@ -0,0 +1,38 @@
+# 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.
+
+load("@rules_cc//cc:defs.bzl", "cc_library", "cc_test")
+
+cc_library(
+    name = "doubly_linked_list",
+    hdrs = [
+        "doubly_linked_list.h",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//src/core/event",
+    ],
+)
+
+cc_test(
+    name = "doubly_linked_list_test",
+    size = "small",
+    srcs = [
+        "doubly_linked_list_test.cc",
+    ],
+    deps = [
+        ":doubly_linked_list",
+        "@com_google_googletest//:gtest_main",
+    ],
+)

src/util/containers/doubly_linked_list.h

@@ -0,0 +1,130 @@
+//  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 SRC_UTIL_CONTAINERS_DOUBLY_LINKED_LIST_H_
+#define SRC_UTIL_CONTAINERS_DOUBLY_LINKED_LIST_H_
+
+#include <memory>
+#include <utility>
+
+#include "src/core/event/event.h"
+#include "src/logger/request_context_logger.h"
+
+namespace privacy_sandbox::server_common {
+
+// K-anon data stored in the DLL.
+template <typename KeyT, typename ValueT>
+struct CacheHashData {
+  KeyT key;
+  ValueT value;
+  std::unique_ptr<Event> timer_event = nullptr;
+};
+
+// DLL Node.
+template <typename KeyT, typename ValueT>
+struct Node {
+  std::unique_ptr<CacheHashData<KeyT, ValueT>> data;
+  Node* next = nullptr;
+  Node* prev = nullptr;
+
+  explicit Node(
+      std::unique_ptr<CacheHashData<KeyT, ValueT>> cache_hash_data = nullptr)
+      : data(std::move(cache_hash_data)) {}
+};
+
+template <typename KeyT, typename ValueT>
+class DoublyLinkedList {
+ public:
+  DoublyLinkedList()
+      : head_(std::make_unique<Node<KeyT, ValueT>>()),
+        tail_(std::make_unique<Node<KeyT, ValueT>>()) {
+    head_->next = tail_.get();
+    tail_->prev = head_.get();
+  }
+
+  ~DoublyLinkedList() {
+    auto* cur = head_->next;
+    while (cur != tail_.get()) {
+      auto* tmp_next = cur->next;
+      cur->next = nullptr;
+      cur->prev = nullptr;
+      delete cur;
+      cur = tmp_next;
+    }
+    head_->next = nullptr;
+    tail_->prev = nullptr;
+  }
+
+  Node<KeyT, ValueT>* InsertAtFront(
+      std::unique_ptr<CacheHashData<KeyT, ValueT>> cache_hash_data) {
+    auto node =
+        std::make_unique<Node<KeyT, ValueT>>(std::move(cache_hash_data));
+    auto* node_ptr = node.release();
+    node_ptr->next = head_->next;
+    node_ptr->prev = head_.get();
+    // Head's next is guaranteed to be present since we use a sentinel for tail
+    // as well.
+    head_->next->prev = node_ptr;
+    head_->next = node_ptr;
+    return node_ptr;
+  }
+
+  void MoveToFront(Node<KeyT, ValueT>* node) {
+    // Disconnect from neighbors
+    node->prev->next = node->next;
+    node->next->prev = node->prev;
+
+    // Link at front
+    node->next = head_->next;
+    node->prev = head_.get();
+    head_->next->prev = node;
+    head_->next = node;
+  }
+
+  void Remove(Node<KeyT, ValueT>* node) {
+    PS_VLOG(5) << __func__ << ": Removing node";
+    auto node_to_clean = std::unique_ptr<Node<KeyT, ValueT>>(node);
+    node->prev->next = node->next;
+    node->next->prev = node->prev;
+    node_to_clean.reset();
+  }
+
+  Node<KeyT, ValueT>* Head() {
+    // Head and tail are always sentinels, so if they point at each other that
+    // implies an empty list.
+    if (head_->next == tail_.get()) {
+      return nullptr;
+    }
+
+    return head_->next;
+  }
+
+  Node<KeyT, ValueT>* Tail() {
+    // Head and tail are always sentinels, so if they point at each other that
+    // implies an empty list.
+    if (tail_->prev == head_.get()) {
+      return nullptr;
+    }
+
+    return tail_->prev;
+  }
+
+ private:
+  std::unique_ptr<Node<KeyT, ValueT>> head_;
+  std::unique_ptr<Node<KeyT, ValueT>> tail_;
+};
+
+}  // namespace privacy_sandbox::server_common
+
+#endif  // SRC_UTIL_CONTAINERS_DOUBLY_LINKED_LIST_H_

src/util/containers/doubly_linked_list_test.cc

@@ -0,0 +1,108 @@
+/*
+ * 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/util/containers/doubly_linked_list.h"
+
+#include <string>
+#include <string_view>
+
+#include "include/gtest/gtest.h"
+
+namespace privacy_sandbox::server_common {
+namespace {
+
+constexpr std::string_view kTestKey1 = "key1";
+constexpr std::string_view kTestKey2 = "key2";
+
+class DoublyLinkedListTest : public ::testing::Test {
+ protected:
+  DoublyLinkedList<std::string, std::string> dll_;
+
+  std::unique_ptr<CacheHashData<std::string, std::string>> TestHashData1() {
+    return std::make_unique<CacheHashData<std::string, std::string>>(
+        CacheHashData<std::string, std::string>{
+            .key = std::string(kTestKey1),
+        });
+  }
+
+  std::unique_ptr<CacheHashData<std::string, std::string>> TestHashData2() {
+    return std::make_unique<CacheHashData<std::string, std::string>>(
+        CacheHashData<std::string, std::string>{
+            .key = std::string(kTestKey2),
+        });
+  }
+};
+
+TEST_F(DoublyLinkedListTest, EmptyList) { EXPECT_EQ(dll_.Tail(), nullptr); }
+
+TEST_F(DoublyLinkedListTest, CanAddNode) {
+  auto* node = dll_.InsertAtFront(TestHashData1());
+  ASSERT_NE(node, nullptr);
+  EXPECT_EQ(node->data->key, kTestKey1);
+
+  ASSERT_NE(dll_.Tail(), nullptr);
+  EXPECT_EQ(dll_.Tail()->data->key, kTestKey1);
+}
+
+TEST_F(DoublyLinkedListTest, CanRemoveNode) {
+  ASSERT_EQ(dll_.Tail(), nullptr) << "Expected no item in an empty list";
+
+  auto* node = dll_.InsertAtFront(TestHashData1());
+  ASSERT_NE(node, nullptr);
+  EXPECT_EQ(node->data->key, kTestKey1);
+
+  ASSERT_NE(dll_.Tail(), nullptr);
+  dll_.Remove(dll_.Tail());
+
+  EXPECT_EQ(dll_.Tail(), nullptr) << "Expected no item in an empty list";
+}
+
+TEST_F(DoublyLinkedListTest, InsertsInOrder) {
+  ASSERT_EQ(dll_.Tail(), nullptr) << "Expected no item in an empty list";
+
+  dll_.InsertAtFront(TestHashData1());
+  EXPECT_EQ(dll_.Tail()->data->key, kTestKey1);
+
+  dll_.InsertAtFront(TestHashData2());
+  // Tail node still has key1.
+  EXPECT_EQ(dll_.Tail()->data->key, kTestKey1);
+
+  // Remove the tail node and the new tail node should now contain key2.
+  dll_.Remove(dll_.Tail());
+  EXPECT_EQ(dll_.Tail()->data->key, kTestKey2);
+
+  // Remove tail node again and there should be no node remaining in the list.
+  dll_.Remove(dll_.Tail());
+  EXPECT_EQ(dll_.Tail(), nullptr);
+}
+
+TEST_F(DoublyLinkedListTest, MovesToFront) {
+  ASSERT_EQ(dll_.Tail(), nullptr) << "Expected no item in an empty list";
+
+  dll_.InsertAtFront(TestHashData1());
+  EXPECT_EQ(dll_.Tail()->data->key, kTestKey1);
+
+  dll_.InsertAtFront(TestHashData2());
+  // Tail node still has key1.
+  EXPECT_EQ(dll_.Tail()->data->key, kTestKey1);
+
+  // Move the tail node to front.
+  dll_.MoveToFront(dll_.Tail());
+  EXPECT_EQ(dll_.Tail()->data->key, kTestKey2);
+}
+
+}  // namespace
+}  // namespace privacy_sandbox::server_common