Rename TransportClient to TransportConnection

The change is auto-generated through IDE rename function and makes the
following naming changes:

1. TransportClient -> TransportConnection
2. TransportClientManager -> TransportConnectionManager
3. + corresponding test files

TransportConnection is a more appropriate name for the class as it's
exactly what it does - manages the connection to the remote
BackupTransport service implementation.

This is a preparatory change to making the BackupTransport AIDL async.
TransportClient name will later be used more appropriately for a class
that wraps the actual communication with the transport.

Bug: 202716271
Test: m -j
Change-Id: I76a98edc7102c8fcffdb050208e9e65543e6e10c

8 files changed, 145 insertions, 139 deletions

diff --git a/services/robotests/backup/src/com/android/server/backup/TransportManagerTest.java b/services/robotests/backup/src/com/android/server/backup/TransportManagerTest.java
index 42115d437ee0..b7f8c00896d4 100644
--- a/services/robotests/backup/src/com/android/server/backup/TransportManagerTest.java
+++ b/services/robotests/backup/src/com/android/server/backup/TransportManagerTest.java
@@ -55,8 +55,8 @@ import android.platform.test.annotations.Presubmit;
 import com.android.server.backup.testing.TransportData;
 import com.android.server.backup.testing.TransportTestUtils.TransportMock;
 import com.android.server.backup.transport.OnTransportRegisteredListener;
-import com.android.server.backup.transport.TransportClient;
-import com.android.server.backup.transport.TransportClientManager;
+import com.android.server.backup.transport.TransportConnection;
+import com.android.server.backup.transport.TransportConnectionManager;
 import com.android.server.backup.transport.TransportNotRegisteredException;
 import com.android.server.testing.shadows.ShadowApplicationPackageManager;
 
