binder: Add LeakSafeOneWayBinder and tests. (#8021)

Another util class, this one with tests which need to run on
an Android emulator.

Author: markb74

binder/build.gradle

@@ -40,6 +40,8 @@ dependencies {
         exclude group: 'com.google.auto.service', module: 'auto-service'
     }
     testImplementation libraries.truth
+    androidTestImplementation libraries.androidx_test_rules
+    androidTestImplementation libraries.androidx_test_ext_junit
+    androidTestImplementation libraries.truth
 }
-
 [publishMavenPublicationToMavenRepository]*.onlyIf { false }

binder/src/androidTest/java/io/grpc/binder/internal/LeakSafeOneWayBinderTest.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2020 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc.binder.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.os.Parcel;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+public final class LeakSafeOneWayBinderTest {
+
+  private LeakSafeOneWayBinder binder;
+
+  private int transactionsHandled;
+  private int lastCode;
+  private Parcel lastParcel;
+
+  @Before
+  public void setUp() {
+    binder = new LeakSafeOneWayBinder((code, parcel) -> {
+      transactionsHandled++;
+      lastCode = code;
+      lastParcel = parcel;
+      return true;
+    });
+  }
+
+  @Test
+  public void testTransaction() {
+    Parcel p = Parcel.obtain();
+    assertThat(binder.onTransact(123, p, null, 0)).isTrue();
+    assertThat(transactionsHandled).isEqualTo(1);
+    assertThat(lastCode).isEqualTo(123);
+    assertThat(lastParcel).isSameInstanceAs(p);
+    p.recycle();
+  }
+
+  @Test
+  public void testDetach() {
+    Parcel p = Parcel.obtain();
+    binder.detach();
+    assertThat(binder.onTransact(456, p, null, 0)).isFalse();
+
+    // The transaction shouldn't have been processed.
+    assertThat(transactionsHandled).isEqualTo(0);
+
+    p.recycle();
+  }
+
+  @Test
+  public void testMultipleTransactions() {
+    Parcel p = Parcel.obtain();
+    assertThat(binder.onTransact(123, p, null, 0)).isTrue();
+    assertThat(binder.onTransact(456, p, null, 0)).isTrue();
+    assertThat(transactionsHandled).isEqualTo(2);
+    assertThat(lastCode).isEqualTo(456);
+    assertThat(lastParcel).isSameInstanceAs(p);
+    p.recycle();
+  }
+
+  @Test
+  public void testPing() {
+    assertThat(binder.pingBinder()).isTrue();
+  }
+
+  @Test
+  public void testPing_Detached() {
+    binder.detach();
+    assertThat(binder.pingBinder()).isFalse();
+  }
+}

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2020 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc.binder.internal;
+
+import android.os.Binder;
+import android.os.Parcel;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * An extension of {@link Binder} which delegates all transactions to an internal handler, and only
+ * supports one way transactions.
+ *
+ * <p>Since Binder objects can be anchored forever by a misbehaved remote process, any references
+ * they hold can lead to significant memory leaks. To prevent that, the {@link #detach} method
+ * clears the reference to the delegate handler, ensuring that only this simple class is leaked.
+ * Once detached, this binder returns false from any future transactions (and pings).
+ *
+ * <p>Since two-way transactions block the calling thread on a remote process, this class only
+ * supports one-way calls.
+ */
+final class LeakSafeOneWayBinder extends Binder {
+
+  private static final Logger logger = Logger.getLogger(LeakSafeOneWayBinder.class.getName());
+
+  interface TransactionHandler {
+    boolean handleTransaction(int code, Parcel data);
+  }
+
+  @Nullable private TransactionHandler handler;
+
+  LeakSafeOneWayBinder(TransactionHandler handler) {
+    this.handler = handler;
+  }
+
+  void detach() {
+    handler = null;
+  }
+
+  @Override
+  protected boolean onTransact(int code, Parcel parcel, Parcel reply, int flags) {
+    TransactionHandler handler = this.handler;
+    if (handler != null) {
+      try {
+        return handler.handleTransaction(code, parcel);
+      } catch (RuntimeException re) {
+        logger.log(Level.WARNING, "failure sending transaction " + code, re);
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+
+  @Override
+  public boolean pingBinder() {
+    return handler != null;
+  }
+}

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

@@ -32,7 +32,7 @@
 import androidx.test.core.app.ApplicationProvider;
 import io.grpc.Status;
 import io.grpc.Status.Code;
-import io.grpc.binder.util.Bindable.Observer;
+import io.grpc.binder.internal.Bindable.Observer;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;

build.gradle

@@ -191,6 +191,8 @@ subprojects {
             androidx_annotation: "androidx.annotation:annotation:1.1.0",
             androidx_core: "androidx.core:core:1.3.0",
             androidx_test: "androidx.test:core:1.3.0",
+            androidx_test_rules: "androidx.test:rules:1.3.0",
+            androidx_test_ext_junit: "androidx.test.ext:junit:1.1.2",
             robolectric: "org.robolectric:robolectric:4.4",
 
             // Benchmark dependencies