Stop leaking 'this' from the BinderServerTransport ctor.

Accomplish this by splitting out the linkToDeath() part of setOutgoingBinder().

We also add a test for the DOA case and document why ignoring errors from linkToDeath() is ok.

Author: jdcormie

binder/src/main/java/io/grpc/binder/internal/BinderClientTransport.java

@@ -335,7 +335,8 @@ protected void handleSetupTransport(Parcel parcel) {
       return;
     }
 
-    if (!setOutgoingBinder(OneWayBinderProxy.wrap(binder, offloadExecutor))) {
+    setOutgoingBinder(OneWayBinderProxy.wrap(binder, offloadExecutor));
+    if (!linkToDeathOfOutgoingBinder()) {
       shutdownInternal(
           Status.UNAVAILABLE.withDescription("Failed to observe outgoing binder"), true);
       return;

binder/src/main/java/io/grpc/binder/internal/BinderServerTransport.java

@@ -69,17 +69,15 @@ public BinderServerTransport(
    */
   public synchronized void start(ServerTransportListener serverTransportListener) {
     this.listenerPromise.set(serverTransportListener);
-    if (isShutdown()) {
-      // It's unlikely, but we could be shutdown externally between construction and start(). One
-      // possible cause is an extremely short handshake timeout.
-      return;
-    }
+
+    // Ignore errors. If outgoingBinder is DOA, sendSetupTransaction() will fail with the same code.
+    linkToDeathOfOutgoingBinder();
 
     sendSetupTransaction();
 
-    // Check we're not shutdown again, since a failure inside sendSetupTransaction (or a callback
-    // it triggers), could have shut us down.
     if (isShutdown()) {
+      // It's unlikely, but we could already be shutdown at this point. One possible cause is an
+      // extremely short handshake timeout. Another is if the client's binder was dead on arrival.
       return;
     }
 

binder/src/main/java/io/grpc/binder/internal/BinderTransport.java

@@ -159,6 +159,7 @@ protected enum TransportState {
   private final ObjectPool<ScheduledExecutorService> executorServicePool;
   private final ScheduledExecutorService scheduledExecutorService;
   private final InternalLogId logId;
+
   @GuardedBy("this")
   private final LeakSafeOneWayBinder incomingBinder;
 
@@ -277,12 +278,30 @@ final void setState(TransportState newState) {
     transportState = newState;
   }
 
+  /**
+   * Sets the binder to use for sending subsequent transactions to our peer.
+   *
+   * <p>Subclasses should call this as early as possible.
+   */
+  @GuardedBy("this")
+  protected void setOutgoingBinder(OneWayBinderProxy binder) {
+    this.outgoingBinder = binderDecorator.decorate(binder);
+  }
+
+  /**
+   * Registers for notification of the death of the process hosting our peer.
+   *
+   * <p>Subclasses should call this ASAP after #setOutgoingBinder but not from a constructor.
+   *
+   * <p>Returns true for success and false if the outgoing binder is already dead. Callers should
+   * shutdown the transport in this case.
+   */
   @GuardedBy("this")
-  protected boolean setOutgoingBinder(OneWayBinderProxy binder) {
-    binder = binderDecorator.decorate(binder);
-    this.outgoingBinder = binder;
+  protected boolean linkToDeathOfOutgoingBinder() {
     try {
-      binder.getDelegate().linkToDeath(this, 0);
+      checkNotNull(outgoingBinder, "Call setOutgoingBinder() first!")
+          .getDelegate()
+          .linkToDeath(this, 0);
       return true;
     } catch (RemoteException re) {
       return false;

binder/src/test/java/io/grpc/binder/internal/BinderServerTransportTest.java

@@ -21,10 +21,8 @@
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.when;
 import static org.robolectric.Shadows.shadowOf;
 
-import android.os.DeadObjectException;
 import android.os.IBinder;
 import android.os.Looper;
 import android.os.Parcel;
@@ -33,6 +31,7 @@
 import io.grpc.Attributes;
 import io.grpc.ServerStreamTracer;
 import io.grpc.Status;
+import io.grpc.binder.FakeDeadBinder;
 import io.grpc.internal.FixedObjectPool;
 import io.grpc.internal.MockServerTransportListener;
 import io.grpc.internal.ObjectPool;
@@ -96,6 +95,17 @@ public void testSetupTransactionFailureReportsMultipleTerminations_b153460678()
     assertThat(transportListener.isTerminated()).isTrue();
   }
 
+  @Test
+  public void testClientBinderIsDeadOnArrival() throws Exception {
+    transport = newBinderServerTransportBuilder()
+        .setCallbackBinder(new FakeDeadBinder())
+        .build();
+    transport.start(transportListener);
+    shadowOf(Looper.getMainLooper()).idle();
+
+    assertThat(transportListener.isTerminated()).isTrue();
+  }
+
   @Test
   public void testStartAfterShutdownAndIdle() throws Exception {
     transport = newBinderServerTransportBuilder().build();