ipcz: Extract single-process driver base
Pulls some code out of the existing single-process reference driver
into a location which can be shared by multiple new single-process
drivers, which will only differ by transport implementation.
The driver is also renamed to the "sync" driver, since there will
soon be a second (async) single-process driver.
No functional changes here.
Bug: 1299283
Change-Id: I6e24d2dd8b9fc0636c82896de5386934ae670733
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3701023
Reviewed-by: Alex Gough <ajgo@chromium.org>
Commit-Queue: Ken Rockot <rockot@google.com>
Cr-Commit-Position: refs/heads/main@{#1017012}
NOKEYCHECK=True
GitOrigin-RevId: a947f3a0b3e46ab49fda2327275e19801e78eace
diff --git a/src/BUILD.gn b/src/BUILD.gn
index d73bb4e..90436cb 100644
--- a/src/BUILD.gn
+++ b/src/BUILD.gn
@@ -138,7 +138,7 @@
public = [
"reference_drivers/blob.h",
- "reference_drivers/single_process_reference_driver.h",
+ "reference_drivers/sync_reference_driver.h",
]
sources = [
@@ -147,7 +147,9 @@
"reference_drivers/object.h",
"reference_drivers/random.cc",
"reference_drivers/random.h",
- "reference_drivers/single_process_reference_driver.cc",
+ "reference_drivers/single_process_reference_driver_base.cc",
+ "reference_drivers/single_process_reference_driver_base.h",
+ "reference_drivers/sync_reference_driver.cc",
]
if (enable_multiprocess_tests) {
@@ -327,7 +329,7 @@
"ipcz/node_link_test.cc",
"ipcz/parcel_queue_test.cc",
"ipcz/sequenced_queue_test.cc",
- "reference_drivers/single_process_reference_driver_test.cc",
+ "reference_drivers/sync_reference_driver_test.cc",
"remote_portal_test.cc",
"test/mock_driver.cc",
"test/mock_driver.h",
diff --git a/src/api_test.cc b/src/api_test.cc
index 02407d1..ce83991 100644
--- a/src/api_test.cc
+++ b/src/api_test.cc
@@ -5,15 +5,14 @@
#include <string>
#include "ipcz/ipcz.h"
-#include "reference_drivers/single_process_reference_driver.h"
+#include "reference_drivers/sync_reference_driver.h"
#include "test/test.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace ipcz {
namespace {
-const IpczDriver& kDefaultDriver =
- reference_drivers::kSingleProcessReferenceDriver;
+const IpczDriver& kDefaultDriver = reference_drivers::kSyncReferenceDriver;
using APITest = test::Test;
diff --git a/src/ipcz/buffer_pool_test.cc b/src/ipcz/buffer_pool_test.cc
index ea5aadd..a82dd34 100644
--- a/src/ipcz/buffer_pool_test.cc
+++ b/src/ipcz/buffer_pool_test.cc
@@ -10,7 +10,7 @@
#include "ipcz/driver_memory.h"
#include "ipcz/driver_memory_mapping.h"
#include "ipcz/node.h"
-#include "reference_drivers/single_process_reference_driver.h"
+#include "reference_drivers/sync_reference_driver.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/abseil-cpp/absl/types/span.h"
#include "util/ref_counted.h"
@@ -27,7 +27,7 @@
private:
const Ref<Node> node_{
MakeRefCounted<Node>(Node::Type::kBroker,
- reference_drivers::kSingleProcessReferenceDriver,
+ reference_drivers::kSyncReferenceDriver,
IPCZ_INVALID_DRIVER_HANDLE)};
};
diff --git a/src/ipcz/node_connector_test.cc b/src/ipcz/node_connector_test.cc
index ae9733b..7bd3fe7 100644
--- a/src/ipcz/node_connector_test.cc
+++ b/src/ipcz/node_connector_test.cc
@@ -13,7 +13,7 @@
#include "ipcz/node_messages.h"
#include "ipcz/portal.h"
#include "ipcz/router.h"
-#include "reference_drivers/single_process_reference_driver.h"
+#include "reference_drivers/sync_reference_driver.h"
#include "test/test.h"
#include "test/test_transport_listener.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -22,7 +22,7 @@
namespace ipcz {
namespace {
-const IpczDriver& kDriver = reference_drivers::kSingleProcessReferenceDriver;
+const IpczDriver& kDriver = reference_drivers::kSyncReferenceDriver;
class NodeConnectorTest : public test::Test {
protected:
diff --git a/src/ipcz/node_link_test.cc b/src/ipcz/node_link_test.cc
index 8e34c3e..8f26dd5 100644
--- a/src/ipcz/node_link_test.cc
+++ b/src/ipcz/node_link_test.cc
@@ -12,7 +12,7 @@
#include "ipcz/remote_router_link.h"
#include "ipcz/router.h"
#include "ipcz/sublink_id.h"
-#include "reference_drivers/single_process_reference_driver.h"
+#include "reference_drivers/sync_reference_driver.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/abseil-cpp/absl/base/macros.h"
#include "util/ref_counted.h"
@@ -20,7 +20,7 @@
namespace ipcz {
namespace {
-const IpczDriver& kDriver = reference_drivers::kSingleProcessReferenceDriver;
+const IpczDriver& kDriver = reference_drivers::kSyncReferenceDriver;
std::pair<Ref<NodeLink>, Ref<NodeLink>> LinkNodes(Ref<Node> broker,
Ref<Node> non_broker) {
@@ -74,6 +74,9 @@
router0->CloseRoute();
EXPECT_TRUE(router1->IsPeerClosed());
router1->CloseRoute();
+
+ link0->Deactivate();
+ link1->Deactivate();
}
} // namespace
diff --git a/src/reference_drivers/single_process_reference_driver_base.cc b/src/reference_drivers/single_process_reference_driver_base.cc
new file mode 100644
index 0000000..f9b5cb1
--- /dev/null
+++ b/src/reference_drivers/single_process_reference_driver_base.cc
@@ -0,0 +1,187 @@
+// Copyright 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "reference_drivers/single_process_reference_driver_base.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <utility>
+
+#include "ipcz/ipcz.h"
+#include "reference_drivers/object.h"
+#include "reference_drivers/random.h"
+#include "third_party/abseil-cpp/absl/base/macros.h"
+#include "util/ref_counted.h"
+
+namespace ipcz::reference_drivers {
+
+namespace {
+
+// Shared memory objects in single-process drivers are plain heap allocations.
+class InProcessMemory : public ObjectImpl<InProcessMemory, Object::kMemory> {
+ public:
+ explicit InProcessMemory(size_t size)
+ : size_(size), data_(new uint8_t[size]) {
+ memset(&data_[0], 0, size_);
+ }
+
+ size_t size() const { return size_; }
+ void* address() const { return &data_[0]; }
+
+ private:
+ ~InProcessMemory() override = default;
+
+ const size_t size_;
+ const std::unique_ptr<uint8_t[]> data_;
+};
+
+// As there's nothing to "map" from a heap allocation, single-process driver
+// memory mappings simply hold an active reference to the underlying
+// heap allocation.
+class InProcessMapping : public ObjectImpl<InProcessMapping, Object::kMapping> {
+ public:
+ explicit InProcessMapping(Ref<InProcessMemory> memory)
+ : memory_(std::move(memory)) {}
+
+ size_t size() const { return memory_->size(); }
+ void* address() const { return memory_->address(); }
+
+ private:
+ ~InProcessMapping() override = default;
+
+ const Ref<InProcessMemory> memory_;
+};
+
+IpczResult IPCZ_API Close(IpczDriverHandle handle,
+ uint32_t flags,
+ const void* options) {
+ Ref<Object> object = Object::TakeFromHandle(handle);
+ if (!object) {
+ return IPCZ_RESULT_INVALID_ARGUMENT;
+ }
+
+ return object->Close();
+}
+
+IpczResult IPCZ_API Serialize(IpczDriverHandle handle,
+ IpczDriverHandle transport,
+ uint32_t flags,
+ const void* options,
+ void* data,
+ size_t* num_bytes,
+ IpczDriverHandle* handles,
+ size_t* num_handles) {
+ Object* object = Object::FromHandle(handle);
+ if (!object) {
+ return IPCZ_RESULT_INVALID_ARGUMENT;
+ }
+
+ if (num_bytes) {
+ *num_bytes = 0;
+ }
+
+ // Since this is all in-process, all driver handles can be transmitted as-is.
+ const size_t handle_capacity = num_handles ? *num_handles : 0;
+ if (num_handles) {
+ *num_handles = 1;
+ }
+ if (handle_capacity < 1) {
+ return IPCZ_RESULT_RESOURCE_EXHAUSTED;
+ }
+
+ handles[0] = handle;
+ return IPCZ_RESULT_OK;
+}
+
+IpczResult IPCZ_API Deserialize(const void* data,
+ size_t num_bytes,
+ const IpczDriverHandle* handles,
+ size_t num_handles,
+ IpczDriverHandle transport,
+ uint32_t flags,
+ const void* options,
+ IpczDriverHandle* driver_handle) {
+ ABSL_ASSERT(num_bytes == 0);
+ ABSL_ASSERT(num_handles == 1);
+ *driver_handle = handles[0];
+ return IPCZ_RESULT_OK;
+}
+
+IpczResult IPCZ_API AllocateSharedMemory(size_t num_bytes,
+ uint32_t flags,
+ const void* options,
+ IpczDriverHandle* driver_memory) {
+ if (num_bytes > std::numeric_limits<size_t>::max()) {
+ return IPCZ_RESULT_RESOURCE_EXHAUSTED;
+ }
+
+ auto memory = MakeRefCounted<InProcessMemory>(static_cast<size_t>(num_bytes));
+ *driver_memory = Object::ReleaseAsHandle(std::move(memory));
+ return IPCZ_RESULT_OK;
+}
+
+IpczResult GetSharedMemoryInfo(IpczDriverHandle driver_memory,
+ uint32_t flags,
+ const void* options,
+ IpczSharedMemoryInfo* info) {
+ Object* object = Object::FromHandle(driver_memory);
+ if (!object || object->type() != Object::kMemory || !info ||
+ info->size < sizeof(IpczSharedMemoryInfo)) {
+ return IPCZ_RESULT_INVALID_ARGUMENT;
+ }
+
+ info->region_num_bytes = static_cast<InProcessMemory*>(object)->size();
+ return IPCZ_RESULT_OK;
+}
+
+IpczResult IPCZ_API DuplicateSharedMemory(IpczDriverHandle driver_memory,
+ uint32_t flags,
+ const void* options,
+ IpczDriverHandle* new_driver_memory) {
+ Ref<InProcessMemory> memory(InProcessMemory::FromHandle(driver_memory));
+ *new_driver_memory = Object::ReleaseAsHandle(std::move(memory));
+ return IPCZ_RESULT_OK;
+}
+
+IpczResult IPCZ_API MapSharedMemory(IpczDriverHandle driver_memory,
+ uint32_t flags,
+ const void* options,
+ void** address,
+ IpczDriverHandle* driver_mapping) {
+ Ref<InProcessMemory> memory(InProcessMemory::FromHandle(driver_memory));
+ auto mapping = MakeRefCounted<InProcessMapping>(std::move(memory));
+ *address = mapping->address();
+ *driver_mapping = Object::ReleaseAsHandle(std::move(mapping));
+ return IPCZ_RESULT_OK;
+}
+
+IpczResult IPCZ_API GenerateRandomBytes(size_t num_bytes,
+ uint32_t flags,
+ const void* options,
+ void* buffer) {
+ RandomBytes(absl::MakeSpan(static_cast<uint8_t*>(buffer), num_bytes));
+ return IPCZ_RESULT_OK;
+}
+
+} // namespace
+
+const IpczDriver kSingleProcessReferenceDriverBase = {
+ sizeof(kSingleProcessReferenceDriverBase),
+ Close,
+ Serialize,
+ Deserialize,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ AllocateSharedMemory,
+ GetSharedMemoryInfo,
+ DuplicateSharedMemory,
+ MapSharedMemory,
+ GenerateRandomBytes,
+};
+
+} // namespace ipcz::reference_drivers
diff --git a/src/reference_drivers/single_process_reference_driver_base.h b/src/reference_drivers/single_process_reference_driver_base.h
new file mode 100644
index 0000000..e0e89b5
--- /dev/null
+++ b/src/reference_drivers/single_process_reference_driver_base.h
@@ -0,0 +1,18 @@
+// Copyright 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef IPCZ_SRC_REFERENCE_DRIVERS_SINGLE_PROCESS_REFERENCE_DRIVER_BASE_H_
+#define IPCZ_SRC_REFERENCE_DRIVERS_SINGLE_PROCESS_REFERENCE_DRIVER_BASE_H_
+
+#include "ipcz/ipcz.h"
+
+namespace ipcz::reference_drivers {
+
+// A partial IpczDriver providing implementation common to both the sync and
+// and async single-process drivers.
+extern const IpczDriver kSingleProcessReferenceDriverBase;
+
+} // namespace ipcz::reference_drivers
+
+#endif // IPCZ_SRC_REFERENCE_DRIVERS_SINGLE_PROCESS_REFERENCE_DRIVER_BASE_H_
diff --git a/src/reference_drivers/single_process_reference_driver.cc b/src/reference_drivers/sync_reference_driver.cc
similarity index 65%
rename from src/reference_drivers/single_process_reference_driver.cc
rename to src/reference_drivers/sync_reference_driver.cc
index 888d4f5..af9c0bc 100644
--- a/src/reference_drivers/single_process_reference_driver.cc
+++ b/src/reference_drivers/sync_reference_driver.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 "reference_drivers/single_process_reference_driver.h"
+#include "reference_drivers/sync_reference_driver.h"
#include <algorithm>
#include <cstdint>
@@ -12,12 +12,10 @@
#include <tuple>
#include <vector>
-#include "ipcz/driver_object.h"
-#include "ipcz/driver_transport.h"
#include "ipcz/ipcz.h"
-#include "ipcz/message.h"
#include "reference_drivers/object.h"
#include "reference_drivers/random.h"
+#include "reference_drivers/single_process_reference_driver_base.h"
#include "third_party/abseil-cpp/absl/synchronization/mutex.h"
#include "third_party/abseil-cpp/absl/types/span.h"
#include "util/ref_counted.h"
@@ -161,28 +159,12 @@
}
if (peer) {
- // Kind of a hack so we can deserialize messages as if they were read
- // and deserialized by the peer. We want to do this because the serialized
- // messages may encode driver objects with live resources that would
- // otherwise leak. This is particularly problematic in test environments
- // where we want to exercise various edge cases that can result in
- // dropped connections and dropped messages, within a single test process
- // that may run multiple such tests in succession.
- //
- // We construct a temporary DriverObject which wraps `this`, as needed
- // for Message deserialization. This must be released when done, as it
- // does not actually own a handle to the peer.
- auto peer_transport = MakeRefCounted<DriverTransport>(
- DriverObject(kSingleProcessReferenceDriver, peer->handle()));
for (SavedMessage& m : saved_messages) {
- ipcz::Message message;
- message.DeserializeUnknownType(
- ipcz::DriverTransport::RawMessage{m.data, m.handles},
- *peer_transport);
+ for (IpczDriverHandle handle : m.handles) {
+ Object::TakeFromHandle(handle)->Close();
+ }
}
- std::ignore = peer_transport->Release();
-
// NOTE: Although nothing should ever call back into `this` after Close(),
// for consistency with other methods we still take precaution not to call
// into the peer while holding `mutex_`.
@@ -337,94 +319,6 @@
std::vector<SavedMessage> saved_messages_ ABSL_GUARDED_BY(mutex_);
};
-// Shared memory regions for the single-process driver are just regular private
-// heap allocations.
-class InProcessMemory : public ObjectImpl<InProcessMemory, Object::kMemory> {
- public:
- explicit InProcessMemory(size_t size)
- : size_(size), data_(new uint8_t[size]) {
- memset(&data_[0], 0, size_);
- }
-
- size_t size() const { return size_; }
- void* address() const { return &data_[0]; }
-
- private:
- ~InProcessMemory() override = default;
-
- const size_t size_;
- const std::unique_ptr<uint8_t[]> data_;
-};
-
-class InProcessMapping : public ObjectImpl<InProcessMapping, Object::kMapping> {
- public:
- explicit InProcessMapping(Ref<InProcessMemory> memory)
- : memory_(std::move(memory)) {}
-
- size_t size() const { return memory_->size(); }
- void* address() const { return memory_->address(); }
-
- private:
- ~InProcessMapping() override = default;
-
- const Ref<InProcessMemory> memory_;
-};
-
-IpczResult IPCZ_API Close(IpczDriverHandle handle,
- uint32_t flags,
- const void* options) {
- Ref<Object> object = Object::TakeFromHandle(handle);
- if (!object) {
- return IPCZ_RESULT_INVALID_ARGUMENT;
- }
-
- return object->Close();
-}
-
-IpczResult IPCZ_API Serialize(IpczDriverHandle handle,
- IpczDriverHandle transport,
- uint32_t flags,
- const void* options,
- void* data,
- size_t* num_bytes,
- IpczDriverHandle* handles,
- size_t* num_handles) {
- Object* object = Object::FromHandle(handle);
- if (!object) {
- return IPCZ_RESULT_INVALID_ARGUMENT;
- }
-
- if (num_bytes) {
- *num_bytes = 0;
- }
-
- // Since this is all in-process, all driver handles can be transmitted as-is.
- const size_t handle_capacity = num_handles ? *num_handles : 0;
- if (num_handles) {
- *num_handles = 1;
- }
- if (handle_capacity < 1) {
- return IPCZ_RESULT_RESOURCE_EXHAUSTED;
- }
-
- handles[0] = handle;
- return IPCZ_RESULT_OK;
-}
-
-IpczResult IPCZ_API Deserialize(const void* data,
- size_t num_bytes,
- const IpczDriverHandle* handles,
- size_t num_handles,
- IpczDriverHandle transport,
- uint32_t flags,
- const void* options,
- IpczDriverHandle* driver_handle) {
- ABSL_ASSERT(num_bytes == 0);
- ABSL_ASSERT(num_handles == 1);
- *driver_handle = handles[0];
- return IPCZ_RESULT_OK;
-}
-
IpczResult IPCZ_API CreateTransports(IpczDriverHandle transport0,
IpczDriverHandle transport1,
uint32_t flags,
@@ -468,78 +362,22 @@
absl::MakeSpan(handles, num_handles));
}
-IpczResult IPCZ_API AllocateSharedMemory(size_t num_bytes,
- uint32_t flags,
- const void* options,
- IpczDriverHandle* driver_memory) {
- if (num_bytes > std::numeric_limits<size_t>::max()) {
- return IPCZ_RESULT_RESOURCE_EXHAUSTED;
- }
-
- auto memory = MakeRefCounted<InProcessMemory>(static_cast<size_t>(num_bytes));
- *driver_memory = Object::ReleaseAsHandle(std::move(memory));
- return IPCZ_RESULT_OK;
-}
-
-IpczResult GetSharedMemoryInfo(IpczDriverHandle driver_memory,
- uint32_t flags,
- const void* options,
- IpczSharedMemoryInfo* info) {
- Object* object = Object::FromHandle(driver_memory);
- if (!object || object->type() != Object::kMemory || !info ||
- info->size < sizeof(IpczSharedMemoryInfo)) {
- return IPCZ_RESULT_INVALID_ARGUMENT;
- }
-
- info->region_num_bytes = static_cast<InProcessMemory*>(object)->size();
- return IPCZ_RESULT_OK;
-}
-
-IpczResult IPCZ_API DuplicateSharedMemory(IpczDriverHandle driver_memory,
- uint32_t flags,
- const void* options,
- IpczDriverHandle* new_driver_memory) {
- Ref<InProcessMemory> memory(InProcessMemory::FromHandle(driver_memory));
- *new_driver_memory = Object::ReleaseAsHandle(std::move(memory));
- return IPCZ_RESULT_OK;
-}
-
-IpczResult IPCZ_API MapSharedMemory(IpczDriverHandle driver_memory,
- uint32_t flags,
- const void* options,
- void** address,
- IpczDriverHandle* driver_mapping) {
- Ref<InProcessMemory> memory(InProcessMemory::FromHandle(driver_memory));
- auto mapping = MakeRefCounted<InProcessMapping>(std::move(memory));
- *address = mapping->address();
- *driver_mapping = Object::ReleaseAsHandle(std::move(mapping));
- return IPCZ_RESULT_OK;
-}
-
-IpczResult IPCZ_API GenerateRandomBytes(size_t num_bytes,
- uint32_t flags,
- const void* options,
- void* buffer) {
- RandomBytes(absl::MakeSpan(static_cast<uint8_t*>(buffer), num_bytes));
- return IPCZ_RESULT_OK;
-}
-
} // namespace
-const IpczDriver kSingleProcessReferenceDriver = {
- sizeof(kSingleProcessReferenceDriver),
- Close,
- Serialize,
- Deserialize,
+const IpczDriver kSyncReferenceDriver = {
+ sizeof(kSyncReferenceDriver),
+ kSingleProcessReferenceDriverBase.Close,
+ kSingleProcessReferenceDriverBase.Serialize,
+ kSingleProcessReferenceDriverBase.Deserialize,
CreateTransports,
ActivateTransport,
DeactivateTransport,
Transmit,
- AllocateSharedMemory,
- GetSharedMemoryInfo,
- DuplicateSharedMemory,
- MapSharedMemory,
- GenerateRandomBytes,
+ kSingleProcessReferenceDriverBase.AllocateSharedMemory,
+ kSingleProcessReferenceDriverBase.GetSharedMemoryInfo,
+ kSingleProcessReferenceDriverBase.DuplicateSharedMemory,
+ kSingleProcessReferenceDriverBase.MapSharedMemory,
+ kSingleProcessReferenceDriverBase.GenerateRandomBytes,
};
} // namespace ipcz::reference_drivers
diff --git a/src/reference_drivers/single_process_reference_driver.h b/src/reference_drivers/sync_reference_driver.h
similarity index 69%
rename from src/reference_drivers/single_process_reference_driver.h
rename to src/reference_drivers/sync_reference_driver.h
index fbd139e..4dd4c26 100644
--- a/src/reference_drivers/single_process_reference_driver.h
+++ b/src/reference_drivers/sync_reference_driver.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 IPCZ_SRC_DRIVERS_SINGLE_PROCESS_REFERENCE_DRIVER_H_
-#define IPCZ_SRC_DRIVERS_SINGLE_PROCESS_REFERENCE_DRIVER_H_
+#ifndef IPCZ_SRC_REFERENCE_DRIVERS_SYNC_REFERENCE_DRIVER_H_
+#define IPCZ_SRC_REFERENCE_DRIVERS_SYNC_REFERENCE_DRIVER_H_
#include "ipcz/ipcz.h"
@@ -13,8 +13,8 @@
// on one transport directly calls into the activity handler of its peer, so all
// node operations and therefore all ipcz operations complete synchronously from
// end to end.
-extern const IpczDriver kSingleProcessReferenceDriver;
+extern const IpczDriver kSyncReferenceDriver;
} // namespace ipcz::reference_drivers
-#endif // IPCZ_SRC_DRIVERS_SINGLE_PROCESS_REFERENCE_DRIVER_H_
+#endif // IPCZ_SRC_REFERENCE_DRIVERS_SYNC_REFERENCE_DRIVER_H_
diff --git a/src/reference_drivers/single_process_reference_driver_test.cc b/src/reference_drivers/sync_reference_driver_test.cc
similarity index 92%
rename from src/reference_drivers/single_process_reference_driver_test.cc
rename to src/reference_drivers/sync_reference_driver_test.cc
index 3381ee3..2ec1f9a 100644
--- a/src/reference_drivers/single_process_reference_driver_test.cc
+++ b/src/reference_drivers/sync_reference_driver_test.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 "reference_drivers/single_process_reference_driver.h"
+#include "reference_drivers/sync_reference_driver.h"
#include <cstddef>
#include <functional>
@@ -77,8 +77,8 @@
const TransportHandlers handlers_;
};
-TEST(SingleProcessReferenceDriverTest, CreateTransports) {
- const IpczDriver& driver = kSingleProcessReferenceDriver;
+TEST(SyncReferenceDriverTest, CreateTransports) {
+ const IpczDriver& driver = kSyncReferenceDriver;
IpczDriverHandle a, b;
EXPECT_EQ(IPCZ_RESULT_OK,
driver.CreateTransports(IPCZ_INVALID_DRIVER_HANDLE,
@@ -88,8 +88,8 @@
EXPECT_EQ(IPCZ_RESULT_OK, driver.Close(b, IPCZ_NO_FLAGS, nullptr));
}
-TEST(SingleProcessReferenceDriverTest, TransmitBeforeActive) {
- const IpczDriver& driver = kSingleProcessReferenceDriver;
+TEST(SyncReferenceDriverTest, TransmitBeforeActive) {
+ const IpczDriver& driver = kSyncReferenceDriver;
IpczDriverHandle a, b;
EXPECT_EQ(IPCZ_RESULT_OK,
driver.CreateTransports(IPCZ_INVALID_DRIVER_HANDLE,
@@ -122,8 +122,8 @@
EXPECT_EQ(IPCZ_RESULT_OK, driver.Close(b, IPCZ_NO_FLAGS, nullptr));
}
-TEST(SingleProcessReferenceDriverTest, TransmitWhileActive) {
- const IpczDriver& driver = kSingleProcessReferenceDriver;
+TEST(SyncReferenceDriverTest, TransmitWhileActive) {
+ const IpczDriver& driver = kSyncReferenceDriver;
IpczDriverHandle a, b;
EXPECT_EQ(IPCZ_RESULT_OK,
driver.CreateTransports(IPCZ_INVALID_DRIVER_HANDLE,
@@ -155,8 +155,8 @@
EXPECT_EQ(IPCZ_RESULT_OK, driver.Close(b, IPCZ_NO_FLAGS, nullptr));
}
-TEST(SingleProcessReferenceDriverTest, Deactivate) {
- const IpczDriver& driver = kSingleProcessReferenceDriver;
+TEST(SyncReferenceDriverTest, Deactivate) {
+ const IpczDriver& driver = kSyncReferenceDriver;
IpczDriverHandle a, b;
EXPECT_EQ(IPCZ_RESULT_OK,
driver.CreateTransports(IPCZ_INVALID_DRIVER_HANDLE,
@@ -179,8 +179,8 @@
EXPECT_EQ(IPCZ_RESULT_OK, driver.Close(b, IPCZ_NO_FLAGS, nullptr));
}
-TEST(SingleProcessReferenceDriverTest, TransmitAfterDeactivated) {
- const IpczDriver& driver = kSingleProcessReferenceDriver;
+TEST(SyncReferenceDriverTest, TransmitAfterDeactivated) {
+ const IpczDriver& driver = kSyncReferenceDriver;
IpczDriverHandle a, b;
EXPECT_EQ(IPCZ_RESULT_OK,
driver.CreateTransports(IPCZ_INVALID_DRIVER_HANDLE,
@@ -217,8 +217,8 @@
EXPECT_EQ(IPCZ_RESULT_OK, driver.Close(b, IPCZ_NO_FLAGS, nullptr));
}
-TEST(SingleProcessReferenceDriverTest, NotifyError) {
- const IpczDriver& driver = kSingleProcessReferenceDriver;
+TEST(SyncReferenceDriverTest, NotifyError) {
+ const IpczDriver& driver = kSyncReferenceDriver;
IpczDriverHandle a, b;
EXPECT_EQ(IPCZ_RESULT_OK,
driver.CreateTransports(IPCZ_INVALID_DRIVER_HANDLE,
@@ -255,8 +255,8 @@
EXPECT_EQ(IPCZ_RESULT_OK, driver.Close(b, IPCZ_NO_FLAGS, nullptr));
}
-TEST(SingleProcessReferenceDriverTest, SharedMemory) {
- const IpczDriver& driver = kSingleProcessReferenceDriver;
+TEST(SyncReferenceDriverTest, SharedMemory) {
+ const IpczDriver& driver = kSyncReferenceDriver;
const size_t kSize = 64;
IpczDriverHandle memory;
@@ -297,8 +297,8 @@
EXPECT_EQ(IPCZ_RESULT_OK, driver.Close(memory, IPCZ_NO_FLAGS, nullptr));
}
-TEST(SingleProcessReferenceDriverTest, TransmitHandles) {
- const IpczDriver& driver = kSingleProcessReferenceDriver;
+TEST(SyncReferenceDriverTest, TransmitHandles) {
+ const IpczDriver& driver = kSyncReferenceDriver;
IpczDriverHandle a, b;
EXPECT_EQ(IPCZ_RESULT_OK,
driver.CreateTransports(IPCZ_INVALID_DRIVER_HANDLE,
diff --git a/src/test/multinode_test.cc b/src/test/multinode_test.cc
index ed24c24..91a1059 100644
--- a/src/test/multinode_test.cc
+++ b/src/test/multinode_test.cc
@@ -9,7 +9,7 @@
#include <thread>
#include "ipcz/ipcz.h"
-#include "reference_drivers/single_process_reference_driver.h"
+#include "reference_drivers/sync_reference_driver.h"
#include "third_party/abseil-cpp/absl/base/macros.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#include "third_party/abseil-cpp/absl/types/variant.h"
@@ -112,7 +112,7 @@
static IpczDriver kInvalidDriver = {};
switch (driver_mode_) {
case DriverMode::kSync:
- return reference_drivers::kSingleProcessReferenceDriver;
+ return reference_drivers::kSyncReferenceDriver;
#if BUILDFLAG(ENABLE_IPCZ_MULTIPROCESS_TESTS)
case DriverMode::kMultiprocess:
diff --git a/src/trap_test.cc b/src/trap_test.cc
index cf30087..5c2f537 100644
--- a/src/trap_test.cc
+++ b/src/trap_test.cc
@@ -6,7 +6,7 @@
#include <utility>
#include "ipcz/ipcz.h"
-#include "reference_drivers/single_process_reference_driver.h"
+#include "reference_drivers/sync_reference_driver.h"
#include "test/test.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/abseil-cpp/absl/memory/memory.h"
@@ -23,8 +23,7 @@
}
private:
- const IpczHandle node_{
- CreateNode(reference_drivers::kSingleProcessReferenceDriver)};
+ const IpczHandle node_{CreateNode(reference_drivers::kSyncReferenceDriver)};
};
TEST_F(TrapTest, RemoveOnClose) {
