From 409339e45488d71c7807cbc9c1915f5b6f5d456f Mon Sep 17 00:00:00 2001 From: Mike Aizatsky Date: Thu, 16 Apr 2026 08:57:37 -0700 Subject: [PATCH] Rc and Rc --- build/deps/gen/deps.MODULE.bazel | 6 +++--- src/workerd/api/restore.c++ | 7 +++---- src/workerd/api/worker-rpc.c++ | 17 ++++++----------- src/workerd/io/trace-stream.c++ | 5 ++--- src/workerd/util/completion-membrane.h | 12 ++---------- 5 files changed, 16 insertions(+), 31 deletions(-) diff --git a/build/deps/gen/deps.MODULE.bazel b/build/deps/gen/deps.MODULE.bazel index bcc1c911a40..226753c860f 100644 --- a/build/deps/gen/deps.MODULE.bazel +++ b/build/deps/gen/deps.MODULE.bazel @@ -27,10 +27,10 @@ bazel_dep(name = "brotli", version = "1.2.1") # capnp-cpp http.archive( name = "capnp-cpp", - sha256 = "c8eed3eccf8f839dcea831818e72e03c78a0f5ab4c458497fa380fd007797c57", - strip_prefix = "capnproto-capnproto-2d48111/c++", + sha256 = "4cc9c1efd0310ce82899612df6439c9e401f896c538e07ba9e3990ac8d8c62f4", + strip_prefix = "capnproto-capnproto-a122ef9/c++", type = "tgz", - url = "https://github.com/capnproto/capnproto/tarball/2d481112f6fdab63c8e557ddcb8323a9c6d5733d", + url = "https://github.com/capnproto/capnproto/tarball/a122ef9a31db579544ad421c7ec412568bce8e7b", ) use_repo(http, "capnp-cpp") diff --git a/src/workerd/api/restore.c++ b/src/workerd/api/restore.c++ index f50a1037df2..9c05c46bb38 100644 --- a/src/workerd/api/restore.c++ +++ b/src/workerd/api/restore.c++ @@ -477,7 +477,7 @@ kj::Promise RestoreRpcStubCustomEvent::run auto [donePromise, doneFulfiller] = kj::newPromiseAndFulfiller(); capFulfiller->fulfill( - capnp::membrane(kj::mv(cap), kj::refcounted(kj::mv(doneFulfiller)))); + capnp::membrane(kj::mv(cap), kj::rc(kj::mv(doneFulfiller)))); // `donePromise` resolves once there are no longer any capabilities pointing between the client // and server as part of this session. @@ -517,11 +517,10 @@ kj::Promise RestoreRpcStubCustomEvent::sen rpc::JsRpcTarget::Client cap = sent.getTarget(); - cap = capnp::membrane(kj::mv(cap), kj::refcounted(kj::mv(revokePaf.promise))); + cap = capnp::membrane(kj::mv(cap), kj::rc(kj::mv(revokePaf.promise))); auto completionPaf = kj::newPromiseAndFulfiller(); - cap = capnp::membrane( - kj::mv(cap), kj::refcounted(kj::mv(completionPaf.fulfiller))); + cap = capnp::membrane(kj::mv(cap), kj::rc(kj::mv(completionPaf.fulfiller))); capFulfiller->fulfill(kj::mv(cap)); diff --git a/src/workerd/api/worker-rpc.c++ b/src/workerd/api/worker-rpc.c++ index c673fe35af7..ad28df4e579 100644 --- a/src/workerd/api/worker-rpc.c++ +++ b/src/workerd/api/worker-rpc.c++ @@ -372,7 +372,7 @@ jsg::JsValue deserializeRpcReturnValue(jsg::Lock& js, // A membrane which attaches some object until it is destroyed. // // TODO(cleanup): This is generally useful, should it be part of capnp? -class AttachmentMembrane final: public capnp::MembranePolicy, public kj::Refcounted { +class AttachmentMembrane final: public capnp::MembranePolicy { public: explicit AttachmentMembrane(kj::Own attachment): attachment(kj::mv(attachment)) {} @@ -386,10 +386,6 @@ class AttachmentMembrane final: public capnp::MembranePolicy, public kj::Refcoun return kj::none; } - kj::Own addRef() override { - return kj::addRef(*this); - } - private: kj::Own attachment; }; @@ -1816,8 +1812,8 @@ void JsRpcStub::serialize(jsg::Lock& js, jsg::Serializer& serializer) { // to getClient() will force it to be created, invoking the restore chain, just so the stub // can be sent over RPC. Maybe we should actually leave it null and leave it up to the // receiving end to invoke the restore chain if desired? - auto cap = capnp::membrane( - getClient(), kj::refcounted(ioctx.registerPendingEvent())); + auto cap = + capnp::membrane(getClient(), kj::rc(ioctx.registerPendingEvent())); // If a channel is present, send a channel token for it. kj::Maybe, kj::Promise>>> channelToken; @@ -3499,7 +3495,7 @@ kj::Promise JsRpcSessionCustomEvent::run( auto [donePromise, doneFulfiller] = kj::newPromiseAndFulfiller(); capFulfiller->fulfill(capnp::membrane( - revocableTarget.getClient(), kj::refcounted(kj::mv(doneFulfiller)))); + revocableTarget.getClient(), kj::rc(kj::mv(doneFulfiller)))); // `donePromise` resolves once there are no longer any capabilities pointing between the client // and server as part of this session. @@ -3549,7 +3545,7 @@ kj::Promise JsRpcSessionCustomEvent::sendR rpc::JsRpcTarget::Client cap = sent.getTopLevel(); - cap = capnp::membrane(kj::mv(cap), kj::refcounted(kj::mv(revokePaf.promise))); + cap = capnp::membrane(kj::mv(cap), kj::rc(kj::mv(revokePaf.promise))); // When no more capabilities exist on the connection, we want to proactively cancel the RPC. // This is needed in particular for the case where the client is dropped without making any calls @@ -3562,8 +3558,7 @@ kj::Promise JsRpcSessionCustomEvent::sendR // TODO(cleanup): It feels like there's something wrong with the design here. Can we make this // less ugly? auto completionPaf = kj::newPromiseAndFulfiller(); - cap = capnp::membrane( - kj::mv(cap), kj::refcounted(kj::mv(completionPaf.fulfiller))); + cap = capnp::membrane(kj::mv(cap), kj::rc(kj::mv(completionPaf.fulfiller))); this->capFulfiller->fulfill(kj::mv(cap)); diff --git a/src/workerd/io/trace-stream.c++ b/src/workerd/io/trace-stream.c++ index 889b6448904..9675e1b79ba 100644 --- a/src/workerd/io/trace-stream.c++ +++ b/src/workerd/io/trace-stream.c++ @@ -1149,11 +1149,10 @@ kj::Promise TailStreamCustomEvent::sendRpc rpc::TailStreamTarget::Client cap = sent.getTopLevel(); - cap = capnp::membrane(kj::mv(cap), kj::refcounted(kj::mv(revokePaf.promise))); + cap = capnp::membrane(kj::mv(cap), kj::rc(kj::mv(revokePaf.promise))); auto completionPaf = kj::newPromiseAndFulfiller(); - cap = capnp::membrane( - kj::mv(cap), kj::refcounted(kj::mv(completionPaf.fulfiller))); + cap = capnp::membrane(kj::mv(cap), kj::rc(kj::mv(completionPaf.fulfiller))); capFulfiller->fulfill(kj::mv(cap)); diff --git a/src/workerd/util/completion-membrane.h b/src/workerd/util/completion-membrane.h index 9f7076cada1..becb4414397 100644 --- a/src/workerd/util/completion-membrane.h +++ b/src/workerd/util/completion-membrane.h @@ -8,7 +8,7 @@ namespace workerd { // fulfills a fulfiller. // // TODO(cleanup): This is generally useful, should it be part of capnp? -class CompletionMembrane final: public capnp::MembranePolicy, public kj::Refcounted { +class CompletionMembrane final: public capnp::MembranePolicy { public: explicit CompletionMembrane(kj::Own> doneFulfiller) : doneFulfiller(kj::mv(doneFulfiller)) {} @@ -26,10 +26,6 @@ class CompletionMembrane final: public capnp::MembranePolicy, public kj::Refcoun return kj::none; } - kj::Own addRef() override { - return kj::addRef(*this); - } - void reject(kj::Exception&& e) { doneFulfiller->reject(kj::mv(e)); } @@ -41,7 +37,7 @@ class CompletionMembrane final: public capnp::MembranePolicy, public kj::Refcoun // A membrane which revokes when some Promise is fulfilled. // // TODO(cleanup): This is generally useful, should it be part of capnp? -class RevokerMembrane final: public capnp::MembranePolicy, public kj::Refcounted { +class RevokerMembrane final: public capnp::MembranePolicy { public: explicit RevokerMembrane(kj::Promise promise): promise(promise.fork()) {} @@ -61,10 +57,6 @@ class RevokerMembrane final: public capnp::MembranePolicy, public kj::Refcounted return kj::none; } - kj::Own addRef() override { - return kj::addRef(*this); - } - kj::Maybe> onRevoked() override { return promise.addBranch(); }