@@ -85,7 +85,7 @@ public class TransportManagerTest {
     private static final String PACKAGE_B = "some.package.b";
 
     @Mock private OnTransportRegisteredListener mListener;
-    @Mock private TransportClientManager mTransportClientManager;
+    @Mock private TransportConnectionManager mTransportConnectionManager;
     private TransportData mTransportA1;
     private TransportData mTransportA2;
     private TransportData mTransportB1;
@@ -206,7 +206,7 @@ public class TransportManagerTest {
 
         transportManager.registerTransports();
 
-        verify(mTransportClientManager)
+        verify(mTransportConnectionManager)
                 .getTransportClient(
                         eq(mTransportA1.getTransportComponent()),
                         argThat(
@@ -433,10 +433,10 @@ public class TransportManagerTest {
         TransportManager transportManager =
                 createTransportManagerWithRegisteredTransports(mTransportA1, mTransportA2);
 
-        TransportClient transportClient =
+        TransportConnection transportConnection =
                 transportManager.getTransportClient(mTransportA1.transportName, "caller");
 
-        assertThat(transportClient.getTransportComponent())
+        assertThat(transportConnection.getTransportComponent())
                 .isEqualTo(mTransportA1.getTransportComponent());
     }
 
@@ -453,10 +453,10 @@ public class TransportManagerTest {
                 null,
                 null);
 
-        TransportClient transportClient =
+        TransportConnection transportConnection =
                 transportManager.getTransportClient(mTransportA1.transportName, "caller");
 
-        assertThat(transportClient).isNull();
+        assertThat(transportConnection).isNull();
     }
 
     @Test
@@ -471,9 +471,10 @@ public class TransportManagerTest {
                 null,
                 null);
 
-        TransportClient transportClient = transportManager.getTransportClient("newName", "caller");
+        TransportConnection transportConnection = transportManager.getTransportClient(
+                "newName", "caller");
 
-        assertThat(transportClient.getTransportComponent())
+        assertThat(transportConnection.getTransportComponent())
                 .isEqualTo(mTransportA1.getTransportComponent());
     }
 
@@ -482,9 +483,10 @@ public class TransportManagerTest {
         TransportManager transportManager =
                 createTransportManagerWithRegisteredTransports(mTransportA1, mTransportA2);
 
-        TransportClient transportClient = transportManager.getCurrentTransportClient("caller");
+        TransportConnection transportConnection = transportManager.getCurrentTransportClient(
+                "caller");
 
-        assertThat(transportClient.getTransportComponent())
+        assertThat(transportConnection.getTransportComponent())
                 .isEqualTo(mTransportA1.getTransportComponent());
     }
 
@@ -660,12 +662,12 @@ public class TransportManagerTest {
         List<TransportMock> transportMocks = new ArrayList<>(transports.length);
         for (TransportData transport : transports) {
             TransportMock transportMock = mockTransport(transport);
-            when(mTransportClientManager.getTransportClient(
+            when(mTransportConnectionManager.getTransportClient(
                             eq(transport.getTransportComponent()), any()))
-                    .thenReturn(transportMock.transportClient);
-            when(mTransportClientManager.getTransportClient(
+                    .thenReturn(transportMock.mTransportConnection);
+            when(mTransportConnectionManager.getTransportClient(
                             eq(transport.getTransportComponent()), any(), any()))
-                    .thenReturn(transportMock.transportClient);
+                    .thenReturn(transportMock.mTransportConnection);
             transportMocks.add(transportMock);
         }
         return transportMocks;
@@ -706,7 +708,7 @@ public class TransportManagerTest {
                                 .map(TransportData::getTransportComponent)
                                 .collect(toSet()),
                         selectedTransport != null ? selectedTransport.transportName : null,
-                        mTransportClientManager);
+                        mTransportConnectionManager);
         transportManager.setOnTransportRegisteredListener(mListener);
         return transportManager;
     }
diff --git a/services/robotests/backup/src/com/android/server/backup/UserBackupManagerServiceTest.java b/services/robotests/backup/src/com/android/server/backup/UserBackupManagerServiceTest.java
index 06d51a4be920..297538ad7b4b 100644
--- a/services/robotests/backup/src/com/android/server/backup/UserBackupManagerServiceTest.java
+++ b/services/robotests/backup/src/com/android/server/backup/UserBackupManagerServiceTest.java
@@ -243,7 +243,7 @@ public class UserBackupManagerServiceTest {
 
         assertThat(result).isTrue();
         verify(mTransportManager)
-                .disposeOfTransportClient(eq(transportMock.transportClient), any());
+                .disposeOfTransportClient(eq(transportMock.mTransportConnection), any());
     }
 
     /**
@@ -282,7 +282,7 @@ public class UserBackupManagerServiceTest {
 
         assertThat(filtered).asList().containsExactly(PACKAGE_1);
         verify(mTransportManager)
-                .disposeOfTransportClient(eq(transportMock.transportClient), any());
+                .disposeOfTransportClient(eq(transportMock.mTransportConnection), any());
     }
 
     /**
@@ -357,7 +357,7 @@ public class UserBackupManagerServiceTest {
         assertThat(getSettingsTransport()).isEqualTo(mNewTransport.transportName);
         assertThat(oldTransport).isEqualTo(mOldTransport.transportName);
         verify(mTransportManager)
-                .disposeOfTransportClient(eq(mNewTransportMock.transportClient), any());
+                .disposeOfTransportClient(eq(mNewTransportMock.mTransportConnection), any());
     }
 
     /**
@@ -395,7 +395,7 @@ public class UserBackupManagerServiceTest {
         assertThat(getSettingsTransport()).isEqualTo(mNewTransport.transportName);
         verify(callback).onSuccess(eq(mNewTransport.transportName));
         verify(mTransportManager)
-                .disposeOfTransportClient(eq(mNewTransportMock.transportClient), any());
+                .disposeOfTransportClient(eq(mNewTransportMock.mTransportConnection), any());
     }
 
     /**
diff --git a/services/robotests/backup/src/com/android/server/backup/internal/PerformInitializeTaskTest.java b/services/robotests/backup/src/com/android/server/backup/internal/PerformInitializeTaskTest.java
index a14cc51a3ab6..bf4eeae4b4b2 100644
--- a/services/robotests/backup/src/com/android/server/backup/internal/PerformInitializeTaskTest.java
+++ b/services/robotests/backup/src/com/android/server/backup/internal/PerformInitializeTaskTest.java
@@ -50,7 +50,7 @@ import com.android.server.backup.UserBackupManagerService;
 import com.android.server.backup.testing.TransportData;
 import com.android.server.backup.testing.TransportTestUtils;
 import com.android.server.backup.testing.TransportTestUtils.TransportMock;
-import com.android.server.backup.transport.TransportClient;
+import com.android.server.backup.transport.TransportConnection;
 import com.android.server.testing.shadows.ShadowSlog;
 
 import org.junit.Before;
@@ -285,7 +285,7 @@ public class PerformInitializeTaskTest {
             TransportData transport = transportsIterator.next();
             verify(mTransportManager).getTransportClient(eq(transport.transportName), any());
             verify(mTransportManager)
-                    .disposeOfTransportClient(eq(transportMock.transportClient), any());
+                    .disposeOfTransportClient(eq(transportMock.mTransportConnection), any());
         }
     }
 
@@ -303,9 +303,9 @@ public class PerformInitializeTaskTest {
         performInitializeTask.run();
 
         verify(mTransportManager)
-                .disposeOfTransportClient(eq(transportMocks.get(0).transportClient), any());
+                .disposeOfTransportClient(eq(transportMocks.get(0).mTransportConnection), any());
         verify(mTransportManager)
-                .disposeOfTransportClient(eq(transportMocks.get(1).transportClient), any());
+                .disposeOfTransportClient(eq(transportMocks.get(1).mTransportConnection), any());
     }
 
     @Test
@@ -328,14 +328,16 @@ public class PerformInitializeTaskTest {
                 setUpTransports(mTransportManager, transport1, transport2);
         String registeredTransportName = transport2.transportName;
         IBackupTransport registeredTransport = transportMocks.get(1).transport;
-        TransportClient registeredTransportClient = transportMocks.get(1).transportClient;
+        TransportConnection
+                registeredTransportConnection = transportMocks.get(1).mTransportConnection;
         PerformInitializeTask performInitializeTask =
                 createPerformInitializeTask(transport1.transportName, transport2.transportName);
 
         performInitializeTask.run();
 
         verify(registeredTransport).initializeDevice();
-        verify(mTransportManager).disposeOfTransportClient(eq(registeredTransportClient), any());
+        verify(mTransportManager).disposeOfTransportClient(eq(registeredTransportConnection),
+                any());
         verify(mObserver).onResult(eq(registeredTransportName), eq(TRANSPORT_OK));
     }
 
@@ -347,7 +349,7 @@ public class PerformInitializeTaskTest {
         performInitializeTask.run();
 
         verify(mTransportManager)
-                .disposeOfTransportClient(eq(transportMock.transportClient), any());
+                .disposeOfTransportClient(eq(transportMock.mTransportConnection), any());
         verify(mObserver).backupFinished(eq(TRANSPORT_ERROR));
         verify(mListener).onFinished(any());
     }
@@ -356,13 +358,13 @@ public class PerformInitializeTaskTest {
     public void testRun_whenTransportThrowsDeadObjectException() throws Exception {
         TransportMock transportMock = setUpTransport(mTransport);
         IBackupTransport transport = transportMock.transport;
-        TransportClient transportClient = transportMock.transportClient;
+        TransportConnection transportConnection = transportMock.mTransportConnection;
         when(transport.initializeDevice()).thenThrow(DeadObjectException.class);
         PerformInitializeTask performInitializeTask = createPerformInitializeTask(mTransportName);
 
         performInitializeTask.run();
 
-        verify(mTransportManager).disposeOfTransportClient(eq(transportClient), any());
+        verify(mTransportManager).disposeOfTransportClient(eq(transportConnection), any());
         verify(mObserver).backupFinished(eq(TRANSPORT_ERROR));
         verify(mListener).onFinished(any());
     }
diff --git a/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java b/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java
index 7d17109af7d3..fd295c0739cf 100644
--- a/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java
+++ b/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java
@@ -2665,7 +2665,7 @@ public class KeyValueBackupTaskTest  {
         KeyValueBackupTask task =
                 new KeyValueBackupTask(
                         mBackupManagerService,
-                        transportMock.transportClient,
+                        transportMock.mTransportConnection,
                         transportMock.transportData.transportDirName,
                         queue,
                         mOldJournal,
diff --git a/services/robotests/backup/src/com/android/server/backup/restore/ActiveRestoreSessionTest.java b/services/robotests/backup/src/com/android/server/backup/restore/ActiveRestoreSessionTest.java
index 5883c1cb5995..9eb99aed2ba8 100644
--- a/services/robotests/backup/src/com/android/server/backup/restore/ActiveRestoreSessionTest.java
+++ b/services/robotests/backup/src/com/android/server/backup/restore/ActiveRestoreSessionTest.java
@@ -202,7 +202,7 @@ public class ActiveRestoreSessionTest {
         verify(mObserver)
                 .restoreSetsAvailable(aryEq(new RestoreSet[] {mRestoreSet1, mRestoreSet2}));
         verify(mTransportManager)
-                .disposeOfTransportClient(eq(transportMock.transportClient), any());
+                .disposeOfTransportClient(eq(transportMock.mTransportConnection), any());
         assertThat(mWakeLock.isHeld()).isFalse();
     }
 
@@ -235,7 +235,7 @@ public class ActiveRestoreSessionTest {
         verify(mObserver).restoreSetsAvailable(isNull());
         assertEventLogged(EventLogTags.RESTORE_TRANSPORT_FAILURE);
         verify(mTransportManager)
-                .disposeOfTransportClient(eq(transportMock.transportClient), any());
+                .disposeOfTransportClient(eq(transportMock.mTransportConnection), any());
         assertThat(mWakeLock.isHeld()).isFalse();
     }
 
@@ -253,7 +253,7 @@ public class ActiveRestoreSessionTest {
         mShadowBackupLooper.runToEndOfTasks();
         assertThat(result).isEqualTo(0);
         verify(mTransportManager)
-                .disposeOfTransportClient(eq(transportMock.transportClient), any());
+                .disposeOfTransportClient(eq(transportMock.mTransportConnection), any());
         assertThat(mWakeLock.isHeld()).isFalse();
         assertThat(mBackupManagerService.isRestoreInProgress()).isFalse();
         // Verify it created the task properly
@@ -341,7 +341,7 @@ public class ActiveRestoreSessionTest {
         mShadowBackupLooper.runToEndOfTasks();
         assertThat(result).isEqualTo(0);
         verify(mTransportManager)
-                .disposeOfTransportClient(eq(transportMock.transportClient), any());
+                .disposeOfTransportClient(eq(transportMock.mTransportConnection), any());
         assertThat(mWakeLock.isHeld()).isFalse();
         assertThat(mBackupManagerService.isRestoreInProgress()).isFalse();
         ShadowPerformUnifiedRestoreTask shadowTask =
@@ -463,7 +463,7 @@ public class ActiveRestoreSessionTest {
         mShadowBackupLooper.runToEndOfTasks();
         assertThat(result).isEqualTo(0);
         verify(mTransportManager)
-                .disposeOfTransportClient(eq(transportMock.transportClient), any());
+                .disposeOfTransportClient(eq(transportMock.mTransportConnection), any());
         assertThat(mWakeLock.isHeld()).isFalse();
         assertThat(mBackupManagerService.isRestoreInProgress()).isFalse();
         ShadowPerformUnifiedRestoreTask shadowTask =
diff --git a/services/robotests/backup/src/com/android/server/backup/testing/TransportTestUtils.java b/services/robotests/backup/src/com/android/server/backup/testing/TransportTestUtils.java
index 7dd5be53157b..ce44f067aeaa 100644
--- a/services/robotests/backup/src/com/android/server/backup/testing/TransportTestUtils.java
+++ b/services/robotests/backup/src/com/android/server/backup/testing/TransportTestUtils.java
@@ -36,7 +36,7 @@ import android.os.RemoteException;
 
 import com.android.internal.backup.IBackupTransport;
 import com.android.server.backup.TransportManager;
-import com.android.server.backup.transport.TransportClient;
+import com.android.server.backup.transport.TransportConnection;
 import com.android.server.backup.transport.TransportNotAvailableException;
 import com.android.server.backup.transport.TransportNotRegisteredException;
 
@@ -91,9 +91,9 @@ public class TransportTestUtils {
                 || status == TransportStatus.REGISTERED_UNAVAILABLE) {
             // Transport registered
             when(transportManager.getCurrentTransportClient(any()))
-                    .thenReturn(transportMock.transportClient);
+                    .thenReturn(transportMock.mTransportConnection);
             when(transportManager.getCurrentTransportClientOrThrow(any()))
-                    .thenReturn(transportMock.transportClient);
+                    .thenReturn(transportMock.mTransportConnection);
         } else {
             // Transport not registered
             when(transportManager.getCurrentTransportClient(any())).thenReturn(null);
@@ -123,9 +123,9 @@ public class TransportTestUtils {
                 || status == TransportStatus.REGISTERED_UNAVAILABLE) {
             // Transport registered
             when(transportManager.getTransportClient(eq(transportName), any()))
-                    .thenReturn(transportMock.transportClient);
+                    .thenReturn(transportMock.mTransportConnection);
             when(transportManager.getTransportClientOrThrow(eq(transportName), any()))
-                    .thenReturn(transportMock.transportClient);
+                    .thenReturn(transportMock.mTransportConnection);
             when(transportManager.getTransportName(transportComponent)).thenReturn(transportName);
             when(transportManager.getTransportDirName(eq(transportName)))
                     .thenReturn(transportDirName);
@@ -150,28 +150,28 @@ public class TransportTestUtils {
     }
 
     public static TransportMock mockTransport(TransportData transport) throws Exception {
-        final TransportClient transportClientMock;
+        final TransportConnection transportConnectionMock;
         int status = transport.transportStatus;
         ComponentName transportComponent = transport.getTransportComponent();
         if (status == TransportStatus.REGISTERED_AVAILABLE
                 || status == TransportStatus.REGISTERED_UNAVAILABLE) {
             // Transport registered
-            transportClientMock = mock(TransportClient.class);
-            when(transportClientMock.getTransportComponent()).thenReturn(transportComponent);
+            transportConnectionMock = mock(TransportConnection.class);
+            when(transportConnectionMock.getTransportComponent()).thenReturn(transportComponent);
             if (status == TransportStatus.REGISTERED_AVAILABLE) {
                 // Transport registered and available
                 IBackupTransport transportMock = mockTransportBinder(transport);
-                when(transportClientMock.connectOrThrow(any())).thenReturn(transportMock);
-                when(transportClientMock.connect(any())).thenReturn(transportMock);
+                when(transportConnectionMock.connectOrThrow(any())).thenReturn(transportMock);
+                when(transportConnectionMock.connect(any())).thenReturn(transportMock);
 
-                return new TransportMock(transport, transportClientMock, transportMock);
+                return new TransportMock(transport, transportConnectionMock, transportMock);
             } else {
                 // Transport registered but unavailable
-                when(transportClientMock.connectOrThrow(any()))
+                when(transportConnectionMock.connectOrThrow(any()))
                         .thenThrow(TransportNotAvailableException.class);
-                when(transportClientMock.connect(any())).thenReturn(null);
+                when(transportConnectionMock.connect(any())).thenReturn(null);
 
-                return new TransportMock(transport, transportClientMock, null);
+                return new TransportMock(transport, transportConnectionMock, null);
             }
         } else {
             // Transport not registered
@@ -198,15 +198,15 @@ public class TransportTestUtils {
 
     public static class TransportMock {
         public final TransportData transportData;
-        @Nullable public final TransportClient transportClient;
+        @Nullable public final TransportConnection mTransportConnection;
         @Nullable public final IBackupTransport transport;
 
         private TransportMock(
                 TransportData transportData,
-                @Nullable TransportClient transportClient,
+                @Nullable TransportConnection transportConnection,
                 @Nullable IBackupTransport transport) {
             this.transportData = transportData;
-            this.transportClient = transportClient;
+            this.mTransportConnection = transportConnection;
             this.transport = transport;
         }
     }
diff --git a/services/robotests/backup/src/com/android/server/backup/transport/TransportClientManagerTest.java b/services/robotests/backup/src/com/android/server/backup/transport/TransportConnectionManagerTest.java
index f033af8a9b63..102f594003fa 100644
--- a/services/robotests/backup/src/com/android/server/backup/transport/TransportClientManagerTest.java
+++ b/services/robotests/backup/src/com/android/server/backup/transport/TransportConnectionManagerTest.java
@@ -44,14 +44,14 @@ import org.robolectric.RobolectricTestRunner;
 
 @RunWith(RobolectricTestRunner.class)
 @Presubmit
-public class TransportClientManagerTest {
+public class TransportConnectionManagerTest {
     private static final String PACKAGE_NAME = "random.package.name";
     private static final String CLASS_NAME = "random.package.name.transport.Transport";
 
     @Mock private Context mContext;
     @Mock private TransportConnectionListener mTransportConnectionListener;
     private @UserIdInt int mUserId;
-    private TransportClientManager mTransportClientManager;
+    private TransportConnectionManager mTransportConnectionManager;
     private ComponentName mTransportComponent;
     private Intent mBindIntent;
 
@@ -60,8 +60,8 @@ public class TransportClientManagerTest {
         MockitoAnnotations.initMocks(this);
 
         mUserId = UserHandle.USER_SYSTEM;
-        mTransportClientManager =
-                new TransportClientManager(mUserId, mContext, new TransportStats());
+        mTransportConnectionManager =
+                new TransportConnectionManager(mUserId, mContext, new TransportStats());
         mTransportComponent = new ComponentName(PACKAGE_NAME, CLASS_NAME);
         mBindIntent = new Intent(SERVICE_ACTION_TRANSPORT_HOST).setComponent(mTransportComponent);
 
@@ -75,11 +75,11 @@ public class TransportClientManagerTest {
 
     @Test
     public void testGetTransportClient() {
-        TransportClient transportClient =
-                mTransportClientManager.getTransportClient(mTransportComponent, "caller");
+        TransportConnection transportConnection =
+                mTransportConnectionManager.getTransportClient(mTransportComponent, "caller");
 
         // Connect to be able to extract the intent
-        transportClient.connectAsync(mTransportConnectionListener, "caller");
+        transportConnection.connectAsync(mTransportConnectionListener, "caller");
         verify(mContext)
                 .bindServiceAsUser(
                         argThat(matchesIntentAndExtras(mBindIntent)),
@@ -93,10 +93,11 @@ public class TransportClientManagerTest {
         Bundle extras = new Bundle();
         extras.putBoolean("random_extra", true);
 
-        TransportClient transportClient =
-                mTransportClientManager.getTransportClient(mTransportComponent, extras, "caller");
+        TransportConnection transportConnection =
+                mTransportConnectionManager.getTransportClient(mTransportComponent, extras,
+                        "caller");
 
-        transportClient.connectAsync(mTransportConnectionListener, "caller");
+        transportConnection.connectAsync(mTransportConnectionListener, "caller");
         mBindIntent.putExtras(extras);
         verify(mContext)
                 .bindServiceAsUser(
@@ -108,13 +109,13 @@ public class TransportClientManagerTest {
 
     @Test
     public void testDisposeOfTransportClient() {
-        TransportClient transportClient =
-                spy(mTransportClientManager.getTransportClient(mTransportComponent, "caller"));
+        TransportConnection transportConnection =
+                spy(mTransportConnectionManager.getTransportClient(mTransportComponent, "caller"));
 
-        mTransportClientManager.disposeOfTransportClient(transportClient, "caller");
+        mTransportConnectionManager.disposeOfTransportClient(transportConnection, "caller");
 
-        verify(transportClient).unbind(any());
-        verify(transportClient).markAsDisposed();
+        verify(transportConnection).unbind(any());
+        verify(transportConnection).markAsDisposed();
     }
 
     private ArgumentMatcher<Intent> matchesIntentAndExtras(Intent expectedIntent) {
diff --git a/services/robotests/backup/src/com/android/server/backup/transport/TransportClientTest.java b/services/robotests/backup/src/com/android/server/backup/transport/TransportConnectionTest.java
index 392f2ca9490e..de4aec61aef2 100644
--- a/services/robotests/backup/src/com/android/server/backup/transport/TransportClientTest.java
+++ b/services/robotests/backup/src/com/android/server/backup/transport/TransportConnectionTest.java
@@ -77,7 +77,7 @@ import java.util.function.Supplier;
             FrameworkShadowLooper.class
         })
 @Presubmit
-public class TransportClientTest {
+public class TransportConnectionTest {
     private static final String PACKAGE_NAME = "some.package.name";
 
     @Mock private Context mContext;
@@ -86,7 +86,7 @@ public class TransportClientTest {
     @Mock private IBackupTransport.Stub mTransportBinder;
     @UserIdInt private int mUserId;
     private TransportStats mTransportStats;
-    private TransportClient mTransportClient;
+    private TransportConnection mTransportConnection;
     private ComponentName mTransportComponent;
     private String mTransportString;
     private Intent mBindIntent;
@@ -106,8 +106,8 @@ public class TransportClientTest {
         mTransportString = mTransportComponent.flattenToShortString();
         mTransportStats = new TransportStats();
         mBindIntent = new Intent(SERVICE_ACTION_TRANSPORT_HOST).setComponent(mTransportComponent);
-        mTransportClient =
-                new TransportClient(
+        mTransportConnection =
+                new TransportConnection(
                         mUserId,
                         mContext,
                         mTransportStats,
@@ -132,12 +132,12 @@ public class TransportClientTest {
 
     @Test
     public void testGetTransportComponent_returnsTransportComponent() {
-        assertThat(mTransportClient.getTransportComponent()).isEqualTo(mTransportComponent);
+        assertThat(mTransportConnection.getTransportComponent()).isEqualTo(mTransportComponent);
     }
 
     @Test
     public void testConnectAsync_callsBindService() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller");
 
         verify(mContext)
                 .bindServiceAsUser(
@@ -149,42 +149,42 @@ public class TransportClientTest {
 
     @Test
     public void testConnectAsync_callsListenerWhenConnected() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
 
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
 
         mShadowMainLooper.runToEndOfTasks();
         verify(mTransportConnectionListener)
-                .onTransportConnectionResult(any(IBackupTransport.class), eq(mTransportClient));
+                .onTransportConnectionResult(any(IBackupTransport.class), eq(mTransportConnection));
     }
 
     @Test
     public void testConnectAsync_whenPendingConnection_callsAllListenersWhenConnected() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
 
-        mTransportClient.connectAsync(mTransportConnectionListener2, "caller2");
+        mTransportConnection.connectAsync(mTransportConnectionListener2, "caller2");
 
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
         mShadowMainLooper.runToEndOfTasks();
         verify(mTransportConnectionListener)
-                .onTransportConnectionResult(any(IBackupTransport.class), eq(mTransportClient));
+                .onTransportConnectionResult(any(IBackupTransport.class), eq(mTransportConnection));
         verify(mTransportConnectionListener2)
-                .onTransportConnectionResult(any(IBackupTransport.class), eq(mTransportClient));
+                .onTransportConnectionResult(any(IBackupTransport.class), eq(mTransportConnection));
     }
 
     @Test
     public void testConnectAsync_whenAlreadyConnected_callsListener() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
 
-        mTransportClient.connectAsync(mTransportConnectionListener2, "caller2");
+        mTransportConnection.connectAsync(mTransportConnectionListener2, "caller2");
 
         mShadowMainLooper.runToEndOfTasks();
         verify(mTransportConnectionListener2)
-                .onTransportConnectionResult(any(IBackupTransport.class), eq(mTransportClient));
+                .onTransportConnectionResult(any(IBackupTransport.class), eq(mTransportConnection));
     }
 
     @Test
@@ -196,11 +196,11 @@ public class TransportClientTest {
                         any(UserHandle.class)))
                 .thenReturn(false);
 
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller");
 
         mShadowMainLooper.runToEndOfTasks();
         verify(mTransportConnectionListener)
-                .onTransportConnectionResult(isNull(), eq(mTransportClient));
+                .onTransportConnectionResult(isNull(), eq(mTransportConnection));
     }
 
     @Test
@@ -212,7 +212,7 @@ public class TransportClientTest {
                         any(UserHandle.class)))
                 .thenReturn(false);
 
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller");
 
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         verify(mContext).unbindService(eq(connection));
@@ -220,64 +220,64 @@ public class TransportClientTest {
 
     @Test
     public void testConnectAsync_afterOnServiceDisconnectedBeforeNewConnection_callsListener() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
         connection.onServiceDisconnected(mTransportComponent);
 
-        mTransportClient.connectAsync(mTransportConnectionListener2, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener2, "caller1");
 
         verify(mTransportConnectionListener2)
-                .onTransportConnectionResult(isNull(), eq(mTransportClient));
+                .onTransportConnectionResult(isNull(), eq(mTransportConnection));
     }
 
     @Test
     public void testConnectAsync_afterOnServiceDisconnectedAfterNewConnection_callsListener() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
         connection.onServiceDisconnected(mTransportComponent);
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
 
-        mTransportClient.connectAsync(mTransportConnectionListener2, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener2, "caller1");
 
         // Yes, it should return null because the object became unusable, check design doc
         verify(mTransportConnectionListener2)
-                .onTransportConnectionResult(isNull(), eq(mTransportClient));
+                .onTransportConnectionResult(isNull(), eq(mTransportConnection));
     }
 
     @Test
     public void testConnectAsync_callsListenerIfBindingDies() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
 
         connection.onBindingDied(mTransportComponent);
 
         mShadowMainLooper.runToEndOfTasks();
         verify(mTransportConnectionListener)
-                .onTransportConnectionResult(isNull(), eq(mTransportClient));
+                .onTransportConnectionResult(isNull(), eq(mTransportConnection));
     }
 
     @Test
     public void testConnectAsync_whenPendingConnection_callsListenersIfBindingDies() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
 
-        mTransportClient.connectAsync(mTransportConnectionListener2, "caller2");
+        mTransportConnection.connectAsync(mTransportConnectionListener2, "caller2");
 
         connection.onBindingDied(mTransportComponent);
         mShadowMainLooper.runToEndOfTasks();
         verify(mTransportConnectionListener)
-                .onTransportConnectionResult(isNull(), eq(mTransportClient));
+                .onTransportConnectionResult(isNull(), eq(mTransportConnection));
         verify(mTransportConnectionListener2)
-                .onTransportConnectionResult(isNull(), eq(mTransportClient));
+                .onTransportConnectionResult(isNull(), eq(mTransportConnection));
     }
 
     @Test
     public void testConnectAsync_beforeFrameworkCall_logsBoundTransitionEvent() {
         ShadowEventLog.setUp();
 
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
 
         assertEventLogged(EventLogTags.BACKUP_TRANSPORT_LIFECYCLE, mTransportString, 1);
     }
@@ -285,7 +285,7 @@ public class TransportClientTest {
     @Test
     public void testConnectAsync_afterOnServiceConnected_logsBoundAndConnectedTransitionEvents() {
         ShadowEventLog.setUp();
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
 
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
@@ -297,7 +297,7 @@ public class TransportClientTest {
     @Test
     public void testConnectAsync_afterOnBindingDied_logsBoundAndUnboundTransitionEvents() {
         ShadowEventLog.setUp();
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
 
         connection.onBindingDied(mTransportComponent);
@@ -308,37 +308,37 @@ public class TransportClientTest {
 
     @Test
     public void testConnect_whenConnected_returnsTransport() throws Exception {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
 
         IBackupTransport transportBinder =
-                runInWorkerThread(() -> mTransportClient.connect("caller2"));
+                runInWorkerThread(() -> mTransportConnection.connect("caller2"));
 
         assertThat(transportBinder).isNotNull();
     }
 
     @Test
     public void testConnect_afterOnServiceDisconnected_returnsNull() throws Exception {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
         connection.onServiceDisconnected(mTransportComponent);
 
         IBackupTransport transportBinder =
-                runInWorkerThread(() -> mTransportClient.connect("caller2"));
+                runInWorkerThread(() -> mTransportConnection.connect("caller2"));
 
         assertThat(transportBinder).isNull();
     }
 
     @Test
     public void testConnect_afterOnBindingDied_returnsNull() throws Exception {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         connection.onBindingDied(mTransportComponent);
 
         IBackupTransport transportBinder =
-                runInWorkerThread(() -> mTransportClient.connect("caller2"));
+                runInWorkerThread(() -> mTransportConnection.connect("caller2"));
 
         assertThat(transportBinder).isNull();
     }
@@ -350,30 +350,31 @@ public class TransportClientTest {
         // reentrant lock can't be acquired by the listener at the call-site of bindServiceAsUser(),
         // which is what would happened if we mocked bindServiceAsUser() to call the listener
         // inline.
-        TransportClient transportClient = spy(mTransportClient);
+        TransportConnection transportConnection = spy(mTransportConnection);
         doAnswer(
                         invocation -> {
                             TransportConnectionListener listener = invocation.getArgument(0);
-                            listener.onTransportConnectionResult(mTransportBinder, transportClient);
+                            listener.onTransportConnectionResult(mTransportBinder,
+                                    transportConnection);
                             return null;
                         })
-                .when(transportClient)
+                .when(transportConnection)
                 .connectAsync(any(), any());
 
         IBackupTransport transportBinder =
-                runInWorkerThread(() -> transportClient.connect("caller"));
+                runInWorkerThread(() -> transportConnection.connect("caller"));
 
         assertThat(transportBinder).isNotNull();
     }
 
     @Test
     public void testUnbind_whenConnected_logsDisconnectedAndUnboundTransitionEvents() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
         ShadowEventLog.setUp();
 
-        mTransportClient.unbind("caller1");
+        mTransportConnection.unbind("caller1");
 
         assertEventLogged(EventLogTags.BACKUP_TRANSPORT_CONNECTION, mTransportString, 0);
         assertEventLogged(EventLogTags.BACKUP_TRANSPORT_LIFECYCLE, mTransportString, 0);
@@ -382,7 +383,7 @@ public class TransportClientTest {
     @Test
     public void
             testOnServiceDisconnected_whenConnected_logsDisconnectedAndUnboundTransitionEvents() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
         ShadowEventLog.setUp();
@@ -395,7 +396,7 @@ public class TransportClientTest {
 
     @Test
     public void testOnBindingDied_whenConnected_logsDisconnectedAndUnboundTransitionEvents() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
         ShadowEventLog.setUp();
@@ -408,60 +409,60 @@ public class TransportClientTest {
 
     @Test
     public void testMarkAsDisposed_whenCreated() {
-        mTransportClient.markAsDisposed();
+        mTransportConnection.markAsDisposed();
 
         // No exception thrown
     }
 
     @Test
     public void testMarkAsDisposed_afterOnBindingDied() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         connection.onBindingDied(mTransportComponent);
 
-        mTransportClient.markAsDisposed();
+        mTransportConnection.markAsDisposed();
 
         // No exception thrown
     }
 
     @Test
     public void testMarkAsDisposed_whenConnectedAndUnbound() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
-        mTransportClient.unbind("caller1");
+        mTransportConnection.unbind("caller1");
 
-        mTransportClient.markAsDisposed();
+        mTransportConnection.markAsDisposed();
 
         // No exception thrown
     }
 
     @Test
     public void testMarkAsDisposed_afterOnServiceDisconnected() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
         connection.onServiceDisconnected(mTransportComponent);
 
-        mTransportClient.markAsDisposed();
+        mTransportConnection.markAsDisposed();
 
         // No exception thrown
     }
 
     @Test
     public void testMarkAsDisposed_whenBound() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
 
-        expectThrows(RuntimeException.class, mTransportClient::markAsDisposed);
+        expectThrows(RuntimeException.class, mTransportConnection::markAsDisposed);
     }
 
     @Test
     public void testMarkAsDisposed_whenConnected() {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
 
-        expectThrows(RuntimeException.class, mTransportClient::markAsDisposed);
+        expectThrows(RuntimeException.class, mTransportConnection::markAsDisposed);
     }
 
     @Test
@@ -469,36 +470,36 @@ public class TransportClientTest {
     public void testFinalize_afterCreated() throws Throwable {
         ShadowLog.reset();
 
-        mTransportClient.finalize();
+        mTransportConnection.finalize();
 
-        assertLogcatAtMost(TransportClient.TAG, Log.INFO);
+        assertLogcatAtMost(TransportConnection.TAG, Log.INFO);
     }
 
     @Test
     @SuppressWarnings("FinalizeCalledExplicitly")
     public void testFinalize_whenBound() throws Throwable {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ShadowLog.reset();
 
-        mTransportClient.finalize();
+        mTransportConnection.finalize();
 
-        assertLogcatAtLeast(TransportClient.TAG, Log.ERROR);
+        assertLogcatAtLeast(TransportConnection.TAG, Log.ERROR);
     }
 
     @Test
     @SuppressWarnings("FinalizeCalledExplicitly")
     public void testFinalize_whenConnected() throws Throwable {
-        mTransportClient.connectAsync(mTransportConnectionListener, "caller1");
+        mTransportConnection.connectAsync(mTransportConnectionListener, "caller1");
         ServiceConnection connection = verifyBindServiceAsUserAndCaptureServiceConnection(mContext);
         connection.onServiceConnected(mTransportComponent, mTransportBinder);
         ShadowLog.reset();
 
-        mTransportClient.finalize();
+        mTransportConnection.finalize();
 
         expectThrows(
                 TransportNotAvailableException.class,
-                () -> mTransportClient.getConnectedTransport("caller1"));
-        assertLogcatAtLeast(TransportClient.TAG, Log.ERROR);
+                () -> mTransportConnection.getConnectedTransport("caller1"));
+        assertLogcatAtLeast(TransportConnection.TAG, Log.ERROR);
     }
 
     @Test
@@ -506,7 +507,7 @@ public class TransportClientTest {
     public void testFinalize_whenNotMarkedAsDisposed() throws Throwable {
         ShadowCloseGuard.setUp();
 
-        mTransportClient.finalize();
+        mTransportConnection.finalize();
 
         assertThat(ShadowCloseGuard.hasReported()).isTrue();
     }
@@ -514,10 +515,10 @@ public class TransportClientTest {
     @Test
     @SuppressWarnings("FinalizeCalledExplicitly")
     public void testFinalize_whenMarkedAsDisposed() throws Throwable {
-        mTransportClient.markAsDisposed();
+        mTransportConnection.markAsDisposed();
         ShadowCloseGuard.setUp();
 
-        mTransportClient.finalize();
+        mTransportConnection.finalize();
 
         assertThat(ShadowCloseGuard.hasReported()).isFalse();
     }