libbinder: RPC big 'session' rename
Before, 'connection' was used for a group of TCP connection. This
updates the names for most types to work with the following definitions:
- session - group of connections
- connection - a single tcp connection
- socket - only when referring to a socket being setup for a connection
Bug: N/A
Fixes: 187393805 # conflict
Test: binderRpcTest, binderRpcBenchmark
Change-Id: If07afd9af680cd2a5ece6506df5383e5cc258663
(cherry picked from commit bdb53ab39d08f9d189706532d347f575cbdac257)
diff --git a/libs/binder/tests/IBinderRpcTest.aidl b/libs/binder/tests/IBinderRpcTest.aidl
index 814e094..ef4198d 100644
--- a/libs/binder/tests/IBinderRpcTest.aidl
+++ b/libs/binder/tests/IBinderRpcTest.aidl
@@ -18,7 +18,7 @@
oneway void sendString(@utf8InCpp String str);
@utf8InCpp String doubleString(@utf8InCpp String str);
- // number of known RPC binders to process, RpcState::countBinders by connection
+ // number of known RPC binders to process, RpcState::countBinders by session
int[] countBinders();
// Caller sends server, callee pings caller's server and returns error code.
@@ -36,7 +36,7 @@
// should always return the same binder
IBinder alwaysGiveMeTheSameBinder();
- // Idea is that the server will not hold onto the session, the remote connection
+ // Idea is that the server will not hold onto the session, the remote session
// object must. This is to test lifetimes of binder objects, and consequently, also
// identity (since by assigning sessions names, we can make sure a section always
// references the session it was originally opened with).
diff --git a/libs/binder/tests/binderRpcBenchmark.cpp b/libs/binder/tests/binderRpcBenchmark.cpp
index f64bc5b..a457e67 100644
--- a/libs/binder/tests/binderRpcBenchmark.cpp
+++ b/libs/binder/tests/binderRpcBenchmark.cpp
@@ -18,8 +18,8 @@
#include <android-base/logging.h>
#include <benchmark/benchmark.h>
#include <binder/Binder.h>
-#include <binder/RpcConnection.h>
#include <binder/RpcServer.h>
+#include <binder/RpcSession.h>
#include <thread>
@@ -30,8 +30,8 @@
using android::IBinder;
using android::interface_cast;
using android::OK;
-using android::RpcConnection;
using android::RpcServer;
+using android::RpcSession;
using android::sp;
using android::binder::Status;
@@ -46,17 +46,17 @@
}
};
-static sp<RpcConnection> gConnection = RpcConnection::make();
+static sp<RpcSession> gSession = RpcSession::make();
void BM_getRootObject(benchmark::State& state) {
while (state.KeepRunning()) {
- CHECK(gConnection->getRootObject() != nullptr);
+ CHECK(gSession->getRootObject() != nullptr);
}
}
BENCHMARK(BM_getRootObject);
void BM_pingTransaction(benchmark::State& state) {
- sp<IBinder> binder = gConnection->getRootObject();
+ sp<IBinder> binder = gSession->getRootObject();
CHECK(binder != nullptr);
while (state.KeepRunning()) {
@@ -66,7 +66,7 @@
BENCHMARK(BM_pingTransaction);
void BM_repeatString(benchmark::State& state) {
- sp<IBinder> binder = gConnection->getRootObject();
+ sp<IBinder> binder = gSession->getRootObject();
CHECK(binder != nullptr);
sp<IBinderRpcBenchmark> iface = interface_cast<IBinderRpcBenchmark>(binder);
CHECK(iface != nullptr);
@@ -95,7 +95,7 @@
BENCHMARK(BM_repeatString);
void BM_repeatBinder(benchmark::State& state) {
- sp<IBinder> binder = gConnection->getRootObject();
+ sp<IBinder> binder = gSession->getRootObject();
CHECK(binder != nullptr);
sp<IBinderRpcBenchmark> iface = interface_cast<IBinderRpcBenchmark>(binder);
CHECK(iface != nullptr);
@@ -128,7 +128,7 @@
for (size_t tries = 0; tries < 5; tries++) {
usleep(10000);
- if (gConnection->setupUnixDomainClient(addr.c_str())) goto success;
+ if (gSession->setupUnixDomainClient(addr.c_str())) goto success;
}
LOG(FATAL) << "Could not connect.";
success:
diff --git a/libs/binder/tests/binderRpcTest.cpp b/libs/binder/tests/binderRpcTest.cpp
index 50bff91..8d10727 100644
--- a/libs/binder/tests/binderRpcTest.cpp
+++ b/libs/binder/tests/binderRpcTest.cpp
@@ -25,8 +25,8 @@
#include <binder/BpBinder.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
-#include <binder/RpcConnection.h>
#include <binder/RpcServer.h>
+#include <binder/RpcSession.h>
#include <gtest/gtest.h>
#include <chrono>
@@ -94,12 +94,12 @@
return Status::fromExceptionCode(Status::EX_NULL_POINTER);
}
out->clear();
- for (auto connection : spServer->listConnections()) {
- size_t count = connection->state()->countBinders();
+ for (auto session : spServer->listSessions()) {
+ size_t count = session->state()->countBinders();
if (count != 1) {
// this is called when there is only one binder held remaining,
// so to aid debugging
- connection->state()->dump();
+ session->state()->dump();
}
out->push_back(count);
}
@@ -225,61 +225,60 @@
return temp + "/binderRpcTest_" + std::to_string(id++);
};
-struct ProcessConnection {
+struct ProcessSession {
// reference to process hosting a socket server
Process host;
- struct ConnectionInfo {
- sp<RpcConnection> connection;
+ struct SessionInfo {
+ sp<RpcSession> session;
sp<IBinder> root;
};
- // client connection objects associated with other process
- // each one represents a separate connection
- std::vector<ConnectionInfo> connections;
+ // client session objects associated with other process
+ // each one represents a separate session
+ std::vector<SessionInfo> sessions;
- ProcessConnection(ProcessConnection&&) = default;
- ~ProcessConnection() {
- for (auto& connection : connections) {
- connection.root = nullptr;
+ ProcessSession(ProcessSession&&) = default;
+ ~ProcessSession() {
+ for (auto& session : sessions) {
+ session.root = nullptr;
}
- for (auto& info : connections) {
- sp<RpcConnection>& connection = info.connection;
+ for (auto& info : sessions) {
+ sp<RpcSession>& session = info.session;
- EXPECT_NE(nullptr, connection);
- EXPECT_NE(nullptr, connection->state());
- EXPECT_EQ(0, connection->state()->countBinders())
- << (connection->state()->dump(), "dump:");
+ EXPECT_NE(nullptr, session);
+ EXPECT_NE(nullptr, session->state());
+ EXPECT_EQ(0, session->state()->countBinders()) << (session->state()->dump(), "dump:");
- wp<RpcConnection> weakConnection = connection;
- connection = nullptr;
- EXPECT_EQ(nullptr, weakConnection.promote()) << "Leaked connection";
+ wp<RpcSession> weakSession = session;
+ session = nullptr;
+ EXPECT_EQ(nullptr, weakSession.promote()) << "Leaked session";
}
}
};
-// Process connection where the process hosts IBinderRpcTest, the server used
+// Process session where the process hosts IBinderRpcTest, the server used
// for most testing here
-struct BinderRpcTestProcessConnection {
- ProcessConnection proc;
+struct BinderRpcTestProcessSession {
+ ProcessSession proc;
- // pre-fetched root object (for first connection)
+ // pre-fetched root object (for first session)
sp<IBinder> rootBinder;
- // pre-casted root object (for first connection)
+ // pre-casted root object (for first session)
sp<IBinderRpcTest> rootIface;
- // whether connection should be invalidated by end of run
+ // whether session should be invalidated by end of run
bool expectInvalid = false;
- BinderRpcTestProcessConnection(BinderRpcTestProcessConnection&&) = default;
- ~BinderRpcTestProcessConnection() {
+ BinderRpcTestProcessSession(BinderRpcTestProcessSession&&) = default;
+ ~BinderRpcTestProcessSession() {
if (!expectInvalid) {
std::vector<int32_t> remoteCounts;
- // calling over any connections counts across all connections
+ // calling over any sessions counts across all sessions
EXPECT_OK(rootIface->countBinders(&remoteCounts));
- EXPECT_EQ(remoteCounts.size(), proc.connections.size());
+ EXPECT_EQ(remoteCounts.size(), proc.sessions.size());
for (auto remoteCount : remoteCounts) {
EXPECT_EQ(remoteCount, 1);
}
@@ -316,10 +315,10 @@
public:
// This creates a new process serving an interface on a certain number of
// threads.
- ProcessConnection createRpcTestSocketServerProcess(
- size_t numThreads, size_t numConnections,
+ ProcessSession createRpcTestSocketServerProcess(
+ size_t numThreads, size_t numSessions,
const std::function<void(const sp<RpcServer>&)>& configure) {
- CHECK_GE(numConnections, 1) << "Must have at least one connection to a server";
+ CHECK_GE(numSessions, 1) << "Must have at least one session to a server";
SocketType socketType = GetParam();
@@ -328,7 +327,7 @@
static unsigned int vsockPort = 3456;
vsockPort++;
- auto ret = ProcessConnection{
+ auto ret = ProcessSession{
.host = Process([&](Pipe* pipe) {
sp<RpcServer> server = RpcServer::make();
@@ -369,21 +368,21 @@
CHECK_NE(0, inetPort);
}
- for (size_t i = 0; i < numConnections; i++) {
- sp<RpcConnection> connection = RpcConnection::make();
+ for (size_t i = 0; i < numSessions; i++) {
+ sp<RpcSession> session = RpcSession::make();
for (size_t tries = 0; tries < 10; tries++) {
usleep(10000);
switch (socketType) {
case SocketType::UNIX:
- if (connection->setupUnixDomainClient(addr.c_str())) goto success;
+ if (session->setupUnixDomainClient(addr.c_str())) goto success;
break;
#ifdef __BIONIC__
case SocketType::VSOCK:
- if (connection->setupVsockClient(VMADDR_CID_LOCAL, vsockPort)) goto success;
+ if (session->setupVsockClient(VMADDR_CID_LOCAL, vsockPort)) goto success;
break;
#endif // __BIONIC__
case SocketType::INET:
- if (connection->setupInetClient("127.0.0.1", inetPort)) goto success;
+ if (session->setupInetClient("127.0.0.1", inetPort)) goto success;
break;
default:
LOG_ALWAYS_FATAL("Unknown socket type");
@@ -391,15 +390,15 @@
}
LOG_ALWAYS_FATAL("Could not connect");
success:
- ret.connections.push_back({connection, connection->getRootObject()});
+ ret.sessions.push_back({session, session->getRootObject()});
}
return ret;
}
- BinderRpcTestProcessConnection createRpcTestSocketServerProcess(size_t numThreads,
- size_t numConnections = 1) {
- BinderRpcTestProcessConnection ret{
- .proc = createRpcTestSocketServerProcess(numThreads, numConnections,
+ BinderRpcTestProcessSession createRpcTestSocketServerProcess(size_t numThreads,
+ size_t numSessions = 1) {
+ BinderRpcTestProcessSession ret{
+ .proc = createRpcTestSocketServerProcess(numThreads, numSessions,
[&](const sp<RpcServer>& server) {
sp<MyBinderRpcTest> service =
new MyBinderRpcTest;
@@ -408,7 +407,7 @@
}),
};
- ret.rootBinder = ret.proc.connections.at(0).root;
+ ret.rootBinder = ret.proc.sessions.at(0).root;
ret.rootIface = interface_cast<IBinderRpcTest>(ret.rootBinder);
return ret;
@@ -421,7 +420,7 @@
server->setRootObject(nullptr);
});
- EXPECT_EQ(nullptr, proc.connections.at(0).root);
+ EXPECT_EQ(nullptr, proc.sessions.at(0).root);
}
TEST_P(BinderRpc, Ping) {
@@ -436,11 +435,11 @@
EXPECT_EQ(IBinderRpcTest::descriptor, proc.rootBinder->getInterfaceDescriptor());
}
-TEST_P(BinderRpc, MultipleConnections) {
- auto proc = createRpcTestSocketServerProcess(1 /*threads*/, 5 /*connections*/);
- for (auto connection : proc.proc.connections) {
- ASSERT_NE(nullptr, connection.root);
- EXPECT_EQ(OK, connection.root->pingBinder());
+TEST_P(BinderRpc, MultipleSessions) {
+ auto proc = createRpcTestSocketServerProcess(1 /*threads*/, 5 /*sessions*/);
+ for (auto session : proc.proc.sessions) {
+ ASSERT_NE(nullptr, session.root);
+ EXPECT_EQ(OK, session.root->pingBinder());
}
}
@@ -582,7 +581,7 @@
// These are behavioral differences form regular binder, where certain usecases
// aren't supported.
-TEST_P(BinderRpc, CannotMixBindersBetweenUnrelatedSocketConnections) {
+TEST_P(BinderRpc, CannotMixBindersBetweenUnrelatedSocketSessions) {
auto proc1 = createRpcTestSocketServerProcess(1);
auto proc2 = createRpcTestSocketServerProcess(1);
@@ -591,12 +590,12 @@
proc1.rootIface->repeatBinder(proc2.rootBinder, &outBinder).transactionError());
}
-TEST_P(BinderRpc, CannotMixBindersBetweenTwoConnectionsToTheSameServer) {
- auto proc = createRpcTestSocketServerProcess(1 /*threads*/, 2 /*connections*/);
+TEST_P(BinderRpc, CannotMixBindersBetweenTwoSessionsToTheSameServer) {
+ auto proc = createRpcTestSocketServerProcess(1 /*threads*/, 2 /*sessions*/);
sp<IBinder> outBinder;
EXPECT_EQ(INVALID_OPERATION,
- proc.rootIface->repeatBinder(proc.proc.connections.at(1).root, &outBinder)
+ proc.rootIface->repeatBinder(proc.proc.sessions.at(1).root, &outBinder)
.transactionError());
}